Task05：字典、集合和序列

学习链接（字典）
学习链接（集合）
学习链接（序列）
思维导图

字典

1、笔记

• 可变类型和不可变类型

1、序列是以连续的整数为索引，与此不同的是，字典是以“关键字”为索引，关键字可以是任意不可变类型，通常用字符串或者数值。
2、字典是python唯一的一个映射类型，字符串、元组、列表属于序列类型。
那么如何快速判断一个数据类型x是不是可变类型的呢？两种方法：

• 麻烦方法：用id(x)函数，对x进行某种操作，比较操作前后的id，如果不一样，则x不可变，如果一样，则x可变。
• 便捷方法：用hash(x)，只要不报错，证明x可被哈希，即不可变，反过来不可被哈希，即可变。
  详细例子可见学习链接。

字典的定义

字典是无序的键值（key：value）对集合。在同一个字典内，键必须是互不相同的。

• dict内部存放的顺序和“key”放入的顺序是没有关系的。
• dict查找和插入的速度极快，不会随着key的增加而增加，但是需要占用大量的内存。

字典定义语法为

{元素1，元素2，...,元素n}

其中每一个元素是一个键值对（key：value）
关键点是大括号{ }，用来捆绑元素
逗号，用来分隔元素
冒号：将键和值分隔开

创建字典

• 用大括号{ }创建

brand = ["李宁", '耐克', "阿迪达斯"]
slogan = ["一切皆有可能", "Just do it", "Impossible is nothing"]
print("耐克的口号是：", slogan[brand.index("耐克")]) # 耐克的口号是： Just do it

dic = {"李宁": "一切皆有可能", '耐克': "Just do it", "阿迪达斯": "Impossible is nothing"}
print("耐克的口号是：", dic["耐克"]) # 耐克的口号是： Just do it

• 通过元组作为key来创建字典，但一般不这样使用。

dic = {(1, 2, 3): "Tom", "Age": 12, 3: [3, 5, 7]}
print(dic)  # {(1, 2, 3): 'Tom', 'Age': 12, 3: [3, 5, 7]}
print(type(dic))  # <class 'dict'>

• 创建空字典

dict() 创建一个空的字典
通过key直接把数据放入字典中，但一个key只能对应一个value，多次对一个key放入 value，后面的值会把前面的值冲掉。

dic = dict()
dic['a'] = 1
dic['b'] = 2
dic['c'] = 3

print(dic)# {'a': 1, 'b': 2, 'c': 3}

dic['a'] = 11
print(dic)# {'a': 11, 'b': 2, 'c': 3}

• dict(mapping) new dictionary initialized from a mapping object’s (key, value) pairs

dic1 = dict([('apple', 4139), ('peach', 4127), ('cherry', 4098)])
print(dic1)  # {'apple': 4139, 'peach': 4127, 'cherry': 4098}

dic2 = dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
print(dic2)  # {'apple': 4139, 'peach': 4127, 'cherry': 4098}

• dict(**kwargs) new dictionary initialized with the name = value pairs in the keyword argument list. For example:dict(one = 1,two =2)

这种情况下，键只能为字符串类型，并且创建的时候字符串不能加引号，加上会直接报语法错误。

dic = dict(name ='Tom', age = 10)
print(dic)  # {'name': 'Tom', 'age': 10}
print(type(dic))  # <class 'dict'>

• dict.fromkeys(seq[, value])
  用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。

seq = ('name', 'age', 'sex')
dic1 = dict.fromkeys(seq)
print(dic1)# {'name': None, 'age': None, 'sex': None}

dic2 = dict.fromkeys(seq, 10)
print(dic2)# {'name': 10, 'age': 10, 'sex': 10}

dic3 = dict.fromkeys(seq, ('小马', '8', '男'))
print(dic3)# {'name': ('小马', '8', '男'), 'age': ('小马', '8', '男'), 'sex': ('小马', '8', '男')}

访问字典

• 一般用字符串或者数值作为key，中括号索引

dic1 = {1: 'one', 2: 'two', 3: 'three'}
print(dic1)  # {1: 'one', 2: 'two', 3: 'three'}
print(dic1[1])  # one
print(dic1[4])  # KeyError: 4

dic2 = {'rice': 35, 'wheat': 101, 'corn': 67}
print(dic2)  # {'wheat': 101, 'corn': 67, 'rice': 35}
print(dic2['rice'])  # 35

• dict.keys()返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键
• 啥叫可迭代对象？？？
• 迭代器 生成器
• 迭代对象 迭代器 生成器
  

dic = {'Name': 'lsgogroup', 'Age': 7}
print(dic.keys())  # dict_keys(['Name', 'Age'])
lst = list(dic.keys())  # 转换为列表
print(lst)  # ['Name', 'Age']

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

dic = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
print(dic.values())
# dict_values(['female', 7, 'Zara'])

print(list(dic.values()))
# [7, 'female', 'Zara']

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

dic = {'Name': 'Lsgogroup', 'Age': 7}
print(dic.items())
# dict_items([('Name', 'Lsgogroup'), ('Age', 7)])

print(tuple(dic.items()))
# (('Name', 'Lsgogroup'), ('Age', 7))

print(list(dic.items()))
# [('Name', 'Lsgogroup'), ('Age', 7)]

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

dic = {'Name': 'Lsgogroup', 'Age': 27}
print("Age 值为 : %s" % dic.get('Age'))  # Age 值为 : 27
print("Sex 值为 : %s" % dic.get('Sex', "NA"))  # Sex 值为 : NA
print(dic)  # {'Name': 'Lsgogroup', 'Age': 27}

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

删除字典元素

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

dic1 = {1: "a", 2: [1, 2]}
print(dic1.pop(1), dic1)  # a {2: [1, 2]}

# 设置默认值，必须添加，否则报错
print(dic1.pop(3, "nokey"), dic1)  # nokey {2: [1, 2]}

del dic1[2]
print(dic1)  # {}

• dict.popitem()随机返回并删除字典中的一对键和值，如果字典已经为空，却调用了此方法，就报出KeyError异常。
• dict.clear()用于删除字典内所有元素。

2、作业

1、字典基本操作
字典内容如下:

dic = {
    'python': 95,
    'java': 99,
    'c': 100
    }

用程序解答下面的题目：

字典的长度是多少
请修改’java’ 这个key对应的value值为98
删除 c 这个key
增加一个key-value对，key值为 php, value是90
获取所有的key值，存储在列表里
获取所有的value值，存储在列表里
判断 javascript 是否在字典中

• 获得字典里所有value 的和
• 获取字典里最大的value
• 获取字典里最小的value

字典 dic1 = {‘php’: 97}， 将dic1的数据更新到dic中

dic = {
    'python': 95,
    'java': 99,
    'c': 100
}
print('字典长度：%d' % len(dic))  # 字典长度:3
dic['java'] = 98 # 对字典里value的修改，必须通过key才可以
print(dic)  # {'python': 95, 'java': 98, 'c': 100}
dic.pop('c')
print(dic) # {'python': 95, 'java': 98}
dic.update({'php': 90})
print(dic) # {'python': 95, 'java': 98, 'php': 90}
print(list(dic.keys())) # ['python', 'java', 'php']
print(list(dic.values())) # [95, 98, 90]
print('javascript' in dic) # False
print(sum(dic.values())) # 283
print(sum(list(dic.values()))) # 283  直接求和就行  不用转化成列表  sum(iterable, start=0, /)
print(max(dic.values())) # 98
print(max(list(dic.values()))) # 98
print(min(dic.values())) # 90
print(min(list(dic.values()))) # 90
dic1 = {'php':97}
dic.update(dic1)
print(dic) #{'python': 95, 'java': 98, 'php': 97}

2、字典中的value

有一个字典，保存的是学生各个编程语言的成绩，内容如下

data = {
        'python': {'上学期': '90', '下学期': '95'},
        'c++': ['95', '96', '97'],
        'java': [{'月考':'90', '期中考试': '94', '期末考试': '98'}]
        }

各门课程的考试成绩存储方式并不相同，有的用字典，有的用列表，但是分数都是字符串类型，请实现函数transfer_score(score_dict)，将分数修改成int类型

data = {
    'python': {'上学期': '90', '下学期': '95'},
    'c++': ['95', '96', '97'],
    'java': [{'月考': '90', '期中考试': '94', '期末考试': '98'}]
}


def transfer_score(score_dict):
    for key, value in score_dict.items():
        if key == 'python':
            for m, n in value.items():
                value[m] = int(n)
        elif key == 'c++':
            value = [int(each) for each in value]
        elif key == 'java':
            for m, n in value[0].items():
                value[0][m] = int(n)
    return score_dict
# {'python': {'上学期': 90, '下学期': 95}, 'c++': ['95', '96', '97'], 'java': [{'月考': 90, '期中考试': 94, '期末考试': 98}]}

# 参考答案  自己主观已经把字典中键的类型进行了判断  用键名来判断  作出相应的操作 傻唧唧  这样的函数有啥子普适性。。
# 参考答案  没有用if elif分支   直接用并列的if语句  这样也是允许的  代码更简洁 
def transfer_score(data):
	# 如果data是字典
	if isinstance(data, dict):
		for key, value in data.items():
			data[key] = transfer_score(value)
		return data
	# 如果data 是列表
	if isinstance(data, list):
		data_lst = []
		for item in data:
			data_lst.append(transfer_score(item))
		return data_lst
	if isinstance(data, str):
		return int(data)
		
if __name__ == '__main__':
	data = {
	'python': {'上学期': '90', '下学期': '95'},
	'c++': ['95', '96', '97'],
	'java': [{'月考': '90', '期中考试': '94', '期末考试': '98'}]
	} 
	data = transfer_score(data)
	# 这个调用我看的也不是很懂

集合

Python 中set与dict类似，也是一组key的集合，但是不存储value。由于key不能重复，所以在set中，没有重复的key。
注意，key为不可变类型，即可哈希的值。

• 花括号捆绑key
• 逗号分隔key

集合的创建

• 先创建对象再加入元素（添加使用方法add()）。
• 在创建空集合的时候只能使用 s = set()，因为s = {}创建的是空字典。
• 直接把一堆元素用花括号括起来{元素1，元素 2，...，元素n}。
• 重复元素在set中会被自动过滤掉。

basket = set()
basket.add('apple')
basket.add('banana')
print(basket)  # {'banana', 'apple'}

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

a = set('abracadabra')
print(a)   # {'r', 'b', 'd', 'c', 'a'} 顺序咋这样的

去掉列表中的重复元素

lst = [0, 1, 2, 3, 4, 5, 5, 3, 1]
a = set(lst)
print(list(a))  # [0, 1, 2, 3, 4, 5]

从结果发现集合有两个特点：无序和唯一
由于set存储的是无需集合，所以我们不能对集合创建索引或者质性切片的操作，也没有键（keys）可以获取集合中的值，但是可以判断一个元素是否在集合中。

访问集合中的值

• 可以使用len()內建函数得到集合的大小。
• 可以使用for把集合中的数据一个个读取出来。
• 可以通过in或not in判断一个元素是否在集合中已经存在。

集合添加元素

• set.add(elmnt)用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。
• set.update(set)用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

集合删除元素

• set.remove(item) 用于移除集合中的指定元素。如果元素不存在，则会发生错误。
• set.discard(value) 用于移除指定的集合元素。remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。
• set.pop() 用于随机移除一个元素。

由于 set 是无序和无重复元素的集合，所以两个或多个 set 可以做数学意义上的集合操作。

集合取交

• 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。
• set.isdisjoint(set) 用于判断两个集合是不是不相交，如果是返回 True，否则返回 False。

集合的转换

se = set(range(4))
li = list(se)
tu = tuple(se)

print(se, type(se))  # {0, 1, 2, 3} <class 'set'>
print(li, type(li))  # [0, 1, 2, 3] <class 'list'>
print(tu, type(tu))  # (0, 1, 2, 3) <class 'tuple'>

不可变集合

Python 提供了不能改变元素的集合的实现版本，即不能增加或删除元素，类型名叫frozenset。需要注意的是frozenset仍然可以进行集合操作，只是不能用带有update的方法。

• frozenset([iterable]) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

2、作业

怎么表示只包含⼀个数字1的元组。
1个元素的元组，必须在唯⼀的元素后加上逗号，否则不是元组

a = {1}
tu = tuple(a)
print(tu, type(tu)) # (1,) <class 'tuple'>

创建一个空集合，增加 {‘x’,‘y’,‘z’} 三个元素。

a = set()
a.add('x')
a.add('y')
a.add('z')
print(a, type(a)) # {'x', 'z', 'y'} <class 'set'>

# 参考答案 
a = set()
a.update({'x','y','z'})

列表[‘A’, ‘B’, ‘A’, ‘B’]去重。

a = ['A', 'B', 'A', 'B']
lst = set(a)
a = set(lst)
print(a, type(a)) #  {'B', 'A'} <class 'set'>

求两个集合{6, 7, 8}，{7, 8, 9}中不重复的元素（差集指的是两个集合交集外的部分）。

a = {6, 7, 8}
b = {7, 8, 9}
c = a - b
d = b - a
print(c| d) # {9, 6}

显然我没有认真看方法。。。

# 参考答案 
# 解法1: 使⽤运算符 ^
a = {6, 7, 8}
b = {7, 8, 9}
a ^ b
## {9, 6}
# 解法2:使⽤ symmetric_difference ⽅法
a = {6, 7, 8}
b = {7, 8, 9}
a.symmetric_difference(b)
## {9, 6}

求{‘A’, ‘B’, ‘C’}中元素在 {‘B’, ‘C’, ‘D’}中出现的次数。

a = {'A', 'B', 'C'}
b = ['B', 'C', 'D']

n = 0
for each in a:
    if each in b:
        n += 1
print(n) # 2

# 高级解法
m = {'A', 'B', 'C'}
n = {'B', 'C', 'D'}
len(m & n) ## 2  看不懂！！！

集合可以给我直接拿来写代码！！

序列

常用的序列类型

• string
• list
• tuple
• range

序列是一种容器（container），容器是Python中的一种数据结构，用来存储和组织其他任意类型的对象。序列的容器对象由有序排列的成员组成，并能通过一个跟位置相关的序号索引访问。

序列	操作语法
索引	sequence[index]
序列类型转换	list(iter)、tuple(iter)、str(obj)

1 、笔记

Python中 序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘的操作。

针对序列的内置函数

• len(sequence) 返回sequence（字符、列表、元组等）长度或元素个数。

• max(sub)返回序列或者参数集合中的最大值。

• min(sub)返回序列或参数集合中的最小值。

• sum(iterable [, start=0]) 返回序列iterable与可选参数start的总和。

• sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作，返回重新排序的列表。

  key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

  reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

• reversed(sequence) 函数返回一个反转的迭代器。

• enumerate(sequence, [start=0])用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(enumerate(seasons)) # enumerate object at 0x000002874AB35C28>
a = list(enumerate(seasons)) # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
print(a) 

for i, element in enumerate(seasons):
    print('{0},{1}'.format(i, element))
# 0,Spring
# 1,Summer
# 2,Fall
# 3,Winter

• zip(iter1 [,iter2 [...]]) 拆分 并打包 像拉链，将左排链齿和右排链齿来起来组合成两两组合的对。

• 以可迭代对象为参数输入，将对象中对应的元素打包成一个个元组，然后返回迭代器。

• 使用 list() 转换来输出结果。

• 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

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)]  #用list转换输出
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]

2、作业

怎么找出序列中的最⼤、⼩值？

a = {3,44,6,47,546,3,4634}
print(max(a),min(a)) #  4634 3

sort() 和 sorted() 区别

l = [1, 9, 5, 8]

j = l.sort()
print(j) # None sort()是在原序列上排序的  就地排序列表 不创建新列表 python中如果一个函数或者方法对对象就地改动，那它就返回None，让调用者知道传入的参数发生了变动并且未产生新对象。
k = sorted(l)
print(k) #[]  sorted() 新建了一个新的序列

不知道
参考答案：list.sort()方法仅被定义在list中，相反地sorted()方法对所有的可迭代序列都有效

怎么快速求 1 到 100 所有整数相加之和？

print(sum(range(101))) # 5050

求列表 [2,3,4,5] 中每个元素的立方根。

a = [2, 3, 4, 5]
b = [pow(each, 1 / 3) for each in a]
print(b) # [1.2599210498948732, 1.4422495703074083, 1.5874010519681994, 1.7099759466766968]

# 参考答案 
[item for item in map(lambda x:pow(x,1/3), [2,3,4,5])]  #lambda 匿名函数 map将可迭代对象的元素一次传入匿名函数  并以可迭代对象返回函数值  在将其遍历表达

将[‘x’,‘y’,‘z’] 和 [1,2,3] 转成 [(‘x’,1),(‘y’,2),(‘z’,3)] 的形式。

a = ['x', 'y', 'z']
b = [1, 2, 3]
print(list(zip(a,b))) # [('x', 1), ('y', 2), ('z', 3)]