python 零基础入门教程第 4 章：基本数据类型（三）

一、散列类型

散列类型用来表示无序集合。

1. 集合

python 中集合(set)类型与数学中的集合类型一致，用来表示无序不重复元素的集合。

1.1 集合定义

集合使用一对大括号 {} 进行定义，元素直接使用逗号隔开。集合中的元素必须是不可变类型。

a = {1, 2, 3, 4, 5, 6}

b = {1,2,'a',('a',),1.5}      # 集合中元素必须是不可变类型

print('a的类型为：', type(a))    # a的类型为： <class 'set'>

print('b的类型为：', type(b))    # b的类型为： <class 'set'>

a 的类型为： <class 'set'>
b 的类型为： <class 'set'>

{[1,2,3],(1,2,3)}

TypeError Traceback (most recent call last)

in
----> 1 {[1,2,3],(1,2,3)}

TypeError: unhashable type: 'list'
注意空集合的定义方式是 set()

a = set()                      # 空集合# 注a = {} 是空字典print(a)

set()

1.2 集合的常用操作

1.2.1 添加元素

集合添加元素常用函数有两个：add 和 update

set.add(obj)，向集合中添加元素 obj，如果集合中不存在则添加

s = {1,2}

s.add(1)

print(s)

{1, 2}

s.add(3)

print(s)

{1, 2, 3}
set.update(iterable)，向集合中添加多个元素，如何集合中不存在则添加

s = {1,2}

s.update({2,3})

print(s)

{1, 2, 3}

s.update([3,4])

print(s)

{1, 2, 3, 4}

1.2.2 删除元素

set.pop() 随机删除并返回集合中的一个元素，如何集合中元素为空则抛出异常。

s = {'a','b','c'}

s.pop()

'a'
set.remove(ele)，从集合中删除元素 ele，如果不存在则抛出异常。

s = {'a','b','c'}

s.remove('a')

print(s)

{'b', 'c'}

s.remove('d')

KeyError Traceback (most recent call last)

in
----> 1 s.remove('d')

KeyError: 'd'
set.discard(ele)，从集合中删除元素 ele，如果不存在不做任何操作

s = {'a','b','c'}

s.discard('d')

print(s)

{'a', 'b', 'c'}
set.clear()，清空集合

s = {1,2,3}

s.clear()

print(s)

set()

1.2.3 集合运算

数学符号	python 运算符	含义	定义
∩	&	交集	一般地，由所有属于 A 且属于 B 的元素所组成的集合叫做 AB 的交集。
∪	|	并集	一般地，由所有属于集合 A 或属于集合 B 的元素所组成的集合，叫做 AB 的并集
-或\	-	相对补集/差集	A-B，取在 A 集合但不在 B 集合的项
	^	对称差集/反交集	A^B，取只在 A 集合和只在 B 集合的项，去掉两者交集项

交集

取既属于集合 A 和又属于集合 B 的项组成的集合叫做 AB 的交集

s1 = {1,2,3}

s2 = {2,3,4}

s = s1 & s2

print(s)

{2, 3}

并集

集合 A 和集合 B 的所有元素组成的集合称为集合 A 与集合 B 的并集

s1 = {1,2,3}

s2 = {2,3,4}

s = s1|s2

print(s)

{1, 2, 3, 4}

补集

取在集合 A 中不在集合 B 中的项组成的集合称为 A 相对 B 的补集

s1 = {1,2,3}

s2 = {2,3,4}

s = s1-s2

print(s)

{1}

对称差集

取不在集合 AB 交集里的元素组成的集合称为对称差集，也叫反交集

s1 = {1,2,3}

s2 = {2,3,4}

s = s1^s2

print(s)

{1, 4}

1.3 集合去重

集合具有天生去重的性质，因此可以利用它来去除序列中的重复元素

ls = [1,1,2,3,4,4,3,2,5]

ls = list(set(ls))

print(ls)

[1, 2, 3, 4, 5]

set('aabbcc')

{'a', 'b', 'c'}

2. 字典

因为集合无序，因此不能很便捷的获取特定元素。利用集合元素不重复的特性，使集合中的元素映射值组成键值对，再通过键来获取对应的值。

2.1 字典的定义

python 中的字典(dict)数据类型就是键值对的集合，使用一对大括号进行定义，键值对之间使用逗号隔开，键和值使用冒号分割。

字典中的键必须是不可变数据类型，且不会重复，值可以使任意数据类型。

a = {}                      # 空字典

b = {

1: 2,                   # key:数字；value：数字

2: 'hello',             # key:数字；value：字符串

('k1',): 'v1',          # key:元祖；value：字符串

'k2': [1, 2, 3],        # key:字符串；value：列表

'k3': ('a', 'b', 'c'),  # key:字符串；value：元祖

'k4': {                 # key:字符串；value：字典

'name': 'feifei',

'age': '18'

}

}

print('a的类型为：', type(a))    # a的类型为： <class 'dict'>

print('b的类型为：', type(b))    # b的类型为： <class 'dict'>

a 的类型为： <class 'dict'>
b 的类型为： <class 'dict'>

2.2 字典的索引

字典通过键值对中的键作为索引来获取对应的值。字典中的键是无序的。

d = {1:2, 'key': 'value'}

print(d[1])

2

print(d['key'])

value
这种方式很好的将键和值联系起来，就像查字典一样。

2.3 字典的常用操作

2.3.1 增加元素

字典可以直接利用 key 索引赋值的方式进行添加元素，如果 key 存在则修改字典

d = {'name': 'xinlan'}

d['age'] = 18

print(d)

{'name': 'xinlan', 'age': 18}
dict.update(new_dict)，将 new_dict 合并进 dict 中。

d = {'name': 'xinlan'}

n_d = {'age':18, 'sex':'男'}

d.update(n_d)

print(d)

{'name': 'xinlan', 'age': 18, 'sex': '男'}

d.update({'sex': '女','height': 170})  # 当有重复key的时候会覆盖原值

print(d)

{'name': 'xinlan', 'age': 18, 'sex': '女', 'height': 170}

2.3.2 修改元素

直接通过 key 索引赋值的方式可以对字典进行修改，如果 key 不存在则添加

d = {'name': 'xinlan'}d['name'] = 'XinLan'print(d)

{'name': 'XinLan'}

2.3.3 删除元素

dict.pop(key[,d])，删除指定的 key 对应的值并返回该值，如果 key 不存在则返回 d，如果没有给定 d，则抛出异常

d = {'name': 'xinlan'}

d['name'] = 'XinLan'

print(d)

18

print(d)

{'name': 'xinlan'}
d.pop('age')

dict.popitem()，任意删除字典 dict 中的一个键值对，并以二元元组 (key,value) 的方式返回

d = {'name': 'Felix','age': 18}

d.popitem()

('age', 18)

2.3.4 查询元素

通过 key 索引可以直接获取 key 对应的值，如果 key 不存在则抛出异常。

d = {1:2, 'key': 'value'}

print(d[1])

2

d['name']

KeyError Traceback (most recent call last)

in
----> 1 d['name']

KeyError: 'name'
dict.get(key,default=None)，获取 key 对应的 value 如果不存在返回 default

d = {1:2, 'key': 'value'}

d.get(1)

2

d.get('name',0)

0

二、其他类型

1. 布尔型

条件表达式的运算结果返回布尔型(bool)，布尔型数据只有两个，True 和 False 表示 真 和 假。

True

True

False  # 注意首字母大写

False

1.1 比较运算符

运算符	描述	实例
==	等于-比较对象是否相等	print(a==b) # False
is	等于-比较对象的内存地址是否相同	print(a is b)
!=	不等于	print(a!=b) # True
>	大于	print(a>b) # False
<	小于	print(a<b) # True
>=	大于等于	print(a>=b) # False
<=	小于等于	print(a<=b) # True

比较运算符运算后的结果是布尔型

a = 1b = 2

a == b

False

a = 300

b = 300

a is b

False

a == b

True

1.2 成员运算符

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则 False	L = [1, 2, 3, 4, 5] a = 3 print(a in L) # True
not in	如果在指定的序列中没有找到值返回 True，否则 False	print(a not in L) # False

ls = [1,2,3,4,5]

1 in ls

True

s = ['abcdefg']

'a' in s

False

t = (1,2,3)

4 in t

False

d = {'name': 'Felix','age':18}

'name' in d

True

st = {1,2,3}

1 in st

True

1.3 布尔型运算

布尔型数据可以和数值类型数据进行数学计算，这时 True 表示整数·1, False 表示整数 0

True + 1

2

False + 1

1

1.4 布尔类型转换

任意数据都可以通过函数 bool 转换成布尔型。

在 python 中，None, 0（整数），0.0（浮点数），0.0+0.0j（复数），''(空字符串)，空列表，空元组，空字典，空集合的布尔值都为 False，其他数值为 True

print(bool(0))

print(bool(0.0))

print(bool(0.0+0.0j))

print(bool(''))

print(bool([]))

print(bool(()))

print(bool({}))

print(bool(set()))

print(bool(None))

False
False
False
False
False
False
False
False
False

1.2 逻辑运算符

运算符	描述	实例
and	与，如果 x 为 False,x and y 返回 x 的值，否则返回 y 的值	print(a and b) # True
or	或，如果 x 为 True,x and y 返回 x 的值，否则返回 y 的值	print(a or b) # True
not	非，如果 x 为 True，返回 False，反之，返回 True	print(not a) # False

逻辑运算符两边的表达式不是布尔型时，在运算前会转换为布尔型。

True and True

True

True and False

False

0 and 1 # 短路

0

1 and 2

2

True or False

True

False or False

False

1 or 0  # 短路

1

0 or ''  # 短路

''

2. None

None 是 python 中的特殊数据类型，它的值就是它本身 None，表示空，表示不存在。

print(None) # 注意首字母大写

None

本文作者：柠檬班软件测试（lemonban）——专注于最新最前沿的软件测试技术