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'>

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

Traceback (most recent call last):
File “D:/Git/test-practice/py38/day05/a.py”, line 13, in
c = {[1,2,3],(1,2,3)}
TypeError: unhashable type: ‘list’

注意空集合的定义方式是set()

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

set()

1.2 集合的常用操作

1.2.1 添加元素

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

add增加一个，updata增加多个

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

a = {1, 3}
a.add(2)
print(a)

{1, 2, 3}

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

b = {1, 2, 3}
b.add(3)
print(b)

{1, 2, 3}

set.update(iterable)，向集合中添加多个元素，如何集合中不存在则添加，反之，存在不添加

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

{1, 2,}

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

{1, 2, 3, 4}

1.2.2 删除元素

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

a1 = {1, 2, 3, 4}
print(a1.pop())
print(a1)

1
{2, 3, 4}

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

a1 = {1, 2, 3, 4}
a1.remove(2)
print(a1)

{1, 3, 4}

a1 = {1, 2, 3, 4}
a1.remove(5)
print(a1)

Traceback (most recent call last):
File “D:/Git/test-practice/py38/day05/b.py”, line 27, in
a1.remove(5)
KeyError: 5

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

a1 = {1, 2, 3, 4}
a1.discard(5)
print(a1)

{1, 2, 3, 4}

set.clear(),清空集合

a1 = {1, 2, 3, 4}
a1.clear()
print(a1)

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')

{‘c’, ‘a’, ‘b’}

2. 字典

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

2.1 字典的定义

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

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

绝大多数情况下使用字符串作为key值

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'>

2.2 字典的索引

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

a = {
    'name': "李四",
    'age': 18,
    123: 666
}
print(a['name'], a[123])

李四 666

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

2.3 字典的常用操作

2.3.1 增加元素

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

a = {'name': '李四'}
a['age'] = 18
print(a)

{‘name’: ‘李四’, ‘age’: 18}

增加多个，合并
dict.update(new_dict)，将new_dict合并进dict中。

a = {'name': '李四'}
b = {'age': 18, 'address': '北京'}
a.update(b)
print(a)

‘name’: ‘李四’, ‘age’: 18, ‘address’: ‘北京’}

2.3.2 修改元素

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

a = {'name': '李四'}
a['name'] = '张三'
print(a)

{‘name’: ‘张三’}

2.3.3 删除元素

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

a = {'name': '李四', 'age': 18, 'address': '北京'}
a.pop('address')
print(a)

{‘name’: ‘李四’, ‘age’: 18}

a = {'name': '李四', 'age': 18, 'address': '北京'}
a.pop('sex')
print(a)

Traceback (most recent call last):
File “D:/Git/test-practice/py38/day06/c.py”, line 20, in
a.pop(‘sex’)
KeyError: ‘sex’

2.3.4 查询元素

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

a = {'name': '李四', 'age': 18, 'address': '北京'}
print(a['name'])

李四

a = {'name': '李四', 'age': 18, 'address': '北京'}
print(a['sex'])

Traceback (most recent call last):
File “D:/Git/test-practice/py38/day06/c.py”, line 30, in
print(a[‘sex’])
KeyError: ‘sex’

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

d = {1:2, 'key': 'value'}
d.get(1)

2

d = {1:2, 'key': 'value'}	# 不存在name
d.get('name',0)

0

二、其他类型

1. None

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

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

None

2. 布尔型

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

2.1 比较运算符

运算符	描述
==	等于-比较对象是否相等
is	等于-比较对象的内存地址是否相同
!=	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于

a = 1
b = 1
print(a == b)		# True
print(a is b)		# True
print(a != b)		# False
print(a > b)		# False
print(a < b)		# False
print(a >= b)		# True
print(a <= b)		# True

2.2 成员运算符

运算符	描述
in	如果在指定的序列中找到值返回True，否则False
not in	如果在指定的序列中没有找到值返回True，否则Fals

ls = [1,2,3,4,5]
print(1 in ls)

True

s = ['abcdefg']
print('a' in s)

Flase

d = {'name': 'Felix','age':18}
print('name' in d)
a = {'name': '李四', 'age': 18}
print('name' not in a)

True
False

st = {1,2,3}
print(1 in st)

True

2.3 布尔型运算

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

True + 1

2

True + 1

1

2.4 布尔类型转换

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

在python中，None, 0（整数），0.0（浮点数），0.0+0.0j（复数），“” 空字符串，[] 空列表，() 空元组，{} 空字典，set() 空集合的布尔值都为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

2.5 逻辑运算符

运算符	描述
and	与，如果x为False,x and y返回x的值，否则返回y的值
or	或，如果x为True,x and y返回x的值，否则返回y的值
not	非，如果x为True，返回False，反之，返回True

print((True and True))   # 全真为真
print((True and False))  # 有假为假

print((True or False))    # 有真为真
print((False or False))   # 全假为假

True
False
True
False