python常见复合类型基础

文章发布时间:

最后更新时间:

文章总字数:
3.2k

预计阅读时间:
15 分钟

一.列表

  • 列表中可以填充各种类型的数据，且可以同时存在于一个列表中，包括可以包含几个列表。

  • 列表中的数据有顺序、有下标。

1.1 列表创建

1
2
3
4
5
6
7
8
9
10
11
#创建空列表
a = list()
print(a)
 
#创建列表
b = list([1,2,3])
print(b)
 
#创建字符列表
c = list('abc')
print(c)    
[]
[1, 2, 3]
['a', 'b', 'c']

总结：只要可以取下标，就可以传入列表。

1.2 列表运算

  • 与字符串基本相似，可以根据字符串运算参考。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#列表合并
a = [100,200,300]
b = [400,500,600]
c = a + b
print(c)
 
#列表累乘（累乘必须乘以正整数,2.0这类也不可以）
a = [1,2]
b = a * 3
print(b)
 
#加等,即源式加后面的式子
a = [1,2,3]
a+=[4,5,6]
print(a)
 
#乘等，同理
a = [1,2,3]
a*=3
print(a)
 
#判断是否包含，同理于字符串
a = [1,2,3,4,5,6]
print(1 in a)
[100, 200, 300, 400, 500, 600]
[1, 2, 1, 2, 1, 2]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 1, 2, 3, 1, 2, 3]
True

1.3 列表基本访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#下标访问简单列表元素
a = [1,2,3,4,5]
print(a[0])
 
#切片访问列表元素（这里切片出来是一个列表，因为其本身就是一个列表）
a = [1,2,3,4,5]
print(a[1:3])
 
#多重列表
a = [[1,2,3],
     [4,5,6],
     [7,8,9]]
 
#取了第二个列表，然后取了其第一个元素
print(a[1][0])
 
#取了前两个列表
print(a[0:2])
 
#取了前两个列表，然后取了第一个列表
print(a[0:2][0])
 
#取了前两个列表，然后取了第一个列表，然后取了第一个元素
print(a[0:2][0][0])
1
[2, 3]
4
[[1, 2, 3], [4, 5, 6]]
[1, 2, 3]
1

1.4 列表添加元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#增
x = [1,2,3]
x.append(4)
print(x)
 
#插入
x = [1,2,3]
x.insert(1,4)
print(x)
 
#增可迭代对象
x = [1,2,3]
x.extend([4,5,6])
print(x)
[1, 2, 3, 4]
[1, 4, 2, 3]
[1, 2, 3, 4, 5, 6

扩展：id（）函数的运用

其可以查看一个变量保存的数据地址.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#列表append
 
x = [1,2,3]
print(id(x))
 
x.append(4)
print(id(x))
 
#列表相加
 
a = [1,2,3]
print(id(a))
 
b = [4,5,6]
a = a + b
 
print(id(a))
2278015630464
2278015630464
2277993865920
2278015819136

  

1.5 修改元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#在列表下标范围内选元素修改
 
a = [1,2,3,4,5]
a[3] = 100
print(a)
 
#切片赋值
 
#超出范围
a = [1,2,3,4,5]
a[4:100] = [1,2]
print(a)
 
a = [1,2,3,4,5]
a[1:3] = [100,200]
print(a)
[1, 2, 3, 100, 5]
[1, 2, 3, 4, 1, 2]
[1, 100, 200, 4, 5]

总结：若只修改一个元素，必须在列表序列范围内。若用切片修改数据，可以超出范围，但必须是可迭代对象且符合条件。

1.6 删除方法

  • remove是直接删除列表内所含元素值，
  • pop是删除列表内指定位置的元素，
  • clear是清空列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#remove方法
a = [1,2,3,4,5,6,7,8,9,10]
a.remove(1)
print(a)
 
#pop方法
a = [1,2,3,4,5,6,7,8,9,10]
a.pop(0)
print(a)
 
#clear方法
a = [1,2,3,4,5,6,7,8,9,10]
a.clear()
print(a)
 
#后期方法del
a = [1,2,3,4,5,6,7,8,9,10]
del a[0]
print(a)
 
#直接删除变量
del a
print(a)
[2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 3, 4, 5, 6, 7, 8, 9, 10]
[]
[2, 3, 4, 5, 6, 7, 8, 9, 10]

NameError: name 'a' is not defined

1.7 列表常见API

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#len（）
a = [1,2,3,4,5]
print(len(a))
 
#max（）
a = [1,2,3,4,5]
print(max(a))
 
#min（）
a = [1,2,3,4,5]
print(min(a))
 
#list（sep）,转元组为列表
a = (1,2,3,4,5)
print(list(a))
5
5
1
[1, 2, 3, 4, 5]

扩展API

1
2
3
#index()索引一个元素的第一个下标
a = [1,2,3,4,5]
print(a.index(3))
2

二.元组

2.1 元组基本属性

  • 元组中的元素一般不可变动，较列表不同。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#空元组
x = ()
print(x)
 
#元组切片
x = (1,2,3,4)
print(x[1:7])
 
#单个数据的元组
x = (1,)  
print(x)
print(type(x))
 
#注意，元组中只有一个元素时，必须加逗号
y = (1)
print(type(y))
 
#不加括号的元组
x = 1,2,3,'hello'
print(x)
()
(2, 3, 4)
(1,)
<class 'tuple'>
<class 'int'>
(1, 2, 3, 'hello')

2.2 创建元组

1
2
3
4
5
6
x = tuple()
print(x)
 
#也得是可迭代对象
a = tuple(range(10))
print(a)
()
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

由于元组不可变，所以只能删除整个变量，不能对其中元素操作。

1
2
3
4
5
6
7
8
9
10
11
12
#元组切片
x = (1,2,3,4)
print(x[1:7])
 
#元组解包
x = (1,2,3,4)
a,b,c,d = x
print(a,b,c,d)
 
#常用于结构赋值
a,b = (1,2)
print(a,b)
(2, 3, 4)
1 2 3 4
1 2

2.4 元组运算

元组虽不可变，但其可以进行叠加，原元组不变，可合并为一个新元组。

1
2
3
4
5
6
7
8
9
10
#加法
a = (1,2)
b = (3,4)
c = a + b
print(c)
 
#乘法
a = (1,2)
b = a * 3
print(b)
(1, 2, 3, 4)
(1, 2, 1, 2, 1, 2)

2.5 元组常用API

参考列表操作，包括index（）也一样，只有最后的转列表为元组有区别，方法为tuple()。

1
2
3
4
5
#count方法,列表与元组皆有
a = (1,2,3)
b = [1,1,2]
print(a.count(1))
print(b.count(1))
1
2

三.字典

3.1 字典简介

  • 字典是可变容器{}
  • 字典的数据是无序的
  • 字典由键值对构成，键实际就相当于下标

3.2 字典创建

1
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
#数字也可以作为键
a = {1:2,2:3}
print(a)
print(type(a))
 
#也可以嵌套字典
a = {1:2,2:{1:2,2:3}}
print(a)
 
#变量可以作为键
x = 'hello'
y = 1
a = {x:1,y:2}
print(a)
 
#重复的键会以最后一个键值对为准
a = {1:2,1:3}
print(a)
 
#dict函数，等号前为键，后为值
a = dict(a=1,b=2,c=3)
print(a)
 
b = dict([[1,2],[3,4]])
print(b)
 
c = dict([[1,2]])
print(c)
{1: 2, 2: 3}
<class 'dict'>
{1: 2, 2: {1: 2, 2: 3}}
{'hello': 1, 1: 2}
{1: 3}
{'a': 1, 'b': 2, 'c': 3}
{1: 2, 3: 4}
{1: 2}

注意：使用dict（）时需要括号内的数据成对出现，因为要组成键值对。

3.3 字典基本操作

  • in 与not in用来表示一个键是否在字典中
  • 可以向列表、元组一样通过”键”下标来访问字典中的值

3.4 字典常用API

1
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
# 查看字典长度,即键值对个数
a = {'name':'zhangsan','age':18,'sex':'male'}
print(len(a))
 
# str()把字典[字面量]变为字符串,网络传输常把这种字符串（json）传输
a = {'name':'zhangsan','age':18,'sex':'male'}
print(str(a),type(str(a)))
 
# 清空字典
a = {'name':'zhangsan','age':18,'sex':'male'}
a.clear()
print(a)
 
#浅复制
a = {'name':'zhangsan','age':18,'sex':'male'}
b = a.copy()
print(b)
 
#访问键值对 get(key,x),x为找不到键时的返回值，默认为None
a = {'name':'zhangsan','age':18,'sex':'male'}
print(a.get('name'))
print(a.get('address','not found'))
 
# 以列表返回一个视图(可迭代)对象，即一个一个打包的键值对 items()
a = {'name':'zhangsan','age':18,'sex':'male'}
print(a.items(),type(a.items()))
 
# 返回一个键的迭代器 keys()
a = {'name':'zhangsan','age':18,'sex':'male'}
print(a.keys(),type(a.keys()))
 
# 返回一个值的迭代器 values()
a = {'name':'zhangsan','age':18,'sex':'male'}
print(a.values(),type(a.values()))
 
# 更新整个字典 update()，类似append和extend
a = {'name':'zhangsan','age':18,'sex':'male'}
b = {'address':'beijing','phone':'123456789'}
a.update(b)
print(a)
 
# 删除字典中的键值对 pop(key,x),x为找不到键时的返回值，默认为None
a = {'name':'zhangsan','age':18,'sex':'male'}
print(a.pop('name'))
print(a.pop('address','not found'))
3
{'name': 'zhangsan', 'age': 18, 'sex': 'male'} <class 'str'>
{}
{'name': 'zhangsan', 'age': 18, 'sex': 'male'}
zhangsan
not found
dict_items([('name', 'zhangsan'), ('age', 18), ('sex', 'male')]) <class 'dict_items'>
dict_keys(['name', 'age', 'sex']) <class 'dict_keys'>
dict_values(['zhangsan', 18, 'male']) <class 'dict_values'>
{'name': 'zhangsan', 'age': 18, 'sex': 'male', 'address': 'beijing', 'phone': '123456789'}
zhangsan
not found

四.集合

4.1 集合基本介绍

集合分set和固定集合frozenset

set的元素值必须是不可变的，不能存储 list、dict 等可变类型。

  • 集合是可变的容器，固定集合是不可变的集合
  • 集合内的数据绝对不同

4.2 集合创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#set()创建
a = set([1,2,3,4,5])
print(a,type(a))
 
#空集合 注意：空集合创建必须用set()，不能用{}
a = set()
b = {}
print(a,type(a))
print(b,type(b))
 
#与列表的联合应用,set()是允许里面是列表的
a = [1,2,3,4,5,6,1,2,2,3]
b = set(a)
print(b)
{1, 2, 3, 4, 5} <class 'set'>
set() <class 'set'>
{} <class 'dict'>
{1, 2, 3, 4, 5, 6}

来三个容易绕住你的问题 >V<

1
2
3
4
5
6
7
8
9
10
11
# a里有几个数据
a = {(10,20,30),(20,10,30)}
print(a)
 
# a中数据是什么
a = {(10),(10)}
print(a)
 
# a中数据该怎么写
a = {(10,),(10,)}
print(a)
{(20, 10, 30), (10, 20, 30)}
{10}
{(10,)}

总结：
一定要把基础学牢，前面的东西要学会

4.3 集合操作

1
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
#添加元素
a = {1,2,3}
a.add(4)
print(a)
 
#update()添加多个元素,实际为添加容器,不管是列表还是元组都会被取出数据传入
a = {1,2,3}
a.update([4,5,6],(7,8,9))
print(a)
 
#remove()删除元素，如果元素不存在，会报错
a = {1,2,3}
a.remove(1)
print(a)    
 
#discard()删除元素，如果元素不存在，不会报错
a = {1,2,3}
a.discard(4)
print(a)
 
'''
pop()对集合某种排序（有但不清楚，所以其实是固定排序），删除第一个元素并显示，如果集合为空，会报错
方便记的,pop()就是随机删除一个元素并显示
'''
a = {1,2,3}
b = a.pop()
print(a)
print(b)
{1, 2, 3, 4}
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{2, 3}
{1, 2, 3}
{2, 3}
1

注:尽管集合无序，但可以用for循环来遍历集合

4.4 判断集合是否含某元素

1
2
3
4
5
a = {1,2,3}
print(2 in a)
 
b = {1,2,3,4,5}
print(3 not in b)
True
False

4.5 集合常用API

1
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
# 添加元素
 
a = {1,2,3}
a.add(4)
print(a)
 
# 清空集合
 
a = {1,2,3}
a.clear()
print(a)
 
# 拷贝
 
a = {1,2,3}
b = a.copy()
print(b)
 
# 返回差集
 
a = {1,2,3}
b = {2,3,4}
 
print(a.difference(b))
print(a)
 
 
# 返回差集并删除该集合其他元素
 
a = {1,2,3}
b = {2,3,4}
a.difference_update(b)
print(a)
print(b)
 
 
# 返回交集
 
a = {1,2,3}
b = {2,3,4}
print(a.intersection(b))
 
# 返回交集并删除该集合其他元素
a = {1,2,3}
b = {2,3,4}
a.intersection_update(b)
print(a)
print(b)
 
# 判断两个集合是否完全不同
 
a = {1,2,3}
b = {2,3,4}
print(a.isdisjoint(b))
 
# 判断前集合是否为后集合子集
 
a = {1,2,3}
b = {2,3}
print(a.issubset(b))
 
# 判断后集合是否为前集合子集
 
a = {1,2,3}
b = {2,3}
print(a.issuperset(b))
 
# 返回俩集合不重复的元素，I为并集，即 U-I
a = {1,2,3}
b = {2,3,4}
print(a.symmetric_difference(b))
print(a)
 
# 返回俩集合不重复的元素，删除其他元素
a = {1,2,3}
b = {2,3,4}
a.symmetric_difference_update(b)
print(a)
 
# 返回俩集合的并集
a = {1,2,3}
b = {2,3,4}
print(a.union(b))
 
# 看集合长度
a = {1,2,3}
print(len(a))
{1, 2, 3, 4}
set()
{1, 2, 3}
{1}
{1, 2, 3}
{1}
{2, 3, 4}
{2, 3}
{2, 3}
{2, 3, 4}
False
False
True
{1, 4}
{1, 2, 3}
{1, 4}
{1, 2, 3, 4}
3
≡