导图社区 python的基本操作与语法
- 63
- 2
- 1
- 举报
python的基本操作与语法
图文并茂的介绍了python基本学习的语法与代码，富含丰富例子与案例，可以很好辅助同学们学习，文档展示了部分内容，如需学习请购买使用
编辑于2023-10-11 13:06:08- 相似推荐
- 大纲
python
第一部分
认识和下载
基本操作
变量
字面量
代码中，被写在代码中的固定的值，称之为字面量
12、‘小明’
数据类型
数值
整形int
10、-10
浮点型float
12.13、-13.14
布尔
true
false
字符串（str）
显示字符串一定要加“”或者‘’
列表（list）
l=[1,2,3,4]
存储数据
元组（tuple）
t = (1,2,3,4,5,6)
集合（set）
s = {1,2,3,4,5,6}
无序
字典（dict）
d = {1:2,3:4,5:6}
无序
检测方法：type（）
定义：在程序运行时，能储存计算结果或能表示值的抽象概念简单的说，变量就是在程序运行时，记录数据用的
赋值方法
变量名 = 值
变量名⾃定义，要满⾜标识符命名规则。
标识符
标识符命名规则是Python中定义各种名字的时候的统⼀规范，具体如下：
由数字、字⺟、下划线组成
不能数字开头
不能使⽤内置关键字
严格区分⼤⼩写
多个输出的方法：
使用逗号,进行分割
示例
money = 50 # 定义meoney print（money）# 打印money print（'钱包还有:'，50）
#买了一杯奶茶，花费10元 money = money - 10 print("买了冰淇淋花费10元，还剩余:“"，money，"元")
练习
当前钱包余额: 50元 购买了冰淇淋，花费: 10 元 购买了可乐，花费: 10 元 最终，钱包剩余: 35元
运算符
算数运算符
a = 10 b = 3 # 加法 result = a + b print("加法结果：", result) # 输出：13 # 减法 result = a - b print("减法结果：", result) # 输出：7 # 乘法 result = a * b print("乘法结果：", result) # 输出：30 # 除法 result = a / b print("除法结果：", result) # 输出：3.3333333333333335 # 取模（取余） result = a % b print("取模结果：", result) # 输出：1 # 幂运算 result = a ** b print("幂运算结果：", result) # 输出：1000 # 整除 result = a // b print("整除结果：", result) # 输出：3
混合运算优先级顺序： () ⾼于 ** ⾼于 * / // % ⾼于 + -
赋值运算符
= 赋值 将 = 右侧的结果赋值给等号左侧的变量
例子：
复合赋值运算符
a = 10 b = 3 # 加法赋值 a += b print("加法赋值结果：", a) # 输出：13 # 减法赋值 a -= b print("减法赋值结果：", a) # 输出：10 # 乘法赋值 a *= b print("乘法赋值结果：", a) # 输出：30 # 除法赋值 a /= b print("除法赋值结果：", a) # 输出：10.0 # 取模赋值 a %= b print("取模赋值结果：", a) # 输出：1.0 # 幂赋值 a **= b print("幂赋值结果：", a) # 输出：1.0 # 整除赋值 a //= b print("整除赋值结果：", a) # 输出：0.0
⽐较运算符
a = 10 b = 3 # 等于 result = a == b print("是否相等：", result) # 输出：False # 不等于 result = a != b print("是否不相等：", result) # 输出：True # 大于 result = a > b print("是否大于：", result) # 输出：True # 小于 result = a < b print("是否小于：", result) # 输出：False # 大于等于 result = a >= b print("是否大于等于：", result) # 输出：True # 小于等于 result = a <= b print("是否小于等于：", result) # 输出：False
逻辑运算符
x = True y = False # 与运算 result = x and y print("与运算结果：", result) # 输出：False # 或运算 result = x or y print("或运算结果：", result) # 输出：True # 非运算 result = not x print("非运算结果：", result) # 输出：False
# 实际应用示例 a = 10 b = 5 # 检查a是否大于0且b是否小于10 result = a > 0 and b < 10 print("实际应用示例结果：", result) # 输出：True # 检查a是否大于10或b是否小于0 result = a > 10 or b < 0 print("实际应用示例结果：", result) # 输出：False # 检查a是否不等于10 result = not a == 10 print("实际应用示例结果：", result) # 输出：False
输出print
所谓的格式化输出即按照⼀定的格式输出内容。
格式化符号
%s 字符串
%表示占位，s表示把变量转换成字符串显示
a = 5 print（我今年%s年级了）%a
%d 有符号的⼗进制整数
%f 浮点数
小技巧
%06d
，表示输出的整数显示位数，不⾜以 0 补全，超出当前位数则原样输出
%.2f
，表示⼩数点后显示的⼩数位数。
数字的精度控制
我们可以使用辅助符号"m.n"来控制数据的宽度和精度
m，控制宽度，要求是数字(很少使用),设置的宽度小于数字自身，不生效
n，控制小数点精度，要求是数字，会进行小数的四舍五入示例:
%5d:表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成:[空格][空格][空格]111，用三个空格补足宽度。
%5.2f:表示将宽度控制为5，将小数点精度设置为2小数点和小数部分也算入宽度计算。如，对11.345设置了%7.2f 后，结果是:[空格][空格]11.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为.35
%.2f: 表示不限制宽度，只设置小数点精度为2，如11.345设置%.2f后，结果是11.35
格式化字符串除了%s，还可以写为 f'{表达式}'
字符串格式化
f'xxxx{变量}xxx’
特点：不做精度控制，什么类型都可以填
练习：
定义以下变量：1、你的名字；2、你的学校；3、你的分数增长系数，浮点类型（如1.5）；4、你的目前的数学分数；5、增长次数
要求输出出来:我是：xxx，我来自xxx学校，当前的数学分数是：xxx 我每次考试分数增加是xxx分，经过x次考试，我的分数达到了xxx分
name = "番茄" school = '美高编程' score = 60 z = 1.5 x = 8 print(f'我的名字是{name}，我的学校是{school}，我当前的数学分数是：{score}') print(f'我每次考试可以增加{z}分，经历了{x}次考试，我的分数达到了{score+z*x}分')
转义字符
\n ：换⾏。
\t ：制表符，⼀个tab键（4个空格）的距离。
结束符
print('内容', end="")
输入input
input("提示信息")
当程序执⾏到 input ，等待⽤户输⼊，输⼊完成之后才继续向下执⾏。
在Python中， input 接收⽤户输⼊后，⼀般存储到变量，⽅便使⽤。
在Python中， input 会把接收到的任意⽤户输⼊的数据都当做字符串处理
例
练习
模拟场景注册账号； 定义4个变量，1、用户名，2、注册密码，3，重复输入密码，4,验证码（4位数） 要求显示： 请输入您的用户名 请输入您的密码 请再输入您的密码 请按要求输入验证码：XXXX 恭喜你，账号创建成功 您的账号是XXX，密码是XXX
yhm = input('请输入您的用户名：') dlmm = input('请输入您的登陆密码：') cfmm = input('请再输入您的密码：') print('请输入验证码：1234') input() print('恭喜你，用户创建成功') print(f'您的用户名是{yhm}，您的密码是{dlmm}')
海龟画图
海龟绘图的基本原理是，你可以控制海龟在一个平面上移动，并使用简单的指令来控制它的行为。海龟可以前进、后退、转向，还可以在绘图板上绘制线条。通过组合和重复这些基本指令，你可以创建复杂的图形和图案。
turtle
是一个画图库
需要掌握的是笛卡尔坐标
调用海龟的方法
import turtle
控制海龟的方法
forward(距离)
：向前移动一定距离（单位为像素）。
fd
backward(距离)
：向后移动一定距离。
bd
right(角度)
：向右转动一定角度（单位为度）。
rt
left(角度)
：向左转动一定角度。
lt
penup()
：抬起画笔，海龟移动时不绘制图形。
pendown()
：放下画笔，海龟移动时绘制图形。
goto(x,y)
移动到哪个坐标
简单示例
画一个正方形
无循环
import turtle t = turtle.Turtle() t.forward(100) # 前进100个单位 t.right(90) # 右转90度 t.forward(100) t.right(90) t.forward(100) t.right(90) t.forward(100) t.right(90) turtle.done()
有循环
import turtle t=turtle.Turtle() for _ in range(4): t.forward(100) # 前进100个单位 t.right(90) # 右转90度
画一个三角形
import turtle t = turtle.Turtle() t.forward(100) # 前进100个单位 t.left(120) # 左转120度 t.forward(100) t.left(120) t.forward(100) t.left(120) turtle.done()
penup()
：抬起画笔，移动时不绘制图形。
pendown()
：放下画笔，移动时绘制图形。
pensize(width)
：设置画笔宽度。
pencolor(color)
：设置画笔颜色。
circle(radius, extent=None)
：绘制指定半径和角度的圆。注意绘制方向逆时针
示例
import turtle as t t.circle(100) # 绘制半径为100的圆 t.done()
shape（'形状'）
"arrow"：箭头形状
"turtle"：海龟形状（默认形状）
"triangle"：三角形
"square"：正方形
"classic"：经典海龟形状
"circle"：圆形
条件语句
条件成⽴执⾏某些代码，条件不成⽴则不执⾏这些代码。
if 语法
if 条件: 条件成⽴执⾏的代码1 条件成⽴执⾏的代码2 ......
age = 20 if age >= 18: print('已经成年，可以上⽹') print('系统关闭')
# input接受⽤户输⼊的数据是字符串类型，条件是age和整型18做判断，所以这⾥要int转换数据类 型 age = int(input('请输⼊您的年龄：')) if age >= 18: print(f'您的年龄是{age},已经成年，可以上⽹') print('系统关闭')
练习
欢迎来到儿童游乐场，儿童免费，成人收费 请输入你的年龄:XX（注：输入大于等于18表示成年） 您已成年，游玩需要补票10元 祝您游玩愉快。
age = int(input("请输入你的年龄:“)) if age >= 18: print("您已成年，游玩需要买票，10元。") print("祝您游玩偷快”）
条件成⽴执⾏if下⽅的代码; 条件不成⽴执⾏else下⽅的代码
if condition: # 如果条件满足，执行这里的代码块 else: # 如果条件不满足，执行这里的代码块
age = int(input('请输⼊您的年龄：')) if age >= 18: print(f'您的年龄是{age},已经成年，可以上⽹') else: print(f'您的年龄是{age},未成年，请⾃⾏回家写作业') print('系统关闭')
多重判断
if 条件1: 条件1成⽴执⾏的代码1 条件1成⽴执⾏的代码2 ...... elif 条件2： 条件2成⽴执⾏的代码1 条件2成⽴执⾏的代码2 ...... ...... else: 以上条件都不成⽴执⾏执⾏的代码
age = int(input('请输⼊您的年龄：')) if age < 18: print(f'您的年龄是{age},童⼯⼀枚') elif age >= 18 and age <= 60: print(f'您的年龄是{age},合法⼯龄') elif age > 60: print(f'您的年龄是{age},可以退休')
if嵌套
""" 1. 如果有钱，则可以上⻋ 2. 上⻋后，如果有空座，可以坐下 上⻋后，如果没有空座，则站着等空座位 如果没钱，不能上⻋ """ # 假设⽤ money = 1 表示有钱, money = 0表示没有钱; seat = 1 表示有空座，seat = 0 表示 没有空座 money = 1 seat = 0 if money == 1: print('⼟豪，不差钱，顺利上⻋') if seat == 1: print('有空座，可以坐下') else: print('没有空座，站等') else: print('没钱，不能上⻋，追着公交⻋跑')
剪刀石头布示例
# 导⼊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('电脑获胜')
三目运算符
语法
结果1 if 条件 else 结果2
循环
while
while 条件: 条件成⽴重复执⾏的代码1 条件成⽴重复执⾏的代码2 ......
# 循环的计数器 i = 0 while i < 5: print('重复') i += 1 print('任务结束')
1-100的累加和，即1 + 2 + 3 + 4 +….，即前两个数字的相加结果 + 下⼀个数字( 前⼀个数字 +1)
i = 1 result = 0 while i <= 100: result += i i += 1 # 输出5050 print(result)
for
for循环其实是一个遍历，核心语句是 for x in f（其中，x是一个临时变量，f是一个需要遍历的内容，循环的次数其实是f字符串的长度）
#检查多少个字母 sname = 'hhahdshdsadhsasasd' g=0 for f in sname: if f=='a': g+=1 print(f'一共有{g}个a')
range语句
语法1: range(num 获取一个从0开始，到num结束的数字序列(不含num本身)如range(5)取得的数据是:[0,1,2,3,4]
语法2: range(num1，num2)获得一个从num1开始，到num2结束的数字序列(不含num2本身)如，range(5,10)取得的数据是:[5,6,7,8,9]
语法3: range(num1，num2，step)获得一个从num1开始，到num2结束的数字序列(不含num2本身)数字之间的步长，以step为准 (step默认为1)如，range(5,10,2)取得的数据是:[5,7,9]
循环嵌套
语法
#外圈计数器 while 循环条件： #内圈计数器 while 循环条件： 循环内容 内圈计数器增加 外圈计数器增加 print（）#换行作用
g=1 while g<=5: d=1 while d<=5: print('$',end='') d+=1 g+=1 print()
循环打断
continue
打断输出内容后继续
d=1 while d<=5: if d==3: print('累了，休息一下') d+=1 continue print(f'跑了第{d}圈了') d+=1 print('跑完了')
break
打断不继续
o=0 while o<=5: if o==4: print('跑不动了') break o+=1 print(f'跑了第{o}圈了') print('跑完了')
while循环和for循环，都是循环语句，但细节不同
在循环控制上:while循环可以自定循环条件，并自行控制for循环不可以自定循环条件，只可以一个个从容器内取出数据
在无限循环上:while循环可以通过条件控制做到无限循环 for循环理论上不可以，因为被遍历的容器容量不是无限的在使用场景上
while循环适用于任何想要循环的场景 for循环适用于，遍历数据容器的场景或简单的固定次数循环场景
数据容器
定义
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据人如字符串、数字、布尔等。
分类
列表
定义格式
基本语法: # 字面量 [元素1，元素2，元素3，元素4，...] # 定义变量 变量名称 = [元素1，元素2，元素3，元素4，...] # 定义空列表 变量名称 = [] 变量名称 = list()
列表内的每一个数据，称之为元素 以作为标识 列表内每一个元素之间用，逗号隔开
存储的数据类型是可以不同的
示例
常规
# 定义一个列表 s=['小明',666,172.5] print(s) print(type(s))
嵌套
# 列表嵌套 d=['小红',s,666] print(d) f = [['hg','hc'],[1,2]] print(f)
特点
可以容纳多个元素(上限为2**63-1、9223372036854775807个)
可以容纳不同类型的元素(混装)
数据是有序存储的(有下标序号)
允许重复数据存在
可以修改(增加或删除元素等)
列表的方法
下标索引
下标顺序对应从0开始，元素1的下标是0
如
print(s[0])
从右向左取元素依次为，最右是-1,
如
print（s[-3]）
嵌套列表取元素
查找某元素的下标
功能:查找指定元素在列表的下标如果找不到，报错ValueError 列表.index(元素)语法: index就是列表对象 (变量)内置的方法 (函数)
插入元素
格式
列表.insert(下标,元素)
追加元素
将元素追加到列表的尾部
格式
列表.append(元素)
列表.extend(其他数据容器)
删除元素
语法1: del 列表[下标]
语法2: 列表.pop(下标)
删除第一匹配值：列表.remove(元素)
清空列表：列表.clear()
统计
统计列表内某个元素的数量：列表.count()
统计列表元素的数量：len(列表)
练习
练习 练习案例:常用功能练习 有一个列表，内容是:[21, 25, 21, 23, 22, 20], 记录的是一批学生的年龄 请通过列表的功能(方法)，对其进行 1.定义这个列表，并用变量接收它 2.追加一个数字31，到列表的尾部 3. 追加一个新列表[29,33,30]，到列表的尾部 4.取出第一个元素(应是:21) 5.取出最后一个元素(应是:30) 6.查找元素31，在列表中的下标位置
列表的遍历
while循环
循环计数器 while 循环条件（列表的长度） 循环内容 计数器增加
lie = [1,2,3,4,5,5,6,6,6,7] b = 0 while b< len(lie): print(f'遍历列表第{b+1}个的值为：lie[b]}') b += 1
for循环
for 计数器 in 列表
lie = [1,2,3,4,5,5,6,6,6,7] for n in lie: print(f'遍历列表第{n}个的值为：{n}')
练习
练习案例:取出列表内的偶数 定义一个列表，内容是:[1,2,3,4,5,6,7,8,9,10] 遍历列表，取出列表内的偶数，并存入一个新的列表对象中 使用while循环和for循环各操作一次 通过while循环，从列表:[1，2，了，4，5，6，7，8，9，10]中取出偶数，组成新列表:[2，4，6，8，10] 通过for循环，从列表:[1，2，了，4，5，6，7，8，9，10]中取出偶数，组成新列表:[2，4，6，8，10] 提示: 通过if判断来确认偶数 通过列表的append方法，来增加元素
list1 = [1,2,3,4,5,6,7,8,9,10] list2=[] i = 0 while i<=10: if i%2==0: list2.append(i) i+=1 print(f'通过while循环，从列表：{list1}中取出偶数，运行的结果为：{list2}') for f in list1: if i%2==0: list2.append(i) print(f'通过for循环，从列表：{list1}中取出偶数，运行的结果为：{list2}')
元祖
不同于列表，元祖一定定义完成就不可以修改
#定义元组字面量 (元素，元素，元素) # 定义元组变量 变量名称 = (元素，元素，......素) # 定义空元组 变量名称 =() 方法1 变量名称 = tuple() 方法2
如果定义的元祖只有一个元素，那么需要在元素后面加上一个“，”
常用方法
提取元素
元祖[下标]
元祖[下标][下标]
查找元素的下标
元祖.index(元素)
统计元素出现的次数
元祖.count(元素)
统计元祖的长度
len(元祖)
注：元祖里的元素不可以修改，但是元祖里嵌套的列表内容是可以修改的
l1=[7,7,8,8,9,9] t4 = ((t1),(l1)) print(t4) t4[1][5]=999 print(t4)
练习
练习案例:元组的基本操作 定义一个元组，内容是: ('周杰,1,['football，music'])记录的是一个学生的信息(姓名、年龄、爱好 请通过元组的功能(方法)，对其进行 1.查询其年龄所在的下标位置 2.查询学生的姓名 3.删除学生爱好中的football 4.增加爱好:coding到爱好list内
t1=('周杰',1,['football','music']) print(t1[1]) print(t1.index('周杰')) t1[2].remove('football') t1[2].append('coding') print(t1)
字符串
是字符的容器，可以存放任意数量的字符
同元祖一样，是无法进行修改的
常用操作
下标索引
字符串[下标]
左边开头是0，右边开头是-1
index方法
查询元素的下标
字符串.index('内容')
替换
语法: 字符串.replace(字符串1，字符串2)
功能: 将字符串内的全部: 字符串1，替换为符串2注意: 不是修改字符串本身，而是得到了一个新字符串哦
示例
st = '1234568695 122' st1 = st.replace('12','444') print(st) print(st1)
字符串的分割
语法: 字符串.split(分隔符字符串 )
功能: 按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
注意:字符串本身不变，而是得到了一个列表对象
示例
ast = "12 34 56 78" ast1 = ast.split(" ") print(f'将字符串1{ast}按空格分隔后，得到{ast1}，他的类型是{type(ast1)}')
字符串的规整操作(去前后指定字符串)
语法: 字符串.strip(字符串)
示例
ast = '12 21 34 44 55 78 21' ast2 = ast.strip('12') print(f'字符串{ast}去除12，得到的结果是{ast2}')
注：去除的只是前后，而且字符不分顺序
不传参数就是去除前后空格
统计字符串出现的次数
字符串.count('内容')
统计长度
len(字符串)
案例练习
练习案例:分割字符串 给定一个字符串:"py feichanghaoxue ai py' 统计字符串内有多少个"py"字符 将字符串内的空格，全部替换为字符:""并按照”"进行字符串分割，得到列表 去除字符串里面前后py，得到新字符串
py = 'py feichanghaoxue ai py' g = py.count('py') py1 = py.replace(' ','|') py2 = py1.split('|') py3 = py1.strip('py|') print(f'字符串py里面有{g}个py') print(f'字符串py里面有替换空格后为"|"后，得到的新字符串为{py1}') print(f'字符串py里面按"|"分隔后，得到的新字符串为{py2}') print(f'字符串py里面去掉前后py，得到的新字符串为{py3}')
字符串py里面有2个py 字符串py里面有替换空格后为"|"后，得到的新字符串为py|feichanghaoxue|ai|py 字符串py里面按"|"分隔后，得到的新字符串为['py', 'feichanghaoxue', 'ai', 'py'] 字符串py里面去掉前后py，得到的新字符串为feichanghaoxue|ai
序列
内容连续、有序，可使用下标索引的一类数据容器 列表、元组、字符串，均可以可以视为序列。
常用操作
切片
从一个序列中，取出一个子序列
语法：序列[起始下标:结束下标:步长]
起始下标表示从何处开始，可以留空，留空视作从头开始
结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
步长表示，依次取元素的间隔
注：结束下标的数据是不包含的，如果取到结尾的，数据是有包含的 步长1表示，一个个取元素 步长2表示，每次跳过1个元素取 步长N表示，每次跳过N-1个元素取 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
练习
#字符'尚和小个一和尚和老个有里庙，庙座有上山，山座有前从'使用语法获取到老和尚三个字
str = '尚和小个一和尚和老个有里庙，庙座有上山，山座有前从' str1=str[::-1] str2=str.split("，") str3 = str2[0][::-1][4:7:1] print(str3)
集合
不支持重复元素，并且内容无序
不支持下标索引，但是内容可修改
基本语法
花括号{}
基本语法:
#定义集合字面量
{元素，元素，......元素}
# 定义集合变量
变量名称 = {元素，元素，元素}
# 定义空集合
变量名称 = set()
基本操作
添加元素
集合.add(元素)
移除元素
集合.remove(元素)
随机取出元素
集合.pop()
取出之后集合被修改，元素被删除
清空集合
集合.clear()
取出2个集合的差集
语法: 集合1.difference(集合2)
功能: 取出集合1和集合2的差集 (集合1有而集合2没有的) 结果: 得到一个新集合，集合1和集合2不变
示例
set1 = f{1，2，3}
set2 = f{1，5，6}
set3 = set1.difference(set2)
print(set3)
print(set1)
print(set2)
# 结果: {2，3}
得到的新集合
# 结果: {1，2，3] 不变
# 结果: {1，5，6} 不变
消除2个集合的差集
语法:集合1difference_update(集合2) 功能:对比集合1和集合2，在集合1内，删除和集合2相同的元素
结果:集合1被修改，集合2不变
交集
字典1.intersection(字典2)
2个集合合并
语法:集合1.union(集合2)
功能: 将集合1和集合2组合成新集合结果: 得到新集合，集合1和集合2不变
统计长度
len(集合)
集合的遍历
由于不支持下标索引，所以不支持while循环，只支持for循环
练习
有数据1，2，3，4，5，6，1，2，2，4，4，5
请:
定义一个空集合
通过for循环遍历列表
在for循环中将列表的元素添加至集合最终得到元素去重后的集合对象，并打印输出
有列表是[1, 2, 3, 4, 5, 6, 1, 2, 4, 5, 5, 4] 经过去重后得到的数据是{1, 2, 3, 4, 5, 6}
字典
作用
字典的名称指出了这种数据结构的用途，它旨在让你能够轻松地找到特定的键，以获悉其对应的值。
key:value
定义
# 定义字典字面量
每一对需要用逗号隔开
{key: value, key: value, ......, key: value} # 定义字典变量
如{"小明":22,"小红":55}
my_dict = {key: value, key: value,key: value} # 定义空字典
my_dict = {} my_dict = dict()
# 空字典定义方式1
# 空字典定义方式2
字典不可以重复内容，如果重复内容新的会把久的数据覆盖掉
如{"小明":22,"小红":55,"小明":88}
打印后，小明分数是88
常用操作
数据获取
不支持下标索引，但可以通过key获取对应的value
字典[key]
字典的嵌套
key不可以为字典，value可以为任意数据
小明数学88，英语89，语文92
小红数学66，英语99，语文88
小王数学99，英语66，语文88
使用字典完成
d = { "小明":{'数学':88,'英语':89,'语文':92} ,"小红":{'数学':66,'英语':99,'语文':88} ,"小明":{'数学':99,'英语':66,'语文':88} } print(d['小明'])
新增元素
字典[key]=value
也可用作替换元素
删除
字典.pop(key)
指定的key值对应的value值删除
删除时可以得到删除的数值
清空元素
字典.clear()
获取全部key
字典.keys()
遍历字典
方式1
keys=字典.keys()
for key in keys:
方式2
for key in 字典:
字典的元素数量
len(字典)
列表集合字典推导式
推导式comprehensions（又称解析式），是Python的一种独有特性。推导式是可以从一个数据序列构建另一个新的数据序列（一个有规律的列表或控制一个有规律列表）的结构体。 共有三种推导：`列表推导式`、`集合推导式`、`字典推导式。
列表推导式
语法
变量名 = [表达式 for 变量 in 列表 for 变量 in 列表] 变量名 = [表达式 for 变量 in 列表 if 条件]
变量 = [表达式 for 临时变量 in 序列 for 临时变量 in 序列]
字典推导式
语法
变量 = {key:value for key,value in 序列}
应用
合并列表
# 创建一个字典：字典key是1-5数字，value是这个数字的2次方。 dict1 = {i:i**2 for i in range(1,6)} print(dict1)
生成字典
# 快速合并两个列表形成字典 list6 = ['name', 'age', 'gender'] list7 = ['Tom', 20, 'male'] dict2 = {list6[i]:list7[i] for i in range(len(list6))} print(dict2)
提取数据
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'ACER': 99} # 需求：提取上述电脑数量大于等于200的字典数据 counts1 = {k:v for k,v in counts.items() if v>=200} print(counts1)
集合推导式
语法
同上，只是换成了{}
通用操作
遍历
长度len()
最大值max()
最小值min()
排序 sorted(排序的对象)
排序结果会变成列表对象
如果需要反转
sorted(排序的对象,reverse=True)
函数
定义
组织好的、可重复使用的、用来实现特定功能的代码段
为了得到一个针对特定需求、可供重复利用的代码段提高程序的复用性，减少重复性代码，提高开发效率
函数的定义: def 函数名(传入参数)： 函数体 return 返回值
传入参数的数量是不受限制的。 可以不使用参数 也可以仅使用任意N个参数
def 函数(参数...): 函数体 return 返回值 变量 = 函数(参数)
变量就能接收到函数的返回值语法就是: 通过return关键字，就能向调用者返回数据
写在return下面的代码不会被执行
示例
定义一个两数相加的函数
def add(x,y): print(f'{x}*{y}的结果是{x*y}') add(1,2) add(2,3)
none类型
Python中有一个特殊的字面量: None，其类型是:<class NoneType)>
无返回值的函数，实际上就是返回了: None这个字面量
None表示:空的、无实际意义的意思函数返回的None，就表示，这个函数没有返回什么有意义的内容也就是返回了空的意思
应用场景
用在函数无返回值上
用在if判断上 在if判断中，None等同于False 一般用于在函数中主动返回None，配合if判断做相关处理
示例
子主题
用于声明无内容的变量上 定义变量，但暂时不需要变量有具体值，可以用None来代替
函数说明
语法如下:def func(x，y): ''' 函数说明 :paramx:形参x的说明: param :paramy:形参y的说明 :return:返回值的说明 ''' 函数体 return 返回值 通过多行注释的形式，对函数进行说明解释 内突应写在函数体之前
:param用于解释参数 :return 用手解释返回值
函数的嵌套调用
函数A中执行到调用函数B的语句，会将函数B全部执行 完成后，继续执行函数A的剩余内容
def a(): print("123") def b(): print('456') a() print('789') b()
结果是456,123,789
变量的作用域
局部
定义在函数体内的，在函数外访问会报错
全局
在函数外的变量
global关键字
修改函数内的全局变量
global 变量名
函数进阶
多返回值
def a() return 1,2,3 x,y,z = a()
参数种类
位置参数
调⽤函数时根据函数定义的参数位置来传递参数。
def yh(name,age,xx): print(f'我的名字是{name}，年龄是{age}，单位是{xx}') yh("刘建明",28,'警务部')
关键字参数
通过“键=值”形式加以指定。可以让函数更加清晰、容易使⽤，同时也清除了参数的顺序需求
yh(name='陈永仁',xx='卧底',age=29)
缺省参数
也叫默认参数，⽤于定义函数，为参数提供默认值，调⽤函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调⽤）。
不定⻓参数
不定⻓参数也叫可变参数。⽤于不确定调⽤的时候会传递多少个参数(不传参也可以)的场景。此时，可⽤包裹(packing)位置参数，或者包裹关键字参数，来进⾏参数传递，会显得⾮常⽅便。
位置传递
关键字传递
复合函数（嵌套）
匿名函数
lambda 传入参数：函数体(一行代码)
只能使用一次
元祖与字典的拆包
就是把元组或字典中的数据单独的拆分出来，然后赋予给其他的变量。
对于函数中的多个返回数据, 去掉元组, 列表 或者字典直接获取里面数据的过程。
拆包应用
两个变量进行交换
c1 = 10 c2 = 2 c1,c2 = (c2,c1) print(c1) print(c2)
文件操作
主流编码UTF-8
没有特殊要求默认使用
文件的读取
临时文件一般是保存在内存，需要长久保存就需要保存到硬盘等硬件里
open()
打开一个新的，或者创建一个新的文件
open(name, mode, encoding)
name: 是要打开的目标文件名的字符串(可以包含文件所在的具体路径)
mode:设置打开文件的模式(访问模式): 只读、写入、追加等。
r：以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w：打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除.如果该文件不存在，创建新文件。
a：打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后如果该文件不存在，创建新文件进行写入。
encoding:编码格式(推荐使用UTF-8)
示例
f= open('python.txt','r', encoding=”UTF-8) # encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定
读
read()方法
文件对象.read(num)
num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据。
readlines()方法：
文件对象.readlines()
readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
readline()方法：
一次只会读取一行
多次调用的情况下会在上一次调用的结尾开始
循环读取
for 临时变量 in 文件对象
临时变量就是每一行的数据
关闭程序
文件对象.close()
如果没有关闭会被python文件一直占用
with open()
自动关闭文件
语法
with open() as 文件对象:
写
语法
文件对象.write('写入内容')
模板
打开文件
open()
写入文件
刷新文件
文件对象.flush()
关闭文件
关闭文件集成了刷新功能，所以关闭时会自动刷新
ps：当文件不存在时会创建文件，当文件存在会清空文件
文件追加
模板
打开文件以'a'模式运行
open()
写入文件
刷新文件
文件对象.flush()
关闭文件
关闭文件集成了刷新功能，所以关闭时会自动刷新
综合案例：
1、使用'r'打开保存好的文件 2、使用'w'模式写入新的文件，并保存成bak格式 3、检测原文件中的数据是否包含'测试' 4、把没有包含'测试'的文件写入到新文件中
文件内容
name, date,money, type, remarks 周杰轮,2022-01-01,100000,消费,正式 周杰轮,2022-01-02,300000,收入,正式 周杰轮,2022-01-03,100000,消费,测试 林俊节,2022-01-01,300000,收入,正式 林俊节,2022-01-02,100000,消费,测试 林俊节,2022-01-03,100000,消费,正式 林俊节,2022-01-04,100000,消费,测试 林俊节,2022-01-05,500000,收入,正式 张学油,2022-01-01,100000,消费,正式 张学油,2022-01-02,500000,收入,正式 张学油,2022-01-03,900000,收入,测试 王力鸿,2022-01-01,500000,消费,正式 王力鸿,2022-01-02,300000,消费,测试 王力鸿,2022-01-03,950000,收入,正式 刘德滑,2022-01-01,300000,消费,测试 刘德滑,2022-01-02,100000,消费,正式 刘德滑,2022-01-03,300000,消费,正式
代码
f1 = open('C:/Users/奶油太多/Desktop/bill.txt','r',encoding='UTF-8') f2 = open('C:/Users/奶油太多/Desktop/bill.txt.bak','w',encoding='UTF-8') for line in f1: line = line.strip() if line.split(',')[4] == "测试": continue f2.write(line) f2.write('\n') f1.close f2.close