【Python基础】散列类型

集合

什么是集合

• 如下定义的变量last_names的数据类型是集合

last_names = {'赵', '钱', '孙', '李', '周', '吴'}

print(last_names)

{'吴', '赵', '孙', '周', '钱', '李'}

• 通过type()函数可以查看变量last_names的数据类型

last_names = {'赵', '钱', '孙', '李', '周', '吴'}

print(type(last_names))

<class 'set'>

---

集合的特点

元素不重复性

• 集合中的元素不重复

示例

number_set = {1, 1, 2, 2, 3, 3}

print(number_set)

{1, 2, 3}

• 可以看到，集合会自动将重复的元素进行去重

无序性

• 集合中的元素是无序的

示例

last_names = {'赵', '钱', '孙', '李', '周', '吴'}

print(last_names)

{'钱', '孙', '吴', '李', '赵', '周'}

• 可以看到，在定义集合时元素按照百家姓的顺序，在打印时元素是无序的
• 由于集合具有无序性，集合没有索引和切片的概念，在遍历时只能使用for循环进行遍历

---

集合操作

增加元素

add()方法

set_object.add(element)

• add()方法用于向集合中增加元素，如果集合中已经存在该元素的值，集合会自动进行去重

number_set = {1, 2, 3}

number_set.add(4)
print(number_set)

number_set.add(1)
print(number_set)

{1, 2, 3, 4}
{1, 2, 3, 4}

删除元素

clear()方法

set_object.clear()

• clear()方法用于删除集合中的所有元素

number_set = {1, 2, 3}

number_set.clear()

print(number_set)

set()

pop()方法

set_object.pop()

• pop()方法用于随机删除集合中的一个元素，返回值为被删除的元素

number_set = {1, 2, 3}

popped_element = number_set.pop()

print(popped_element)
print(number_set)

1
{2, 3}

remove()方法

set_object.remove(element)

• remove()方法用于删除集合指定元素值的元素

number_set = {1, 2, 3}

number_set.remove(1)

print(number_set)

{2, 3}

交集

intersection()方法

set_object.intersection(set_obj)

• intersection()方法用于返回两个集合的交集

number_set_1 = {1, 2, 3}
number_set_2 = {2, 3, 4}

intersection_set = number_set_1.intersection(number_set_2)

print(intersection_set)

{2, 3}

&符号

• 交集也可以通过&符号实现

number_set_1 = {1, 2, 3}
number_set_2 = {2, 3, 4}

intersection_set = number_set_1 & number_set_2

print(intersection_set)

{2, 3}

isdisjoint()方法

set_object.isdisjoint(set_obj)

• isdisjoint()方法用于判断两个集合是否不相交，是则返回True，否则返回False

number_set_1 = {1, 2, 3}
number_set_2 = {2, 3, 4}

print(number_set_1.isdisjoint(number_set_2))

number_set_1 = {1, 2, 3}
number_set_2 = {4, 5, 6}

print(number_set_1.isdisjoint(number_set_2))

False
True

并集

union()方法

set_object.union(set_obj)

• union()方法用于返回两个集合的并集

number_set_1 = {1, 2, 3}
number_set_2 = {2, 3, 4}

union_set = number_set_1.union(number_set_2)

print(union_set)

{1, 2, 3, 4}

|符号

• 并集也可通过|符号实现

number_set_1 = {1, 2, 3}
number_set_2 = {2, 3, 4}

union_set = number_set_1 | number_set_2

print(union_set)

{1, 2, 3, 4}

差集

difference()方法

set_object.difference(set_obj)

• difference()方法用于返回两个集合的差集

number_set_1 = {1, 2, 3}
number_set_2 = {2, 3, 4}

difference_set = number_set_1.difference(number_set_2)

print(difference_set)

{1}

-符号

• 差集也可通过-符号实现

number_set_1 = {1, 2, 3}
number_set_2 = {2, 3, 4}

difference_set = number_set_1 - number_set_2

print(difference_set)

{1}

对称差集

symmetric_difference()方法

set_object.symmetric_difference(set_obj)

• symmetric_difference()方法用于返回两个集合的对称差集

number_set_1 = {1, 2, 3}
number_set_2 = {2, 3, 4}

symmetric_difference_set = number_set_1.symmetric_difference(number_set_2)

print(symmetric_difference_set)

{1, 4}

子集

issubset()方法

set_object.issubset(set_obj)

• issubset()方法用于判断当前集合是否是参数集合的子集，是则返回True，否则返回False

number_set_1 = {1, 2}
number_set_2 = {1, 2, 3}

print(number_set_1.issubset(number_set_2))

True

issuperset()方法

set_object.issuperset(set_obj)

• issuperset()方法用于判断参数集合是否是当前集合的子集，是则返回True，否则返回False

number_set_1 = {1, 2, 3}
number_set_2 = {1, 2}

print(number_set_1.issuperset(number_set_2))

True

---

字典

什么是字典

• 如下定义的变量author的数据类型是字典

author = {
    'name': '丷从心·',
    'age': 22
}

print(author)

{'name': '丷从心·', 'age': 22}

• 通过type()函数可以查看变量author的数据类型

author = {
    'name': '丷从心·',
    'age': 22
}

print(type(author))

<class 'dict'>

---

键值对

• 字典由键值对组成，对于字典author，'name': '丷从心·'是一个键值对，name为键，'丷从心·'为键所对应的值，键与值之间用:分隔
• 'age': 22也是一个键值对，键值对之间通过,分隔
• 键值对中的键可以理解为索引或下标，通过键可以查询键所对应的值

示例

author = {
    'name': '丷从心·',
    'age': 22
}

print(author['name'])
print(author['age'])

丷从心·
22

键异常

• 当通过键查找对应的值时，如果指定的键不存在则会发生KeyError键异常

author = {
    'name': '丷从心·',
    'age': 22
}

print(author['height'])

Traceback (most recent call last):
  File "C:/Users/FOLLOW_MY_HEART/Desktop/Python Basics/【Python基础】字典/test.py", line 6, in <module>
    print(author['height'])
KeyError: 'height'

---

遍历字典

什么是遍历

• 遍历就是通过循环的方式从string、list、tuple、dict、set等序列数据类型中依次获取元素，这个过程称为遍历

遍历字典的键

• 直接对字典进行遍历时，遍历出的元素为字典的键

author = {
    'name': '丷从心·',
    'age': 22
}

for key in author:
    print(key)

name
age

keys()方法

• keys()方法返回的是字典中所有的键，可以通过对keys()方法返回的结果进行遍历来遍历字典中所有的键

author = {
    'name': '丷从心·',
    'age': 22
}

print(author.keys())

for key in author.keys():
    print(key)

dict_keys(['name', 'age'])
name
age

遍历字典的值

values()方法

• values()方法返回的是字典中所有的值，可以通过对values()方法返回的结果进行遍历来遍历字典中所有的值

author = {
    'name': '丷从心·',
    'age': 22
}

print(author.values())

for value in author.values():
    print(value)

dict_values(['丷从心·', 22])
丷从心·
22

遍历字典的键值对

items()方法

• items()方法返回的是字典中所有的键值对，可以通过对items()方法返回的结果进行遍历来遍历字典中所有的键值对

author = {
    'name': '丷从心·',
    'age': 22
}

print(author.items())

for item in author.items():
    print(item)

dict_items([('name', '丷从心·'), ('age', 22)])
('name', '丷从心·')
('age', 22)

---

字典操作

增加键值对

dict_object[new_key] = new_value

• 当对字典中不存在的键进行赋值时，字典中就会新增这个键值对

author = {
    'name': '丷从心·',
    'age': 22
}
print(author)

author['gender'] = '男'
print(author)

{'name': '丷从心·', 'age': 22}
{'name': '丷从心·', 'age': 22, 'gender': '男'}

修改键值对

dict_object[key] = new_value

• 修改键所对应的值，只需通过对键进行重新赋值

author = {
    'name': '丷从心·',
    'age': 22
}
print(author)

author['age'] = 18
print(author)

{'name': '丷从心·', 'age': 22}
{'name': '丷从心·', 'age': 18}

查询键值对

• 当直接通过键查找对应的值时，如果指定的键不存在则会发生KeyError键异常

author = {
    'name': '丷从心·',
    'age': 22
}

print(author['height'])

Traceback (most recent call last):
  File "C:/Users/FOLLOW_MY_HEART/Desktop/Python Basics/【Python基础】字典/test.py", line 6, in <module>
    print(author['height'])
KeyError: 'height'

get()方法

dict_object.get(key, default_value=None)

• get()方法用于查询键所对应的值，当指定的键不存在时，并不会产生异常，而是返回一个自定义的值，默认情况下返回None

author = {
    'name': '丷从心·',
    'age': 22
}

print(author.get('height'))
print(author.get('height', 180))

None
180

---

删除键值对

del

del dict_object[key]

• del用于删除字典指定键的键值对

author = {
    'name': '丷从心·',
    'age': 22
}

del author['age']

print(author)

{'name': '丷从心·'}

clear()方法

dict_object.clear(index)

• clear()方法用于清空字典的键值对

author = {
    'name': '丷从心·',
    'age': 22
}

author.clear()

print(author)

{}

---