python_Day05||字典&集合&序列

字典

• 数值、字符和元组 都能被哈希，因此它们是不可变类型。
• 列表、集合、字典不能被哈希，因此它是可变类型

1.字典的定义
字典dict定义使用{}定义，变量={key1：value1，key2：value2，…}字典的key可以是字符串类型和数字类型，不能是列表。Value值可以是任何类型。

2.创建和访问字典

my_dict={"name":"phyllis","age":"19"}
print(my_dict)
#访问value值
print(my_dict["age"])
#如果key值不存在，代码报错。如果字典.get（key），key值不存在，返回none

3.字典的内置方法
（1） dict.keys() 返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键。

dic={"name":"phyllis","age":1}
print(dic.keys())#dict_keys(['name', 'age'])
list1=list(dic.keys())#转换为列表
print(list1)#['name', 'age']

（2）dict.values() 返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值

dic={"name":"phyllis","age":1}
print("字典所有值为：" , list(dic.values()))
#字典所有值为： ['phyllis', 1]

（3） dict.items() 以列表返回可遍历的 (键, 值) 元组数组。

dic={"name":"phyllis","age":1}
print(dic.items())
#dict_items([('name', 'phyllis'), ('age', 1)])

（4） dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回默认值。

dic={"name":"phyllis","age":1}
print(dic.get('name'))
#phyllis

（5）key in dict in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true ，否则返回 false 。而 not in 操作符刚好相反，如果键在字典 dict 里返回 false ，否则返回 true

（6）dict.setdefault(key, default=None) 和 get() 方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值

（7）dict.pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。 key 值必须给出。若 key不存在，则返回 default 值。

（8）del dict[key] 删除字典给定键 key 所对应的值。

（9）dict.clear() 用于删除字典内所有元素

（10） dict.popitem() 随机返回并删除字典中的一对键和值，如果字典已经为空，却调用了此方法，就报出KeyError异常

（11）dict.copy() 返回一个字典的浅复制
但id和原来的id不一样

dic1={"name":"phyllis","age":1}
dic2=dic1.copy()
print(dic2)
#{'name': 'phyllis', 'age': 1}
print(id(dic1))#1910362703984
print(id(dic2))#1910362704056

（12） dict.update(dict2) 把字典参数 dict2 的 key:value 对更新到字典 dict 里。

dic1={"name":"phyllis","age":1}
dic2={"sex":"female","age":2}
dic1.update(dic2)
print(dic1)
#{'name': 'phyllis', 'age': 2, 'sex': 'female'}

集合（set）

python 中 set 与 dict 类似，也是一组 key 的集合，但不存储 value 。由于 key 不能重复，所以，在 set 中，没有重复的 key 。

num = {1, 2, 3, 4}
print(type(num)) # <class 'set'>

1.集合的创建
创建空集合的时候只能使用 s = set() ，因为 s = {} 创建的是空字典
ps： 先创建对象再加入元素

num=set()
num.add(1)
num.add(2)
print(num)
#{1, 2}

ps：重复元素在 set 中会被自动被过滤

（1）使用 set(value) 工厂函数，把列表或元组转换成集合

a =set('abcabcabc')
print(a)
#{'a', 'b', 'c'}
b = set(("Google", "Lsgogroup", "Taobao", "Taobao"))
print(b)
#{'Taobao', 'Google', 'Lsgogroup'}
c =set(["phyllis","sweety","phyllis"])
print(c)
#{'sweety', 'phyllis'}

集合的两个特点：无序 (unordered) 和唯一 (unique)

2.访问集合中的值
（1）可以使用 len() 內建函数得到集合的大小

num=set('abc')
print(len(num))
#3,即表明有三个元素

（2）可以使用 for 把集合中的数据一个个读取出来

num=set('abc')
for i in num:
    print(i)
#c
#b
#a

（3）可以通过 in 或 not in 判断一个元素是否在集合中已经存在

3.集合的内置方法
（1）set.add(elmnt) 用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作
（2）set.update(set) 用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，
则该元素只会出现一次，重复的会忽略
（3）set.remove(item) 用于移除集合中的指定元素。如果元素不存在，则会发生错误
（4）set.discard(value) 用于移除指定的集合元素。 remove() 方法在移除一个不存在的元素时会发生错误，而
discard() 方法不会
（5）set.pop() 用于随机移除一个元素
（6）

• set.intersection(set1, set2 …) 返回两个集合的交集。
• set1 & set2 返回两个集合的交集。
• set.intersection_update(set1, set2 …) 交集，在原始的集合上移除不重叠的元素
• set.union(set1, set2…) 返回两个集合的并集。
• set1 | set2 返回两个集合的并集。
• set.difference(set) 返回集合的差集。
• set1 - set2 返回集合的差集。
• set.difference_update(set) 集合的差集，直接在原来的集合中移除元素，没有返回值。
• set.symmetric_difference(set) 返回集合的异或。
• set1 ^ set2 返回集合的异或。
• set.symmetric_difference_update(set) 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中
• set.issubset(set) 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
• set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
• set.issuperset(set) 用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
• set1 >= set2 判断集合是不是包含其他集合，如果是则返回 True，否则返回 False

4.集合的转换

se=set('abc')
li=list(se)
tu=tuple(se)
print(se,type(se))#{'b', 'a', 'c'} <class 'set'>
print(li,type(li))#['b', 'a', 'c'] <class 'list'>
print(tu,type(tu))#('b', 'a', 'c') <class 'tuple'>

5.不可变集合
frozenset（）不能改变元素的集合，既不能增添或删除元素
frozenset([iterable]) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

a = frozenset(range(10)) # 生成一个新的不可变集合
print(a) 
# frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

序列

1.针对序列的内置函数
（1）list(sub) 把一个可迭代对象转换为列表。
（2）tuple(sub) 把一个可迭代对象转换为元组。
（3）str(obj) 把obj对象转换为字符串
（4）len(s) 返回对象（字符、列表、元组等）长度或元素个数
（5） max(sub) 返回序列或者参数集合中的最大值
（6）min(sub) 返回序列或参数集合中的最小值
（7） sum(iterable[, start=0]) 返回序列 iterable 与可选参数 start 的总和
（8）sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作。
a. iterable – 可迭代对象。
b. key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代
对象中的一个元素来进行排序。
c. reverse – 排序规则， reverse = True 降序 ， reverse = False 升序（默认）
（9）reversed(seq) 函数返回一个反转的迭代器

a=(1,2,3,4,5,6)
b=reversed(a)
print(list(b))
#[6, 5, 4, 3, 2, 1]

（10）enumerate 将可迭代序列中元素所在的下标和具体元素数据组合在一块，变成元组

my_list=["a","b","c","d","e"]
for i in my_list:
    print(my_list.index(i),i)
# 0 a
# 1 b
# 2 c
# 3 d
# 4 e
for j in enumerate (my_list):
    print(j)
# (0, 'a')
# (1, 'b')
# (2, 'c')
# (3, 'd')
# (4, 'e')

（11）zip(iter1 [,iter2 […]])
a. 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
b. 我们可以使用 list() 转换来输出列表。
c. 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为
列表。

a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
zipped = zip(a, b)
print(zipped) # <zip object at 0x000000C5D89EDD88>
print(list(zipped)) # [(1, 4), (2, 5), (3, 6)]
zipped = zip(a, c)
print(list(zipped)) # [(1, 4), (2, 5), (3, 6)]
a1, a2 = zip(*zip(a, b))
print(list(a1)) # [1, 2, 3]
print(list(a2)) # [4, 5, 6]