【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'}