学习内容
1. python 容器
python中默认有4中容器，分别是：列表（list）、字典（dict）、集合（set）、元组（tuple）
1.1 python 列表（list）
python支持多种复合数据类型，可将不同值组合在一起。其中最常用的列表 ，是用方括号 '[ ]' 标注，逗号分隔的一组值，列表可以包含不同类型的元素，但一般情况下各个元素的类型相同，并且列表内的数据有先后顺序关系，所以列表是一种可变的容器.
1.1.1 列表的创建
python中可以直接定义列表类型的变量，如：
list_1 = [] # 创建一个空的列表
list_2 = ['北京', '上海', '广州', '西安'] # 创建一个含有4个字符串的列表
list_3 = [1, 'Two', 3.14, True, False, None]
list_4 = [1, 2, [3.1, 3.2], 4] # 含有四个元素的列表，第三个元素是列表
list_5 = [
['姓名', '语文成绩', '数学成绩'],
['小王', 90, 100],
['牛犇', 59, 26]
] 也可以使用构造函数 ' list() ' 如：
list_1 = list() # L = []
list_2 = list("ABC") # L = ['A', 'B', 'C']
list_3 = list(range(5)) # L = [0, 1, 2, 3, 4]1.1.2 列表的运算
列表同字符串都是序列，他们的运算规则基本相同，其中 ' + ' 用于拼接列表、' += ' 追加、' * ' 用于生产重复的列表、' == / != ' 用于比较、' in / not in ' 用于判断一个数据元素是否在列表中.
list_1 = [1, 2, 3] + [4, 5, 6] # [1, 2, 3, 4, 5, 6]
list_2 = [1, 2, 3]
list_2 += "ABC" # L = [1, 2, 3, 'A', 'B', 'C']
list_3 = [1, 2] * 3 # [1, 2, 1, 2, 1, 2]
print([1, 2, 3] == [1, 2, 3]) # True
print([1, 2, 3] != [3, 2, 1]) # True
print("hello" in [1, "hello", 'world']) # True
print('红楼梦' in ['三国演义', '西游记']) # False1.1.3 列表值的访问
列表中值一般是通过索引（列表 [整数表达式] ）与切片（列表[ 开始索引b : 终止索引e : 步长s ]）进行访问.
索引访问：
list_1 = [1, 2, 3, 4, 5, 6]
print(list_1[0]) # 1
print(list_1[-1]) # 6
list_2 = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print(list_2[0]) # red
print(list_2[1]) # green
print(list_2[-1]) # black
print(list_2[-2]) # white切片访问：
x = [1, 2, 3, 4, 5, 6, 7, 8]
y1 = x[:4] # y1 = [1, 2, 3, 4]
y2 = x[::2] # y2 = [1, 3, 5, 7]
y3 = x[::-1] # y3 = [8, 7, 6, 5, 4, 3, 2, 1]
list_1 = ['openAI', 'hqyj', "Zhihu", "Taobao", "Wiki"]
print(list_1[1]) # 读取第二位
print(list_1[1:-2]) # 从第二位开始（包含）截取到倒数第二位（不包含）
print(list_1[2:]) # 从下标2开始(包含2)到最后一个
print(list_1[:3]) # 从下标0开始到下标3结束(左闭右开)1.1.4 列表数据操作(增、删、改、查)
1）python列表中数据的增添有三种方式：
| 方法名(L代表列表) | 说明 |
| L.append(x) | 向列表的末尾追加单个数据 |
| L.insert(index, obj) | 将某个数据obj 插入到 index这个索引位置的数据之前 |
| L.extend (可迭代对象) | 等同于: L += 可迭代对象，如列表、元组、字符串、集合等 |
示例如下：
my_list_1 = [1, 3, 4] # 目标是变成 [1, 2, 3, 4, 5]
my_list_1.append(5) # mylist1 = [1, 3, 4, 5]
my_list_1.insert(1, 2) # mylist1 = [1, 2, 3, 4, 5]
my_list_1.extend(range(6, 10)) # mylist1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]2）修改数据 (改)
用索引赋值可以改变列表内的数据（列表[整数表达式] = 表达式），示例如下：
my_list_2 = [1, 1.99, 3] # 把1.99 改为2
my_list_2[1] = 2 # [1, 2, 3]3）删除数据 (删)，包括del在内的删除有四种方法：
| 方法 | 说明 |
| L.remove(x) | 从列表L中删除第一次出现在列表中的数据元素，如果x不存在则报错 |
| L.pop() | 根据索引删除元素，并返回该元素。若不提供索引，默认删除最后一个元素 |
| L.clear() | 清空列表 |
示例如下：
list_1 = [1, 2, 3, 4, 2, 2, 3, 4]
list_1.remove(3) # list_1 = [1, 2, 4, 2, 2, 3, 4]
list_1.remove(3) # list_1 = [1, 2, 4, 2, 2, 4]
list_1.remove(3) # 报错
list_1.clear() # list_1 = []
list_2 = ['Google', 'Baidu', 'Taobao']
list_2.pop()
print("列表现在为 : ", list_2) # 列表现在为 : ['Google', 'Baidu']
list_2.pop(1)
print("列表现在为 : ", list_2) # 列表现在为 : ['Google']del 语句删除指定位置的数据元素，语法：del 变量名 / del 列表[整数表达式].
示例如下：
list_1 = ['张飞', '赵云', '鲁班7号', '孙悟空']
del list_1[2]
print(list_1) # L = ['张飞', '赵云', '孙悟空']
del list_1 # 删除 L 变量
print(list_1) # NameError: name 'L' is not defined4）查看的具体方法请参考 1.1.3 列表值的访问.
1.1.5 列表常用的API
列表的操作函数：
| 序号 | 函数 |
| 1 | len(list)列表元素个数 |
| 2 | max(list)返回列表元素最大值 |
| 3 | min(list)返回列表元素最小值 |
| 4 | list(seq)将元组转换为列表 |
列表的常用方法：
| 运算 | 结果 |
| s.index( x[, i[, j] ] ) | x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前） |
| s.count() | x 在 s 中出现的总次数 |
| s.append() | 将 x 添加到序列的末尾 (等同于 s[len(s):len(s)] = [x] ) |
| s.clear() | 从 s 中移除所有项 (等同于 del s[:] ) |
| s.copy() | 创建 s 的浅拷贝 (等同于 s[:]) |
| s.extend(t) 或 s += t | 用 t 的内容扩展 s (基本上等同于 s[len(s):len(s)] = t ) |
| s.insert(i, x) | 在由 i 给出的索引位置将 x 插入 s (等同于 s[i:i] = [x] ) |
| s.pop([i]) | 提取在 i 位置上的项，并将其从 s 中移除 |
| s.remove(x) | 删除 s 中第一个 s[i] 等于 x 的项目 |
| s.reverse() | 就地将列表中的元素逆序 |
| s.sort(key=None,reverse=False) | 对列表内的数据进行排序, reverse=False 升序排序，否则是降序排序 |
示例如下：
# len(list)：获取列表的与那苏个数(长度)
l = [1, 2, 3]
print(len(l))
# max(list)：获取列表中的最大元素值
print(max(l))
# min(list)：获取列表中最小元素值
print(min(l))
# list(seq)：将序列转换为列表，序列可以是元组、字符串等
print(list('abc'))
print(list((1, 2, 3)))
# index(x)：x在list中首次出现项的索引号
l = [1, 2, 2, 3]
print(l.index(2))
# count(x)：元素x在list中出现的次数
print(l.count(2))
# reverse()：列表反转
l.reverse()
print(l)
# sort(reverse)：排序，reverse=True表示升序排序，为False表示降序排序，默认为True
l = [5, 4, 6, 2, 8]
l.sort()
print(l)
l.sort(reverse=True)
print(l)1.2 python 元组（tuple）
在python中，元组是不可改变的列表，同列表list 一样，元组可以存放任意类型的数据，但是元组一旦创建将不可修改，包括添加、删除或更改其中的元素，而元组使用小括号 ( )，列表使用方括号 [ ].
1.2.1 元组的创建
创建元组的字面值时，用小括号() 括起来，单个元素括起来后加逗号来区分单个元素还是元组.
t = () # 空元组
t = (100,) # 含有一个数据元素的元组
t = 100, # 含有一个数据元素的元组，元组中只包含一个元素时，需要在元素后面添加逗号 ，否则括号会被当作运算符使用
t = (1, 2, 3) # 含有三个数据元素的元组
t = ('hqyj', 2004) # 存放不同类型的元组
t = 1, 2, 3 # 含有三个数据元素的元组创建元组的函数 tuple()
t = tuple() # t = ()
t = tuple(range(5)) # t = (0, 1, 2, 3, 4)1.2.2 元组的数据操作(删，查，运算)
1）删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，示例如下：
tup = ('openAI', 'hqyj', 100, 200)
print(tup)
del tup
print(tup) # name 'tup' is not defined
2）查看元组
元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等，示例如下：
tup1 = ('python', 'hqyj', 100, 200)
tup2 = (1, 2, 3, 4, 5, 6, 7)
print(tup1[0]) # python
print(tup2[1:5]) # (2, 3, 4, 5)
print(tup2[:4]) # (1, 2, 3, 4)
print(tup2[2:]) # (3, 4, 5, 6, 7)3）元组的运算
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，示例如下：
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)
t = (1, 2, 3) + (4, 5, 6)
t += (7, 8, 9) # 等同于 t = t + (7, 8, 9)
t = t * 2
t *= 2
print(5 in t) # True所谓元组的不可变指的是元组所指向的内存中的内容不可变，例：
tup = (1, 2, 3, 4, 5, 6, 7)
tup[1] = 100
print(tup) # 报错'tuple' object does not support item assignment1.2.3 元组常用API
元组包含了以下内置函数：
| 方法 | 描述 |
| len(tuple) | 返回元组中元素个数 |
| max(tuple) | 返回元组中元素最大值 |
| min(tuple) | 返回元组中元素最小值 |
| tuple(list) | 将列表转换为元组 |
元组常用的方法：
| 运算 | 结果 |
| s.index(x[, i[, j]]) | 元素 x 在 s 中首次出现项的索引号，i(可选)：搜索的起始索引。如果省略，将从元组的开头开始搜索，j(可选)：搜索的结束索引。如果省略，将搜索到元组的末尾 |
| s.count(x) | x 在 s 中出现的总次数 |
1.3 python 字典（dict）
python中的字典是一种可变容器模型，且可存储任意类型对象，其中的数据都是以键(key)-值(value)对的形式进行映射存储，每个键值对( key:value )用冒号分割，每个对之间用逗号分割，整个字典包括在花括号 {} 中（例：' d = {key1 : value1, key2 : value2, key3 : value3 } ' ）
且字典的数据在Python 3.7及更高版本中，字典是有序的；3.6之前的版本中，字典是无序的，字典的键不能重复，且只能用不可变类型作为字典的键；字典中的数据只能用"键"key 进行索引，不能用整数进行索引.
1.3.1 字典的创建
创建字典的字面值时，其表示方式需用 {} 括起来， 以英文的冒号 (:) 分隔键值对，各键值对之间用逗号 (,) 分隔，示例如下：
d = {} # 创建空字典
d = {'name': "weimingze", "age": 35}
d = {'a': [1, 2, 3]}
d = {'b': {"bb": 222}}
d = {1: '壹', 2: '贰', 5: '伍'}
d = {(1, 2, 3): '壹贰伍'}注意字典创建时容易存在的问题：1. 字典的键必须是唯一的，但值则不必；2. 字典的值值可以取任何数据类型，但键必须是不可变的，如字符串，数字.
d = {'a': 1, 'b': 2, 'a': 3} # 字典的键不能重复 d = {'a': 3, 'b': 2}
d = {[1, 2, 3]: 'a'} # 不能用可变类型作为字典的键 # 报错字典的创建函数 dict()
d = dict() # d = {}
d = dict([("name", "小王"), ("age", 35)]) # {'name': '小王', 'age': 35}
d = dict(a=1, b=2, c=3) # {'a':1, 'b':2, 'c':3}
d = dict([1, 2, 3, 4]) # 报错1.3.2 字典的数据操作(增、删、改、查)
1）增加和修改字典
添加和修改字典的元素，语法：' 字典[键key] = 表达式 ' ，当键不存在时，会创建键并绑定键对应的值，当键存在时，会改变键对应的值，例：
d = {}
d['name'] = 'tarena' # 添加键值对 d = {'name': 'tarena'}
d['age'] = 18 # d = {'name': 'tarena', 'age': 18}
d['age'] = 19 # 改变 'age' 键对应的值 d = {'name': 'tarena', 'age': 19}2）访问字典里的值
字典的值通过访问键索引访问，语法：' 字典[键key] '，用键索引可以查看字典中的数据，例：
d = {'one': 1, 'two': 2}
print(d['two'])如果用字典里没有的键访问数据，会输出错误，例：
mydic = {'Name': 'hqyj', 'Age': 7, 'Class': 'First'}
print(mydic['Alice'])注：判断一个键是否存在于字典中时，可以使用 ' in / not in ' 运算符，根据判断结果返回True, 或者返回False，例：
d = dict(a=1, b=2) # d = {'a': 1, 'b': 2}
print('a' in d) # True
print(1 in d) # False
print('hello' not in d) # True3）删除字典元素
字典能删单一的元素也能一次性清空所有元素，并且清空所有元素只需用del命令一项操作，语法：' del 字典[键] ' ，例：
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# 删除指定的键
del dic['a']
print(dic)
# 删除指定的键，并可选地返回其值
v1 = dic.pop('b')
print(v1)
print(dic)
# 删除并返回最后一个插入的键值对
key, value = dic.popitem()
print(key, value)
print(dic)
# 删除字典中的所有项
dic.clear()
print(dic)
# 删除字典
del dic
print(dic) # NameError: name 'dic' is not defined1.3.3 字典的特性
字典值可以是任何的python对象，既可以是标准的对象，也可以是用户定义的，但键不行.
1）在字典中不允许同一个键出现两次，创建字典时如果同一个键被赋值两次，只有后一个值会被记住，例：
mydic = {'Name': 'jack', 'Age': 27, 'Name': 'karen'}
print(mydic['Name'])2）创建好的字典中的键不可变，所以在创建字典中的键时可以用数字，字符串或元组充当，而用列表等就不行，例：
mydic1 = {97: "a", 98: "b"}
mydic2 = {"name": "karen", "age": 27}
mydic3 = {['Name']: 'karen', 'Age': 27}
print(mydic3[['Name']]) # 报错unhashable type: 'list'注：python中有四种可变类型，列表（list）、字典（dict）、集合（set）、字节数组 （bytearray）
3）字典是可迭代对象, 字典只能对所有的键进行迭代访问，默认访问键，例：
d = {'name': 'tarena', 'age': 19}
for k in d:
print(k) # name, age
for k in d:
print("key=", k, 'value=', d[k]) # key=name, value=tarena, key=age, value=19当然，字典可以使用 ' for ' 循环来遍历字典的键和值。可以使用 'dict.keys() ' 方法遍历键，使用 ' dict.values() ' 方法遍历值，使用 ' dict.items() ' 方法同时遍历键和值，例：
# 1.遍历字典的键:
my_dict = {'a': 1, 'b': 2, 'c': 3}
for key in my_dict.keys():
print(f"Key: {key}") # 输出：Key: a Key: b Key: c
# 2.遍历字典的值:
my_dict = {'a': 1, 'b': 2, 'c': 3}
for value in my_dict.values():
print(f"Value: {value}") # 输出：Value: 1 Value: 2 Value: 3
# 3.同时遍历字典的键和值:
my_dict = {'a': 1, 'b': 2, 'c': 3}
for key, value in my_dict.items():
print(f"Key: {key}, Value: {value}") # 输出：Key: a, Value: 1 Key: b, Value: 2 Key: c, Value: 31.3.4 字典常用API
操作字典的函数有：
| 函数 | 描述 |
| len(dict) | 计算字典元素个数，即键的总数 |
| str(dict) | 输出字典，可以打印的字符串表示 |
| type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型 |
字典中的方法有：
| 序号 | 函数 | |
| 1 | dict.clear() | 删除字典内所有元素 |
| 2 | dict.copy() | 返回一个字典的浅复制 |
| 3 | dict.fromkeys(seq) | 创建一个新字典，以序列 seq 中元素做字典的键，val为字典所有键对应的初始值，如果未提供，则所有键的值将被设置为 ' None ' |
| 4 | dict.get(key, default=None) | 返回指定键的值，如果键不在字典中返回 default 设置的默认值 |
| 5 | key in dict | 如果键在字典 dic t里返回 true ，否则返回 false |
| 6 | dict.items() | 以列表返回一个视图对象 |
| 7 | dict.keys() | 返回一个视图对象 |
| 8 | dict.setdefault(key, default=None) | 和 get() 类似，但如果键不存在于字典中，将会添加键并将值设为 default |
| 9 | dict.update(dict2) | 把字典 dict2 的 键/值 对更新到 dict 里 |
| 10 | dict.values() | 返回一个视图对象 |
| 11 | pop(key,default) | 删除字典 key(键)所对应的值，返回被删除的值 |
| 12 | popitem() | 返回并删除字典中的最后一对键和值 |
例：
original_dict = {'a': 1, 'b': [1, 2, 3]}
shallow_copied_dict = original_dict.copy()
# 修改原始字典中的可变对象
# 对于可变对象（如列表、字典），修改原始字典中的值会影响浅复制的字典，因为它们引用的是同一个对象
original_dict['b'].append(4)
# 对于不可变对象（如整数、字符串、元组），修改原始字典中的值不会影响浅复制的字典。
original_dict['a'] = 2
print(original_dict) # 输出: {'a': 2, 'b': [1, 2, 3, 4]}
print(shallow_copied_dict) # 输出: {'a': 1, 'b': [1, 2, 3, 4]}# 创建一个新字典，键为列表中的元素，值为None
keys = ['a', 'b', 'c']
new_dict = dict.fromkeys(keys)
print(new_dict) # 输出: {'a': None, 'b': None, 'c': None}
# 创建一个新字典，键为列表中的元素，值为指定的值
value = 0
new_dict = dict.fromkeys(keys, value)
print(new_dict) # 输出: {'a': 0, 'b': 0, 'c': 0}
# 如果提供的 value 是不可变对象（如整数、字符串、元组等），每个键将有一个独立的值副本
new_dict['a'] = 1
print(new_dict)
# 如果提供的值是可变对象（如列表、字典等），那么所有键将共享同一个可变对象。这意味着对这个可变对象的任何修改都会反映在所有键的值上。
keys = ['a', 'b', 'c']
value = []
new_dict = dict.fromkeys(keys, value)
print(new_dict) # 输出: {'a': [], 'b': [], 'c': []}
# 修改可变对象
new_dict['a'].append('x')
print(new_dict) # 输出: {'a': ['x'], 'b': ['x'], 'c': ['x']}# 返回指定键的值，如果键不在字典中返回 default 设置的默认值
dict = {'a': 1, 'b': 2}
print(dict.get('c'))
print(dict.get('c', 0))
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
# 使用 dict.update() 更新 dict1
# 如果 dict1 中已经存在 dict2 的键，则 dict1 中的值会被 dict2 中的值覆盖
dict1.update(dict2)
print(dict1) # 输出: {'a': 1, 'b': 3, 'c': 4}1.4 python 集合（set）/固定集合（frozenset）
python中集合是可变的容器，固定集合是不可变的集合，集合相当于只有键没有值的字典，是无序的不重复元素的存储结构，并且集合内的数据都是唯一的，不可变的
1.4.1 集合的创建
创建集合的方式，语法：空集合（set()），非空集合（用 {} 括起来，值用逗号分隔开），例：
s = set() # 用函数空集合
s = {1, 2, 3, 4} # 创建非空集合的字面值
s = set(range(5)) # 调用 set(可迭代对象) 来创建集合 s = {0, 1, 2, 3, 4}
s = set("ABC") # s = {'B', 'C', 'A'}
s = set("ABCCCCCCC") # s = {'B', 'C', 'A'}
s = set(['ABC']) # s = {'ABC'} 使用 set()函数从列表创建集合
s = set((4, 5, 6, 7)) # 使用 set()函数从元组创建集合创建固定集合 frozensets 的方式如下：
fs = frozenset() # 空固定集合 fs = frozenset()
fs = frozenset([1, 2, 3]) # fs = frozenset({1, 2, 3})1.4.2 集合的数据操作(增、删)
1）添加元素
集合中当元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作，常用函数如下：
| 函数 | 描述 |
| s.add(x) | 添加元素到集合 |
| s.update(x) | 添加元素到集合，且参数可以是列表，元组，字典等，x 可以有多个，用逗号分开 |
例：
s1 = set((4, 5, 6, 7))
s1.add(100)
print(s1) # 输出：{100, 4, 5, 6, 7}
s1.update([200, 300])
print(s1) # 输出：{100, 4, 5, 6, 7, 200, 300}2）删除元素
常用函数如下：
| 函数 | 描述 |
| s.remove( x ) | 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误 |
| s.discard( x )) | 将元素 x 从集合 s 中移除，如果元素不存在，不会发生错误 |
| s.pop()) | 对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除 |
例：
s1 = {10, 20, 30}
s1.remove(20)
print(s1)
s1.remove(40) # 报错
s2 = {10, 20, 30}
s2.discard(20)
print(s2)
s2.discard(40)
s3 = {10, 20, 30}
s3.pop()
print(s3)
del s3 # 也可以直接删除整个集合注：集合（set）没有索引查看的功能，集合是一种无序、不可重复的数据结构，用于存储唯一的元素，由于集合是无序的，所以不能通过索引来访问其中的元素，所以也没有对应的修改功能
1.4.3 集合内置方法常用API
常见的方法如下：
| 序号 | 方法 | 描述 |
| 1 | add() | 为集合添加元素 |
| 2 | clear() | 移除集合中的所有元素 |
| 3 | copy() | 拷贝一个集合 |
| 4 | difference() | 返回多个集合的差集，返回一个新集合 |
| 5 | difference_update() | 移除集合中的元素，该元素在指定的集合也存在。直接修改第一个集合 |
| 6 | discard() | 删除集合中指定的元素 |
| 7 | intersection() | 返回集合的交集，返回一个新集合 |
| 8 | intersection_update() | 返回集合的交集。直接修改第一个集合 |
| 9 | isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False |
| 10 | issubset() | 判断指定集合是否为该方法参数集合的子集 |
| 11 | issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| 12 | pop() | 随机移除元素 |
| 13 | remove() | 移除指定元素 |
| 14 | symmetric_difference() | 返回两个集合中不重复的元素集合 |
| 15 | symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中 |
| 16 | union() | 返回两个集合的并集 |
| 17 | update() | 给集合添加元素 |
| 18 | len() | 计算集合元素个数 |
例：
# 1.len()
s1 = {10, 20, 30}
print(len(s1))
# 2. clear()
s1 = {10, 20, 30}
s1.clear()
print(s1)
# 3.union()
set1 = {1, 2, 3}
set2 = {3, 4, 5}
set3 = {5, 6, 7}
result = set1.union(set2, set3)
print(result) # 输出：{1, 2, 3, 4, 5, 6, 7}2. python 推导式
python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体，python支持各种数据结构的推导式：列表(list)推导式、字典(dict)推导式、集合(set)推导式、元组(tuple)推导式
2.1 列表推导式
语法规则：[ 表达式 for 自定义变量 in 可迭代对象 ] 或
[ 表达式 for 自定义变量 in 可迭代对象 if 真值表达式 ]
例：
# 生成一个列表， 里面有 100 个数是[1, 4, 9, 16, 25, ...]
# 用 for 语句实现
L = []
for x in range(1, 101):
L.append(x ** 2)
print(L)
# 用列表推导式
L2 = [x ** 2 for x in range(1, 101)]
print(L2)
L3 = []
for x in range(1, 101):
if x % 2 == 0:
L3.append(x ** 2)
L3 = [x ** 2 for x in range(1, 101) if x % 2 == 0] # 取出所有的偶数
# L3 = [4, 16, 36, ...]2.2 字典推导式
语法规则：{ 键表达式: 值表达式 for 元素 in 集合 } 或
{ 键表达式: 值表达式 for 元素 in 集合 if 条件 }
例：
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
listdemo = ['karen', 'jack', 'marry']
newdict = {key: len(key) for key in listdemo}
print(newdict) # {'karen': 5, 'jack': 4, 'marry': 5}
# 提供三个数字，以三个数字为键，三个数字的平方为值来创建字典：
dic = {x: x ** 2 for x in (2, 4, 6)}
print(dic) # {2: 4, 4: 16, 6: 36}2.3 集合推导式
语法规则：{ 表达式 for 元素 in 序列 } 或
{ 表达式 for 元素 in 序列 if 条件 }
例：
# 计算数字 1,2,3 的平方数：
setnew = {i ** 2 for i in (1, 2, 3)}
print(setnew) # {1, 4, 9}
# 判断不是 abc 的字母并输出：
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a) # {'d', 'r'}2.4 元组推导式
语法规则：(表达式 for 元素 in 序列 ) 或
(表达式 for 元素 in 序列 if 条件 )
例：
# 生成一个包含数字 1~9 的元组
a = (x for x in range(1, 10))
print(a) # 返回的是生成器对象
print(tuple(a)) # 使用 tuple() 函数，可以直接将生成器对象转换成元组
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
