第 4 章.数值数据类型（三）

一、散列类型

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

1.集合

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

1.1 集合定义

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

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

print('a的类型为：',type(a))
print('b的类型为：',type(b))
print(a)                   # 集合会对重复项进行去重
a的类型为： <class 'set'>
b的类型为： <class 'set'>
{1, 2, 3, 4, 5, 6}

{[1,11,2,3],(1,2,3,4)}     #集合中数据可变数据类型会报错
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_17172/1500028651.py in <module>
----> 1 {[1,11,2,3],(1,2,3,4)}     #集合中数据可变数据类型会报错

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(interable),向集合中添加多个元素，如果集合中不存在则添加

s = {1,2}
s.update({2,3,4})
print(s)
{1, 2, 3, 4}

1.2.2 删除元素

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

s = {'a','b','c'}
s.pop()

'b'

print(s)
{'a', 'c'}

set.remove 从集合中删除元素ele，如何不存在则抛出异常

s = {'a','b','c'}
s.remove('a')
print(s)
{'b', 'c'}

s.remove('1')    # 删除集合不存在元素报异常
print(s)
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_17172/223901992.py in <module>
----> 1 s.remove('1')    # 删除集合不存在元素报异常
      2 print(s)

KeyError: '1'

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

s = {'a','b','c'}
s.discard('a')
print(s)
{'b', 'c'}

s.discard('1')
print(s)
{'b', 'c'}

set.clear()，清空集合

s = {'a',1,'as'}
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 = ['s',1,2,3,4,3,2,1,'s']
ls = list(set(ls))
print(ls)
[1, 2, 3, 4, 's']

set('aavvccbbss11')    # 将字符串中的字符去重后单独进行显示

{'1', 'a', 'b', 'c', 's', 'v'}

2.字典

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

2.1 字典的定义

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

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

a = {}                        # 空字典
b = {
    1: 2,                        # key：数字：value：数字
    2: 'holle',                  # key：数字：value：字符串
    'k2': [1,2,3],               # key：字符串：value：列表
    'k3': (1,2,'a','b'),         # key：字符串：value：元组
    'k4': {                      # key：字符串：value：字典
        'name': 'feifei',
        'age': 18
    },
    'k4': {1,2,3,4},             # key：字符串：value：集合
    (1,'a'): 'v1'                # key：元组：value：字符串
}
print('a的类型为:',type(a))
print('b的类型为:',type(b))
a的类型为: <class 'dict'>
b的类型为: <class 'dict'>

2.2 字典的索引

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

d = {12: 2,'key': 'value'}
print(d[12])
2

print(d['key'])
value

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

2.3 字典的常用操作

2.3.1 增加元素

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

d = {'name': 'ZLF'}
d['age'] = 18
print(d)
{'name': 'ZLF', 'age': 18}

dict.update(new_dict),将new_dict合并进dict中。

d = {'name': 'zlf'}
n_d = {'age': 18,'sex': '男'}
d.update(n_d)
print(d)
{'name': 'zlf', 'age': 18, 'sex': '男'}

d.update({'age': 28,'number': 15645555})
print(d)
{'name': 'zlf', 'age': 28, 'sex': '男', 'number': 15645555}

2.3.2 修改元素

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

d = {'name': 'zlf','age': 18,'sex': '男'}
d['name'] = 'andiueng'
print(d)
{'name': 'andiueng', 'age': 18, 'sex': '男'}

2.3.3 删除元素

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

d = {'name': 'zlf','age': 18,'sex': '男'}
d.pop('sex')
print(d)
{'name': 'zlf', 'age': 18}

d.pop('sex',['null'])

['null']

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

d = {'name': 'zlf','age': 18,'sex': '男'}
d.popitem()

('sex', '男')

2.3.4 查询元素

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

d = {'name': 'zlf','age': 18,'sex': '男'}
print(d['age'])
18

d['sex1']
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_17172/1339591407.py in <module>
----> 1 d['sex1']

KeyError: 'sex1'

dict.get(key,defaulf=None),获取key对应的values如果不存在返回defaulf

d = {'name': 'zlf','age': 18,'sex': '男'}
d.get('name')

'zlf'

d.get('name1',0)

0

五、其他类型

1.布尔型

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

True

True

False

False

1.1 比较运算符

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

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

a = 1
b = 2

a == b

False

a = 300
b = 300

a is b       # 内存地址不一致False

False

a == b      # 值相同True

True

1.2 成员运算符

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

True

s = ['asdfgh']
'a' in s         # 查询字符串'a'是否在s列表内

False

t = (1,2,3)
1 in t        # 查询数值1是否在t元组内

True

s = {1,2,3}
1 in s        # 查询数值1是否在s集合内

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))
print(bool(123))
False
False
False
False
False
False
False
False
False
True

1.5 逻辑运算符

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

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

True and True

True

1+0 and 2+5

7

# 当x为True的时候，这个表达式的结果就有y来确认，所以返回y的值
True and False

False

5-4 and 7-2-5   # True and False

0

3-2 and 5-5

0

False and True

False

# x and y 已知x为False没有必要计算y的值，直接返回x的值
# 特别：把这种情况叫短路
0 and 1

0

1-1 and 2+3

0



# x or y 已知x为True没有必要计算y的值，直接返回x的值
# 特别：把这种情况叫短路
True or False

True

1 or 0

1

# 当x为False的时候，这个表达式的结果就有y来确认，所以返回y的值
False or True

True

0 or 4

4

0 or ''

''

# not只返回布尔值，实际需要配合bool来进行使用
not True

False

not False

True

not bool(100)

False

not bool(0)

True

2. None

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

print(None) # 注意首字母大小写
None
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容