一、序列类型(字符串,元组(),列表[])

序列类型支持in，len(),分片[],迭代，5种内置序列类型：bytearray,bytes,list,str,tuple(元组）。

1、元组可以嵌套(如:x=str[2][1][0][1])

2、元组的命名（collections.namedtuple()，即自定义)

       样：sale=collctions.namedtuple("sale","productid customerid date price") 逗号前的为元组类型的名称，逗号后的参数为字符串，用空格分隔，每个名称都代表该元组数据类型的一项，数据项如：x=sale(121,"2017-03-22",1,10.99);调用某一项则可用x.price来实现，此处结果为10.99;

       对于格式化替换，可用**namedtuple._asdict()函数实现直接用名称替换索引，如："{productid}{price}".format(**x._asdict())。此方法用于多层元组较好,name即为最外层元组的name.

       单个元素的元组需要加上逗号。

3、列表

       1>列表也可存储任意类型的数据，且可使用比较操作符（逐项进行比较）和修改列表内容。

       2>列表支持元组的所有操作，同时还有以下函数：

       append()　　追加

       count(x)　　统计x出现的次数

       index(x,start,end)找x,如没有则产生一个ValueError,

       extend()　　  (等同于+＝），

       insert(i,x)　　(在索引位置i处插入x),

       pop()　　　　移除最后一项

       pop(i)　　　　(移除i索引位置处的数据项，如没有i值，则默认移除最后一项），

       remove(x)　　(移除从左边开始出现的第一个数据为x的项，如没有则返回一个ValueError),

       reverse()　　  反转，

       sort()　　　　 排序。

       对序列特定位置进行赋值可以对列表中单个数据进行替换修改（x[1]=2;x[1:2]=[a,b],对片进行替换时新数据项的个数不一定要等于原数据项的个数，可以是任意个数，结果都是新的分片替换已选定的分片，如果新的替换分片为空，就相当于删除了已选定的原分片），del x[1:2]也可以起到删除这一分片的效果（不过del其实是解除了这一数据项与变量之间的绑定）。

       3>用*对序列进行拆分赋值

       样：a,*b,c=[1,2,3,4,5,6]  -> a,b,c=(1, [2, 3, 4, 5], 6)

       数据项按位置依次经变量赋值，然后将剩余的所有数据都赋给带有*号的变量。*的作用就是将一个iterable进行拆分.

       “*”的另一个作用是复制操作符，其效果相当于乘号，不过对象不限于数字，可以为任何对象。

       4>列表内涵(用于创建一些含有大量数据的列表)

       [expression for item in iterable](对iterable中每个数据项进行expression操作）

       [expression for item in iterable if condition],对限定条件的对象进行操作。

       例：leaps=[y for y in range(1900,2000) if (y%4==0 and y%100!=0)or(y%400==0)] 计算闰年。(range同样为前闭后开)

       列表内涵的多变量嵌套:

       例:cods=[s+z+c for s in "MF" for z in "SMLX" for c in "BGW"

              if not(s=="F" and z=="X")]相当于三层叠加的for循环.

二、集合类型（set)（{}）

　　set支持 in ,len(),比较，位逻辑操作符；并且也是iterable的。只有可hash运算的对象才可以添加到集合中。所有内置的固定数据类型（float,frozenset,int,str,tupul...)都是可hash运算的。内置的可变数据类型（如：dict,list,set)都不是可hash运算的。

　　创建一个集合可用set("a","b",3),且创建一个空集合必须用set()。集合创建时可以存在两个相同的项，但没意义，最终形成的集合只会保留一个。

例：s={2,"veil",("a",5),frozenset({8,4,7}),"a"}

　　集合是没索引位置区分的，也不能分片或按步距分片。集合中每个数据都是独一无二的，所以集合常被用于删除重复的数据项（x=list(set(x))）。

1、集合常用函数：

       s.add(x)　　添加x到集合s中；

       s.clear()　　清空；

       s.pop()　　  移除集合中任意一项，如果为空了则返回产生KeyError异常；

       s.remove(x) 移除x项，如x不存在就产生KeyError异常；

       s.discard(x)  如果x 存在就移除掉该项；

       s.copy()　　 浅拷贝；  *

       s.different(t)s-t  返回一个新集合，其只包含s但不在集合t中；  *

       s.difference_update(t)s-=t  移除每一个在集合t但不在s中的项；

       s.intersection(t)s&t     返回s和t的交集；  *

2、集合联合操作运算符结果：

       s|t,合集；s&t,交集；s-t,减去与t的交集；s^t,合集减去交集。

3、集合内涵（同列表内涵）

       {expression for item in iterable}

       {expression for item in iterable if condition}

4、固定集合（frozenset())

       一旦创建了就不可改变，同static，可用的函数只有那些不改变集合本身内容的函数（上已用*标注）。

三、映射类型（dict)

映射是键－值数据的无序组合。内置的映射类型有：dict(),collections.defaultdict();对于3.1以上的还有collections.OrderedDict(),它同dict()一样，不过有索引序列。

映射的键只有可hash运算的类型才可使用，而值则可使用任意类型的数据。

1、字典的创建

d=dict(id=1948,name="washer",size=3)  #关键字参数

d={"id":1948,"name":"washer","size":3}   #面值

d=dict({"id":1948,"name":"washer","size":3})    #面值

d=dict([("id",1948),("name","washer"),("size",3)])  #序列

d=dict(zip(("id","name","size"),(1948,"washer",3)))  #序列

{}或用d=dict()来创建一个空字典

2、使用d["id"]则返回相应的值，如果此键不存在，则产生一个KeyError.

d["xx"]=34可添加一个项，如果此键已经存在，则会修改原始的值。

del d["xx"]会删除键为"xx"的项，如果不存在则产生一个KeyError。

3、常用函数（全）

       d.clear()　　清空

       d.copy()　　浅拷贝

       d.pop(k,v)　返回k的值，并删除k项，如果k不存在，就返回KeyError或者v(如v存在的话）

       d.popitem() 移除任意一对键－值，如果d为空就产生KeyError

       d.values()　 返回字典中所有值的视图

       d.keys()　　 返回字典所有键的视图

       d.items()　　返回字典所有（key,value)对的视图

       d.get(k)　　 返回k的值，如果k不存在就返回None

       d.get(k,v)　 返回k的值，如果k不存在就返回v

       d.setdefault(k,v) 同get()，如果k不存在就插入一个k项，值为None或者v（如果给了v)

       d.fromkeys(s,v) 返回一个dict,它的键为序列s的项，值为None或者v(如果给了v)

       d.update(a) 用a更新d，如果键已存在则更新值，如不存在则插入。a可以是dict也可以是（key,value)对的一个iterable.

for

4、对字典的迭代

       对键：for key in d:    print(key)

              或：for key in d.keys():   print(key)

       对值：for value in d.values():     print(value)

       对键－值：for key,value in d.items():    print(key,value)

              或：for item in d.items():    print(item[0],item[1])

5、字典键的视图与项的视图支持一些类似于集合的操作（集合处的联合操作运算）

此可用in来查看某个键是否存在于dict，也可用联合操作运算查看特定集合的键是否存在于dict,如下：

d={}.fromkeys("ABCD",3);  s=set("ACX"); matches=d.keys()&s  #matches=={‘A‘,‘C‘}

6、字典内涵

{keyexpression:valueexpression for key ,value in terable}

{keyexpression:valueexpression for key ,value in terable if condition}

例：一个字典的键－值反转：inverted_d={v:k for k, v in d.items()}

7、默认字典（collectons.defaultdict())

默认字典永远不会产生KeyError,当查询的键不存在时，字典就会自动生成一个新的以此查询键为键的项，其值为创建字典时设定的默认值。

例：words=collections.defaultdict(int),新增入此字典的默认值就会是数字0。传入的int为工厂函数(也就是一个不带括号、没有参数的函数），以后可用lambda函数进行简单设置。

8、有序字典（collctions.OrderedDict())

字典的数据项以插入的顺序进行保存，如果用了一个无序的字典来进行update()，得到的结果也会变成无序的。

do=collections.OderedDict([(‘z‘,5),(3,6),(8,‘a‘)])或者先建一个空的，再一项一项的添加。

将一个普通字典转换成有序字典：d=collections.OderedDict(sorted(d.items()))。

四、组合数据的迭代与复制

1、常见迭代操作符与函数：

       s+t　　两个序列的连接；

       s*n　　返回n个s序列的连接的序列；

       x in s　　判断是否在内，not in;

       all(i)　　  如果iterable i中的每一项都评估为True,则返回True;

       any(i)　　如果任意一项为True，则返回True;

       enumerate(i,start)通常用于for...in循环，提供一个（index,item)元组序列，其中的索引起始值为0或start;{相当于将一个序列i折分成单个，并给每个一个序列号，用(index，item)，index为自动产生的序列号，item则依次为i每一项的值}

       len()　　 返回长度；

       max(i,key) 返回iterable i 中最大的项，如果给定的是key函数，就返回key(item)值最大的项；

       min(i,key)  同上；

       range(start,stop,step) 返回一个数字迭代子，左闭右开，如果没给start，则从0开始；

       reversed(i) 反转序列；

       sorted(i,key,reverse)   排序；reverse=True时进行逆序排列。当key存在时可以设置为需要的任意函数规则，甚至可以是自己构造的函数，如key=abs以绝对值排列，key=str.lower，以str中的lower()函数规则排序。sorted（）排序只适用于所有数据项都可以进行互相比较的组合类型，如果有不同的类型则会产生一个TypeError。

       sum(i,start)  求和，start为可选

       zip(i1,...,iN)　　返回元组的迭代子，使用迭代子i1到iN;i1-iN都是iterable数据组，例可参考dict的zip构造方式。只要有某个iterable中的元素用完，就终止迭代过程。

2、用a=iter(iterable结构）可以获取一个迭代子，在每次循环时可用next(a)方法获取下一个数据项，当结尾时会产生一个StopIteration异常。

3、组合数据类型的复制。

样：b="sudent",a=b   这样的用等号只是简单的将b的值赋给了a，但b的值"student"在系统内并没有被复制成2份，只是a和b都指向"student"这个值，无论是从a还是从b改变这个对象"student",另一个变量也会显示出改变后的结果。要想复制出一个"student"的副本则可以用加上类型名：a=str(b)；或者分片的方式a=b[:],因为提取分片时会产生一个副本。对于字典和集合类型则用copy()函数来实现。

       以上的方法都属于浅拷贝，因为它只会复制对象的第一层内容。如果对象中还存在可变的iterable对象，它拷贝的只是iterable对象的引用地址，如果iterable从原对象改变了，拷贝对象的iterable部分也会跟着改变。如嵌套的列表：[‘a‘,[‘b‘,‘c‘]],复制此对象[‘b‘,‘c‘]部分时只是复制的一个引用地址。 如果要对此对象进行完全的复制则需用到深拷贝，import copy;       a=copy.deepcopy(b)

4、位置常量命名一般方法：WATER,TREE,MONEY=range(1,4);那么这三个字符的值依次就为1，2，3

Python3组合数据类型（元组、列表、集合、字典）语法