2.2 Python组合数据类型

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 = []

# 向lt新增5个元素
# lt += [1,2,3,4,5]
lt.extend([1,2,3,4,5])
lt

[1, 2, 3, 4, 5]

# 修改lt中第2个元素
lt[2] = 6
lt

[1, 2, 6, 4, 5]

# 向lt中第2个位置增加一个元素
lt.insert(2,7)
lt

[1, 2, 7, 6, 4, 5]

# 从lt中第1个位置删除一个元素
del lt[1]
lt

[1, 7, 6, 4, 5]

# 删除lt中第1-3位置元素
del lt[1:4]
lt

[1, 5]

# 判断lt中是否包含数字0
0 in lt

False

# 向lt新增数字0
lt.append(0)
lt

[1, 5, 0]

# 返回数字0所在lt中的索引
lt.index(0)

2

# lt的长度
len(lt)

3

# lt中最大元素
max(lt)

5

# 清空lt
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)