版权声明:@Abby-YTJ https://blog.csdn.net/weixin_43564773/article/details/85998793
1. 组合数据类型概述
组合数据类型:包含一组数据且作为单一管理结构的数据类型
- 顺序性:一组数据以无序或有序方式组织
- 一致性:一组数据以相同或不同的类型组织
- 索引性:一组数据能否以及采用序号或自定义索引方式组织
Python组合数据类型:3大类7小类
- 集合(无序、非一致、无索引):可变集合(set)、不可变集合(frozenset)
- 序列(有序、非一致/一致、序号索引):元组、列表、字符串、字节串
- 字典(无序、非一致、自定义索引):字典
可变类型与不可变类型
- 可变类型:创建后值可以改变的类型,如:列表、字典等
- 不可变类型:创建后值不可以改变的类型,如:数值类型、字符/字节串、元组等。
可哈希性和hash()函数
- hash(x)函数返回x的一个哈希值
- 并不是所有类型都可以被哈希,不可变类型可以被哈希,例如数值类型、字符串、元组等
- 列表和字典等可变类型不能被计算哈希值
2. 集合类型
集合类型:一组数据的集合
- 无序:元素间没有顺序,因此要求元素不能相同,元素必须是不可变类型
- 非一致:元素类型可以不同
- 无索引:不能对某个元素进行定点索引,可以遍历或随机获取元素
可变集合类型、不可变集合类型
- 可变集合类型set():集合元素的个数可以不断增加或减少
- 不可变集合类型frozenset():集合创建后不可改变
A = {"c","s",123}
B = set("cscs123")
A - B
{123}
B - A
{'1', '2', '3'}
A = frozenset("cs123")
A
frozenset({'1', '2', '3', 'c', 's'})
3. 序列类型
3.1 序列类型基础
序列类型:一组数据的有序组合
- 有序:元素间存在顺序,因此,可以存在值相同的多个元素
- 非一致:元组和列表中元素类型可以不同
- 一致:字符串和字节串中元素类型必须相同
- 序号索引:采用正向递增或反向递减方式索引,根据序号精确访问单个元素
3.2 元组类型基础
元组类型:创建后一般不能被修改的序列类型
a = tuple("cscs101")
a
('c', 's', 'c', 's', '1', '0', '1')
b = 123,456
b
(123, 456)
3.3 列表类型基础
列表类型:创建后可以随时被修改的序列类型
a = list("cscs101")
a
['c', 's', 'c', 's', '1', '0', '1']
b = [123,456]
b
[123, 456]
3.4 序列的索引
正向递增或反向递减方式索引
a = ['c','s','c','s','1','0','1']
a[-2]
'0'
a[2]
'c'
4. 字典类型
4.1 字典类型基础
字典类型:一组包含映射关系的数据组合
- 无序:元素间不存在顺序,因此,字典所包含“键值对”元素不能相同
- 非一致:每个元素是一个键值对不,其键和值类型均可不同
- 自定义索引:键值对相当于对“值”建立了新的以“键”为方式的索引
4.2 字典类型定义
- 映射:一种键(索引)和值(数据)的对应
- 字典的自定义索引
d = {"中国":"北京","日本":"东京","英国":"伦敦"}
d
{'中国': '北京', '日本': '东京', '英国': '伦敦'}
d['中国']
'北京'
de = {};type(de)
dict
5. 集合类型的使用
5.1 集合类型的操作符
基本操作符(交并差补)
操作符 |
含义 |
示例 |
in |
元素判断 |
x in S |
not in |
元素判断 |
x not in S |
& |
集合的交集,返回一个新集合 |
S & T |
|
集合的并集,返回一个新集合 |
S | T |
- |
集合的差集,返回一个新集合 |
S - T |
^ |
集合的补集,返回一个新集合 |
S ^ T |
比较操作符
操作符 |
含义 |
示例 |
< |
真子集判断 |
S < T |
<= |
子集判断 |
S <= T |
> |
真子集判断 |
S > T |
>= |
真子集判断 |
S >= T |
== |
全相同判断 |
S == T |
!= |
不相同判断 |
S != T |
5.2 集合类型的函数
内置操作函数
函数 |
含义 |
示例 |
len(x) |
返回集合的元素个数 |
len(S) |
set(x) |
转换组合类型,创建一个集合 |
set([1,2,2,1,2,1)] |
5.3 集合类型的方法
集合元素的维护类方法
方法 |
含义 |
示例 |
.add(x) |
增加x到集合 |
S.add(x) |
.remove(x) |
删除S中元素x,如果x不存在,产生KeyError |
S.remove(x) |
.discard(x) |
删除S中元素x,如果x不存在,不报错 |
S.discard(x) |
.clear() |
删除S中所有元素 |
S.clear() |
.pop() |
随机返回S中一个元素,如果S为空,产生KeyError |
S.pop() |
.copy() |
复制集合S,产生一个副本 |
S.copy() |
集合间运算类方法
方法 |
含义 |
示例 |
.intersection(x) |
集合的交集,返回一个新集合 |
S.intersection(T) 不更新S |
.union(x) |
集合的并集,返回一个新集合 |
S.union(T) 不更新S |
.difference(x) |
集合的差集,返回一个新集合 |
S.difference(T) 不更新S |
.symmetric_difference() |
集合的补集,返回一个新集合 |
S.symmetric_difference(T) |
.intersection_updata(x) |
集合的交集,更新原集合 |
S.intersection_update(T) 更新S |
.update(x) |
集合的并集,更新原集合 |
S.update(T) |
.difference_update(x) |
集合的差集,更新原集合 |
S.difference_update(T) |
.symmetric_difference_update() |
集合的补集,更新原集合 |
S.symmetric_difference_update(T) |
集合间比较类方法
方法 |
含义 |
示例 |
.isdisjoint(x) |
无关判断,两个集合之间无共同元素则返回True |
S.isdisjoint(T) |
.issubset(x) |
子集判断,如果x是集合的子集则返回True |
S.issubset(T) |
.issuperset(x) |
超集判断,如果x是集合的超集则返回True |
S.issuperset(T) |
"p" in {"p","y",123}
True
{"p","y"} >= {"p","y",123}
False
ls = ["p","y","y","p",123]
s = set(ls)
s
{123, 'p', 'y'}
lt = list(s)
lt
[123, 'p', 'y']
6. 元组类型的使用
6.1 元组类型的操作符
基本操作符
操作符 |
含义 |
示例 |
in |
元素判断 |
1 in (1,2,3) |
not in |
元素判断 |
1 not in (1,2,3) |
+ |
连接多个元组,返回一个新元组 |
(1,2,3)+(4,5,6)+(7,8) |
* |
重复元组多次,返回一个新元组 |
(1,2,3)*3 |
比较操作符
- 按照顺序,逐个元素比较,只要元素比较得出True/False,则返回结果。比较时,元素要有可比性。
操作符 |
示例 |
结果 |
< |
(11,2)<(13,1) |
True |
<= |
(11,2)<=(11,1,2) |
False |
> |
(11,2)<(10,“abc”) |
True |
>= |
(11,2)>=(11,2) |
True |
== |
(11,2)==(11,2,1) |
False |
!= |
(11,2)!=(1,2) |
True |
6.2 元组类型的函数
内置操作函数
函数 |
含义 |
示例 |
len(x) |
返回元组的元素个数 |
len(S) |
tuple(x) |
转换组合类型,创建一个元组 |
tuple([1,2,2,1,2,1)] |
min(x) |
返回元组中最小的元素 |
min((1,1,1,2,2,2)) |
max(x) |
返回元组中最大的元素 |
max((1,1,1,2,2,2)) |
6.3 元祖类型的方法
- 元组类型无增删改查需求,只能索引、切片、查询和统计
方法 |
含义 |
示例 |
.index(x) |
返回元组中第一次出现x的位置 |
tp.index(x) |
.count(x) |
返回元组中出现x的总次数 |
tp.count(x) |
7. 列表类型的使用
7.1 列表类型的操作符
基本操作符
操作符 |
含义 |
示例 |
in |
元素判断 |
1 in [1,2,3] |
not in |
元素判断 |
1 not in [1,2,3] |
del |
删除列表元素或列表片段 |
del ls[2] 或 del[:-2] |
+ |
连接多个列表,返回一个新列表 |
[1,2,3]+[4,5,6]+[7,8] |
* |
重复列表多次,返回一个新列表 |
[1,2,3]*3 |
7.2 列表类型的函数
内置操作函数
函数 |
含义 |
示例 |
len(x) |
返回列表的元素个数 |
len(S) |
list(x) |
转换组合类型,创建一个列表 |
list((1,1,1,2,2,2)) |
min(x) |
返回列表中最小的元素 |
min([1,1,1,2,2,2]) |
max(x) |
返回列表中最大的元素 |
max([1,1,1,2,2,2]) |
7.3 列表类型的方法
列表的增删方法
方法 |
含义 |
示例 |
.append(x) |
在列表最后增加一个元素x |
ls.append(x) |
.insert(i,x) |
在列表第i位置增加元素x |
ls.insert(i,x) |
.extend(lt) |
在列表最后增加一个新列表 |
ls.extend(lt) |
.remove(x) |
删除列表中第一次出现的元素x |
ls.remove(x) |
.clear() |
删除列表中所有元素 |
ls.clear() |
列表的维护查询
方法 |
含义 |
示例 |
.copy() |
拷贝列表中所有元素,生成一个新列表 |
lt= ls.copy() |
.pop(i) |
将列表第i位置元素取出并删除该元素 |
ls.pop(i) |
.reverse() |
列表中顺序元素反转 |
ls.reverse() |
.index(x) |
返回列表中第一次出现x的位置 |
ls.index(x) |
.count(x) |
返回列表中出现x的总次数 |
ls.count(x) |
.sort() |
对列表进行排序,默认是值递增 |
ls.sort() |
lt = []
lt.extend([1,2,3,4,5])
lt
[1, 2, 3, 4, 5]
lt[2] = 6
lt
[1, 2, 6, 4, 5]
lt.insert(2,7)
lt
[1, 2, 7, 6, 4, 5]
del lt[1]
lt
[1, 7, 6, 4, 5]
del lt[1:4]
lt
[1, 5]
0 in lt
False
lt.append(0)
lt
[1, 5, 0]
lt.index(0)
2
len(lt)
3
max(lt)
5
lt.clear()
lt
[]
7.4 列表类型的应用场景
列表类型使用与组织数据
- 列表用来组织数据,非常灵活,它是最常用的组合数据类型
- 列表可用于表示一组有序数据或一组顺序无关数据,进而操作它们
- 列表将用于表达一二维数据
- 列表计算性能并不高,对于大规模数据,建议采用第三方库
8. 字典类型的使用
8.1 字典类型的操作符
基本操作符
操作符 |
含义 |
示例 |
in |
元素判断 |
‘a’ in {‘a’:1,‘b’:2,‘c’:3} |
not in |
元素判断 |
‘a’ not in {‘a’:1,‘b’:2,‘c’:3} |
del |
根据键删除字典中单个元素 |
del d[‘b’] |
== |
判断两个字典相同 |
d == {‘a’:1,‘b’:2,‘c’:3} |
!= |
判断两个字典不同 |
d != {‘a’:1,‘b’:2,‘c’:3} |
8.2 字典类型的函数
内置操作函数
函数 |
含义 |
示例 |
len(d) |
返回字典的元素个数 |
len(d) |
dict() |
创建一个字典,一般用于创建空字典 |
dict() |
iter(d) |
根据字典d的键形成一个迭代类型 |
iter(d) |
8.3 字典类型的方法
字典的元素获取(键值对)
方法 |
含义 |
示例 |
.items() |
返回字典所有键值对,键值对采用(key,value)元组形式返回 |
d.items() |
.keys() |
返回字典的键 |
d.keys() |
.values() |
返回字典的值 |
d.values() |
.pop(k) |
取出特定键k对应的值,并删除键值对 |
d.pop(‘a’) |
.popitem() |
随机从字典中取出一个键值对,以(key,value)元组形式返回 |
d.popitem() |
字典的维护方法
方法 |
含义 |
示例 |
.update(t) |
扩展其他字典t的内容到当前字典,键重复的替换 |
d.update(t) |
.clear() |
删除字典所有元素 |
d.clear() |
.copy() |
拷贝字典中所有元素,生成一个新字典 |
t = d.copy() |
get(k,default) |
键k存在则返回对应值,否则返回default |
d.get(‘a’,4) |