史上最全python基础记录
一、Python简介
1. 了解Python
Python是一种解释型（这意味着开发过程中没有了编译这个环节）、面向对象（支持面向对象的风格或代码封装在对象的编程技术）、动态数据类型的交互式（可在命令行中通过Python提示符及直接代码执行程序）高级程序设计语言。
2. Python介绍
Python是时下最流行、最火爆的编程语言，具体原因：
简单、易学，适应人群广泛
免费、开源
应用领域广泛
3. Python特点
易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
易于阅读：Python代码定义的更清晰。
易于维护：Python的成功在于它的源代码是相当容易维护的。
一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
数据库：Python提供所有主要的商业数据库的接口。
GUI编程：Python支持GUI可以创建和移植到许多系统调用。
可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。
4. Python发展历史
Python发展历史：https://baike.baidu.com/item/Python/407313?fr=aladdin
5. Python版本
Python 2.X
Python 3.X
二、Python解释器
1. 解释器的作用
Python解释器作用：运行文件
Python解释器种类
PyPy，基于Python语言开发的解释器。
Jython，运行在Java平台的解释器，直接把Python代码编译成Java字节码执行。
IronPython，运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。
CPython，C语言开发的解释器[官方]，应用广泛的解释器。
IPython，基于CPython的一种交互式解释器。
其他解释器
2. 解释器的安装
Python解释器的安装：https://blog.csdn.net/weixin_43495473/article/details/103559812
三、PyCharm安装与使用
1. PyCharm的作用
PyCharm是一种Python IDE（集成开发环境），带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具，内部集成的功能如下：
Project管理
智能提示
语法高亮
代码跳转
调试代码
解释代码(解释器)
框架和库
…
2. PyCharm安装与使用
PyCharm的安装：https://blog.csdn.net/weixin_43495473/article/details/103560198
四、注释
1. 注释的作用
通过用自己熟悉的语言，在程序中对某些代码进行标注说明，这就是注释的作用，能够大大增强程序的可读性。
2. 注释的分类及语法
注释分为两类：单行注释 和 多行注释。
单行注释
只能注释一行内容，语法如下：
# 注释内容
多行注释
可以注释多行内容，一般用在注释一段代码的情况， 语法如下：
""" 第一行注释 第二行注释 第三行注释"""
''' 注释1 注释2 注释3'''
快捷键： ctrl + /
注意：解释器不执行任何的注释内容。
五、变量
1. 变量的作用
变量，简单来说，其实就是计算机内存中的一块储存空间，用来存储CPU需要使用的数据。而这个储存空间需要一个名字，这个名字的统称就叫变量。
作用：
用来临时保存数据
便于项目的后期升级维护
节约内存
2. 定义变量
变量名 = 值
变量名自定义，要满足标识符命名规则。
2.1 标识符
标识符命名规则是Python中定义各种名字的时候的统一规范，具体如下：
由数字、字母、下划线组成
不能数字开头
不能使用内置关键字
严格区分大小写
2.2 命名习惯
见名知义。
大驼峰：即每个单词首字母都大写，例如：MyName。
小驼峰：第二个（含）以后的单词首字母大写，例如：myName。
下划线：例如：my_name。
2.3 使用变量
my_name = "张三"
print(my_name)
myAge = 23
print(myAge)
2.4 认识bug
所谓bug，就是程序中的错误。如果程序有错误，需要程序员排查问题，纠正错误。
2.5 Debug工具
Debug工具是PyCharm IDE中集成的用来调试程序的工具，在这里程序员可以查看程序的执行细节和流程或者调解bug。
Debug工具使用步骤：
打断点
Debug调试
六、数据类型
在 Python 里为了应对不同的业务需求，也把数据分为不同的类型。
检测数据类型的方法：type(变量名或者数值)
a = 1print(type(a)) # <class 'int'> -- 整型
b = 1.1print(type(b)) # <class 'float'> -- 浮点型
c = Trueprint(type(c)) # <class 'bool'> -- 布尔型
d = "12345"print(type(d)) # <class 'str'> -- 字符串
e = [10, 20, 30]print(type(e)) # <class 'list'> -- 列表
f = (10, 20, 30)print(type(f)) # <class 'tuple'> -- 元组
h = {10, 20, 30}print(type(h)) # <class 'set'> -- 集合
g = {"name": "张三", "age": 20}print(type(g)) # <class 'dict'> -- 字典
思考：
为什么Python会提出这么多种的数据类型?
有限的内存, 无限的变量, 合理的使用内存
Python中，程序员定义变量需要关心变量的类型吗?
Python弱类型语言
程序员不需要关心变量的类型, 只需要把数据书写正确即可，python会通过自动推到出您变量的类型。
七、输出
作用：程序输出内容给用户。
print('hello Python')
age = 18
print(age)
# 需求：输出“今年我的年龄是18岁”
1. 格式化输出
%06d，表示输出的整数显示位数，不足以0补全，超出当前位数则原样输出。
%.2f，表示小数点后显示的小数位数。
2. 内置函数format
format()用于字符串格式化，功能非常强大，格式是str.format()，format函数可以接受不限个参数，位置可以不按顺序。
3. f-格式化字符串
f-string是格式化字符串的一种很好的新方法。与其他格式化方式相比，它不仅更易读，更简洁，不易出错，而且速度更快！格式为：f'{表达式}'。
4. 体验格式化字符串
name = "张三"age = 23weight = 75.5student_id = 1
# 我的名字是张三
print('我的名字是%s' % name)
# 我的学号是0001
print('我的学号是%04d' % student_id)
# 我的体重是75.50公斤
print('我的体重是%.2f公斤' % weight)
# 我的名字是张三，今年23岁了
print('我的名字是%s，今年%d岁了' % (name, age))
# 我的名字是张三，明年24岁了
print('我的名字是%s，明年%d岁了' % (name, age + 1))
# 我的名字是张三，明年24岁了
print('我的名字是{0}, 明年{1}岁了'.format(name, age+1))
# 我的名字是李思，今年18岁了
print('我的名字是{0}, 今年{1}岁了'.format("李思", 18))
# 我的名字是张三，明年24岁了
print(f'我的名字是{name}, 明年{age + 1}岁了')
5. 补充知识
字符串输出的本质其实就是拼接字符串，那么我们都用%s完全也是可以的。很多时候，我们不用区分整型、浮点型等，直接用%s输出就可以了。
print('我的名字是%s，今年%s岁了，我的体重是%s公斤' % (name, age ,weight))
6. 转义字符
\n：换行。
\t：制表符，一个tab键（4个空格）的距离。
7. 结束符
# print会默认换行输出print('输出的内容', end="\n")
在Python中，print()， 默认自带end="\n"这个换行结束符，所以导致每两个print直接会换行展示，用户可以按需求更改结束符。
# 改变Python换行输出
print('内容', end=" ")
print('内容', end="···")
八、输入
在Python中，程序接收用户输入的数据的功能即是输入。
1. 输入的语法
input("提示信息")
2. 输入的特点
当程序执行到input，等待用户输入，输入完成之后才继续向下执行。
在Python中，input接收用户输入后，一般存储到变量，方便使用。
在Python中，input会把接收到的任意用户输入的数据都当做字符串处理。
password = input('请输入您的密码：')
print(f'您输入的密码是{password}')
# <class 'str'>
print(type(password))
九、转换数据类型
1. 转换数据类型的作用
问：input()接收用户输入的数据都是字符串类型，如果用户输入1，想得到整型该如何操作？
答：转换数据类型即可，即将字符串类型转换成整型。
2. 转换数据类型的函数
3. 体验转换数据类型
需求：input接收用户输入，用户输入“1”，将这个数据1转换成整型。
# 1. 接收用户输入
num = input('请输入您的幸运数字：')
# 2. 打印结果
print(f"您的幸运数字是{num}")
# 3. 检测接收到的用户输入的数据类型 -- str类型
print(type(num))
# 4. 转换数据类型为整型 -- int类型
print(type(int(num)))
# 1. float() -- 转换成浮点型
num1 = 1print(float(num1))
print(type(float(num1)))
# 2. str() -- 转换成字符串类型
num2 = 10
print(type(str(num2)))
# 3. tuple() -- 将一个序列转换成元组
list1 = [10, 20, 30]
print(tuple(list1))
print(type(tuple(list1)))
# 4. list() -- 将一个序列转换成列表
t1 = (100, 200, 300)
print(list(t1))
print(type(list(t1)))
# 5. eval() -- 将字符串中的数据转换成Python表达式原本类型
str1 = '10'str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(str3)))
十、运算符
1. 运算符的分类
算数运算符
赋值运算符
复合赋值运算符
比较运算符
逻辑运算符
2. 算数运算符
混合运算优先级顺序：()高于 ** 高于 * / // % 高于 + -
3. 赋值运算符
1.单个变量赋值
num = 1print(num)
2. 多个变量赋值
num1, float1, str1 = 10, 0.5, 'hello world'print(num1)print(float1)print(str1)
3. 多变量赋相同值
a = b = 10print(a)print(b)
4. 复合赋值运算符
a = 100
a += 1# 输出101
a = a + 1,最终
a = 100 + 1
print(a)
b = 2b *= 3# 输出6 b = b * 3,最终b = 2 * 3print(b)
c = 10c += 1 + 2# 输出13, 先算运算符右侧1 + 2 = 3， c += 3 , 推导出c = 10 + 3print(c)
5. 比较运算符
比较运算符也叫关系运算符， 通常用来判断。
a = 7
b = 5
print(a == b)# False
print(a != b) # True
print(a < b) # False
print(a > b) # True
print(a <= b) # False
print(a >= b) # True
6. 逻辑运算符
a = 1
b = 2
c = 3
print((a < b) and (b < c)) # True
print((a > b) and (b < c)) # False
print((a > b) or (b < c)) # True
print(not (a > b)) # True
7. 补充知识
数字之间的逻辑运算
a = 0b = 1c = 2
# and运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字
print(a and b) # 0
print(b and a) # 0
print(a and c) # 0
print(c and a) # 0
print(b and c) # 2
print(c and b) # 1
# or运算符，只有所有值为0结果才为0，否则结果为第一个非0数字
print(a or b) # 1print(a or c) # 2print(b or c) # 1
十一、条件语句
1. 了解条件语句
Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。
2. if语法
if 条件: 条件成立执行的代码1 条件成立执行的代码2 ......
2.1 体验if语句
if True:
print('条件成立执行的代码1')
print('条件成立执行的代码2')
# 下方的代码没有缩进到if语句块，所以和if条件无关print('我是无论条件是否成立都要执行的代码')
2.2 简单版：网吧上网
需求分析：如果用户年龄大于等于18岁，即成年，输出"已经成年，可以上网"。
age = 20
if age >= 18:
print('已经成年，可以上网')
print('系统关闭')
2.3 进阶版：网吧上网
新增需求：用户可以输出自己的年龄，然后系统进行判断是否成年，成年则输出"您的年龄是’用户输入的年龄’，已经成年，可以上网"。
# input接受用户输入的数据是字符串类型，条件是age和整型18做判断，所以这里要int转换数据类型
age = int(input('请输入您的年龄：'))
if age >= 18:
print(f'您的年龄是{age},已经成年，可以上网')
print('系统关闭')
3. if…else…
作用：条件成立执行if下方的代码; 条件不成立执行else下方的代码。
if 条件: 条件成立执行的代码1 条件成立执行的代码2 ......else: 条件不成立执行的代码1 条件不成立执行的代码2 ......
思考：网吧上网的实例，如果成年，允许上网，如果不成年呢？是不是应该回复用户不能上网？
3.1 实用版：网吧上网
age = int(input('请输入您的年龄：'))
if age >= 18:
print(f'您的年龄是{age},已经成年，可以上网')
else:
print(f'您的年龄是{age},未成年，请自行回家写作业')
print('系统关闭')
注意：如果条件成立执行了某些代码，那么其他的情况的代码将不会执行。
4. 多重判断
if 条件1: 条件1成立执行的代码1 条件1成立执行的代码2 ......elif 条件2： 条件2成立执行的代码1 条件2成立执行的代码2 ............else: 以上条件都不成立执行执行的代码
多重判断也可以和else配合使用。一般else放在整个if语句的最后，表示以上条件都不成立的时候执行的代码。
思考：中国合法工作年龄为18-60岁，即如果年龄小于18的情况为童工，不合法；如果年龄在18-60岁之间为合法工龄；大于60岁为法定退休年龄。
4.1 实例：工龄判断
age = int(input('请输入您的年龄：'))if age < 18:
print(f'您的年龄是{age},童工一枚')elif (age >= 18) and (age <= 60):print(f'您的年龄是{age},合法工龄')elif age > 60:
print(f'您的年龄是{age},可以退休')
5. if嵌套
if 条件1： 条件1成立执行的代码 条件1成立执行的代码
if 条件2： 条件2成立执行的代码 条件2成立执行的代码
注意：条件2的if也是出于条件1的缩进关系内部。
思考：坐公交：如果有钱可以上车，没钱不能上车；上车后如果有空座，则可以坐下；如果没空座，就要站着。怎么书写程序？
5.1 实例：坐公交
1.判断是否能上车
""" 1. 如果有钱，则可以上车 2. 上车后，如果有空座，可以坐下 上车后，如果没有空座，则站着等空座位 如果没钱，不能上车"""
# 假设用 money = 1 表示有钱, money = 0表示没有钱
money = 1
if money == 1:
print('土豪，不差钱，顺利上车')
else:
print('没钱，不能上车，追着公交车跑')
2. 判断是否能坐下
""" 1. 如果有钱，则可以上车 2. 上车后，如果有空座，可以坐下 上车后，如果没有空座，则站着等空座位 如果没钱，不能上车"""# 假设用 money = 1 表示有钱, money = 0表示没有钱; seat = 1 表示有空座，seat = 0 表示没有空座m
oney = 1
seat = 0
if money == 1:
print('土豪，不差钱，顺利上车')
if seat == 1:
print('有空座，可以坐下')
else:
print('没有空座，站等')
else:
print('没钱，不能上车，追着公交车跑')
5.2 if嵌套执行流程
6. 应用：猜拳游戏
需求分析：
参与游戏的角色
随机出拳
手动出拳
玩家
电脑
判断输赢
玩家 电脑
石头 剪刀
剪刀 布
布 石头
玩家出拳 和 电脑出拳相同
平局
电脑获胜
玩家获胜
随机做法：
1.导出random模块
import 模块名
2. 使用random模块中的随机整数功能
random.randint(开始,结束)
6.1 初始版：猜拳游戏
"""提示：0-石头，1-剪刀，2-布3. 出拳玩家输入出拳电脑随机出拳
4. 判断输赢玩家获胜平局电脑获胜"""
# 导入random模块
import random
# 计算电脑出拳的随机数字
computer = random.randint(0, 2)
print(computer)
player = int(input('请出拳：0-石头，1-剪刀，2-布：'))
# 玩家胜利 p0:c1 或 p1:c2 或 p2:c0
if (player == 0 and computer == 1) or (player == 1 and computer == 2) or (player == 2 and computer == 0):
print('玩家获胜')
# 平局：玩家 == 电脑
elif player == computer:
print('平局')
else:
print('电脑获胜')
6.2 进阶版：猜拳游戏
"""石头剪刀布游戏玩家VS电脑站在玩家的角度，分析胜利、失败、平局0-石头，1-剪刀，2-布"""# 导入随机数模块import random
import random
import sys
print("-----欢迎来到人机对战小游戏-----")
name = input("请输入您的游戏名：")
while True:
stats = input("欢迎“%s”来到本游戏，开始游戏输入Y，退出游戏输入N，请您输入：" % name)
if stats == "Y" or stats == "y":
print("游戏开始……")
print("石头输入0、剪刀输入1、布输入2")
break
elif stats == "N" or stats == "n":
print("游戏结束……")
sys.exit(0)
else:
print("请按照要求重新输入！")
print("-------------加载中-------------")
def Game(user, comp):
if (user== 0 and comp== 1) or (user== 1 and comp== 2) or (user== 2 and comp== 0):
print("机器输入%d，您赢了！" % comp)
elif user == comp:
print("机器输入%d，平局了！" % comp)
else:
print("机器输入%d，您输了！" % comp)
res = input("重新游戏请输入X，退出游戏按任意键")
if res == "X" or res == "x":
return
else:
sys.exit(0)
while True:
user = int(input("请您出拳，输入相应数字！"))
if user == 0 or user == 1 or user == 2:
comp = random.randint(0, 2)
Game(user, comp)
else:
print("输入数字有误，请确认后，重新输入！")7. 三目运算符三目运算符也叫三元运算符。
语法如下：
值1 if 条件 else 值2
快速体验：
a = 1
b = 2
c = a if a > b else b
print(c)
十二、循环简介
1. 循环的作用
让代码更高效的重复执行。
2. 循环的分类
在Python中，循环分为while和for两种，最终实现效果相同。
3. while的语法
while 条件: 条件成立重复执行的代码1 条件成立重复执行的代码2 ......
4. while循环快速体验
需求：复现重复执行10次print('Hello World')。
分析：初始值是0次，终点是10次，重复做的事情输出“Hello World”。
# 循环的计数器
i = 0
while i < 10:
print('Hello World')
i += 1
print('任务结束')
5. while的应用
5.1 应用一：计算1-100累加和
分析：1-100的累加和，即1 + 2 + 3 + 4 +….，即前两个数字的相加结果 + 下一个数字( 前一个数字 + 1)。
i = 1
result = 0
while i <= 100:
result += i
i += 1
# 输出5050
print(result)
注意：为了验证程序的准确性，可以先改小数值，验证结果正确后，再改成1-100做累加。
5.2 应用二：计算1-100偶数累加和
分析：1-100的偶数和，即 2 + 4 + 6 + 8…，得到偶数的方法如下：
偶数即是和2取余结果为0的数字，可以加入条件语句判断是否为偶数，为偶数则累加
初始值为0 / 2 , 计数器每次累加2
方法一：条件判断和2取余数则累加
# 方法一：条件判断和2取余数为0则累加计算
i = 1result = 0
while i <= 100:
if i % 2 == 0:
result += i
i += 1
# 输出2550
print(result)
方法二：计数器控制
# 方法二：计数器控制增量为2
i = 0
result = 0
while i <= 100:
result += i
i += 2
# 输出2550
print(result)
6. break和continue
break和continue是循环中满足一定条件退出循环的两种不同方式。
6.1 理解
举例：一共吃5个苹果，吃完第一个，吃第二个…，这里"吃苹果"的动作是不是重复执行？
情况一：如果吃的过程中，吃完第三个吃饱了，则不需要再吃第4个和第五个苹果，即是吃苹果的动作停止，这里就是break控制循环流程，即终止此循环。
情况二：如果吃的过程中，吃到第三个吃出一个大虫子…,是不是这个苹果就不吃了，开始吃第四个苹果，这里就是continue控制循环流程，即退出当前一次循环继而执行下一次循环代码。
6.2 break实例
i = 1
while i <= 5:
if i == 4:
print(f'吃饱了不吃了')
break
print(f'吃了第{i}个苹果')
i += 1
6.3 continue实例
i = 1
while i <= 5:
if i == 3:
print(f'大虫子，第{i}个不吃了')
# 在continue之前一定要修改计数器，否则会陷入死循环
i += 1
continue
print(f'吃了第{i}个苹果')
i += 1
7. while循环嵌套
7.1 语法
while 条件1: 条件1成立执行的代码 ...... while 条件2: 条件2成立执行的代码 ......
总结：所谓while循环嵌套，就是一个while里面嵌套一个while的写法，每个while和之前的基础语法是相同的。
7.2 执行过程
当内部循环执行完成之后，再执行下一次外部循环的条件判断。
7.3 while循环嵌套应用
应用一：打印星号（正方形）
# 重复打印5行星星
j = 0
while j <= 4:
# 一行星星的打印
i = 0
while i <= 4:
# 一行内的星星不能换行，取消print默认结束符\n
print('*', end='')
i += 1
# 每行结束要换行，这里借助一个空的print，利用print默认结束符换行
print()
j += 1
应用二：打印星号（三角形）
# 重复打印5行星星
# j表示行号
j = 0
while j <= 4:
# 一行星星的打印
i = 0
# i表示每行里面星星的个数，这个数字要和行号相等所以i要和j联动
while i <= j:
print('*', end='')
i += 1
print()
j += 1
应用二：九九乘法表
# 重复打印9行表达式
j = 1
while j <= 9:
# 打印一行里面的表达式 a * b = a*b
i = 1
while i <= j:
print(f'{i}*{j}={j*i}', end='\t')
i += 1
print()
j += 1
8. for循环
8.1 语法
for 临时变量 in 序列:
重复执行的代码1
重复执行的代码2 ......
8.2 快速体验
str1 = 'Hello World'
for i in str1:
print(i)
8.3 break
str1 = 'Hello World'
for i in str1:
if i == 'e':
print('遇到e不打印')
break
print(i)
8.4 continue
str1 = 'Hello World'
for i in str1:
if i == 'e':
print('遇到e不打印')
continue
print(i)
十三、else
循环可以和else配合使用，else下方缩进的代码指的是当循环正常结束之后要执行的代码。
1. while…else
1.1 语法
while 条件: 条件成立重复执行的代码else: 循环正常结束之后要执行的代码
1.2 示例
i = 1
while i <= 5:
print('Hello World')
i += 1else:
print('执行完毕')
1.3 退出循环的方式
1.break终止循环
i = 1
while i <= 5:
if i == 3:
print("提前结束")
break
print('Hello World')
i += 1
else:
print('执行完毕')
所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进的代码将不执行。
2.continue控制循环
i = 1
while i <= 5:
if i == 3:
print("打断一下")
i += 1
continue
print('Hello World')
i += 1
else:
print('执行完毕')
因为continue是退出当前一次循环，继续下一次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执行了else缩进的代码。
2. for…else
2.1 语法
for 临时变量 in 序列: 重复执行的代码 ...else: 循环正常结束之后要执行的代码
所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进的代码将不执行。
2.2 示例
str1 = 'Hello World'
for i in str1:
print(i)
else:
print('循环正常结束之后执行的代码')
2.3 退出循环的方式
1.break终止循环
str1 = 'Hello World'
for i in str1:
if i == 'e':
print('遇到e不打印')
break
print(i)
else:
print('循环正常结束之后执行的代码')
没有执行else缩进的代码。
2.continue控制循环
str1 = 'Hello World'
for i in str1:
if i == 'e':
print('遇到e不打印')
continue
print(i)
else:
print('循环正常结束之后执行的代码')
因为continue是退出当前一次循环，继续下一次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执行了else缩进的代码。
十四、字符串
1. 认识字符串
字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。
a = 'hello world'b = "abcdefg"print(type(a))print(type(b))
注意：控制台显示结果为<class 'str'>， 即数据类型为str(字符串)。
2. 字符串特征
一对引号字符串
name1 = 'Tom'na
me2 = "Rose"
三引号字符串
name3 = ''' Tom '''
name4 = """ Rose """
a = ''' i am Tom, nice to meet you! '''
b = """ i am Rose, nice to meet you! """
注意：三引号形式的字符串支持换行。
思考：如果创建一个字符串I'm Tom?
c = "I'm Tom"
d = 'I\'m Tom'
3. 字符串输出
print('hello world')
name = 'Tom'
print('我的名字是%s' % name)print(f'我的名字是{name}')
4. 字符串输入
在Python中，使用input()接收用户输入。
name = input('请输入您的名字：')
print(f'您输入的名字是{name}')
print(type(name))
password = input('请输入您的密码：')
print(f'您输入的密码是{password}')
print(type(password))
5. 下标
5.1 概念
“下标”又叫“索引”，就是编号。比如火车座位号，座位号的作用：按照编号快速找到对应的座位。同理，下标的作用即是通过下标快速找到对应的数据。
5.2 快速体验
需求：字符串name = "abcdef"，取到不同下标对应的数据。
代码
name = "abcdef"
print(name[1])
print(name[0])
print(name[2])
输出结果
注意：下标从0开始。
6. 切片
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
6.1 语法
序列[开始位置下标:结束位置下标:步长]
注意：
不包含结束位置下标对应的数据， 正负整数均可；
步长是选取间隔，正负整数均可，默认步长为1。
6.2 示例
name = "abcdefg"
print(name[2:5:1]) # cde
print(name[2:5]) # cde
print(name[:5]) # abcde
print(name[1:]) # bcdefg
print(name[:]) # abcdefg
print(name[::2]) # aceg
print(name[:-1]) # abcdef, 负1表示倒数第一个数据
print(name[-4:-1]) # def
print(name[::-1]) # gfedcba
7. 常用操作方法
字符串的常用操作方法有查找、修改和判断三大类。
7.1 查找
所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数。
find()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。
语法
字符串序列.find(子串, 开始位置下标, 结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
快速体验
mystr = "hello world and buran and list and Python"
print(mystr.find('and')) # 12
print(mystr.find('and', 15, 30)) # 22
print(mystr.find('ands')) # -1
index()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常。
语法
字符串序列.index(子串, 开始位置下标, 结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
快速体验
mystr = "hello world and buran and list and Python"
print(mystr.index('and')) # 12
print(mystr.index('and', 15, 30)) # 22
print(mystr.index('ands')) # 报错
rfind()：和find()功能相同，但查找方向为
右侧
开始。
rindex()：和index()功能相同，但查找方向为
右侧
开始。
count()：返回某个子串在字符串中出现的次数。
语法
字符串序列.count(子串, 开始位置下标, 结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
快速体验
mystr = "hello world and buran and list and Python"
print(mystr.count('and')) # 3
print(mystr.count('ands')) # 0
print(mystr.count('and', 0, 20)) # 1
7.2 修改
所谓修改字符串，指的就是通过函数的形式修改字符串中的数据。
replace()：替换字符串。
语法
字符串序列.replace(旧子串, 新子串, 替换次数)
注意：替换次数如果查出子串出现次数，则替换次数为该子串出现次数。
快速体验
mystr = "hello world and buran and list and Python"
print(mystr.replace('and', 'he'))# 结果：hello world he buran he list he Python
print(mystr.replace('and', 'he', 10))# 结果：hello world he buran he list he Python
print(mystr)# 结果：hello world and buran and list and Python
注意：数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。
split()：按照指定字符分割字符串。
语法
字符串序列.split(分割字符, num)
注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。
快速体验
mystr = "hello world and buran and list and Python"
print(mystr.split('and'))# 结果：['hello world ', ' buran ', ' list ', ' Python']
print(mystr.split('and', 2))# 结果：['hello world ', ' buran ', ' list and Python']
print(mystr.split(' '))# 结果：['hello', 'world', 'and', 'buran', 'and', 'list', 'and', 'Python']
print(mystr.split(' ', 2))# 结果：['hello', 'world', 'and buran and list and Python']
注意：如果分割字符是原有字符串中的子串，分割后则丢失该子串。
join()：用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串。
1.语法
字符或子串.join(多字符串组成的序列)
2. 快速体验
list1 = ['hello', 'buran', 'list']t1 = ('aa', 'b', 'cc', 'ddd')
print('_'.join(list1))# hello_buran_list
print('...'.join(t1))# 结果：aa...b...cc...ddd
capitalize()：将字符串第一个字符转换成大写。
mystr = "hello world and buran and list and Python"
print(mystr.capitalize())# 结果：Hello world and buran and list and python
注意：capitalize()函数转换后，只字符串第一个字符大写，其他的字符全都小写。
title()：将字符串每个单词首字母转换成大写。
mystr = "hello world and buran and list and Python"
print(mystr.title())# 结果：Hello World And Buran And List And Python
lower()：将字符串中大写转小写。
mystr = "hello world and buran and list and Python"
print(mystr.lower())# 结果：hello world and buran and list and python
upper()：将字符串中小写转大写。
mystr = "hello world and buran and list and Python"
print(mystr.upper())# 结果：HELLO WORLD AND BURAN AND LIST AND PYTHON
lstrip()：删除字符串左侧空白字符。
rstrip()：删除字符串右侧空白字符。
strip()：删除字符串两侧空白字符。
ljust()：返回一个原字符串左对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串。
rjust()：返回一个原字符串右对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串，语法和ljust()相同。
center()：返回一个原字符串居中对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串，语法和ljust()相同。
7.3 判断
所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。
startswith()：检查字符串是否是以指定子串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
语法
字符串序列.startswith(子串, 开始位置下标, 结束位置下标)
快速体验
mystr = "hello world and buran and list and Python"
print(mystr.startswith('hello'))# 结果：True
print(mystr.startswith('hello', 5, 20))# 结果：False
endswith()：：检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
语法
字符串序列.endswith(子串, 开始位置下标, 结束位置下标)
快速体验
mystr = "hello world and buran and list and Python"
print(mystr.endswith('Python'))# 结果：True
print(mystr.endswith('python'))# 结果：False
print(mystr.endswith('Python', 2, 20))# 结果：False
isalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False。
mystr1 = 'hello'mystr2 = 'hello12345'
print(mystr1.isalpha())# 结果：True
print(mystr2.isalpha())# 结果：False
isdigit()：如果字符串只包含数字则返回 True 否则返回 False。
mystr1 = 'aaa12345'mystr2 = '12345'
print(mystr1.isdigit())# 结果：False
print(mystr2.isdigit())# 结果：False
isalnum()：如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False。
mystr1 = 'aaa12345'mystr2 = '12345-'
print(mystr1.isalnum())# 结果：True
print(mystr2.isalnum())# 结果：False
isspace()：如果字符串中只包含空白，则返回 True，否则返回 False。
mystr1 = '1 2 3 4 5'mystr2 = ' '
print(mystr1.isspace())# 结果：Falseprint(mystr2.isspace())# 结果：True
十五、列表
1. 列表的格式
[数据1, 数据2, 数据3, 数据4......]
列表可以一次性有序存储多个不同类型的数据。
2. 列表的常用操作
列表的作用是一次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查。
2.1 查找
下标
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tom
print(name_list[1]) # Lily
print(name_list[2]) # Rose
函数
index()：返回指定数据所在位置的下标 。
列表序列.index(数据, 开始位置下标, 结束位置下标)
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2)) # 1
注意：如果查找的数据不存在则报错。
count()：统计指定数据在当前列表中出现的次数。
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.count('Lily')) # 1
len()：访问列表长度，即列表中数据的个数。
name_list = ['Tom', 'Lily', 'Rose']
print(len(name_list)) # 3
2.2 判断是否存在
in：判断指定数据在某个列表序列，如果在返回True，否则返回False。
name_list = ['Tom', 'Lily', 'Rose']
# 结果：True
print('Lily' in name_list)
# 结果：False
print('Lilys' in name_list)
not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False。
name_list = ['Tom', 'Lily', 'Rose']
# 结果：False
print('Lily' not in name_list)
# 结果：True
print('Lilys' not in name_list)
2.2 增加
作用：增加指定数据到列表中。
append()：列表结尾追加数据。
列表序列.append(数据)
name_list = ['Tom', 'Lily', 'Rose']
name_list.append('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming']
print(name_list)
列表追加数据的时候，直接在原列表里面追加了指定数据，即修改了原列表，故列表为可变类型数据。
注意点：如果append()追加的数据是一个序列，则追加整个序列到列表。
name_list = ['Tom', 'Lily', 'Rose']
name_list.append(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]print(name_list)
extend()：列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表。
列表序列.extend(数据)
单个数据：
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
print(name_list)
序列数据：
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
print(name_list)
insert()：指定位置新增数据。
列表序列.insert(位置下标, 数据)
name_list = ['Tom', 'Lily', 'Rose']
name_list.insert(1, 'xiaoming')
# 结果：['Tom', 'xiaoming', 'Lily', 'Rose']
print(name_list)
2.3 删除
del
del 目标# del(目标)
删除列表：
name_list = ['Tom', 'Lily', 'Rose']
# 结果：报错提示：name 'name_list' is not defineddel name_list
print(name_list)
删除指定数据：
name_list = ['Tom', 'Lily', 'Rose']
del name_list[0]
# 结果：['Lily', 'Rose']
print(name_list)
pop()：删除指定下标的数据(默认为最后一个)，并返回该数据。
列表序列.pop(下标)
name_list = ['Tom', 'Lily', 'Rose']
del_name = name_list.pop(1)
# 结果：Lily
print(del_name)
# 结果：['Tom', 'Rose']
print(name_list)
remove()：移除列表中某个数据的第一个匹配项。
列表序列.remove(数据)
name_list = ['Tom', 'Lily', 'Rose']
name_list.remove('Rose')
# 结果：['Tom', 'Lily']
print(name_list)
clear()：清空列表
name_list = ['Tom', 'Lily', 'Rose']
name_list.clear()
print(name_list) # 结果： []
2.4 修改
修改指定下标数据
name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'aaa'
# 结果：['aaa', 'Lily', 'Rose']
print(name_list)
逆置：reverse()
num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
# 结果：[8, 6, 3, 2, 5, 1]
print(num_list)
排序：sort()
列表序列.sort( key=None, reverse=False)
num_list = [1, 5, 2, 3, 6, 8]
num_list.sort()
# 结果：[1, 2, 3, 5, 6, 8]
print(num_list)
注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）
2.5 复制
函数：copy()
name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
# 结果：['Tom', 'Lily', 'Rose']
print(name_li2)
3. 列表的循环遍历
需求：依次打印列表中的各个数据。
3.1 while
name_list = ['Tom', 'Lily', 'Rose']
i = 0
while i < len(name_list):
print(name_list[i])
i += 1
3.2 for
name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
print(i)
4. 列表嵌套
所谓列表嵌套指的就是一个列表里面包含了其他的子列表。
应用场景：要存储班级一、二、三三个班级学生姓名，且每个班级的学生姓名在一个列表。
name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]
思考：如何查找到数据"李四"？
# 第一步：按下标查找到李四所在的列表
print(name_list[2])
# 第二步：从李四所在的列表里面，再按下标找到数据李四
print(name_list[2][1])
十六、元组
一个元组可以存储多个数据，元组内的数据是不能修改的。
1. 定义元组
元组特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型。
# 多个数据元组t1 = (10, 20, 30)
# 单个数据元组t2 = (10,)
注意：如果定义的元组只有一个数据，那么这个数据后面也好添加逗号，否则数据类型为唯一的这个数据的数据类型。
t2 = (10,)
print(type(t2)) # tuple
t3 = (20)
print(type(t3)) # int
t4 = ('hello')
print(type(t4)) # str
2. 元组的常见操作
元组数据不支持修改，只支持查找，具体如下：
按下标查找数据
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) # aa
index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa')) # 0
count()：统计某个数据在当前元组出现的次数。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb')) # 2
len()：统计元组中数据的个数。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1)) # 4
3. 元组的注意事项
元组内的直接数据如果修改则立即报错。
tuple1 = ('aa', 'bb', 'cc', 'bb')
tuple1[0] = 'aaa'
但是如果元组里面有列表，修改列表里面的数据则是支持的，故自觉很重要。
tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2]) # 访问到列表
# 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple2[2][0] = 'aaaaa'
print(tuple2)
十七、字典
字典里面的数据是以“键值对”形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。
1. 创建字典的语法
字典特点：
符号为
大括号
数据为
键值对
形式出现
各个键值对之间用
逗号
隔开
# 有数据字典dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典dict2 = {}
dict3 = dict()
注意：一般称冒号前面的为键(key)，简称k；冒号后面的为值(value)，简称v。
2. 字典常见操作
2.1 增
写法：字典序列[key] = 值
注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1['name'] = 'Rose'# 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)
dict1['id'] = 110
# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
print(dict1)
注意：字典为可变类型。
2.2 删
del() / del：删除字典或删除字典中指定键值对。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['gender']# 结果：{'name': 'Tom', 'age': 20}
print(dict1)
clear()：清空字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1) # {}
2.3 改
写法：字典序列[key] = 值
注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对。
2.4 查
key值查找
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1['name']) # Tom
print(dict1['id']) # 报错
如果当前查找的key存在，则返回对应的值；否则则报错。
get()
字典序列.get(key, 默认值)
注意：如果当前查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数，则返回None。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name')) # Tom
print(dict1.get('id', 110)) # 110
print(dict1.get('id')) # None
keys()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])
values()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values()) # dict_values(['Tom', 20, '男'])
items()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])
3. 字典的循环遍历
3.1 遍历字典的key
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for key in dict1.keys(): print(key)
3.2 遍历字典的value
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for value in dict1.values(): print(value)
3.3 遍历字典的元素
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for item in dict1.items(): print(item)
3.4 遍历字典的键值对
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for key, value in dict1.items(): print(f'{key} = {value}')
十八、集合
集合具有确定性，无序性和去重性。
1. 创建集合
创建集合使用{}或set()， 但是如果要创建空集合只能使用set()，因为{}用来创建空字典。
s1 = {10, 20, 30, 40, 50}print(s1)
s2 = {10, 30, 20, 10, 30, 40, 30, 50}print(s2)
s3 = set('abcdefg')print(s3)
s4 = set()print(type(s4)) # set
s5 = {}print(type(s5)) # dict
特点：
集合可以去掉重复数据；
集合数据是无序的，故不支持下标。
2. 集合常见操作方法
2.1 增加数据
add()
s1 = {10, 20}s1.add(100)s1.add(10)print(s1) # {100, 10, 20}
因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作。
update(), 追加的数据是序列。
s1 = {10, 20}# s1.update(100) # 报错s1.update([100, 200])s1.update('abc')print(s1) # {'a', 100, 200, 10, 'b', 'c', 20}
2.2 删除数据
remove()，删除集合中的指定数据，如果数据不存在则报错。
s1 = {10, 20}
s1.remove(10)print(s1)
s1.remove(10) # 报错print(s1)
discard()，删除集合中的指定数据，如果数据不存在也不会报错。
s1 = {10, 20}
s1.discard(10)print(s1)
s1.discard(10)print(s1)
pop()，随机删除集合中的某个数据，并返回这个数据。
s1 = {10, 20, 30, 40, 50}
del_num = s1.pop()print(del_num)print(s1)
2.3 查找数据
in：判断数据在集合序列
not in：判断数据不在集合序列
s1 = {10, 20, 30, 40, 50}
print(10 in s1)print(10 not in s1)
十九、公共操作
1. 运算符
1.1 +
# 1. 字符串 str1 = 'aa'str2 = 'bb'str3 = str1 + str2print(str3) # aabb
# 2. 列表 list1 = [1, 2]list2 = [10, 20]list3 = list1 + list2print(list3) # [1, 2, 10, 20]
# 3. 元组 t1 = (1, 2)t2 = (10, 20)t3 = t1 + t2print(t3) # (10, 20, 100, 200)
1.2 *
# 1. 字符串print('-' * 10) # ----------
# 2. 列表list1 = ['hello']print(list1 * 4) # ['hello', 'hello', 'hello', 'hello']
# 3. 元组t1 = ('world',)print(t1 * 4) # ('world', 'world', 'world', 'world')
1.3 in或not in
# 1. 字符串print('a' in 'abcd') # Trueprint('a' not in 'abcd') # False
# 2. 列表list1 = ['a', 'b', 'c', 'd']print('a' in list1) # Trueprint('a' not in list1) # False
# 3. 元组t1 = ('a', 'b', 'c', 'd')print('aa' in t1) # Falseprint('aa' not in t1) # True
2. 公共方法
2.1 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
2.2 del()
# 1. 字符串str1 = 'abcdefg'del str1print(str1)
# 2. 列表list1 = [10, 20, 30, 40]del(list1[0])print(list1) # [20, 30, 40]
2.3 max()
# 1. 字符串str1 = 'abcdefg'print(max(str1)) # g
# 2. 列表list1 = [10, 20, 30, 40]print(max(list1)) # 40
2.4 min()
# 1. 字符串str1 = 'abcdefg'print(min(str1)) # a
# 2. 列表list1 = [10, 20, 30, 40]print(min(list1)) # 10
2.5 range()
# 1 2 3 4 5 6 7 8 9for i in range(1, 10, 1): print(i)
# 1 3 5 7 9for i in range(1, 10, 2): print(i)
# 0 1 2 3 4 5 6 7 8 9for i in range(10): print(i)
注意：range()生成的序列不包含end数字。
2.6 enumerate()
enumerate(可遍历对象, start=0)
注意：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}')
3. 容器类型转换
3.1 tuple()
作用：将某个序列转换成元组。
list1 = [10, 20, 30, 40, 50, 20]s1 = {100, 200, 300, 400, 500}
print(tuple(list1))print(tuple(s1))
3.2 list()
作用：将某个序列转换成列表。
t1 = ('a', 'b', 'c', 'd', 'e')s1 = {100, 200, 300, 400, 500}
print(list(t1))print(list(s1))
3.3 set()
作用：将某个序列转换成集合。
list1 = [10, 20, 30, 40, 50, 20]t1 = ('a', 'b', 'c', 'd', 'e')
print(set(list1))print(set(t1))
注意：
集合可以快速完成列表去重。
集合不支持下标。
二十、推导式
1. 列表推导式
作用：用一个表达式创建一个有规律的列表或控制一个有规律列表。
列表推导式又叫列表生成式。
1.1 快速体验
需求：创建一个0-10的列表。
while循环实现
# 1. 准备一个空列表list1 = []
# 2. 书写循环，依次追加数字到空列表list1中i = 0while 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)
1.2 带if的列表推导式
需求：创建0-10的偶数列表
方法一：range()步长实现
list1 = [i for i in range(0, 10, 2)]print(list1)
1.3 多个for循环实现列表推导式
需求：创建列表如下：
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
代码如下：
list1 = [(i, j) for i in range(1, 3) for j in range(3)]print(list1)
2. 字典推导式
字典推导式作用：快速合并列表为字典或提取字典中目标数据。
2.1 快速体验
创建一个字典：字典key是1-5数字，value是这个数字的2次方。
dict1 = {i: i**2 for i in range(1, 5)}print(dict1) # {1: 1, 2: 4, 3: 9, 4: 16}
将两个列表合并为一个字典
list1 = ['name', 'age', 'gender']list2 = ['Tom', 20, 'man']
dict1 = {list1[i]: list2[i] for i in range(len(list1))}print(dict1)
提取字典中目标数据
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
# 需求：提取上述电脑数量大于等于200的字典数据count1 = {key: value for key, value in counts.items() if value >= 200}print(count1) # {'MBP': 268, 'DELL': 201}
3. 集合推导式
需求：创建一个集合，数据为下方列表的2次方。
list1 = [1, 1, 2]
# 代码如下：
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1) # {1, 4}
end