if语法
if True:
print('条件成⽴执⾏的代码1')
print('条件成⽴执⾏的代码2')
# 下⽅的代码没有缩进到if语句块，所以和if条件⽆关
print('我是⽆论条件是否成⽴都要执⾏的代码')
if …else …
if 条件:
条件成⽴执⾏的代码1
条件成⽴执⾏的代码2
......
else:
条件不成⽴执⾏的代码1
条件不成⽴执⾏的代码2
多重判断
if 条件1:
条件1成⽴执⾏的代码1
条件1成⽴执⾏的代码2
......
elif 条件2：
条件2成⽴执⾏的代码1
条件2成⽴执⾏的代码2
......
......
else:
以上条件都不成⽴执⾏执⾏的代码
例子
money = 1
seat = 0
if money == 1:
print('⼟豪，不差钱，顺利上⻋')
if seat == 1:
print('有空座，可以坐下')
else:
print('没有空座，站等')
else:
print('没钱，不能上⻋，追着公交⻋跑')
random模块
-
导出random模块
import 模块名
-
使⽤random模块中的随机整数功能
import 模块名
random.randint(开始,结束) #包含开始和结束值
三目运算符：
语法如下：
条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式
# 例子
a = 1
b = 2
c = a if a > b else b
print(c)
# 两个变量比较大小 变量1 大于变量2
aa = 10
bb = 6
cc = aa - bb if aa > bb else bb - aa
print(cc)
循环
作用：让代码高效重复执行
while循环
计算机的习惯：从零计数
while 条件:
条件成⽴重复执⾏的代码
条件成⽴重复执⾏的代码
# 例子 累加1~100
i= 1
result = 0
while i <= 100:
result += i
i += 1
# 输出5050
print(result)
# 为了验证程序的准确性，可以先改⼩数值，验证结果正确后，再改成1-100做累加。
注意：计数器的变换，否则容易陷入死循环
break和continue
break和continue是循环中满⾜⼀定条件退出循环的两种不同⽅式。
break控制循环流程，即终⽌此循环
continue控制循环流程，即退出当前⼀次循环继⽽执⾏下⼀次循环代码。
# break：当某些条件成立，退出整个循环
i = 1
while i <= 5:
# 条件：如果吃到4 或 > 3 打印吃饱了不吃了
if i == 4:
print('吃饱了，不吃了')
break
print(f'吃了第{i}个苹果')
i += 1
# continue : 当条件成立，退出当前一次循环，继而执行下一次循环
i = 1
while i <= 5:
# 条件
if i == 3:
print('吃出一个大虫子，这个苹果不吃了')
# 如果使用continue，在continue之前一定要修改计数器，否则进入死循环
i += 1
continue
print(f'吃了第{i}个苹果')
i += 1
# 例子九九乘法表
j = 1
while j <= 9:
# 一行的表达式开始
i = 1
while i <= j:
print(f'{i} * {j} = {i*j}', end='\t')
i += 1
# 一行的表达式结束
print()
j += 1
while…else
while 条件:
条件成⽴重复执⾏的代码
else:
循环正常结束之后要执⾏的代码
# break
i = 1
while i <= 5:
if i == 3:
print('这遍说的不真诚')
break #所谓else指的是循环正常结束之后要执⾏的代码，即如果是break终⽌循环的情况， else下⽅缩进的代码将不执⾏
print('媳妇⼉，我错了')
i += 1
else:
print('媳妇原谅我了，真开⼼，哈哈哈哈')
#continue
i = 1
while i <= 5:
if i == 3:
print('这遍说的不真诚')
i += 1
continue #因为continue是退出当前⼀次循环，继续下⼀次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执⾏了else缩进的代码。
print('媳妇⼉，我错了')
i += 1
else:
print('媳妇原谅我了，真开⼼，哈哈哈哈')
for循环
for 临时变量 in 序列:
重复执⾏的代码1
重复执⾏的代码2
例子
str1 = 'itheima'
for i in str1:
print(i)
# break
str1 = 'itheima'
for i in str1:
if i == 'e':
print('遇到e不打印')
break
print(i)
# continue
str1 = 'itheima'
for i in str1:
if i == 'e':
print('遇到e不打印')
continue
print(i)
for… else
for 临时变量 in 序列:
重复执⾏的代码
...
else:
循环正常结束之后要执⾏的代码
#break 没有执⾏else缩进的代码
str1 = 'itheima'
for i in str1:
if i == 'e':
print('遇到e不打印')
break
print(i)
else:
print('循环正常结束之后执⾏的代码')
# continue 因为continue是退出当前⼀次循环，继续下⼀次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执⾏了else缩进的代码。
str1 = 'itheima'
for i in str1:
if i == 'e':
print('遇到e不打印')
continue
print(i)
else:
print('循环正常结束之后执⾏的代码')
字符串
字符串特征
#⼀对引号字符串
a = 'hello world' #当敲入回车时
a = 'hello ' \
'world'
print(a)
print(type(a))
b = "TOM"
print(type(b))
#三引号字符串
#注意：三引号形式的字符串⽀持换⾏。
e = '''i am TOM'''
print(type(e))
f = """I
am TOM"""
print(type(f))
print(f)
# 将单引号打印出来
# d = 'I'm TOM'
d = 'I\'m TOM'
print(d)
print(type(d))
下标
下标的作⽤即是通过下标快速找到对应的数据
str1 = 'abcdefg'
print(str1)
# 数据在程序运行过程中存储在内存
# ？ 得到数据a字符， 得到数据b字符 -- 使用字符串中某个特定的数据
# 这些字符数据从0开始顺序分配一个编号 -- 使用这个编号精确找到某个字符数据 -- 下标或索引或索引值
# str1[下标]
print(str1[0])
print(str1[1])
注意：下标从0开始
切片
切⽚是指对操作的对象截取其中⼀部分的操作。 字符串、列表、元组都⽀持切⽚操作
- 不包含结束位置下标对应的数据， 正负整数均可；
- 步⻓是选取间隔，正负整数均可，默认步⻓为1。
# 序列名[开始位置的下标:结束位置的下标:步长]
str1 = '012345678'
# print(str1[2:5:1]) # 234
print(str1[2:5:2]) # 24
print(str1[2:5]) # 234
print(str1[:5]) # 01234 -- 如果不写开始，默认从0开始选取
print(str1[2:]) # 2345678 -- 如果不写结束，表示选取到最后
print(str1[:]) # 012345678 -- 如果不写开始和结束，表示选取所有
# 负数测试
print(str1[::-1]) # 876543210 -- 如果步长为负数，表示倒叙选取
print(str1[-4:-1]) # 567 -- 下标-1表示最后一个数据，依次向前类推
# 终极测试
print(str1[-4:-1:1]) # 567
print(str1[-4:-1:-1]) #不能选取出数据：从-4开始到-1结束，选取方向为从左到右，但是-1步长：从右向左选取
# **** 如果选取方向(下标开始到结束的方向) 和 步长的方向冲突，则无法选取数据
print(str1[-1:-4:-1]) # 876
判断
mystr = "hello world and itcast and itheima and Python"
# 1. startswith(): 判断字符串是否以某个子串开头
# print(mystr.startswith('hello'))
# print(mystr.startswith('hel'))
# print(mystr.startswith('hels'))
# 2. endswith(): 判断字符串是否以某个子串结尾
# print(mystr.endswith('Python'))
# print(mystr.endswith('Pythons'))
# 3. isalpha(): 字母
# print(mystr.isalpha())
# 4. isdigit(): 数字
# print(mystr.isdigit())
mystr1 = '12345'
# print(mystr1.isdigit())
# 5. isalnum() : 数字或字母或组合
# print(mystr1.isalnum())
# print(mystr.isalnum())
mystr2 = 'abc123'
# print(mystr2.isalnum())
# 6.isspace(): 空白
# print(mystr.isspace())
mystr3 = ' '
# print(mystr3.isspace())
列表
列表可以⼀次性存储多个数据，且可以为不同数据类型。
[数据1, 数据2, 数据3, 数据4......]
查找
下标
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tom
print(name_list[1]) # Lily
print(name_list[2])
函数
'''
index()：返回指定数据所在位置的下标
列表序列.index(数据, 开始位置下标, 结束位置下标)
如果查找的数据不存在则报错。
count()：统计指定数据在当前列表中出现的次数。
len()：访问列表⻓度，即列表中数据的个数。
'''
name_list = ['TOM', 'Lily', 'ROSE']
# 1. index()
# print(name_list.index('TOM'))
# print(name_list.index('TOMS'))
# 2. count()
# print(name_list.count('TOM'))
# print(name_list.count('TOMS'))
# 3.len()
print(len(name_list))
判断是否存在
'''
in：判断指定数据在某个列表序列，如果在返回True，否则返回False
not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False
'''
name_list = ['TOM', 'Lily', 'ROSE']
# 1. in
# print('TOM' in name_list)
# print('TOMS' in name_list)
# 2. not in
# print('TOM' not in name_list)
print('TOMs' not in name_list)
增加
增加指定数据到列表中。
'''
append()：列表结尾追加数据。
列表序列.append(数据)
列表追加数据的时候，直接在原列表⾥⾯追加了指定数据，即修改了原列表，故列表为可变类型
数据。
列表数据可改的 -- 列表可变类型
append函数追加数据的时候如果数据是一个序列，追加整个序列到列表的结尾
extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表
列表序列.extend(数据)
extend() 追加数据是一个序列，把数据序列里面的数据拆开然后逐一追加到列表的结尾
nsert()：指定位置新增数据。
列表序列.insert(位置下标, 数据)
'''
name_list = ['TOM', 'Lily', 'ROSE']
# name_list.append('xiaoming')
name_list.append([11, 22])
print(name_list)
name_list = ['TOM', 'Lily', 'ROSE']
# name_list.extend('xiaoming')
name_list.extend(['xiaoming', 'xiaohong'])
print(name_list)
name_list = ['TOM', 'Lily', 'ROSE']
# name_list.insert(下标, 数据)
name_list.insert(1, 'aaa')
print(name_list)
删除
'''
del ⽬标
pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据
列表序列.pop(下标)
remove()：移除列表中某个数据的第⼀个匹配项
列表序列.remove(数据)
clear()：清空列表
'''
name_list = ['TOM', 'Lily', 'ROSE']
# 1. del
# del name_list
# del(name_list)
# del 可以删除指定下标的数据
# del name_list[0]
# print(name_list)
# 2. pop() -- 删除指定下标的数据，如果不指定下标，默认删除最后一个数据，
# 无论是按照下标还是删除最后一个，pop函数都会返回这个被删除的数据
# del_name = name_list.pop()
# del_name = name_list.pop(1)
# print(del_name)
# print(name_list)
# 3. remove(数据)
# name_list.remove('ROSE')
# print(name_list)
# 4. clear() -- 清空
name_list.clear()
print(name_list)
修改
修改指定下标数据
'''
逆置： reverse()
排序： sort()
列表序列.sort( key=None, reverse=False)
reverse表示排序规则， reverse = True 降序， reverse = False 升序（默认）
'''
name_list = ['TOM', 'Lily', 'ROSE']
# 1. 修改指定下标的数据
# name_list[0] = 'aaa'
# print(name_list)
# 2. 逆序 reverse()
list1 = [1, 3, 2, 5, 4, 6]
# list1.reverse()
# print(list1)
# 3. sort() 排序：升序(默认) 和 降序
# list1.sort()
# list1.sort(reverse=False)
list1.sort(reverse=True)
print(list1)
复制
'''
copy()
'''
name_list = ['TOM', 'Lily', 'ROSE']
list1 = name_list.copy()
print(list1)
print(name_list)
遍历
依次打印列表中的各个数据。
name_list = ['TOM', 'Lily', 'ROSE']
'''
1. 准备表示下标数据
2. 循环while
条件 i < 3 len()
遍历：依次按顺序访问到序列的每一个数据
i += 1
'''
i = 0
while i < len(name_list):
print(name_list[i])
i += 1
name_list = ['TOM', 'Lily', 'ROSE']
for i in name_list:
# 遍历序列中的数据
print(i)
镶嵌
'''
所谓列表嵌套指的就是⼀个列表⾥⾯包含了其他的⼦列表。
'''
name_list = [['TOM', 'Lily', 'Rose'], ['张三', '李四', '王五'], ['xiaohong', 'xiaoming', 'xiaolv']]
# print(name_list)
# 列表嵌套的时候的数据查询
# print(name_list[0])
print(name_list[0][1])
元组
⼀个元组可以存储多个数据，元组内的数据是不能修改的。
元组特点：定义元组使⽤⼩括号，且逗号隔开各个数据，数据可以是不同的数据类型。
果定义的元组只有⼀个数据，那么这个数据后⾯也好添加逗号，否则数据类型为唯⼀的
这个数据的数据类型
# 1. 多个数据元组
t1 = (10, 20, 30)
# print(type(t1))
# 2. 单个数据的元组
t2 = (10,)
# print(type(t2))
# 3. 如果单个数据的元组不加逗号
t3 = (10)
# print(type(t3)) # int
t4 = ('aaa')
# print(type(t4)) # str
t5 = ('aaa',)
print(type(t5))
######################
t1 = ('aa', 'bb', 'cc', 'bb')
# 1. 下标
# print(t1[0])
# 2. index()
# print(t1.index('bb'))
# print(t1.index('bbb'))
# 3. count()
# print(t1.count('aa'))
# print(t1.count('aaa'))
# 4. len()
print(len(t1))
# 但是如果元组⾥⾯有列表，修改列表⾥⾯的数据则是⽀持的，故⾃觉很重要。
t1 = ('aa', 'bb', 'cc', 'bb')
# t1[0] = 'aaa'
t2 = ('aa', 'bb', ['cc', 'dd'])
# print(t2[2])
# print(t2[2][0])
t2[2][0] = 'TOM'
print(t2)
字典
字典⾥⾯的数据是以键值对形式出现 ，特点：
- 符号为⼤括号
数据为键值对形式出现
各个键值对之间⽤逗号隔开
- 字典为可变类型
⼀般称冒号前⾯的为键(key)，简称k；冒号后⾯的为值(value)，简称v。
# {} 键值对 各个键值对用逗号隔开
# 1. 有数据的字典： name的值TOM， age的值是20， gender的值是男
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
# print(dict1)
# print(type(dict1))
# 2. 创建空字典
dict2 = {}
# print(type(dict2))
dict3 = dict()
print(type(dict3))
常见操作
# 增加： 如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
# 字典序列[key] = 值
# id的值是110
dict1['id'] = 110
print(dict1)
dict1['name'] = 'ROSE'
print(dict1)
#删
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
# del 删除字典或指定的键值对
# del(dict1)
# print(dict1)
# del dict1['name']
# del dict1['names'] # 报错
# print(dict1)
# clear() 清空字典
dict1.clear()
print(dict1)
#改 字典序列[key] = 值
# 注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
# dict1['name'] = 'Lily'
# print(dict1)
dict1['id'] = 110
print(dict1)
#查找
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
# 1. [key]
# print(dict1['name']) # 返回对应的值(key存在)
# print(dict1['names'])
# 2. 函数
# 2.1 字典序列.get(key, 默认值) 如果当前查找的key不存在则返回第⼆个参数(默认值)，如果省略第⼆个参数，则返回None。
# print(dict1.get('name'))
# print(dict1.get('names')) # 如果key不存在，返回None
# print(dict1.get('names', 'Lily'))
# 2.2 keys() 查找字典中所有的key，返回可迭代对象
# print(dict1.keys())
# 2.3 values() 查找字典中的所有的value，返回可迭代对象
# print(dict1.values())
# 2.4 items() 查找字典中所有的键值对，返回可迭代对象，里面的数据是元组，元组数据1是字典的key，元组数据2是字典key对应的值
print(dict1.items())
遍历
#key
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
for key in dict1.keys():
print(key)
#value
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
for value in dict1.values():
print(value)
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
#键值对
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
for item in dict1.items():
print(item)
#键值对拆包
# xx.items(): 返回可迭代对象，内部是元组，元组有2个数据
# 元组数据1是字典的key，元组数据2是字典的value
for key, value in dict1.items():
# print(key)
# print(value)
# 目标： key=value
print(f'{key}={value}')
集合
创建集合使⽤ {} 或 set() ， 但是如果要创建空集合只能使⽤ set() ，因为 {} ⽤来创建空字典。
- 集合可以去掉重复数据；
- 集合数据是⽆序的，故不⽀持下标
# 1. 创建有数据的集合
s1 = {10, 20, 30, 40, 50}
print(s1)
s2 = {10, 30, 20, 40, 30, 20}
print(s2)
s3 = set('abcdefg')
print(s3)
# 2. 创建空集合: set()
s4 = set()
print(s4)
print(type(s4))
s5 = {}
print(type(s5))
操作
#增加
s1 = {10, 20}
# 1. 集合是可变类型
# add()
# s1.add(100)
# print(s1)
# 集合有去重功能，如果追加的数据是集合已有数据，则什么事情都不做
# s1.add(100)
# print(s1)
# s1.add([10, 20, 30]) # 报错
# print(s1)
# update()： 增加的数据是序列
s1.update([10, 20, 30, 40, 50])
print(s1)
# s1.update(100) # 报错
# print(s1)
#删除
s1 = {10, 20, 30, 40, 50}
# remove(): 删除指定数据，如果数据不存在报错
# s1.remove(10)
# print(s1)
# s1.remove(10) # 报错
# print(s1)
# discard()：删除指定数据，如果数据不存在不报错
# s1.discard(10)
# print(s1)
# s1.discard(10)
# print(s1)
# pop(): 随机删除某个数据，并返回这个数据
del_num = s1.pop()
print(del_num)
print(s1)
#查找
s1 = {10, 20, 30, 40, 50}
# in 或not in 判断数据10是否存在
print(10 in s1)
print(10 not in s1)
公共操作
运算符
| 运算符 |
描述 |
⽀持的容器类型 |
| + |
合并 |
字符串、列表、元组 |
| * |
复制 |
字符串、列表、元组 |
| in |
元素是否存在 |
字符串、列表、元组、字典 |
| not in |
元素是否不存在 |
字符串、列表、元组、字典 |
#合并
# 1. 字符串
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3) # aabb
# 2. 列表
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3) # [1, 2, 10, 20]
# 3. 元组
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(t3) # (10, 20, 100, 200)
# 复制
# 1. 字符串
print('-' * 10) # ----------
# 2. 列表
list1 = ['hello']
print(list1 * 4) # ['hello', 'hello', 'hello', 'hello']
# 3. 元组
t1 = ('world',)
print(t1 * 4) # ('world', 'world', 'world', 'world')
#存在
# 1. 字符串
print('a' in 'abcd') # True
print('a' not in 'abcd') # Fal
# 2. 列表
list1 = ['a', 'b', 'c', 'd']
print('a' in list1) # True
print('a' not in list1) # Fals
# 3. 元组
t1 = ('a', 'b', 'c', 'd')
print('aa' in t1) # False
print('aa' not in t1) # True
公共方法
| 函数 |
描述 |
| len() |
计算容器中元素个数 |
| del 或 del() |
删除 |
| max() |
返回容器中元素最⼤值 |
| min() |
返回容器中元素最⼩值 |
| range(start, end, step) |
⽣成从start到end的数字，步⻓为 step，供for循环使⽤ |
| enumerate() |
函数⽤于将⼀个可遍历的数据对象(如列表、元组或字符串)组合为⼀个索引序 列，同时列出数据和数据下标，⼀般⽤在 for 循环当中。 |
#len
# 1. 字符串
str1 = 'abcdefg'
print(len(str1)) # 7
# 2. 列表
list1 = [10, 20, 30, 40]
print(len(list1)) # 4
# 3. 元组
t1 = (10, 20, 30, 40, 50)
print(len(t1)) # 5
# 4. 集合
s1 = {10, 20, 30}
print(len(s1)) # 3
# 5. 字典
dict1 = {'name': 'Rose', 'age': 18}
print(len(dict1)) # 2
#del
# 1. 字符串
str1 = 'abcdefg'
del str1
print(str1)
# 2. 列表
list1 = [10, 20, 30, 40]
del(list1[0])
print(list1) # [20, 30, 40]
#max
# 1. 字符串
str1 = 'abcdefg'
print(max(str1)) # g
# 2. 列表
list1 = [10, 20, 30, 40]
print(max(list1)) # 40
#min
# 1. 字符串
str1 = 'abcdefg'
print(min(str1)) # a
# 2. 列表
list1 = [10, 20, 30, 40]
print(min(list1)) # 10
#range range()⽣成的序列不包含end数字。
# 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):
print(i)
# 1 3 5 7 9
for i in range(1, 10, 2):
print(i)
# 0 1 2 3 4 5 6 7 8 9
for i in range(10):
print(i)
#不写步长默认为为1，不写开始默认从零开始
#enumerate：start参数⽤来设置遍历数据的下标的起始值，默认为0
list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1):
print(i)
for index, char in enumerate(list1, start=1):
print(f'下标是{index}, 对应的字符是{char}')
容器转换
list1 = [10, 20, 30, 20, 40, 50]
s1 = {100, 300, 200, 500}
t1 = ('a', 'b', 'c', 'd', 'e')
# tuple(): 转换成元组
# print(tuple(list1))
# print(tuple(s1))
# list()：转换成列表
# print(list(s1))
# print(list(t1))
# set()：转换成集合
print(set(list1))
print(set(t1))
#集合可以快速完成列表去重
#2. 集合不⽀持下标
推导式
简化代码
# 列表推导式
[xx for xx in range()]
# 字典推导式
{xx1: xx2 for ... in ...}
# 集合推导式
{xx for xx in ...}
列表推导式
⽤⼀个表达式创建⼀个有规律的列表或控制⼀个有规律列表。列表推导式⼜叫列表⽣成式。
# 需求：0， 1， 2,4..
# 1. 循环实现；2. 列表推导式(化简代码；创建或控制有规律的列表)
"""
1.1 创建空列表
1.2 循环将有规律的数据写入到列表
"""
# while实现-------------
# list1 = []
#
# i = 0
# while i < 10:
# list1.append(i)
# i += 1
#
# print(list1)
# for 实现--------------
# list1 = []
# for i in range(10):
# list1.append(i)
#
# print(list1)
# 列表推导式实现------------------------
list1 = [i for i in range(10)]
print(list1)
# 需求：0-10偶数数据的列表
# 1. 简单列表推导式 range步长
list1 = [i for i in range(0, 10, 2)]
print(list1)
# 2. for循环加if 创建有规律的列表
list2 = []
for i in range(10):
if i % 2 == 0:
list2.append(i)
print(list2)
# 3. 把for循环配合if的代码 改写 带if的列表推导式
list3 = [i for i in range(10) if i % 2 == 0]
print(list3)
# 多for的列表推导式等同于for循环嵌套
# [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
# 数据1 ： 1 和 2 range(1,3)
# 数据2 ：0 1 2 range(3)
list1 = []
for i in range(1, 3):
for j in range(3):
# 列表里面追加元组： 循环前准备一个空列表，然后这里追加元组数据到列表
list1.append((i, j))
print(list1)
# 多个for实现列表推导式
list2 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list2)
字典推导式
字典推导式作⽤：快速合并列表为字典或提取字典中⽬标数据。
# 创建字典 key是1-5的数字，v是这个数字的平方
# dict1 = {k: v for i in range(1, 5)}
dict1 = {i: i**2 for i in range(1, 5)}
print(dict1)
list1 = ['name', 'age', 'gender', 'id']
list2 = ['Tom', 20, 'man']
dict1 = {list1[i]: list2[i] for i in range(len(list2))}
print(dict1)
# 总结：
# 1. 如果两个列表数据个数相同，len统计任何一个列表的长度都可以
# 2. 如果两个列表数据个数不同，len统计数据多的列表数据个数会报错；len统计数据少的列表数据个数不会报错
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
# 1. 需求：提取电脑台数大于等于200
# 获取所有键值对数据，判断v值大于等于200 返回 字典
# print(counts.items())
dict1 = {key: value for key, value in counts.items() if value >= 200}
print(dict1)
集合推导式
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1)
# 集合有去重功能所以这个集合数据只有两个数据分别是1, 4
