python的基本操作与语法

图文并茂的介绍了python基本学习的语法与代码，富含丰富例子与案例，可以很好辅助同学们学习，文档展示了部分内容，如需学习请购买使用

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