【Python】第二章组合数据类型学习笔记

Python组合数据类型

概述

1. Python中常用的组合数据类型有列表、元组、字符串、字典、集合以及range等对象也支持很多类似的操作
2. 其操作相当于其他语言的数组，但功能更加强大。
3. 列表、元组、字符串支持双向索引。

推荐网址：可视化网站传送门

1-列表

有序可变，放在一对中括号中，并用逗号隔开。
自动扩展收缩，一个列表中的各种元素类型可以不同，甚至可以是其他组合数据类型以及自定义类型。

列表的创建与删除

1. 直接等号赋值
2. 用list()将元组、字符串、range对象等可迭代对象转化为列表
3. del删除

列表元素增加

1. +，本质是创建新列表然后复制，效率差，详见上述可视化网站。
2. append()，尾部追加，原地修改

列表元素删除

1. list.remove(),根据参数值删除，但是在需要删除整个列表多个元素时，删除一个后列表压缩会导致出错。
2. del list[i],i为索引。

切片

1. 两个冒号分隔三个数字，第一个数字表示切片开始位置（默认为0），第二个数字表示切片结束位置（但不包括，默认为列表长度），第三个数字表示切片步长（默认为1，默认时可省略第二个冒号）
2. 返回的是浅复制，即原列表不变。

列表排序

关于lambda表达式
lambda表达式可以声明匿名函数。也可以取名。用法如下：

>>> f=lambda x,y,z:x+y+z
>>> f(1,2,3)
6

1. list.sort(key,reverse)，原地排序。key值决定利用lambda表达式来决定排序规则，reverse决定正序或逆序。True为逆序，默认为正。
2. 内置函数sorted()，返回新列表，原列表不变
3. list.reverse()，原地逆序。
4. 内置函数reversed()，逆序排列，返回迭代对象。关于迭代对象以后会讲。

其他常用内置函数

1. len()，返回列表元素个数
2. max(),min()，返回最大最小元素。
3. sum()，求和，对非数值型列表要指定start参数。用法如下

>>> sum(range(1,11)) #1到10求和
55
>>> sum(range(1,11),5) #start=5,相当于5+sum(range(1,11))
60

列表推导式

直接上例题。

1. 国王赏米，1粒开始，64格依次翻倍。

>>> sum([2**i for i in range(64)])
18446744073709551615

2. 筛选自然数

>>> lst=[-1,-4,6,7.5,-2.3,9,-11]
>>> [i for i in lst if i>0]
[6, 7.5, 9]

3. 有成绩字典，算最高最低平均分，查找所有最高分同学

>>> average=sum(scores.values())/len(scores)
>>> scores={"Zhang San":45,"Li Si":78,"Wang Wu":40,
	"Zhao Liu":96,"Zhao Qi":97,"Sun Ba":90,
	"Zheng Jiu":78,"Wu Shi":99,"Dong Shiyi":60}
>>> higest=max(scores.values())
>>> lowest=min(scores.values())
>>> average=sum(scores.values())/len(scores)
>>> higest,lowest,average
(99, 40, 75.88888888888889)
>>> higestPerson=[name for name,score in scores.items() if score==higest]
>>> higestPerson
[\'Wu Shi\']

4. 也可使用多个循环，或者使用函数或复杂表达式
5. 生成100以内素数

>>> [p for p in range(2,100) if 0 not in [p%d for d in range(2,int(p**0.5)+1)]]
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

2-元组

和列表类似，但属于不可变序列。一旦创建不能修改其元素。
定义方式和列表相同，放在一对圆括号当中。

元组的创建和删除

1. 等号赋值（包含一个元素的元组创建最后要加一个逗号）。
2. 使用tuple函数可以把其他序列转化为元组。
3. 可以索引和切片
4. del删除整个元组，不能删元素。

元组和列表的区别

1. 不允许更改，无法添加、删除元素，可以看作list()融化元组，tuple()冻结列表。
2. 速度比列表快，写保护更加安全，可用作字典的键，也可以作为集合的元素

序列解包

对多个变量同时赋值。用法如下。

x,y,z=1,2,3#多个变量同时赋值
v_tuple = (False, 3.5, \'exp\')
(x,y,z)=v_tuple
x,y,z =v_tuple
x,y,z = range(3)#可以对range对象进行序列解包
x,y,z = map(str, range(3)) #使用可迭代的map对象进行序列解包
a,b=b,a#交换两个变量的值
x, y, z = sorted([1, 3, 2])#sorted()函数返回排序后的列表
a, b, c =\'ABC\'#字符串也支持序列解包
x=[1,2,3,4,5,6]
x[:3] = map(str, range(5))#切片也支持序列解包

对于列表和字典也有效

>>>s = {\'a\':1, \'b\':2, \'C\':3}
>>>b, c, d = s.items()
>>>b
(\'c\',3)
>>>b, c,d=s #字典不考虑顺序
>>>b
\'c\'
>>>b, c, d = s.values()
>>>print(b, c, d)
1 3 2

序列解包遍历多个序列

>>>keys = [\'a\', \'b\', \'C\', \'d\']
>>>values = [1, 2, 3, 4]
>>>for k, v in zip(keys, values):
	print((k，v), end=\' \')
(\'a\',1) (\'b\',2) (\'c\',3) (\'d\',4)

使用序列解包遍历enumerate对象

>>>x = [\'a\', \'b\',\'c\']
>>>for i, v in enumerate(x):
	print(\'The value on position {0} is {1}\' .format(i,v))
The value on position 0 is a
The value on position 1 is b
The value on position 2 is C
>>>aList = [1,2,3]
>>>bList = [4,5,6]
>>>cList = [7,8,9]
>>>dList = zip(aList, bList, cList)
>>>for index, value in enumerate( dList):
	print(index, \':\' , value)
0 : (1,4,7)
1 : (2,5,8)
2 : (3,6,9)

python 3.5支持下列方法解包

>>>print(*[1,2,3],4,*(5,6))
1 2 3 4 5 6
>>>*range(4),4
(0,1,2,3,4)
>>>{*range(4),4,*(5,6,7)}
{0,1,2,3,4,5,6,7}
>>>{\'x\':1,**{\'y\':2}}
{\'y\':2,\'x\':1}

内置函数zip

把多个可迭代的对象中的元素压缩到一起，返回一个可迭代的zip对象。

生成器推导式

惰性求值，可用生成器对象的__next__()方法或内置函数next()进行遍历，也可以转化为列表或元组，或者直接将其作为迭代器对象。

g=((i+2)**2 for i in range(10))

3-字典

无序可变，键和值用冒号分隔，元素之间用逗号分割，所有元素放在一对大括号中。字典中的键可以为任意不可变数据。
global()返回包含当前作用域内所有全局变量和值的字典
locals()返回包含当前作用域内所有局部变量和值的字典

字典的创建与删除

• 使用 = 将一个字典赋值给一个变量

>>> a_dict = {\'server\': \'db.diveintopython3.org\', \'database\': \'mysql\'}
>>> a_dict
{\'database\': \'mysql\', \'server\': \'db.diveintopython3.org\'}
>>> x = {} #空字典
>>> x
{}

• 使用dict利用已有数据创建字典

>>> keys = [\'a\', \'b\', \'c\', \'d\']
>>> values = [1, 2, 3, 4]
>>> dictionary = dict(zip(keys, values))
>>> dictionary
{\'a\': 1, \'c\': 3, \'b\': 2, \'d\': 4}
>>> x = dict() #空字典
>>> x
{}

• 使用dict根据给定的键、值创建字典

>>> d = dict(name=\'Bob\', age=23)
>>> d
{\'age\': 23, \'name\': \'Bob\'}

• 以给定内容为键，创建值为空的字典

>>> adict = dict.fromkeys([\'name\', \'age\', \'sex\'])
>>> adict
{\'age\': None, \'name\': None, \'sex\': None}

• 可以使用del删除整个字典

字典元素的读取

• 以键作为下标可以读取字典元素，若键不存在则抛出异常

>>> aDict = {\'name\':\'Bob\',\'age\':23}
>>> aDict[\'name\']
\'Bob\'
>>> aDict[\'tel\'] #键不存在，抛出异常
Traceback (most recent call last):
File "<pyshell#53>", line 1, in <module>
aDict[\'tel\']
KeyError: \'tel\'

• 使用字典对象的get方法获取指定键对应的值，并且可以在键不存在的时候返回指定值。

>>> print(aDict.get(\'tel\'))
None
>>> print(aDict.get(\'tel\', \'12345678\')) #返回指定值，没有增加字典元素
\'12345678‘
>>> aDict[\'tel\'] = aDict.get(\'tel\', \'12345678\') #增加一个键值对
>>> aDict[\'score\'] = aDict.get(\'score\',[])
>>> aDict[\'score\'].append(98)
>>> aDict[\'score\'].append(97)
>>> aDict
{\'age\': 23, \'score\': [98, 97], \'name\': \'Bob\', \'tel\': ‘12345678\'}

• 使用字典对象的items()方法可以返回字典的键、值对
• 使用字典对象的keys()方法可以返回字典的键
• 使用字典对象的values()方法可以返回字典的值

>>> aDict={\'name\':\'Bob\', \'sex\':\'male\', \'age\':23}
>>> for item in aDict.items(): #输出字典中所有元素
		print(item)
(\'age\', 23)
(\'name\', \'Bob\')
(\'sex\', \'male\')
>>> for key in aDict: #不加特殊说明，默认输出键
		print(key)
age
name
sex
>>> for key, value in aDict.items(): #序列解包用法
		print(key, value)
age 23
name Bob
sex male
>>> aDict.keys() #返回所有键
dict_keys([\'name\', \'sex\', \'age\'])
>>> aDict.values() #返回所有值
dict_values([\'Bob\', \'male\', 23])

字典元素的添加与修改

• 当以指定键为下标为字典赋值时：1）若键存在，则可以修改该键的值；2）若不存在，则表示添加一个键、值对。

>>> aDict[\'age\'] = 37 #修改元素值
>>> aDict
{\'age\': 37, \'name\': \'Bob\', \'sex\': \'male\'}
>>> aDict[\'address\'] = \'Wenzhou\' #增加新元素
>>> aDict
{\'age\': 37, \'address\': \'Wenzhou\', \'name\': \'Bob\', \'sex\': \'male\'}

• 使用字典对象的update()方法将另一个字典的键、值对添加到当前字典对象。

>>> aDict
{\'age\': 37, \'score\': [98, 97], \'name\': \'Bob\', \'sex\': \'male\'}
>>> aDict.items()
dict_items([(\'age\', 37), (\'score\', [98, 97]), (\'name\', \'Bob\'), (\'sex\', \'male\')])
>>> aDict.update({\'a\':\'a\',\'b\':\'b\'})
>>> aDict
{\'a\': \'a\', \'score\': [98, 97], \'name\': \'Bob\', \'age\': 37, \'b\': \'b\', \'sex\': \'male\'}

• 使用del删除字典中指定键的元素

>>> del aDict[\'tel\']

• 使用字典对象的clear()方法来删除字典中所有元素

>>> aDict.clear()

• 使用字典对象的pop()方法删除并返回指定键的元素

>>> aDict.pop(\'name\')

• 使用字典对象的popitem()方法删除并返回字典中的一个元素

>>> aDict.popitem()

字典应用案例

• 已知有一个包含一些同学成绩的字典，计算成绩的最高分、最低分、平均分，并查找所有最高分同学。

>>> scores = {"Zhang San": 45, "Li Si": 78, "Wang Wu": 40,
"Zhou Liu": 96,"Zhao Qi": 65, "Sun Ba": 90,
"Zheng Jiu": 78, "Wu Shi": 99,"Dong Shiyi": 60}
>>> highest = max(scores.values())
>>> lowest = min(scores.values())
>>> average = sum(scores.values())*1.0/len(scores)
>>> highest, lowest, average
99 40 72.33333333333333
# 对字典，如何从值找到键？
>>> highestPerson = [name for name, score in scores.items()
if score == highest]
>>> highestPerson
[\'Wu Shi\']

• 首先生成包含1000个随机字符的字符串，然后统计每个字符的出现次数。

>>> import string
>>> import random
>>> x = string.ascii_letters + string.digits\
+ string.punctuation
>>> y = [random.choice(x) for i in range(1000)]
>>> z = \'\'.join(y)
>>> d = dict() #使用字典保存每个字符出现次数
>>> for ch in z:
d[ch] = d.get(ch, 0) + 1 #这里如果使用 d[ch] = d[ch]+1 会怎样？

补充：jieba库的使用

函数	描述
jieba.cut(s)	精确模式，返回一个可迭代的数据类型
jieba.cut(s, cut_all=True)	全模式，输出文本s中所有可能单词
jieba.cut_for_search(s)	搜索引擎模式，适合搜索引擎建立索引的分词结果
jieba.lcut(s)	精确模式，返回一个列表类型，建议使用
jieba.lcut(s, cut_all=True)	全模式，返回一个列表类型，建议使用
jieba.lcut_for_search(s)	搜索引擎模式，返回一个列表类型，建议使用
jieba.add_word(w)	向分词词典中增加新词w

>>>import jieba
>>>jieba.lcut("中华人民共和国是一个伟大的国家")
[\'中华人民共和国\', \'是\', \'一个\', \'伟大\', \'的\', \'国家\']
>>>jieba.lcut("中华人民共和国是一个伟大的国家", cut_all=True)
[\'中华\', \'中华人民\', \'中华人民共和国\', \'华人\', \'人民\', \'人民共和国\', \'共和\', \'共和国\', \'国是\', \'一个\', \'伟大\', \'的\', \'国家\']
>>>jieba.lcut_for_search("中华人民共和国是一个伟大的国家")
[\'中华\', \'华人\', \'人民\', \'共和\', \'共和国\', \'中华人民共和国\', \'是\', \'一个\', \'伟大\', \'的\', \'国家\']

collections模块的Counter类介绍

• 使用collections模块的Counter类可以快速实现这个功能，并且提供更多功能，例如查找出现次数最多的元素。
• Counter返回counter对象，类似字典，不同于字典，可以用dict()函数转换为字典

>>> from collections import Counter
>>> frequences = Counter(z)
>>> frequences.items()
>>> frequences.most_common(1) #出现次数最多的一个字符
[(\'A\', 22)]
>>> frequences.most_common(3)
[(\'A\', 22), (\';\', 18), (\'`\', 17)]

内置函数filter()

• 内置函数filter()将一个单参数函数作用到一个序列上，返回该序列中使得该函数返回值为True的那些元素组成的filter对象，如果指定函数为None，则返回序列中等价于True的元素。

>>> seq = [\'foo\', \'x41\', \'?!\', \'***\']
>>> def func(x):
return x.isalnum() #测试是否为字母或数字
>>> filter(func, seq) #返回filter对象
<filter object at 0x000000000305D898>
>>> list(filter(func, seq)) #把filter对象转换为列表
[\'foo\', \'x41\']

字典推导式

>>> s = {x:x.strip() for x in (\' he \', \'she \', \' I\')}
>>> s
{\' he \': \'he\', \' I\': \'I\', \'she \': \'she\'}
>>> for k, v in s.items():
print(k, \':\', v)
he : he
I : I
she : she

>>> {i:str(i) for i in range(1, 5)}
{1: \'1\', 2: \'2\', 3: \'3\', 4: \'4\'}
>>> x = [\'A\', \'B\', \'C\', \'D\']
>>> y = [\'a\', \'b\', \'b\', \'d\']
>>> {i:j for i,j in zip(x,y)}
{\'A\': \'a\', \'C\': \'b\', \'B\': \'b\', \'D\': \'d\'}