python基础学习三——混合数据类型

一、元组
元组创建后即固定，不能动态修改，若想修改可用list()函数转为列表修改。创建可以调用tuple()函数或者直接创建。有时元组必须包含在括号里，以避免语义的二义性，例如将元组1，2，3传递给一个函数，则应该写成function((1,2,3))。元组只提供了两种方法，t.count(x)返回对象x在元组中出现的次数，t.index(x)返回元组中从左侧开始第一次出现x的位置，若元组不包含x，则产生ValueError异常。
组元可以使用操作符+、*、[]分片，或in 以及 not in来测试成员关系，增强型运算符也可以使用。
拆分序列可以用于交换值：

a,b = (b,a)

（1）命名的元组
通过collections提供的namedtuple()函数，创建自定义的元组数据类型。

import collectionssale = collections.namedtuple('sale','name price number')product1 = sale('LK',100,8)product1Out[169]: sale(name='LK', price=100, number=8)

函数collections.namedtuple()第一个参数为创建的元组的名称，第二个参数为字符串，定义元组的内容。
输出调用方式：

print('{0.name}  {0.price} {0.number}'.format(product1))LK  100 8

或

'{name}  {price} {number}'.format(**product1._asdict())Out[177]: 'LK  100 8'

或

"{0.product} {0.price} {0.number}".format(shoes)Out[5]: 'shoes 100 10'

二、列表
列表可以直接通过[]创建，或者调用list()函数，可以使用索引或者分片符操作。

任意可迭代的数据类型（元组，列表，字符串）都可以通过序列拆分操作符进行拆分，即。用于赋值操作符左边的两个或多个变量时，数据项将赋值给不带的变量，剩余的变量赋值给带*的变量。

one,*other = nameone,otherOut[30]: ('1111', ['kai',  'name1',  'name2',  'name3',  'wang',  'shi',  'xiong'])

带*的变量也可以作为参数传递。

迭代处理列表中的数据项：

for i in range(len(lst)):    print (lst[i])

(1)列表扩展：
方法一:

lstOut[36]: [1, 2, 3, 4, 5]lst += [6,7]lstOut[38]: [1, 2, 3, 4, 5, 6, 7]

方法二：

lst.extend([8,9])lstOut[40]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

(2)列表插入：
方法一：

lst[0:0] = [0]lstOut[42]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

方法二：

lst.insert(0,-1)

(3)列表数据项替换：
替换单个数据项:与上述添加的区别在于索引格式与冒号

lst[2] = 3

替换一定长度的数据项：

lst[1:4] = [5,4,3]

(4)列表内涵
列表内涵用来快速创建列表，列表内涵是一个表达式，也是一个循环，该循环可以有一个可选在、在方括号内部的条件，作用是为列表生成数据项，并且滤过不需要的数据项。列表内涵最简单的形式为如下两种：

lst = [expression for item in iterable]lst = [expression for item in iterable if condition]

实例一:

lst = [num for num in range(5)]print(lst)

实例二:

code = [s + z + c for s in 'MF' for z in 'SMLX' for c in 'BGW' if not(s == 'F' and z == 'X')]print(code)

三、集合
集合中的数据项的排列是无序的，包括set()与固定集合forzenset()。只有可哈希运算的对象可以添加到集合中，例如（float、frozenset、int、str、tuple）。可变数据类型都不是可哈希运算的。因为其哈希值会随着包含数据项的多少而变化，因此这些数据项不能添加到集合中。
注：哈希算法，是指将任意长度的二进制值映射为一个较短的固定长度的二进制值，如果原明文改变长度，则其哈希值将会改变。
集合是可变的，可以任意添加或删除数据项，并且集合中的数据项是唯一的，没有重复的数据项，因此集合常常用于删除重复的数据项。



可通过集合差别操作符删去集合中的数据项：

filname = set(filename) - {'name1','name2'}

（1）集合内涵
与列表内涵类似，见上文。
（2）固定集合
只能使用frozenset()创建，如果将二元运算应用于集合与固定集合，那么产生的数据类型与左边操作数的数据类型一致。
若f为固定集合，s为集合，f & s产生一个固定集合，s & f产生一个集合。

四、字典
dict是一种无序的组合数据类型，键是指向可哈希运算的对象的对象引用，值可以指向任意对象的对象引用。字典是可变的无序的。字典的创建方法如下几种：

d = dict({'name':'luo','age':10,'gender':'man'})d = dict(age = 10 , name = 'kai' , size = 3)d = dict([['age',10],['name','kai'],['size',3]])d = dict(zip(('id','name','age'),('112','long',10)))d = {'age': 10, 'name': 'kai', 'size': 3}

字典的键是独一无二的，因此如果重复添加键，则会产生覆盖效果。
添加或删除：

d['gender'] = 'man'

del(d['gender'])

迭代方式有如下几种：

for k in d:    print(k)

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

for key,value in d.items():    print(key,value)

for value in d.values():    print(value)

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

字典的键或项视图可以相互之间或与集合之间进行一些二值操作，v为字典视图，x为集合：

v & xv | xv ^ xv - x

（1）字典内涵
与列表内涵，集合内涵类似，格式如下：

{key:value for key,value in iterable}{key:value for key,value in iterable if condition}

file_size = {name:os.path.getsize(name) for name in os.listdir('.')}

（2）默认字典
存取字典时，如果一个键不存在，则创建该键并将值赋为默认值。
创建默认字典时，可以传入一个工厂函数，调用时，返回某种特定类型的对象，python所有的内置数据类型都可以作为工厂函数，工厂函数返回的值为默认值。

import collectionswords = collections.defaultdict(int)

如上，工厂函数为int()，默认值为整数0。
（3）有序字典
不要使用字典创建，或者使用update()。

五、组合数据类型的迭代与复制
（1）迭代
iterable数据类型每次返回其中的一个数据项，任意包含iter()方法的对象或任意序列都是一个迭代子。例如，列表，集合，元组，字典等。


在迭代子iter()进行迭代时，如果对象无法进行迭代就会产生一个TypeError异常，如果迭代完成，就会返回一个StopIteration异常。
使用for item in iterable实际上就是调用了iter(iterable)迭代子。
可以eumerate()函数以一个迭代子为参数，返回一个枚举对象，该对象可被看作一个迭代子，每次迭代时，返回一个二元组，二元组的第一项为迭代数（默认从零开始，可以使用start = 1，参数配置为从1开始。例如eumerate(iterable，start=1)）。
*操作符可以对iterable 进行拆分，例如可以对range()返回的迭代子进行拆分，例如function(1,2,3,4)为一个函数。

function(1,2,3,4)function(*range(1,5))

（2）组合
可以通过调用zip()函数，将来自两个或多个列表（或其他iterable）中的数据项进行组合，zip()的参数为一个或多个iterable，返回一个迭代子，该迭代子为一个元组，第一项为所有参数的第一项的组合，第二项为所有参数第二项的组合，只要有一个iterable的参数用完，就停止。

for item in zip(range(1,10,2),range(10,20,3),range(4,80,7)):    print(item)(1, 10, 4)(3, 13, 11)(5, 16, 18)(7, 19, 25)

（3）排序
reversed()函数与sort()函数能对迭代子进行排序，其中sort可以传递一个key参数，来指定对数据做一个预先处理再排序。

list(reversed(range(1,5)))Out[14]: [4, 3, 2, 1]

x = [-1,-2,-3,-4,0,9,8,7]sorted(x,key = abs)Out[17]: [0, -1, -2, -3, -4, 7, 8, 9]

（4）赋值
由于python使用对象引用，赋值操作符（=）,右边若为字面值，即数字，字符串。那么左边的操作数被置为一个对象引用，该对象引用将指向存放字面值的内存对象。如果赋值操作符右边为对象引用，那么左边的操作数将被设置为一个对象引用，并于右边的操作数指向相同的对象。若两个对象引用指向同一个内存对象，则对其中一个对象引用进行修改，会影响另一个对象引用的值。

first_list = [0,1,2,3,4,5]second_list = first_listsecond_listOut[25]: [0, 1, 2, 3, 4, 5]second_list[0] = 10first_list,second_listOut[27]: ([10, 1, 2, 3, 4, 5], [10, 1, 2, 3, 4, 5])

如果需要整个序列的副本，而不仅仅是对象引用，可以使用如下方法，但如下方法仅为浅拷贝，赋值的只是对象引用，而非数据本身。对于固定数据类型，比如数字与字符串，这与复制的效果是相同的，但是对于可变的数据类型，比如嵌套的组合类型，这意味着相关对象同时被原来的组合与复制得来的组合引用，如下代码展示了这一特点：
方法一:

third_list = first_list[:]third_list[0] = 11third_list,first_listOut[30]: ([11, 1, 2, 3, 4, 5], [10, 1, 2, 3, 4, 5])

方法二：

first_list = [[0,1,2],3,4,5]second_list = copy.copy(first_list)second_list[0][1] = 11first_list,second_listOut[47]: ([[0, 11, 2], 3, 4, 5], [[0, 11, 2], 3, 4, 5])

方法三：

first_list = [[0,1,2],3,4,5]second_list = list(first_list)second_list[1] = 11second_list[0][1] = 12first_list,second_listOut[52]: ([[0, 12, 2], 3, 4, 5], [[0, 12, 2], 11, 4, 5])

如果确实需要一个独立的副本，并且可以操纵任意的嵌套组合，则可以选择深拷贝。

import copyfirst_list = [[0,1,2],3,4,5]second_list = copy.deepcopy(first_list)second_list[0][1] = 12second_list[1] = 11first_list,second_listOut[58]: ([[0, 1, 2], 3, 4, 5], [[0, 12, 2], 11, 4, 5])

注：
固定数据类型：float、frozenset、int、str、tuple
可变数据类型：dict、list、set

WALDM