1.常见的组合类型有3大类：

• 集合类型：是一个元素集合，元素之间无序，相同元素在集合中唯一存在。集合（set）
• 序列类型：是一个元素向量，元素之间存在先后关系，通过序号访问，元素之间不排他。序列类型的典型代表是字符串(str)、列表(list)、元组(tuple)
• 映射类型：是“键-值”数据项的组合，每个元素是一个键值对，表示为(key,value).映射类型的典型代表是字典(dict)

 2.集合类型概述：

        Python语言中的集合类型与数学中的集合概念一致，即包含0个或多个数据项的无序组合。用大括号{}表示，它没有索引和位置的概念，集合中的元素可以动态增加或删除。由于集合元素独一无二，使用集合类型能够过滤掉重复类型。

s={1,2,2,6,3,2,1,8,8}
print(s)
#运行结果：{1, 2, 3, 6, 8}

集合类型有4个操作符，交集&，并集|，差集-，补集^，操作逻辑与数学定义相同。

操作符的运算	描述
S-T	返回一个新集合包括在集合S中但不在集合T中的元素
S&T	返回一个新集合包括同时在集合S和集合T中的元素
S^T	返回一个新集合包括集合S和集合T中的非共同元素
S|T	返回一个新集合包括集合S和集合T中的所有元素

s={111,"python",123}
t={111,1010}
print(s-t)
print(s&t)
print(s|t)
print(s^t)
'''运行结果：
{123, 'python'}
{111}
{1010, 123, 'python', 111}
{123, 1010, 'python'}
'''

 3.集合类型有一些常用的操作函数或方法：

函数或方法	描述
S.add(x）	如果数据域x不在集合S中，将x增加到s
S.remove(x)	如果x在集合S中，移动该元素；不在产生KeyError异常
S.clear()	移除S中所有数据域
len(S)	返回集合S元素个数
x in S	如果x是S的元素，返回True，否则返回Flase
x not in S	如果x不是S的元素，返回True，否则返回Flase

set()函数将其他的组合数据类型转换成集合类型，返回结果是一个无重复且排序任意的集合。set()函数也可以生成空集合变量。 

s={111,"python",123}
s.add('abc')
print(s)
s.remove(111)
print(s)
len(s)
print(123 in s)
print(111 in s)
s.clear()
'''print(s)
运算结果：
{'python', 'abc', 123, 111}
{'python', 'abc', 123}
True
False
set()
'''

4.列表类型概述：

列表类型用括号[ ]表示，列表没有长度限制，元素类型可以不同。通过list(x)函数将集合或字符串类型转换成列表类型。

列表属于序列类型，所以列表类型支持序列类型对应的操作

序列类型有一些通用的操作符和函数

操作符	描述
x in s	如果x是s的元素，返回True，否则返回Flase
x not in s	如果x不是s的元素，返回True，否则返回Flase
s +t	连接s和t
s *n或n*s	将序列s复制n次
s[i]	索引，返回序列的第i个元素
s[i:j]	切片，返回序列s到第i到第j个元素的子序列（不包含第j个元素）
s[i:j:k]	步骤切片，返回包括序列s到第i到第j个元素以k为步长的子序列
len(s)	序列s的元素个数（长度）
min(s)	序列s中的最小元素
max(s)	序列s中的最大元素
s.index(x)	序列s中第一次出现元素x的位置
s.count(x)	序列s中元素x出现的总次数

 

                                                列表类型14个常用函数或方法 

print(list((3,5,7,9,11)))               #将元组转换为列表
# [3, 5, 7, 9, 11]
print(list(range(1, 10, 2)))             #将range对象转换为列表
# [1, 3, 5, 7, 9]
print(list('hello world'))               #将字符串转换为列表
# ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
print(list({3,7,5}))                     #将集合转换为列表
# [3, 5, 7]
print(list({'a':3, 'b':9, 'c':78}))      #将字典的“键”转换为列表
# ['a', 'c', 'b']
print(list({'a':3, 'b':9, 'c':78}.items()))#将字典的“键:值”对转换为列表
# [('b', 9), ('c', 78), ('a', 3)]
x = list()                        #创建空列表
print(x)

aList=[1,2,3,4,5,6,7]
print(aList)
print(aList[0],aList[len(aList)-1])
print(aList[-1],aList[-len(aList)])
print(aList[2:6])
print(aList[2:6:2])
print(aList[2:6:2]*2)
print(aList[2:6]+aList[2:6:2])
print(aList[:4],aList[4:])
print(aList[-1::-1])

5.向列表里添加新元素 

（1） 使用aList.append(obj)方法添加元素。obj将被添加到aList尾部。如果obj也是一个序列，则该序列会整体被当做一个元素添加到aList列表的尾部。

（2） 使用aList.extend(obj)方法添加元素。obj将被添加到aList的尾部。如果obj也是一个序列，该序列中所有的元素会被当成不同的元素，依次添加到aList列表尾部。

（3） 使用aList.insert(index, obj)方法添加元素。obj将被添加到aList中index位置上。如果obj是一个序列，该序列会被当做一个元素添加到aList列表的index位置。

aList=[1,2,3,4,5]
aList.append(6)
print(aList)
exList=[7,8,9]
aList.extend(exList)
print(aList)
aList.append(exList)
print(aList)
aList.insert(3,3.5)
print(aList)
'''运行结果：
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, [7, 8, 9]]
[1, 2, 3, 3.5, 4, 5, 6, 7, 8, 9, [7, 8, 9]]'''

 6.向列表中删除元素

（1） 使用del aList[index]方法，删除列表中索引号为index的那个元素。

（2） 使用del aList[index1 : index2]方法，删除列表中从索引号index1开始，到索引号index2 – 1结束，之间的所有元素。   

（3） 使用aList.pop()方法，可以出栈列表中的最后一个元素。运行pop()命令之后，返回值为列表最后一个元素，aList的最后一个元素从列表中删除。

（4） 使用aList.remove(obj)方法，可以删除与obj指定值相同的第一个元素。如果在列表中找不到obj值，就会发生一个ValueError错误。

（5） 使用aList.clear()方法，可以删除aList列表中所有的元素，仅仅保留一个名为aList的空列表。

aList=[1,2,3,4,5,6,7]
del aList[3]
print(aList)
del aList[2:4]
print(aList)
print(aList.pop())
print(aList)
aList.remove(6)
print(aList)
aList.clear()
print(aList)
'''运行结果：
[1, 2, 3, 5, 6, 7]
[1, 2, 6, 7]
7
[1, 2, 6]
[1, 2]
[]'''

7.列表的索引：索引是列表的基本操作，用于获得列表的一个元素。使用中括号作为索引操作符，可以使用遍历循环对列表类型的元素进行遍历操作。

                        for 循环变量 in 列表变量：

                                语句块

 8.切片是列表的基本操作，用于获得列表的一个片段，即获得一个或多个元素。切片后的结果也是列表类型。

                切片的使用方式：

                                        列表或列表变量[N:M:K]

切片获取列表类型从N到M（不包含M）的元素组成新的列表。当K存在时，切片获取列表类型从N到M（不包含M）以K为步长所对应元素组成的列表。

9.元组的概述：

Python的元组与列表类似，不同之处在于元组的元素不能修改，元组使用小括号（），列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用括号隔开即可。元组是序列类型中比较特殊的类型，因为它一旦创建就不能被修改。元组类型在表达固定数据项、函数多返回值、多变量同步赋值、循环遍历等情况下十分有用。Python中元组采用逗号和圆括号（可选）来表示。一个元组可以作为另一个元组的元素，可以采用多级索引获取信息。

•         元组属于不可变序列，不可以直接修改元组中元素的值，也无法为元组增加或删除元素。
  •         元组没有提供append()、extend()和insert()等方法，无法向元组中添加元素；同样，元组也没有remove()和pop()方法，也不支持对元组元素进行del操作，不能从元组中删除元素，而只能使用del命令删除整个元组。
• •         Python的内部实现对元组做了大量优化，访问速度比列表更快。如果定义了一系列常量值，主要用途仅是对它们进行遍历或其他类似用途，而不需要对其元素进行任何修改，那么一般建议使用元组而不用列表。
    •         元组在内部实现上不允许修改其元素值，从而使得代码更加安全，例如调用函数时使用元组传递参数可以防止在函数中修改元组，而使用列表则很难保证这一点。

creature = "cat", "dog", "tiger", "human"
print(creature)
# ('cat', 'dog', 'tiger', 'human')
color = ("red", 0x001100, "blue", creature)
print( color)
# ('red', 4352, 'blue', ('cat', 'dog', 'tiger', 'human'))
print(color[2])
# 'blue'
print(color[-1][2])
# 'tiger'

10.字典概述：

列表与元组，在内存中是依次存放的，是有序排列的，元素能够通过索引顺序访问。字典不一样。字典(dictionary)是映射类型的序列结构，是一种无序的、可变的序列，如图7-3所示。它的元素以“键值对（key-value）”的形式存储。简单的说，是通过关键字，找到对应值。键的指向可以进行修改，值的存储可以被改变。

字典中元素的“键”可以是Python中任意不可变数据，例如整数、实数、复数、字符串、元组等类型等可哈希数据，但不能使用列表、集合、字典或其他可变类型作为字典的“键”。另外，字典中的“键”不允许重复，而“值”是可以重复的。

建立模式如下：

              {<键1>:<值1>, <键2>:<值2>, … , <键n>:<值n>}

由于大括号可以表示集合，因此字典类型也具有和集合类似的性质，即键值对之间没有顺序且不能重复。

Dcountry={"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
print(Dcountry)
# {'中国': '北京', '法国': '巴黎', '美国': '华盛顿'}

        创建一个字典，可以用一个标识符指代作为字典名，然后用大括号括起来一个一个的键值对，键与值之间用冒号隔开，每个键值对之间用英文逗号隔开。如：

  （1） 使用整数作为键，映射字符串。

  weekDayDic = {0:"Sun", 1:"mon", 2:"Tue", 3:"wed", 4:"Thu", 5:"Fri", 6:"Sat"}

  （2） 使用字符串作为键，映射数。

  scoresDic = {"语文": 90, "数学": 82, "英语": 79}

  （3） 可以创建空字典。

  emptyDic = { }

# 也可以使用内置类dict以不同形式创建字典。
x = dict()  #空字典
keys = ['a', 'b', 'c', 'd']
values = [1, 2, 3, 4]
dictionary = dict(zip(keys, values)) #根据已有数据创建字典
print(dictionary)
# {'a': 1, 'b': 2, 'c': 3, 'd': 4}
d = dict(name="Dong",age=39)  #以关键参数的形式创建字典
aDict = dict.fromkeys(['name', 'age', 'sex'])#以给定内容为“键”，创建“值”为空的字典
print(aDict)
# {'age': None, 'name': None, 'sex': None}

                 ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        字典类型的操作

函数和方法	描述
<d>.keys()	返回所有的键信息
<d>.values()	返回所有的值信息
<d>.items()	返回所有的键值对(以元组形式)
<d>.get(<key>,<default>)	键存在则返回相应值，否则返回特定值
<d>.pop(<key>,<default>)	删除字典中指定键对应的键值对并返回被删除的值，指定的键如果不在字典中，则必须设置一个default值，否则会报错，此时返回的就是default值 dict={'name':'喀什大学','url':'www.ksu.edu.cn'} dict.pop('name','no') dict.pop('nama','no')
<d>.popitem()	随机从字典中取出一个键值对，以元组(key, value)形式返回
<d>.clear()	删除字典中的全部元素，执行clear()后原字典将变为空字典
<d>.copy( )	用于浅复制一个字典，返回一个具有相同键值对的新字典
del <d>[<key>]	删除字典中某一个键值对
<key> in <d>	如果键在字典中返回True，否则返回False
<d>.setdefault(key,value)	如果有此键就返回键的值，如果无此键就添加
<d>.update(args)	更新字典  d = dict(name='zhangsan',age=39,sex='man') t={0:1} d.update(t)

Dcountry={"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
print(Dcountry.keys())
# dict_keys(['中国', '美国', '法国'])
print(list(Dcountry.values()))
# ['北京', '华盛顿', '巴黎']
print(Dcountry.items())
# dict_items([('中国', '北京'), ('美国', '华盛顿'), ('法国', '巴黎')])
print('中国' in Dcountry)   #只对键进行判断
# True
print(Dcountry.get('美国', '悉尼')) #'美国'在字典中存在
# '华盛顿'
print(Dcountry.get('澳大利亚', '悉尼')) #'澳大利亚'在字典中不存在
# '悉尼'

 

Dcountry={"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
for key in Dcountry:
    print(key,Dcountry[key])
for key in Dcountry.keys():
    print(key,Dcountry[key])
for key,values in Dcountry.items():
    print(key,values)
for values in Dcountry.values():
    print(values)
for item in Dcountry.items():
    print(item)
dic={'counter':'柜台','stall':'收货摊','shelf':'货架','discount':'标价签'}
for item in dic.items():
    print(item[0])
    print(item[1])
'''中国 北京
美国 华盛顿
法国 巴黎
中国 北京
美国 华盛顿
法国 巴黎
中国 北京
美国 华盛顿
法国 巴黎
北京
华盛顿
巴黎
('中国', '北京')
('美国', '华盛顿')
('法国', '巴黎')
counter
柜台
stall
收货摊
shelf
货架
discount
标价签'''