学习链接(字典)
学习链接(集合)
学习链接(序列)
思维导图
文章目录
字典
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 thename = 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)]