时间：2025-03-08 15:06
人气：
作者：admin
注释的作用
解释代码
提示代码顺序
记录修改代码
暂时禁用代码块
1.加入#号注释
#print("注释")
2.快速注释 选中 ctrl+？
#print("注释")
#print("注释")
3.多行注释
"""
print("注释")
print("注释")
print("注释")
"""
普通字符需要使用双引号
数字不需要使用双引号，否则不能计算
age=22 #数字类型
name="汤lx" #普通类型
namne2="""
汤
l
x
""" #三引号可以多行写变量
编写代码时，对变量，类，方法等编写的名字，叫做标识符
注意事项：
字符串的三种定义法
1)单引号定义法：name = 'helloword'
1)双引号定义法：name = "helloword"
1)三引号定义法：name = """helloword"""
字符串的引号嵌用
计算机中需要处理各种各样的数据，不同的数据，需要定义不同的数据类型
整型 浮点型 字符型 布尔型 空
整型(int)
例如：0，100，-8080，0
浮点型(float)
注意：整数和浮点数的存储方式不同，浮点运算时可能会产生一点误差。
字符型(str)
定义字符型要用单引号或者双引号
例如：'abc' "xyz"
布尔型(bool)
布尔值用于真假的判断，一个布尔值只有True，False两种值；
在Python中，可以直接用True，False表示布尔值（注意大小写）也可以表示式计算。
空(None)
空值表示什么也没有。
Nono不能理解为0，因为0是有意义的，，而None是一个特殊的空值。
语法
int(x) #将x转换为整数
float(x) #将x转换为浮点数
str(x) #将x转换为字符串
注意事项
基础运算符
| 运算符 | 描述 | 备注 |
|---|---|---|
| + | 加 | |
| - | 减 | |
| * | 乘 | |
| / | 除 | |
| // | 取整除 | 11//2=5 |
| % | 取余 | 11%2=1 |
| ** | 指数 | a**b,b是a的指数 |
| 赋值运算符 | ||
| 运算符 | 描述 | 备注 |
| ------ | ---------- | --------------------------- |
| = | 赋值运算符 | 把=号右边的值赋给左边的变量 |
复合赋值运算符
| 运算符 | 描述 | 备注 |
|---|---|---|
| += | 加法赋值运算法 | a+=b等效于a=a+b |
| -= | 减法赋值运算法 | a-=b等效于a=a-b |
| *= | 乘法赋值运算法 | a=b等效于a=ab |
| /= | 除法赋值运算法 | a/=b等效于a=a/b |
| //= | 取整除赋值运算法 | a//=b等效于a=a//b |
| %= | 取余赋值运算法 | a%=b等效于a=a%b |
| **= | 幂赋值运算法 | a=b等效于a=ab |
| 运算符 | 描述 | 备注 |
|---|---|---|
| not | 非 | 相当于“反义词” |
| and | 和 | 条件同时为真，才可以是真 |
| or | 或 | 条件有一个为真，结果就为真 |
| 三个逻辑运算符的优先级为： |
not > and > or
在程序中，字符串所用的所有字符如：
都有对应的ASCII码值表，每一个字符都能对应上一个：数字的码值
例如：
abc和abd比较(d比c大，那么abd就大)
a和ab比较(a和a一样，b就大，那么ab就大)
使用"+"号拼接
语法：
"字面量" + 非数字变量
特点：
只能字符串之间进行拼接，非字符串无法拼接
通过%来占位，后面的变量来替换%
语法：
"%s %f" % (变量1,变量n)
常用的占位符有三个：
特点：
name = "tanglx"
qq = 54312795
Height = 1.75
message = "我叫%s"%name
Message = "我叫%s,升高%是,qq是%s"%(name,Height,qq)
Message_2 = "我叫%s,升高%f是,qq是%d"%(name,Height,qq)
精度控制的语法：
"m.n%s .n%f" % (变量1,变量n)
特点：
例子：
name = "tanglx"
int = 21
height = 1.75
print("宽度为不限制：%s"%name)
print("宽度限制为7：%7s"%name)
print("不设置精度：%f"%height)
print("设置精度为2：%.2f"%height)
print("设置宽度为7,精度为1:%7.1f"%height)
对精度没有要求的时候可以快速使用
语法：
f"{变量1}{变量n}"
特点：
name = "tanglx"
age = 21
height = 1.75
print(f"我叫{name},今年{age},身高{height}")
表达式：
表达式就是一个明确是结果的例句
语法：
f"{表达式}"
"%s"%(表达式)
例子:
print("1*1的结果是：%s"%1*1)
print(f"1*1的结果是:{1*1}")
print("字符串在python中的格式类型是:%s"% type('字符串'))
也叫转义符，比如\n表示换行、\t表示制表符(tab)
通常如果要把一个链接或者文件路径写为字符串时特殊字符会被识别为转义符，这时候就需要用到取消转义
全部取消：
语法：
r " "
实例：
file = r"C:\Users\tanglx\Documents\me\study\python\execise\八、函数"
print(f"取消全部转义：{file}")
针对性取消:
语法：
\
示例：
file = "C:\\Users\\tanglx\\Documents\\me\\study\\python\\execise\\八、函数"
print(f"针对性取消转义：{file}")
语句：
变量 = input("提示内容")
特点：
例子：
input的几种写法：
name = input() #直接把输入输入数据给变量
name = input("输入：") # 先打印内容"输入："，再进行
age = int(input()) #输入后转换为int型
布尔类型
比较运算符
通过比较运算符可以得到布尔结果
语句：
if 条件:
成立则执行的语句1
成立则执行的语句n
注意事项：
语句：
if 条件:
成立则执行的语句1
成立则执行的语句n
else :
不成立则执行的语句1
不成立则执行的语句n
注意事项：
语句：
if 条件1:
条件1成立则执行的语句1
条件1成立则执行的语句n
elif 条件2:
条件1不成立则执行的语句1
条件1不成立则执行的语句n
elif 条件3:
条件2不成立则执行的语句1
条件2不成立则执行的语句n
else :
都不成立则执行的语句1
都不成立则执行的语句n
注意事项：
语句：
if 条件:
if 条件：
else 条件：
elif 条件:
if 条件：
else 条件：
else :
if 条件：
else 条件：
注意事项：
语句：
i = 0
while i<100:
执行语句
i+=1
注意事项：
语法：
while 条件1:
满足条件1时，要做的事情1
满足条件1时，要做的事情2
满足条件1时，要做的事情3
while 条件2：
满足条件2时，要做的事情1
满足条件2时，要做的事情2
满足条件2时，要做的事情3
注意事项：
for循环和while区别：
语法：
for 零时变量 in 被处理的数据集(序列):
满足条件执行的代码
注意事项：
range语句的功能是：
语法：
语法1：
range(num)
# 从0开始，到num结束(不含num本身)
语法2：
range(num1,num2)
# 从num1开始，到num2结束(不含num2本身)
语法3：
range(num1,num2,step)
# 从num1开始，到num2结束,step为步长
for循环中的零时变量作用域限定为循环内使用
如果要规范使用零时变量需要在循环前定义好零时变量
注意事项：
语法：
使用range序列的方式控制循环次数，或使用数据集
for i in range(1,101):
print("i")
for j in range(1,11)
print(j)
注意事项：
continue
continue关键字用于：中断本次循环，直接进入下一次
语句：
for i in range(1,101):
print("语句1")
continue
print("语句2")
#直接跳过语句2
break
break关键字用于：直接结束循环
注意事项：
函数：组织好的、可重复使用的、用来实现特定功能的代码段
函数的优点：
语法：
#函数定义
def 函数名(传入参数)
函数体
return 返回值
#函数调用
函数名(传入参数)
#或者
接收变量= 函数名(传入参数)
定义函数时候提供的参数称之为：形式参数(形参)
调用函数时候传入的参数称之为：实际参数(实参)
注意事项：
函数返回值：函数在执行完成后，返回给调用者的结果
语法：
#函数定义
def 函数名(传入参数)
函数体
return 返回值
#接收return返回值
接收变量 = 函数名(传入参数)
注意事项：
None作为一个特殊的字面量，用于表示：空、无意义、具有非常多应用场景
函数中如何返回None：
应用场景：
对函数进行说明解释，帮助更好的理解函数功能
语法:
先写完函数体最后在最上方写""" """并回车，就会自动补充说明格式
def add(x,y):
"""
add函数用于将两个值相加并返回结果
:param x:两个数相加的其中一个值
:param y:两个数相加的另一个值
:return:返回两个数相加的结果
"""
result = x+y
print(f"{x}+{y}={x+y}")
return result
注意事项：
函数的嵌套应用就是定义一个函数时候调用到另外一个函数
语法：
def func_a():
print("---func_a---")
def func_b():
func_a()
print("---func_b---")
func_b()
变量的作用域 #EE3F4D指的是变量作用的范围 #EE3F4D
定义在函数体内的变量，只在函数体内生效
示例：
def testA():
num = 100
print(num)
return num
testA()
print(num) #使用函数内变量会提示报错
注意事项：
在函数内、外都能同时使用的变量
全局变量定义：
示例：
num = 100 #全局变量
def testA(): #定义函数
print("函数内：",num)
return num
testA() #调用函数
print("函数外：",num)
函数不会改变全局变量：
num = 100
def testA():
num = 200
print("函数中的num=",num)
testA()
print("函数外的num=",num)
函数体通过global修改全局变量:
num = 100
def testA():
global num #声明变量
num = 200
print("函数体内num=",num)
testA()
print("函数体外num=",num)
注意事项：
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如字符串，数字，布尔等。
数据容器根据特点的不同，如：
#字面量
[元素1,元素2,元素3,元素4,...]
#定义变量
变量名称 = [元素1,元素2,元素3,元素4,...]
# 定义空列表
变量名称 = []
变量名称 = list()
# 嵌套定义
变量名称= [变量名称1,变量名称2]
列表内的每一个数据，称之为元素
列表的梅一个元素，都有编号称之为下标索引
正向索引：
my_list[下标] 从0开始，依次递增，以n-1为结束(n为列表长度)反向索引：
my_list[下标] 从-1开始，依次递减，以-n为结束(n为列表长度)示例：
#定义列表
my_list = ['tom','any','rose']
#正向索引
print(my_list[0])
print(my_list[1])
print(my_list[2])
#反向索引
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])
列表嵌套的索引：
my_list = [['a1','a2','a3'],['b1','b2','b3']]my_list[0][0]，第一个括号[0]代表第一个元素，第二个括号[0]代表第一个列表中的第一个元素示例：
#嵌套索引
name1=['Tom','Ane','Leo']
name2=['Tom2','Ane2','Leo2']
name3=[name1,name2]
print(name3[0][2]) #括号[0]代表第一个列表，[2]代表第一个列表中的第三个元素
列表的操作称为方法
方法：
方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同
定义了一个Student：类
方法的使用：
变量=类.方法(参数1,参数2)
插入元素：
功能：在指定的下标位置，插入指定的元素
语法：列表.insert(下标,元素)
追加元素：
追加单个元素:
功能：将指定元素，追加到列表尾部
语法：列表.append(元素)
追加多个元素：
功能：将其它数据容器的内容取出，依次追加到列表尾部
语法：列表.extend(其它数据容器)
删除元素：
下标指定法：
功能：通过指定下标删除列表中的元素
语法1：del 列表(下标)
语法2：列表.pop(下标)
元素匹配法：
功能：删除某元素在列表中的第一个匹配项
语法：列表.remove(元素)
清空列表：
功能：清空列表内容
语法：列表.clear()
查找元素：
查找某元素的下标
功能：查找某元素的下标，如果找不到，报错ValueError
语法：列表.index(元素)
统计元素个数:
统计某个元素个数：
功能：统计某一个元素在列表中的个数
语法：列表.count(元素)
统计列表中的所有元素：
功能：用len函数统计列表中元素的个数
语法：len(列表)
修改元素：
功能：修改指定下标的元素
语法：列表[下标]=新元素
while循环和for循环遍历列表，都是循环语句，但细节不同：
在循环控制上：
可以自定循环条件，并自行控制不可以自定循环条件，只可以一个个从容器中取出数据在无限循环上：
可以通过条件控制做到无限循环不可以，因为被遍历的容器容量不是无限的在使用场景上：
可以把元组理解为只读的列表
元组的定义：定义元组使用小括号,且使用逗号,隔开各个数据，数据可以是不同的数据类型。
#定义元组字面量
(元素,元素,.....,元素)
#定义一个元素的元组
变量名称 = (元素,)
#定义元组变量
变量名称 = (元素,元素,....,元素)
#定义空元组
变量名称 = () #方式1
变量名称 = tuple() #方式2
注意事项：
- 只有一个元素的元组带上,号，定义时候也要带上
- 元组和列表本质上一样，只是元组不能篡改内容
多数特征和list一样，只是不能修改元素
元组的特点：
不可以修改(增加或删除元素等)查找元素：
查找某元素的下标
功能：查找某元素的下标，如果找不到，报错ValueError
语法：元组.index(元素)
统计元素个数:
统计某个元素个数：
功能：统计某一个元素在元组中的个数
语法：元组.count(元素)
统计列表中的所有元素：
功能：用len函数统计元组中元素的个数
语法：len(元组)
字符串同样属于数据容器的一员，字符串是字符的容器，一个字符串可以存放任意数量的字符，每一个字符叫做元素
和其它容器如：列表、元组一样，字符串同样通过下标访问
语法：
name = "tanglx"
print(name[0])
print(name[-1])
查找元素：
查找某元素的下标
功能：查找某元素的下标，如果找不到，报错ValueError
语法：字符串.index(元素)
统计元素个数:
统计某个元素个数：
功能：统计某一个元素在字符串中的个数
语法：字符串.count(元素)
统计列表中的所有元素：
功能：用len函数统计字符串中元素的个数
语法：len(字符串)
字符串的替换：
替换字符后获得一个新的字符串，不改变原有字符串
功能：虽然字符串不能修改元素，但是可以修改并生成新字符串
语法：字符串.replace(old字符，new字符)
字符串的分割：
字符串本身不变，而是得到一个列表对象
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象
语法：字符串.split(分隔符字符串)
字符串的规整操作：
字符串的规整操作(不传入参数，去首尾空格)
语法：字符串.strip()
字符串的规整操作(去首尾指定字符串)
语法： 字符串.strip(字符串)
注意：例如传入的"12",其实是"1"和"2"都会移除，按照单个字符
序列是指：内容连续、有序，可以使用下标索引的一类数据类型
列表、元组、字符串，均可以视为序列。
切片：从一个序列中，取出一个子序列(列表，元组，字符串，均支持进行切片操作)
语法：序列[起始下标:结束下标:步长]取值不包含结束下标 #EE3F4D
功能：表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列
例如:list_1[5:0:-1]例如：list_1[::-1]集合是无序的(不支持下标索引)，且不支持重复元素，但是集合和列表一样，是允许修改的
和列表、元组、字符串定义基本相同：
基本语法：
# 定义集合字面量
{元素,元素,....,元素}
#定义变量
变量名称 = {元素,元素,...元素}
#定义空集合
变量名称 = set()
添加新元素：
功能：将一个指定元素，添加到集合1中(改变集合1)
语法：集合1.add(元素)
2个集合合并：
功能：将集合1和集合2组合
语法：新集合=集合1.unior(集合2)
示例：
set1 = {1,2,3}
set2 = {1,4,5}
set3 = set1.unior(set2) #结果：{1,2,3,4,5}
移除元素：
功能：将指定元素，从集合内移除
语法：集合.remove(元素)
清空集合：
功能：清空集合
语法：集合.clear()
集合的遍历：
功能：依次取出元素
语法：for x in 元素:
随机取出元素：
功能：从集合中随机取出一个元素，取出的元素会从集合中移除
语法：集合.pop()
统计元素个数：
功能：统计集合中元素个数
语法：len(集合)
取出2个集合的差集：
功能：取出集合1有集合2没有的元素
语法：集合1.difference(集合2)
消除2个集合的共同值：
功能：消除集合1内和集合2相同的元素。(改变集合1)
语法：集合1.difference_update(集合2)
字典可以实现基于Key检索Value的场景实现
字典的定义，同样使用{}，不过存储的元素是一个个的：健值对，如下语法：
#定义字典字面量
{key:value,...,key:value}
#定义字典变量
my_dict = {key:value,key:value,...,key:value}
#定义空字典
my_dict = {}
my_dict = dict()
#获取key中的元素
my_dict[key]
# 定义嵌套字典
my_dict3 = {
10710401:["leo","2002","男","99"],
10710402:["tom","2002","男","89"],
10710403:["alis","2001","女","90"]
}
新增元素
功能：如果字典中不存在指定key，那么就会新增加
语法：字典[new_Key] = Value
更新元素
功能：如果字典中存在指定key，那么Vlaue值就会被替换
语法：字典[old_Key] = Value
删除元素
功能：删除指定字典中的Key
语法：字典.pop(Key)
清空字典
功能：清空字典
语法：字典.clear()
获取全部Key
功能：获取到字典中的全部key(不包含Value)
语法：接受变量=字典.keys(获取全部value，用字典.Values)
统计字典元素数量
功能：统计字典元素数量
语法：len(字典)
字典的遍历
功能：依次遍历key
语法：
test_dict = {key1:Value1,key2:Value2}
for x in test_dict:
print(f"{x}={test_dict[x]}")
数据容器可以从以下视角进行简单的分类：
| 列表 | 元组 | 字符串 | 集合 | 字典 | |
|---|---|---|---|---|---|
| 元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
| 元素类型 | 任意 | 任意 | 仅字符 |
任意 | key:除字典；Value:任意 |
| 下标索引 | 支持 | 支持 | 支持 | 不支持 |
不支持 |
| 重复元素 | 支持 | 支持 | 支持 | 不支持 |
不支持 |
| 可修改性 | 支持 | 不支持 |
不支持 |
支持 | 支持 |
| 数据有序 | 是 | 是 | 是 | 否 |
否 |
| 使用场景 | 可以修改、可重复的一批数据记录场景 | 不可修改，可重复的一批数据记录场景 | 一串字符的记录场景 | 不可重复的数据记录场景 | 以Key检索Value的数据记录场景 |
是否支持下标索引
是否支持重复元素
是否可以修改
数据容器尽管各自有各自的特点，但是它们也有通用的一些操作。
尽管遍历的形式各有不同，但是，他们都支持遍历操作
统计容器的元素个数：
语法：len(容器)
统计容器的最大元素：
语法：max(容器)
统计容器的最小元素：
语法: min(容器)
将指定容器转换为列表：
语法：list()
将指定容器转换为字符串：
语法：str()
将指定容器转换为元组：
语法：tuple()
将指定容器转换为集合：
语法：set()
将给定容器进行排序：
从小到大排序：
语法：sorted(容器,[reverse=True])
从大到小排序：
语法：sorted(容器,reverse=True)
如果一个函数要有多个返回值
语法：
def test_return():
return 1,2
x,y = test_return() #用两个变量接收
print(x) #1
print(y) #2
位置参数：调用函数时根据函数定义的参数位置来传递参数
语法：
def uesr_info(name,age,gender):
print(f"名字是{name},年龄是{age},性别是{gender}")
user_info('tom',20,'男')
注意事项：
关键字参数：函数调用时通过 健=值 形式传递参数
作用：可以让函数更加清晰，容易使用，同时也清除了参数的顺序需求
语法：
def uesr_info(name,age,gender):
print(f"名字是{name},年龄是{age},性别是{gender}")
#可以不固定位置传入参数
user_info(age=20,gender="男",name="小明")
#可以和位置参数混用，位置参数必须在前，且匹配参数顺序
user_info(小明,age=20,gender="男")
注意事项:
缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可以不传该默认值
作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值。
语法：
def uesr_info(name,age,gender='男'):
print(f"名字是{name},年龄是{age},性别是{gender}")
#使用默认值
user_info('tom',20)
#不使用默认值
user_info('Rose',20,'女')
注意事项：
不定长参数：不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。
作用：当调用函数时不确定个数时，可以使用不定参数。
不定长参数的类型：
1.位置传递
形参使用*号，传入的值作为元组存在
语法：
#不定长参数_位置传递
def user_info(*args):
print(f"类型是{type(args)},值为:{args}")
user_info(18,17,16,18)
2.关键字传递
形参使用**号，传入的值作为字典存在
#不定长参数_关键字传递
def user_info(**kwarg):
print(f"类型是{type(kwarg)},值为:{kwarg}")
user_info(a1=1,a2=2,a3=3)
示例：
def test_func(compute):
result = compute(1,2)
print(result)
def compute(x,y)
return x+y
test_func(compute)
函数定义中
带有名称的函数匿名函数(无名称)有名称的函数，可以基于名称重复使用
无名称的匿名函数，只可以零时使用一次
语法：
lambda 传入参数:函数体(一行代码)
示例：
def test_func(compute):
result = compute(1,2)
print(result)
test_func(lambda x,y:x+y)
ManimCE v0.20.1 发布：LaTeX 渲染修复与动画稳
关注微信