1.列表
- 列表是python的内置可变序列，是包含若干元素的有序连续内存空间，用[ ]表示，列表可以和元组，字典等嵌套使用，可以增加删除元素，列表对象自动进行内存的扩展与收缩
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
a.append(6) #将元素x添加到列表尾部
print(a)
a.extend(a) #将列表L中所有元素添加至列表尾部
print(a)
a.insert(2,0) #在列表指定位置添加元素x，第一个是位置
print(a)
a.remove(0) #删除列表中首次出现的指定元素x
print(a)
a.pop() #删除并返回列表指定位置的元素，默认最后一个元素
print(a)
print(a.index(1)) #返回第一个值为x的元素下表,若不存在则抛出异常
print(a.count(6)) #返回指定元素x在列表中出现的次数
a.reverse() #对列表进行反转颠倒(前后移一颠倒)
print(a)
a.sort() #对列表进行排序
print(a)
b=a.copy() #返回列表的浅复制
print(b)
a.clear() #删除列表中所有元素，但保留列表对象
print(a)
``` python
>[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
[1, 2, 0, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]
0
1
[5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1]
[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6]
[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6]
[]
>* 列表的创建与删除
>1.可以使用list()函数将元组，range()对象，字符串等可迭代类型的数据转换为列表
>2.`range([start,] stop [,step])`第一个参数默认值为0，第二个参数表示终止值（不包括这个值），第三个表示步长（间隔）
>3.当列表不再使用时，最好用del命令删除列表，python删除该值
```python
a=list((3,5,7,9))
a
[3, 5, 7, 9]
list(range(1,10,2))
[1, 3, 5, 7, 9]
list("hello world")
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
del a
a
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
a
NameError: name 'a' is not defined- 列表元素的增加
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
a=a+[6]
a
[3, 4, 5, 6]
a.append(7)
a
[3, 4, 5, 6, 7]
id(a)
2173678801864
a=[1,2,3] #python中是基于值的内存管理方式，变量修改值时，并不是直接修改变量的值，而是指向新的内存
id(a) #重新定义首地址发生改变
2173679010184
b=[1,2,4]
a==b
False
id(a)==id(b)
False
id(a[0])==id(b[0]) # 两个列表中相同元素的首地址相同
True
id(a)
2173679010184
a.append(5) #append操作不改变首地址
id(a)
2173679010184
a.remove(5) #remove操作不改变首地址
a
[1, 2, 3]
id(a)
2173679010184
a[0]=5 #直接赋值，也不改变首地址
a
[5, 2, 3]
id(a)
2173679010184
a.extend([7,8,9]) #添加若干列表元素，首地址仍然不变
a
[5, 2, 3, 7, 8, 9]
id(a)
2173679010184- 除非必要尽量避免使用insert在中间插入元素，最好使用append和pop函数
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
id(a)
1255750488008
a=a*2 #列表乘法得到新列表其实是重新定义了一个列表，首地址发生改变
a
[1, 2, 3, 1, 2, 3]
id(a)
1255750562056
x=[[1,2,3]]*3 #当用*运算将列表重复创建时，并不创建元素的赋值，而是创建元素的引用，因此该变其中一个值时，相应的引用也会改变
x
[[1, 2, 3], [1, 2, 3], [1, 2, 3]]
x[0][0]=10
x
[[10, 2, 3], [10, 2, 3], [10, 2, 3]]
id(x[0][0])==id(x[1][0]) #这两个元素其实是一块内存
True；
```
> * 列表元素的删除
```python
>>>x = [1,2,1,2,1,2,1]
for i in x :
if i ==1:
x.remove(i)
x
[2, 2, 2]
x = [1,2,1,2,1,1,1] #列表有自动内存管理功能，当列表元素删除时，内存会自动收缩并移动使元素之间没有缝隙，元素的索引就改变了
for i in x:
if (i ==1):
x.remove(i)
x
[2, 1, 2, 1, 1, 1]
[2, 2, 1, 1, 1]
[2, 2, 1, 1]
[2, 2, 1]
#为解决删除重复元素这个问题，可以采用从后向前的顺序来删除
for i in range(len(x)-1,-1,-1): #len(x)-1 是最后一个元素下表，间隔-1
i
if(x[i]==1):
del x[i]
x
6
[1, 2, 1, 2, 1, 1]
5
[1, 2, 1, 2, 1]
4
[1, 2, 1, 2]
3
2
[1, 2, 2]
1
0
[2, 2]- 切片操作
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
list[ : : ] #第二个数字是终止下表
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17] #第三个是间隔（默认为1）
list[ : : -1]
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
list [ : : 2 ]
[3, 5, 7, 11, 15]
list [3 : : ]
[6, 7, 9, 11, 13, 15, 17]
list[3: 6: 1]
[6, 7, 9]
a = [1,2,3] #通过切片增加元素
a[len(a):]
[]
a[len(a):]=[4]
a
[1, 2, 3, 4]
a[ : 3]=[0]
a
[0, 4]
del a[ : 1] #切片删除元素
a
[4]- 列表排序
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import random
random.shuffle(a) #打乱顺序
a
[4, 6, 8, 7, 10, 3, 1, 9, 2, 5]
a.sort() # 升序排列
a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a. sort (reverse = True) #降序排列
a
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
sorted(a) #升序排列，返回新列表，原列表不变
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]- 简单的列表推导式
2
3
4
5
a
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[(x , y) for x in range(2) for y in range(3)]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]2.元组
- 元组属于不可变序列，一旦创建，用任何方法都不能修改元素的值，也无法增加或删除元素
- 元组的创建与删除
2
3
4
5
6
7
8
9
10
11
12
a
('a',)
a = ('a','b','z')
a
('a', 'b', 'z')
a = 1,2
a
(1, 2)
tuple('abcdef') #可以把其他类型的转化为元组
('a', 'b', 'c', 'd', 'e', 'f')
del a #删除整个元组- 元组和列表的区别：
tuple（）是冻结列表使其不可变，list（）是融化元组使其可变，使用元组可以是代码数据更安全，如果元组中包含列表，情况略有不同
2
3
4
5
6
7
8
9
10
11
12
13
x[0][0]=5 #可以对其中的列表进行列表的操作
x
([5, 2], 3)
x[0].append(8)
x
([5, 2, 8], 3)
x[0] = x[0] + [10] #但不能这样，元组不可改变
Traceback (most recent call last):
File "<pyshell#18>", line 1, in <module>
x[0] = x[0] + [10]
TypeError: 'tuple' object does not support item assignment- 序列解包
2
3
4
5
6
7
8
9
10
11
12
13
14
x,y,z
(1, 2, 3)
print(x,y,z)
1 2 3
keys = ['a','b','c']
values = [1,2,3]
for k , v in zip(keys,values): #zip（）是将多个列表或元组对应位置的元素结合成元组，并返回包含这些元组的列表
print(k,v) #使用序列解包可以很方便的同时遍历多个序列
a 1
b 2
c 3
list(zip(keys,values))
[('a', 1), ('b', 2), ('c', 3)]- 生成器推导式
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
g
<generator object <genexpr> at 0x0000015E92B34F10>
tuple(g)
(4, 9, 16, 25, 36, 49, 64, 81, 100, 121)
tuple() #所有元素访问元素结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象
()
g = ((i+2)**2 for i in range(10))
list(g)
[4, 9, 16, 25, 36, 49, 64, 81, 100, 121]
g = ((i+2)**2 for i in range(10))
g.__next__() #访问下一个元素
4
g.__next__()
9
g = ((i+2)**2 for i in range(10))
for i in g: #循环打印
print(str(i) + ',',end='')
4,9,16,25,36,49,64,81,100,121,3.字典
- 字典是“键值对”的无序可变序列，键和值用冒号分隔，所有元素放在大括号中，键是不可变数据，不能用列表、集合、字典作为字典的键，这些是可变序列，键不允许重复，值可以重复。
2
3
4
5
6
7
8
9
10
b = 'hello world.'
def demo():
a = 3
b = [1,2,3]
print('locals',locals()) #内置函数local（）返回包含当前作用域内所有的局部变量和值的字典
print('globals',globals()) #内置函数globals（）返回和查看当前作用域内所有的全局变量和值的字典
demo()
locals {'b': [1, 2, 3], 'a': 3}
globals {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'a': {1, 2, 3, 4, 5}, 'b': 'hello world.', 'demo': <function demo at 0x000001B02EDE51E0>}- 字典的创建与删除
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
a
{'a': 1, 'b': 2}
k = {'a','b'}
v = {1 ,2}
dictionary = dict(zip(k,v)) #dict()根据已有的数据快速创建字典
dictionary
{'a': 1, 'b': 2}
zip(k,v)
<zip object at 0x000001B02EDCA288>
list(zip(k,v))
[('a', 1), ('b', 2)]
tuple(zip(k,v))
(('a', 1), ('b', 2))
d = dict(name = 'wd' ,age = 18) #dict()根据给定的“键值对”来创建字典
d
{'name': 'wd', 'age': 18}
adict = dict.fromkeys(['name','age','sex']) #给定内容为“键”，创建值为空的字典
adict
{'name': None, 'age': None, 'sex': None}- 字典元素的读取
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
dic
{'name': 'wd', 'sex': 'male', 'age': 18}
dic['name'] #下表为键
'wd'
print(dic.get('address')) #使用get（）方法访问键对应的值
None
dic['score']=dic.get('score',[]) #get（）也可这样添加键值
dic
{'name': 'wd', 'sex': 'male', 'age': 18, 'score': []}
dic['score'].append(100) #使用列表方法添加元素
dic['score'].append(98)
dic
{'name': 'wd', 'sex': 'male', 'age': 18, 'score': [100, 98]}
for item in dic.items(): #items（）方法返回字典的“键值”对列表
print(item)
('name', 'wd')
('sex', 'male')
('age', 18)
('score', [100, 98])
for key in dic.keys(): #keys（）方法返回字典的键的列表
print(key)
name
sex
age
score
for key,value in dic.items():
print(key,value)
name wd
sex male
age 18
score [100, 98]
print(dic.keys())
dict_keys(['name', 'sex', 'age', 'score'])
print(dic.values()) #values（）方法可以返回字典的值的列表
dict_values(['wd', 'male', 18, [100, 98]])- 字典元素的添加与修改
2
3
4
5
6
7
8
9
10
11
dic
{'name': 'wd', 'age': 18}
dic['sex'] = 'male' #当以指定的‘键’为下标给字典赋值时，若键值存在，则表示修改值，若不存在，则表示添加一个键值对，添加一个新元素
dic
{'name': 'wd', 'age': 18, 'sex': 'male'}
dic.items()
dict_items([('name', 'wd'), ('age', 18), ('sex', 'male')])
dic.update({'a' :1,'b' : 2}) #使用update()方法是一次性将另一个字典的键值对全部添加到当前字典对象
dic
{'name': 'wd', 'age': 18, 'sex': 'male', 'a': 1, 'b': 2}- 字典应用案例—-统计数据
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import random
x = string.ascii_letters+string.digits+string.punctuation #添加元素字符串
x
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
y = [random.choice(x) for i in range(100)] #随机100个x中的元素
y
['D', '#', 'B', '4', '~', '9', 'B', 'F', 'i', 'b', '/', '~', '%', 'C', 'x', '3', '7', 'H', 'R', 'i', 'k', '-', 'K', '/', 'd', 'r', 'T', 'O', '4', '&', '/', 'l', 's', 't', "'", '?', 'o', '(', 'j', "'", 'R', 'F', '_', 'W', 'F', 'W', 'O', 'w', ']', 'j', 't', 'P', '1', 'k', 'w', ',', '|', '4', '|', '+', 'X', 'R', '3', '&', 'W', 'U', '3', '+', 'W', '6', '"', ']', 'X', '`', 'o', 'x', '<', '$', 'S', '_', '"', '-', 'Q', 'R', 'I', 'q', 'x', '[', '8', 'G', 'e', 'Q', 'i', '`', '7', 'd', 'u', 'A', '<', '%']
z =' '.join(y) #将列表转化成字符串
z
'D # B 4 ~ 9 B F i b / ~ % C x 3 7 H R i k - K / d r T O 4 & / l s t \' ? o ( j \' R F _ W F W O w ] j t P 1 k w , | 4 | + X R 3 & W U 3 + W 6 " ] X ` o x < $ S _ " - Q R I q x [ 8 G e Q i ` 7 d u A < %'
d = dict() #创建字典
for ch in z: #循环遍历
d[ch] = d.get(ch,0)+1 #如果有键，则在原来基础上+1，如果没有则创建键，并使值初始为0 + 1
d
{'D': 1, ' ': 99, '#': 1, 'B': 2, '4': 3, '~': 2, '9': 1, 'F': 3, 'i': 3, 'b': 1, '/': 3, '%': 2, 'C': 1, 'x': 3, '3': 3, '7': 2, 'H': 1, 'R': 4, 'k': 2, '-': 2, 'K': 1, 'd': 2, 'r': 1, 'T': 1, 'O': 2, '&': 2, 'l': 1, 's': 1, 't': 2, "'": 2, '?': 1, 'o': 2, '(': 1, 'j': 2, '_': 2, 'W': 4, 'w': 2, ']': 2, 'P': 1, '1': 1, ',': 1, '|': 2, '+': 2, 'X': 2, 'U': 1, '6': 1, '"': 2, '`': 2, '<': 2, '$': 1, 'S': 1, 'Q': 2, 'I': 1, 'q': 1, '[': 1, '8': 1, 'G': 1, 'e': 1, 'u': 1, 'A': 1}
from collections import defaultdict #也可使用collections的defaulydict类来实现该功能
frequences = defaultdict(int)
frequences
defaultdict(<class 'int'>, {})
>>> for item in z:
frequences[item]+=1
frequences.items()
dict_items([('D', 1), (' ', 99), ('#', 1), ('B', 2), ('4', 3), ('~', 2), ('9', 1), ('F', 3), ('i', 3), ('b', 1), ('/', 3), ('%', 2), ('C', 1), ('x', 3), ('3', 3), ('7', 2), ('H', 1), ('R', 4), ('k', 2), ('-', 2), ('K', 1), ('d', 2), ('r', 1), ('T', 1), ('O', 2), ('&', 2), ('l', 1), ('s', 1), ('t', 2), ("'", 2), ('?', 1), ('o', 2), ('(', 1), ('j', 2), ('_', 2), ('W', 4), ('w', 2), (']', 2), ('P', 1), ('1', 1), (',', 1), ('|', 2), ('+', 2), ('X', 2), ('U', 1), ('6', 1), ('"', 2), ('`', 2), ('<', 2), ('$', 1), ('S', 1), ('Q', 2), ('I', 1), ('q', 1), ('[', 1), ('8', 1), ('G', 1), ('e', 1), ('u', 1), ('A', 1)])
from collections import Counter #也可使用Collection类快速寻找出现次数最多的元素
frequences = Counter(z)
frequences.items
<built-in method items of Counter object at 0x0000026723A64F10>
frequences.most_common(1)
[(' ', 99)]
frequences.most_common(3)
[(' ', 99), ('R', 4), ('W', 4)]4.集合
- 集合是无序可变序列，与字典一样使用一对大括号，同一个集合的元素之间不允许重复，集合中每一个元素都是唯一的
- 集合的创建与删除
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a.add(6) #添加元素
a
{3, 5, 6}
set([1,2,3,4,5]) #将其他类型的数据转化为集合
{1, 2, 3, 4, 5}
set([0,1,2,0,2,1,3]) #若有重复元素，只保留一个
{0, 1, 2, 3}
a.pop() #删除一个元素 （此方法不能指定元素，不能带参数）
3
a
{5, 6}
a.remove(5) #删除指定元素
a
{6}- 集合操作
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
b={3,4,5,6,7,8,9,10}
a | b #并集
{3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 113}
a.union(b)
{3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 113}
a & b #交集
{8, 9, 10}
a.intersection(b)
{8, 9, 10}
a.difference(b) #差集
{113, 11, 12}
a - b
{113, 11, 12}
a.symmetric_difference(b) #对称差
{3, 4, 5, 6, 7, 11, 12, 113}
a ^ b
{3, 4, 5, 6, 7, 11, 12, 113}
a == b #判断比较两个集合的大小
False
a.issubset(b) #判断是否为子集
False5.内置方法sorted()
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
print(persons)
[{'name': 'Dong', 'age': 37}, {'name': 'Zhang', 'age': 40}, {'name': 'Li', 'age': 50}, {'name': 'Dong', 'age': 43}]
print(sorted(persons,key=lambda x:(x['name'],-x['age']))) #使用key，先按姓名的升序排序，再按年龄的降序排列
[{'name': 'Dong', 'age': 43}, {'name': 'Dong', 'age': 37}, {'name': 'Li', 'age': 50}, {'name': 'Zhang', 'age': 40}]
phonebook = {'Linda':'7750','Bob':'9345','Carol':'5834'}
from operator import itemgetter
sorted(phonebook.items(),key = itemgetter(1)) #按字典中元素值进行排序
[('Carol', '5834'), ('Linda', '7750'), ('Bob', '9345')]
sorted(phonebook.items(),key = itemgetter(0)) #按字典中元素键进行排序
[('Bob', '9345'), ('Carol', '5834'), ('Linda', '7750')]
gameresult = [['Bob',95.0,'A'],['Alan',86.0,'C'],['Mandy',83.5,'A'],['Rob',89.3,'E']]
sorted(gameresult,key = itemgetter(1,0)) #按分数升序，相同按姓名升序
[['Mandy', 83.5, 'A'], ['Alan', 86.0, 'C'], ['Rob', 89.3, 'E'], ['Bob', 95.0, 'A']]
sorted(gameresult,key = itemgetter(0,1)) #按姓名升序，相同按分数升序
[['Alan', 86.0, 'C'], ['Bob', 95.0, 'A'], ['Mandy', 83.5, 'A'], ['Rob', 89.3, 'E']]
sorted(gameresult,key = itemgetter(2,0)) #按等级升序，相同按姓名升序
[['Bob', 95.0, 'A'], ['Mandy', 83.5, 'A'], ['Alan', 86.0, 'C'], ['Rob', 89.3, 'E']]