Python学习笔记(三)

组合数据类型

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 有序字典以数据项插入的顺序进行存储

创建有序字典时使用了无序字典，那么有序字典的顺序是任意的