一、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=aladdin5. Python版本
Python 2.XPython 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的安装：Download PyCharm: Python IDE for Professional Developers by JetBrains四、注释
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 randomimport sysprint("-----欢迎来到人机对战小游戏-----")
name = input("请输入您的游戏名：")
while True:stats = input("欢迎“%s”来到本游戏，开始游戏输入Y，退出游戏输入N，请您输入：" % name)if stats == "Y" or stats == "y":print("游戏开始……")print("石头输入0、剪刀输入1、布输入2")breakelif 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":returnelse: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 += 1print('任务结束')
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# 输出2550print(result)
方法二：计数器控制# 方法二：计数器控制增量为2
i = 0
result = 0
while i <= 100:result += ii += 2# 输出2550print(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'吃饱了不吃了')breakprint(f'吃了第{i}个苹果')i += 16.3 continue实例
i = 1
while i <= 5:if i == 3:print(f'大虫子，第{i}个不吃了')# 在continue之前一定要修改计数器，否则会陷入死循环i += 1continueprint(f'吃了第{i}个苹果')i += 17. 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 = 0while i <= 4:# 一行内的星星不能换行，取消print默认结束符\nprint('*', 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 += 1print()j += 1

应用二：九九乘法表

# 重复打印9行表达式
j = 1
while j <= 9:# 打印一行里面的表达式 a * b = a*bi = 1while i <= j:print(f'{i}*{j}={j*i}', end='\t')i += 1print()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不打印')breakprint(i)8.4 continue
str1 = 'Hello World'
for i in str1:if i == 'e':print('遇到e不打印')continueprint(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("提前结束")breakprint('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