组合数据类型
5种内置的序列类型：bytearray,bytes,list,str,tuple
元组
元组：固定，有序，索引从0开始，分片，步距语法支持
不能替换或者删除其中的任意数据项，使用list()元组可以转换为list,之后就可以修改了
tuple在不指定参数时返回一个空元组
可以使用()创建空元组
在元组作为参数传递时必须加()避免歧义
元组提方法
t.count(x)返回x在元组中出现的次数；
t.index(x)返回x在元组t中出现的最左边位置，如果元组中不包含x，那么抛出ValueError异常
元组使用的操作符
+，*，[]，in ,not in ，+=,*=,(实际上创建了新元组)
<,<=,==,!=,>=,> 逐项进行比较
序列拆分
左边是元组，右边是序列，称为右边拆分，拆分用于交换值
>>> a,b=(1,2)
>>> a
1
>>> b
2
>>> a,b
(1, 2)
>>> a,b=(b,a)
>>> a,b
(2, 1)
for ...in...
>>> for x,y in ((1,2),(2,3),(3,4)):
print(x,y) 1 2
2 3
3 4
命名的元组
和普通元组一样，可以根据名称来引用元组中的项
collections.namedtuple(n,s)函数，该函数用于创建自定义的元组数据类型
第一个参数是想要创建的字符串元组名称
第二个参数是字符串，其中包含使用空格分隔的名称，每个名称代表该元组数据类型中的一项
列表
列表是包含0个或多个对象引用的有序序列，支持分片，步距
列表是可变的，可以进行删除，替换，插入
list()不带参数调用时返回一个空列表，带一个list参数时，返回该参数的浅拷贝，对任意多个参数，则尝试将给定的对象转换为列表。
列表可以使用[]创建
列表中所有数据项实际上都是对象引用，因此和元组一样。列表也可以存放任意类型的数据项。
列表可以使用比较操作符<,<=,==,!=,>=,> 逐项处理
列表方法
l.append(x) 将数据项x追加到列表l的尾部
l.count(x) 数据项x在列表中出现的次数
l.extend(x),l+=x 将迭代x追加到l尾部
l.index(x,start,end) 返回数据项x在列表中最左边出现的索引位置
l.insert(i,x)在索引位置int i处将数据项 x插入列表l
l.pop()返回并移除l中索引位置int i处的数据项
l.pop(i)返回并移除l中索引位置i处的数据项
l.remove(x)从list中移除最左边的数据项x，如果找不到x，产生ValueError异常
l.sort()对列表l进行排序，与内置的sorted()函数一样，这个方法可以接受可选的key与reverse
序列拆分
用于赋值操作符左边有两个或者多个变量时，其中的一个使用*进行引导，数据项赋值给该变量，而所有剩下的数据项赋值给带*的变量
>>> first,*second=[1,2,3,4,5]
>>> first
1
>>> second
[2, 3, 4, 5]
函数调用使用带*的参数
>>> def getadd(a,b,c):
return a+b+c >>> getadd(1,2,3)
6
>>> L=[1,2,3]
>>> getadd(*L)
6
del操作
del的作用是取消变量的引用
>>> a=1
>>> del a
*操作符是用作复制操作符还是拆分操作符并不会产生二义性，
当*出现在赋值操作的左边是，用作拆分操作符，若用作单值操作符，则代表拆分操作符，若用作二进制操作符，则代表复制操作
列表内涵
小列表通常使用列表字面值直接创建，但长一些的列表，对一系列系数我们可以使用 list(range(10)),或者如果只需要一个整数迭代，使用range()足够完成任务，但对更复杂一些的列表使用for...in...循环创建是一种常见的做法。
列表内涵是一个表达式，也是一个循环，该循环有一个可选的，包含在方括号中的条件，作用是为列表生成数据项，
并且可以使用条件过滤不需要的数据项
[item for item in iterable]
可以使用表达式，可以附加条件
[expression for item in iterable]
[expression for item in iterable if condition]
range(n)
>>> a=list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> leaps=[y for y in range(1900,1940) if y%4==0]
>>> leaps
[1900, 1904, 1908, 1912, 1916, 1920, 1924, 1928, 1932, 1936]
集合类型
set也是一种组合数据类型
支持成员关系操作符in，对象大小计算操作符len()，支持比较，支持逻辑操作
set分两种：可变的set，固定的frozenset
只有可哈希运算的对象可以增加到集合中，可哈希运算的对象包含一个__hash__()方法，返回值在某个对象的声明周期中都是相同的
并且可以使用__eq__()方法进行相等性比较
所有内置的固定数据类型都是可hash运算的(float,fozenset,int,str,tuple)
内置可变的数据类型都是不可hash运算的（dict,list,set）
集合是0个或多个对象引用的无序组合，集合是可变的，没有索引位置的概念，也不能分片或按步距分片
set() 不带参数进行调用返回一个空的set，带一个set参数时返回该对象的浅拷贝，对任意其他数据类型尝试进行转换
空集合必须使用set()创建
集合中包含的数据项都是独一无二的，增加重复的数据项固定不会引发问题，但是毫无意义
>>> s=set("apple")
>>> s1=set("aple")
>>> s==s1
True
集合常用语删除重复项
>>> x=list(set("apple"))
>>> x
['p', 'a', 'e', 'l']
集合支持 len(),也支持in，not in
s.add(x) 将数据项x增加到集合s中，若果s中尚未包含x
s.clear() 移除集合s中的所有项
s.copy() 返回集合s的浅拷贝
s.difference(t)s-t 返回一个新集合，其中包含在s中但不在集合t中的所有数据项
s.differecnce_update(t)s-=t 移除每一个在集合t但不在集合s中的项
s.discard(x)如果数据项x存在于集合s中，就移除该数据项
s.intersection(t)s&t返回一个新集合，其中包含所有同时包含在集合t与s中的数据项
s.intersection_update(t)s&=t使得集合s包含自身与集合t的交集
s.isdisjoint(t)如果s与t没有相同项，返回true
s.issubset(t)s<=t如果集合s与集合t相同，或者是t的自己，就返回true,使用s<t可以测试 s是否是t的真子集
s.issuperset(t)s>=t如果集合s与集合t相同，或者是t的超集,返回true，使用s>t可以测试t是否是s的真子集
s.pop（）返回并移除集合s中一个随即项，如果s为空集，就产生KeyError异常
s.remove(x) 从集合s中移除数据项x，如果s中不包含x就产生KeyError异常
s.symmetric_difference（t）s^t返回一个新集合，其中包含s与t中的每一个数据项，但不包含相同项
s.symmetric_difference_update（t）s^=t使得集合s只包含其自身与集合t的对称差
s.union(t) s|t返回一个新集合，其中包含集合s中的所有数据项一级在t中而不在s中的数据项
s.update(t) s|=t 将集合t中每个s中不包含的数据项都增加到集合s中
集合类型的一个常用场景是进行快速的成员关系测试。
>>> x={"192.168.1.1","192.168.1.2"}
>>> x
{'192.168.1.1', '192.168.1.2'}
>>> '192.168.1.1' in x
True
>>> s=sorted(set("apple"))
>>> s
['a', 'e', 'l', 'p']
集合的内涵
除调用set()创建集合，或使用集合字面值创建集合外，我们可以使用集合内涵来创建集合。
集合内涵是一个表达式，也是一个带有条件的循环，与列表内涵类似
{expression for item in iterable}
{expression for item in iterable if condition}
我们可以使用上面的语法来过滤
html={x for x in files if x.lower().endswith((".html",".htm"))}
固定集合
固定集合是指一旦创建就不能改变的集合，固定集合智能使用frozenset()数据类型函数进行创建
不带参数创建换一个空的固定集合，带一个forzenset参数，返回参数的浅拷贝，对任意其他数据项都尝试将给定的数据项转换为一个frozenset.该函数智能接受一个参数
由于固定集合是固定不变的，因此其支持的方法与操作符所产生的结果都不能影响固定集合本身
frozenset.copy()，frozenset.difference(),forzenset.intersection(),frozenset.union()
frozenset.symmetric_difference()
如果将二元运算符应用于集合与固定集合，那么产生结果的数据类型与左边操作数的数据类型一直。
由于固定集合的固定不变性，使得其满足集合项的可哈希运算的标准，因此，集合与固定集合都可以包含固定集合
映射类型
映射是键值数据项的组合，并且提供了存取数据项及其键，值的方法。进行迭代时，映射类型以任意顺序提供其数据项。
两种无序的映射：内置的dict类型，collections.defaultdict，collections.OrderedDict（有序字典）
只有可hash的对象可用做字典的键（float,frozenset,int,str,tuple）都可以用作字典的键
字典
dict是一种无序的组合数据类型，包含0或多个键值对。
键可hash，值可任意类型
字典是可变的
字典是无序的
空的{会创建空字典}
>>> d=dict({"name":"hiuyeung","age":18})
>>> d={"name":"hiuyeung","age":18}
>>> d=dict(name="hiuyeung",age=18)
>>> d=dict([("name","hiuyeung"),("age",18)]) >>> d=dict(zip(("name","age"),("hiuyeung",18)))
del
>>> del d['age']
>>> d
{'name': 'hiuyeung'}
d.clear()从dict d中移除所有项
d.copy()返回dict d的浅拷贝
d.fromkeys(s,v),返回一个dict该字典的键为序列s中的项，值为None或者v
d.get(k)返回键k相关联的值，如果k不在dict d中就返回None
d.get(k,v)返回k相关联的值，如果k不在dict d中就返回v
d.items()返回dict d中所有（key,value）对的视图
d.keys()返回d中所有键的视图
d.pop(k) 返回k关联的值，并移除键为k的项，如果k不包含在d中就产生keyError异常
d.pop(k,v)返回k关联的值，并移除键为k的项，如果k不包含在d中就返回v
d.pop(item)返回并移除dict d中一个任意的(key,value)，如果d为空就产生keyError异常
d.setdefault(k,v)与dict.get()方法一样，不同在于，如果k没有包含在dict d中就插入一个键为k的新乡，其值为v或None
d.update(a)将a中每个尚未包含在dict d中的key，value对增加到d，对同事包含在d与a中的每个键，使用a中对应的值d中对应的值，a可以是字典，可以是（key,value）对的一个iterable
d.values() 返回dict d中所有的值视图
字典的内涵
字典的内涵是一个表达式，同时也是一个循环，该循环带有一个可选的条件，与集合内涵非常类似。
{keyexpression:valueexpression for key,value in iterable}
{keyexpression:valueexpression for key,value in iterable if condition}
有序字典
collections.OrderedDict 有序字典以数据项插入的顺序进行存储
创建有序字典时使用了无序字典，那么有序字典的顺序是任意的