python中dict set的用法和对应的内置方法

dict ：字典的数据类型（序列），存储值的方式和list和tuple不一样
它里面的数据并不是单个值存储的，是以key:value的格式存储
key ：数据的键（名称），不能重复，是唯一的
value ：对应键名的值    value可以重复
dict字典的表达式 ：{}

# dict1 = {"key": "value", "湖北": "武汉", "湖南": "长沙"}
# print(dict1)                            # {'key': 'value', '湖北': '武汉', '湖南': '长沙'}
# print(type(dict1))                      # <class 'dict'>

# 当键值相同时，默认输出的值是最后一个该键对应的值
# dict1 = {"key": "value", "key": "value1"}
# print(dict1)                            # {'key': 'value1'}

数据类型的转换关系 ：
dict tuple list 数据类型之间的转换：

dict 可以转换为list和tuple 但是只会保留对应的键，不会存储dict的value属性

list和tuple不能转换成dict 但是list和tuple之间可以相互转换

# dict1 = {"key": "value"}
# print(type(dict1))                      # <class 'dict'>
# dict1 = list(dict1)
# print(dict1)                             # ['key']
# print(type(dict1))                      # <class 'list'>

# dict1 = {"key": "value"}
# print(type(dict1))                      # <class 'dict'>
# dict1 = tuple(dict1)
# print(dict1)                               # ('key',)
# print(type(dict1))                      # <class 'tuple'>

# list1 = [1, 2, 3, 4, 5]
# list1 = dict(list1)
# # TypeError: cannot convert dictionary update sequence element #0 to a sequence
# print(list1)                            # TypeError

# 多维数组（包含多种数据序列类型），也叫二维数组
# list1 = [("湖北", "武汉"), ("湖南", "长沙")]
# list1 = dict(list1)
# print(list1)                               # {'湖北': '武汉', '湖南': '长沙'}
# print(type(list1))                      # <class 'dict'>

# tuple1 = ["湖北", "武汉"], ["湖南", "长沙"]
# tuple1 = dict(tuple1)
# print(tuple1)                             # {'湖北': '武汉', '湖南': '长沙'}
# print(type(tuple1))                     # <class 'dict'>

# zip 函数 ：打包函数，可以将数据打包成数组类型
# 转换完成后它是一个打包对象，需要手动转换数据
# 如果两组数据不一致时，只会打包相同数据的值，不一致的值不会被处理
# list1 = ["湖北", "湖南"]
# list2 = ["武汉", "长沙"]
# a = zip(list1, list2)
# print(a)                                  # <zip object at 0x012D10A8>
# print(list(a))                            # [('湖北', '武汉'), ('湖南', '长沙')]
# print(dict(a))                           # {'湖北': '武汉', '湖南': '长沙'}
# print(tuple(a))                         # (('湖北', '武汉'), ('湖南', '长沙'))

dict 不能进行索引和切片的操作，他的[]是用来传key的
1.可以通过key  来查找对应的value 属性
2.可以通过key  来修改值
3.可以通过key  来进行赋值

# dict1 = {"湖北": "武汉", "湖南": "长沙", "江西": "南昌"}
# print(dict1["湖北"])                      # 武汉
# dict1["湖北"] = "黄鹤楼"
# dict1["浙江"] = "杭州"
# print(dict1)                                # {'湖北': '黄鹤楼', '湖南': '长沙', '江西': '南昌', '浙江': '杭州'}

dict 函数 ：keys ： 取键的操作
# dict1 = {"湖北": "武汉", "湖南": "长沙", "江西": "南昌"}
# print(dict1.keys())                     # dict_keys(['湖北', '湖南', '江西'])
# # 方法2 ：可以通过循环语句取值 ：for 遍历查找，可以是任意序列
# # 遍历循环完成之后退出循环
# for i in dict1:
#     print(i)
# # 方法3 通过for循环结合关键字处理
# for i in dict1.keys():
#     print(i)

dict 取值的操作 ：values 方法取所有的值
# dict1 = {"湖北": "武汉", "湖南": "长沙", "江西": "南昌"}
# print(dict1.values())                   # dict_values(['武汉', '长沙', '南昌'])
# 方法2
# for i in dict1.values():
#     print(i)
# 方法3
# for i in dict1:
#     print(dict1[i])

dict 取键值的操作 items
# dict1 = {"湖北": "武汉", "湖南": "长沙", "江西": "南昌"}
# print(dict1.items())                    # dict_items([('湖北', '武汉'), ('湖南', '长沙'), ('江西', '南昌')])

# 方法2
# for k, v in dict1.items():
#     print(k, v)

# 方法3
# for i in dict1:
#     print(i, dict1[i])

dict update ：更新dict
# dict1 = {"湖北": "武汉"}
# dict2 = {"湖南": "长沙"}
# dict1.update(dict2)
# print(dict1)                        # {'湖北': '武汉', '湖南': '长沙'}

dict setdefault ：添加值，但是不能修改值
# dict1 = {"湖北": "武汉"}
# dict1["湖南"] = "长沙"
# dict1.setdefault("江西", "南昌")
# dict1.setdefault("湖北", "长江")    # 该语句没有修改
# print(dict1)                                # {'湖北': '武汉', '湖南': '长沙', '江西': '南昌'}

get ：通过键取值
# dict1 = {"湖北": "武汉"}
# print(dict1["湖北"])                    # 武汉
# print(dict1.get("湖北"))              # 武汉

python 2 和 python 3 的区别：
python 2 ：has_key : 判断当前的键是否存在
python 3 ：__contains__ ：判断当前的键是否存在

# dict1 = {"湖北": "武汉"}
# print(dict1.__contains__("湖北"))             # True

清空dict ：clear
# dict1 = {"湖北": "武汉"}
# dict1.clear()
# print(dict1)                                # {}

popitem ：删除值，默认只能删除最后一个键值
# dict1 = {"湖北": "武汉", "湖南": "长沙"}
# dict1.popitem()
# print(dict1)                                # {'湖北': '武汉'}

pop ：删除指定键的键值
# dict1 = {"湖北": "武汉", "湖南": "长沙"}
# dict1.pop("湖北")
# print(dict1)                                # {'湖南': '长沙'}

del  删除多个值逗号隔开
# dict1 = {"湖北": "武汉", "湖南": "长沙"}
# del dict1["湖北"], dict1["湖南"]
# print(dict1)                                # {}

set 集合：
set 集合也是一个无序的序列：里面的数据没有顺序
set 分为可变集合：可变集合里面的内容，都是可以修改的
frozenset ：不可变集合 ：不可变集合里面的内容，里面的内容是写保护的
是不可以被修改的
共同的特点 ：去重
表达式都是 ：{}

不可以被操作索引切片


# 定义一个可变集合
# set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
# print(set1)                         # {1, 2, 3, 4, 5}
# print(type(set1))                   # <class 'set'>
# set1.add("武汉多测师")
# print(set1)                         # {1, 2, 3, 4, 5, '武汉多测师'}
# set1.remove(1)
# print(set1)                         # {2, 3, 4, 5, '武汉多测师'}

# 定义一个序列
# set1 = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

# 通过frozenset转换为不可变集合
# set1 = frozenset(set1)
# print(set1)                         # frozenset({1, 2, 3, 4, 5})
# print(type(set1))                   # <class 'frozenset'>


总结：面试问题
set dict list str tuple 都是序列，分为有序和无序（散序）
list str tuple 属于有序序列
set dict frozenset属于无序序列

可变的数据类型 ：list set dict
不可变的数据类型 ：tuple frozenset str int float bool


if 判断条件语句：
单分支 if 语句 ：只有一个 if
多分支 if 语句 ：多个 if 条件

if 语句条件成立时则执行下面的语句
else 其他的场景情况

# 单分支 if 语句
# a = 10
# if a == 10:
#     print("当前a的值：%s" % a)
# else:
#     print("当前的a的值不为10")

# 多分支 if 语句
# a = 8
# if a > 10:
#     print("当前a的值:%s 大于10" % a)
# elif a < 10:
#     print("当前a的值:%s 小于10" % a)
# else:
#     print("当前a的值:%s 等于10" % a)

三目运算 ：也叫做三元表达式 ：他只适用 if 单分支语句
先写判断成功执行输出的内容，再写判断语句，然后是else语句


# a = 10
# if a == 10:
#     print("当前a的值：%s" % a)
# else:
#     print("当前的a的值不为10")
#
# print("当前a的值：%s" % a) if a == 10 else print("当前的a的值不为10")