关于python:散列类型

"""

汇合  set  符号: {} ( 为空则是字典)  转换形式: set() 可变类型

字典  dict  符号: {} ( 键值对) 表现形式: {"key": "value"} 转换形式: set() 可变类型

"""

"""
汇合的三大个性


无序性  汇合里的各个元素是不须要辨别程序的，不能以索引取值

互同性  一个给定的汇合里的元素是互不雷同的，汇合中不会有反复的元素，可用于去重

确定性  给定的汇合，它的元素必须是确定的，元素不能是可变类型

"""

# 赋值
num = [1, 1, 2, 3, 3, 9, 4, 5, 66, 7, 7, 9]

# 去重 先转换为汇合，利用汇合个性去重，再转换为列表
num_1 = list(set(num))
# 打印
# {1, 2, 3, 4, 5, 66, 7, 9}
print(num_1)

"""

交加  s1 & s2

并集  s1 | s2

差集  s1 - s2

"""

# 赋值
s_1 = {1, 2, 3, 4, 5, 6}
s_2 = {4, 5, 6, 7, 8, 9}


# 交加

# 打印相交的局部
# {4, 5, 6}
print(s_1 & s_2)


# 并集

# 打印相交的局部
# {1, 2, 3, 4, 5, 6, 7, 8, 9}
print(s_1 | s_2)


# 赋值
s_3 = {1, 2, 3, 4, 5, 6}
s_4 = {4, 5, 6}


# 差集

# 打印相交的局部
# {1, 2, 3}
print(s_1 - s_2)

# add 将元素增加到汇合中
# 汇合内只能增加不可变类型


# 赋值
s_1 = {1, 2, 3, 4, 5}

# 增加数据
s_1.add("hello")

# 打印
# {1, 2, 3, 4, 5, 'hello'}
print(s_1)


# pop 删除并返回任意 set 元素

# 赋值
s_1 = {1, 2, 3, 4, 5}

# 打印
# 1
print(s_1.pop())
# {2, 3, 4, 5}
print(s_1)


# 赋值
s_2 = {1, 2, 3, "hello",  4, 5, 6}

# remove 删除指定的元素
s_2.remove("hello")
# 打印
# {1, 2, 3, 4, 5, 6}
print(s_2)

# update 用自身和其它元素的并集更新汇合
# 相当于是增加，只能增加可迭代对象

# 赋值
s_1 = {1, 2, 3, 4, 5}

# 更新汇合
s_1.update({7, 8, 9, 0})

# 打印
# {0, 1, 2, 3, 4, 5, 7, 8, 9}
print(s_1)

# isdisjoint 判断两个汇合的交点是否为空

# 赋值
s_1 = {1, 2, 3, 4, 5}
s_2 = {7, 8, 9, 0}

# 打印判断后果
# True
print(s_1.isdisjoint(s_2))


# 赋值
s_3 = {1, 2, 3, 4, 5}
s_4 = {1, 2, 3}

# issubset 子类汇合 判断另一个汇合是否蕴含该汇合

# 判断 s_3 是 s_4 的子集汇合
# False
print(s_3.issubset(s_4))


# issuperset 父类汇合 判断另一个汇合是否蕴含该汇合

# 判断 s_3 是 s_4 的父集汇合
# True
print(s_3.issuperset(s_4))

"""

字典 key 值有唯一性 key 值不能为可变类型

字典也是无序性

"""

# 赋值
num = {"name": "qi", "age": "20", "sex": "man"}

# 取值
# qi
print(num["name"])

# 查看类型
# <class 'dict'>
print(type(num))

# 赋值 {"key": "value"}
num = {"name": "qi"}

# 打印原字典
# {'name': 'qi'}
print(num)


# setdefault  有则查 key 值所对应的 value 值，无则增

# 有则查

# 增加数据
num_1 = num.setdefault("name")

# 打印
# qi
print(num_1)


# 无则增


# 办法一
# 只增加 key 值 value 值为 None

# 增加数据
num_2 = num.setdefault("age")

# 打印
# None
print(num_2)

# 打印
# {'name': 'qi', 'age': None}
print(num)

# 办法二
# 增加字典 增加 key 值及 key 值所对应的 value 值

# 增加数据
num_3 = num.setdefault("sex", "man")

# 打印
# man
print(num_3)

# 打印
# {'name': 'qi', 'age': None, 'sex': 'man'}
print(num)

# 赋值
num = {'name': 'qi', 'age': 18, 'sex': 'man'}


# pop 查出指定 key 的键值对


# 删除 key 值及 key 值所对应的 value 值 用完再删
# 18
print(num.pop("age"))

# 打印
# {'name': 'qi', 'sex': 'man'}
print(num)


# 赋值
num_2 = {'name': 'qi', 'age': 18, 'sex': 'man', "job": "python 工程师"}


# popitem 返回并删除字典中的最初一对键值对


# 删除 key 值及 key 值所对应的 value 值 用完再删
# ('job', 'python 工程师')
print(num_2.popitem())

# 打印
# {'name': 'qi', 'age': 18, 'sex': 'man'}
print(num_2)


# clear 清空

# 赋值
num_3 = {'name': 'qi', 'age': 18, 'sex': 'man'}

# 清空数据
num_3.clear()

# 打印
# {}
print(num_3)

# 赋值
num = {'name': 'qi', 'age': None}


# update 有则改，无则增


# 有则改

# 改变数据
num.update({"age": 18})

# 打印
# {'name': 'qi', 'age': 18}
print(num)


# 无则增

# 减少数据
num.update({"sex": "man"})

# 打印
# {'name': 'qi', 'age': 18, 'sex': 'man'}
print(num)

# 赋值
num = {"name": "qi", "age": "20", "sex": "man"}


# get  获取指定 key 对应的 value 值，key 不存在则返回 None

# 打印
# qi
print(num.get("name"))


# keys  取出所有的 key

# 打印
# dict_keys(['name', 'age', 'sex'])
print(num.keys())

# 转换为列表
# ['name', 'age', 'sex']
print(list(num.keys()))


# values  取出所有的 value

# 打印
# dict_values(['qi', '20', 'man'])
print(num.values())

# 转换为列表
# ['name', 'age', 'sex']
print(list(num.keys()))


# items  取出所有的键对值

# 打印
# dict_items([('name', 'qi'), ('age', '20'), ('sex', 'man')])
print(num.items())

# 转换为列表
# [('name', 'qi'), ('age', '20'), ('sex', 'man')]
print(list(num.items()))

字典索引 key 与字典 get 办法的区别

# 赋值
num = {"name": "qi", "age": "20", "sex": "man"}


# get 取值  key 不存在则返回 None (举荐应用)

# 打印
# qi
print(num.get("job"))


# 索引取值  key 不存在则报错 (不举荐应用)

# 打印
# KeyError: 'job'
print(num["job"])

关于python:散列类型

散列类型

汇合

1. 汇合的定义

2. 汇合的三种运算

汇合的办法

字典

字典的办法