python基础语法

Python：简洁高效的跨平台编程利器 Python是一门面向对象的高级解释语言，兼具脚本语言的灵活性与跨平台优势它以简洁开源、生态广泛著称，覆盖Web开发、数据分析、AIoT及自动化等领域，适合非计算机专业快速上手通过解释器将代码转换为机器语言，支持多种IDE（如JetBrains系列），但需注意其运行速度较慢、并发处理能力有限，适合中小型项目无论是打破专业壁垒还是赋能行业应用，Python都是理想选择。

起步

• 特性
  • 面向对象的高级解释语言，同时也是脚本语言。 简洁开源，上手轻松。可跨平台。 生态广泛，在web开发、大数据、人工智能、自动化等方向有完整的框架
  • Python语言 有哪些特点。
    • 优点：
      • 易于学习【Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单】
      • 易于阅读【Python代码定义的更清晰】
      • 易于维护【Python的成功在于它的源代码是相当容易维护的】
      • 一个广泛的标准库/模块/包【Python的最大优势之一是丰富的库，跨平台的，在nuix、weindows和mac os上的兼容性很好】
      • 可移植性【基于其开发源代码的特性，Python已经被移植到许多平台】
      • 可扩展性【如果需要一段运行很快的关键代码，或者想要编写一些不愿开发的算法，可以使用C或者C++完成那部分程序，然后从你的Python程序中调用】
      • 数据库【Python提供所有主要的商业数据库的接口，如：MySQL,Oracle,MongoDB,Redis等】
      • GUI编程（图形化界面）【Python支持GUI可以创建和移植到许多系统调用】pyqt等
      • 可嵌入性【可以将Python嵌入到C或者C++程序，让你程序的用户获得“脚本化”的能力】
    • 缺点：
      • 运行速度较慢
  • 缺点：运行速度慢，处理并发能力差， 适合中小型和toB项目的开发，中文资料匮乏
    • 卡顿
    • 访问量不宜过高。
  • 应用生态广 适用于非计算机专业， 适用于打破专业壁垒为各行各业赋能。
  • python职业规划
    • Web全栈
    • AI+物联网 AIoT
    • 自动化
      • 自动化办公
      • 自动化测试
      • 自动化运维
    • 数据分析
      • 爬虫【数据采集】
      • 机器学习
      • 深度学习
      • 数据挖掘
      • ​算法/人工智能
  • Python常⻅的应用领域。
• 安装 解释器 和开发环境
  • python解释器： 将高级语言代码 转换为机器语言的程序。 其底层可能为C语言等。
    • 版本
      • python 3
        • 解释器内部完全以面向对象的方式实现。
        • 注意：与python2不兼容
        • python 3.12.0
          • 根据你的操作系统，在python官网下载解释器安装包
      • Anaconda
        • 与原生python相比，自带了绝大多数第三方库
        • 默认版本
          • python 3.9
      • 记得将安装路径添加到环境变量 Add Python to PATH
        • 方便系统以后根据环境变量值来 确定各种配置和行为。
        • 启动Python终端时无需再输入完整路径
        • 拓展
          • 计算机手动添加环境变量 定义变量+值
            • control system
        • 问题演示：
          • pip不是内部或外部的命令
    • 解释器的 使用方式
      • 交互方式： 一问一答
        • 解释器 python shell
          • shell
            • 用户交互行
          • dos指令
          • 系统终端（terminal）
          • 最底层，最原始的控制命令。
        • IDLE
          • IDLE（Integrated Development and Learning Environment）是Python自带的集成开发环境（IDE），主要用于编写、调试和运行Python代码。
          • IDLE shell
            • 用户交互行
          • 菜单栏：可建立文档并运行多行代码
            • 文件方式
          • 缺点：对于初次开发或小白来讲不太友好
      • 文件方式
        • 记事本
          • 修改后缀名， 成为 python项目
            • .py
              • python文件
        • 执行
          • python文件
  • IDE: 集成开发环境， 编写代码
    • 非必要
    • 常见的 一些第三方IDE
      • vscode 小 jupyter notebook 分步执行程序
      • sublime
      • PyCharm
        • 专业版功能强大，可破解
        • 功能
          • 错误标注
          • 纠错建议
          • 语法高亮
          • 框架和库
        • 安装和配置
          • JetBrains公司官网下载集成开发环境，可跨平台
          • System Interpreter
          • 配置解释器
            • 找到解释器(Python Interpreter)，即python.exe所在路径
        • 功能介绍
          • 设置 Settings
            • 下载插件 plugins
              • AI编程助手
                • Fitten Code
            • Appearance 外表
              • Theme 主题
            • Editor
              • font 字体
            • Project: xxx 项目
              • 子主题
        • 快捷键
          • ctrl+/
            • 批量注释
          • fn+F10（笔记本）
            • F10
          • shift+ctrl+F10
            • 运行程序
          • tab
            • 缩进
          • shift+tab
            • 取消缩进
    • 本质：在电脑路径上创建文件夹和文档。
• 程序语言设计
  • 高级语言 汇编 机器码
    • 机器语言
      • 10111001001011111
    • 汇编语言
      • 在机器语言的基础上添加标记符
  • 解释与编译
    • 编译——静态语言 C、Java
      • 高级语言提前编译成执行文件
      • 执行速度快
    • 解释——脚本语言 JS、Python
      • 直接解释执行源码
      • 可移植性好

Python基础语法

• 源文件默认编码方式
  • # -*- coding: utf-8 -*-
    • 可用来改变编码方式。
• 数据与变量
  • 标识符
    • 命名变量：指向一个内存空间，区分不同数据，由标识符组成。
    • 标识符 命名
      • 概念：计算机编程语言中，标识符是用户编程时使用的名字，用于给变量、常量、函数、语句块等命名，以建立起名称与使用之间的关系
      • 合法标识符的命名规则：
        • 合法标识符 由字母、数字、下划线组成
          • 如 abc%y不合法
          • 不可以是除了下划线之外的其他特殊字符
        • 开头不能是数字或者空格，如：1abc不合法
          • 1code
        • 不能是Python的关键字
        • 严格区分大小写，如：age和Age是两个不同的标识符
      • 约定规范
        • 尽量做到见名知意【具有描述性】：尽量使用简单的英文单词表示。
          • 不要太长，不要中文
          • 要有意义
        • 推荐下划线命名和驼峰命名 例如：cheng_jie、chengJie
          • Python官方推荐的命名方式：变量名，函数名和文件名全小写，使用下划线连接，如：stu_name check_qq
          • 驼峰命名法：不同的单词之间使用首字母大写的方式进行分隔，又分为大驼峰和小驼峰，比如：stuName就是小驼峰，StuName就是大驼峰，小驼峰常用于变量或者函数的命名，大驼峰常用于类的命名
      • 项目的命名虽没有明确规定，但也应该遵守上述规范。
  • 变量 赋值
    • 变量名本质上就是标识符。
      • 后期也可以主动声明
        • num: int = 10
    • 赋值 (assignment) =
      • cheng_jie = "chengJie"
      • 一个变量可以通过赋值指向不同类型的变量。
        • 工作原理：从左到右依次赋值
      • 引用（referenced）赋值： 用一个变量给另一个变量赋值
        • 对象引用赋值
        • v = v1
        • 将同一对象赋值给另一个变量。
          • 赋值操作：总是创建新的引用，而不是复制对象
        • 可变数据类型：变量的值改变时，另一个变量的值也会发生变化。
        • 不变数据类型：
          • "看起来"像值赋值（因为无法修改原对象）
    • 变量相关概念
      • 如果变量在代码中第一次出现， 则称变量的定义。
        • 给变量赋予的第一个值称为初始值。
      • 重新赋值
        • 变量第二次出现被赋予不同的值。
      • 常量
        • 常量命名全部字母大写 （python 无绝对常量）
          • NAME ="chengJie"
        • 无对应的机制，全凭自觉。
      • 变量之间可以运算和比较
      • 原理
        • 在计算机内存中开辟了一份空间（内存地址），并在该空间存储一个指定的数据。
    • 变量的应用
      • 变量值的交换
        • num1, num2 = num2, num1 # Python特有的语法
      • 打包和拆包
        • p1, p2, p3, *p4 = 1, 2, 3
          • 把剩下的数据全部打包（列表）给*修饰的变量。
          • 只能出现一次
        • v1, v2, v3 = (3, 2, 1) # 拆包 print(v1, v2, v3)
    • 删除变量
      • del v1
        • 销毁变量所占的内存空间。
    • 变量的类型转换
      • 参数需要满足要求
      • 将字符串进行转化最为常见
      • 浮点型转化为整型
        • 只取整数部分。
      • 转化为数字时
        • 参数由数字、正负号、小数点组成，且正负号只能在最前面
      • 其他类型转化为布尔型
        • 表示空的为False
          • 表示空的数据类型： None, 0, 0.0, '', [], (), {}, False, b''
        • 其他非空均为True
  • 数据 010111010101
    • 常量、变量、表达式 + 函数、对象
    • 内置数据类型
      • 基本数据类型
        • 数字
          • 整数（）、浮点数（）、复数（）
        • 字符串（str）
      • 数据集
      • 高级教据类型
        • 等
    • 可迭代数据类型 （iterable）
      • 序列容器： 字符串、列表、 元组、字节
        • 特性
          • 有序，可重复
          • 元素：任意数据类型
        • 拼接(concatenate)重复
          • + *
        • 索引切片
        • 元素遍历、索引遍历、枚举遍历
          • in
        • 查：index/count
      • 非序列容器： 集合、字典
        • 特性
          • 无序，不可重复（字典key）
          • 元素：可哈希的数据类型（字典key）
        • 元素遍历
          • in
      • 查：min/max/len
    • 可变/哈希数据类型与 不可变/不可哈希数据类型 （hashable）
      • 可变数据类型： 列表、集合、字典
        • 对象的地址
          • 内容变化后列表对象的地址不发生变化。 改变的是里面元素的地址
        • 拷贝
          • copy
        • 对象内增删改
        • 查
      • 不可变数据类型： 整数、浮点数、复数、字符串、元组
        • 对象的地址
          • 不变且唯一
        • 增删改无法在对象内部完成，对应的系统功能通过返回值产生新的对象
        • 查
    • 真数据与假数据
      • 表示空的数据为假数据
      • 非空的数据为真数据
        • True
    • 数据的定义和调用
• 关键字/保留字 33
  • False None True and as assert async await break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield
  • 分支语句
    • if 条件： 代码块 elif 条件： 代码块 else： 代码块
      • 条件判断if语句 1. 可以只有if 2. 可嵌套
      • 代码块四格（Tab）缩进 条件满足则执行代码
  • 跳转语句
    • break
      • 结束循环
    • continue
      • 结束本次代码进程，直接进行下次循环
  • 循环
    • while 条件: 代码块
      • 多用于死循环
    • for 变量 in 可迭代的数据： 代码块
      • 多用
      • 循化索引
      • 循环元素
  • 数据
    • False
      • 0
    • True
      • 1
    • None
      • 空，什么都不是 应对字典中什么都没有的情况
  • 逻辑运算
    • 或-且-非 #优先级由高到低
      • not
      • and
      • or
  • 成员运算
    • in
  • 身份运算符
    • is
  • 变量、函数、类
    • 声明
      • 变量
        • global
        • nonlocal
      • def
        • 函数定义(function definition)
        • return
          • 调用函数得到返回值。
          • 需要赋值给变量。
        • yield
          • 生成器
        • lambda
      • class
    • del
      • 删除对象
    • 空
      • pass
        • 空代码块占位
  • 上下文管理
    • with
      • ：用于上下文管理。
      • 管理资源的获取和释放（如文件、网络连接）。
    • as
  • 异常处理
    • try
      • ：尝试执行可能出错的代码。
    • except
      • ：捕获并处理异常。
    • finally
      • ：无论是否发生异常，都会执行的代码。
  • 断言
    • x = 10 assert x > 0, "x must be positive"
  • 同步与异步
    • async / await：用于异步编程。
  • 导入模块
    • from
    • import
  • 暂时未知
• 行与缩进
  • 代码块 代码组
    • 冒号后换行 用缩进来表示代码块
      • 同一个代码块缩进的空格数必须相同。
    • 如
      • if 条件： 代码块 elif 条件： 代码块 else： 代码块
  • 折行：
    • 长语句转换为多行语句
      • 目的：美观+可阅读性
    • \
      • 操作方式：在长语句中需要折行的地方敲回车即可。
      • 输出结果不变
    • str_1 = 'hello\nwor' \ 'ld'
  • 空行 ——约定
    • 仅为约定规范 方便维护和重构
    • 定义的方法和类，用空行隔开，
  • 一行显示多条语句
    • 用 ；分隔
• 注释
  • # 单行注释
  • ''' 多行注释 ''' """ 多行注释 """
  • 批量注释快捷键：Ctrl+/
• 运算符
  • 类型
    • 算数运算
      • 运算符
        • +
          • -
        • *
          • **（次幂）
            • print(2 ** 3) print(2 ** 0.5) # 开根号 print(2 ** -1) # 倒数次幂
        • /
          • 结果均为浮点数
          • %
            • 取余
          • //
            • 地板除，取整。
            • 得到左侧整数
      • 优先级
        • **（次幂）
        • * / % //
          • 相同优先级从左到右运算
        • +
          • -
        • print(2 + 3 * 5 / 2 ** 2 % 3 - 3 // 2) # 1.75 print((2 + 3) * 5 / 2 ** 2 % 3 - 3 // 2) # -0.75
      • 有浮点数参与运算结果均为浮点数。
    • 赋值运算
      • 赋值语句
        • 一回只能赋值一次
      • 简单赋值运算符
        • =
      • 复合赋值运算符
        • +=、 -= 、...
        • 前提是先定义变量
        • a=a+b a += b
          • 先运算后赋值
      • 3.8 海象运算符 :=
    • 比较/关系/关系运算
      • >、 >=、 <、 <=、 ==、 !=
      • 可以进行比较 的数据类型
        • 数字
          • print(1.0 < 2)
        • 字符串
          • 依据：ASCII码
            • ASCII码对照表
              • https://c.biancheng.net/c/ascii/
            • 数字 < 大写字母 < 小写字母
              • 字母的大小写之间相差32
          • 在实际应用中意义不大，只有==应用最多。
          • print('12226521jgdh' == '12226521jgdh')
        • 不同数据类型之间比较也没有意义。
      • 结果是布尔值，表达式成立为True，不成立为False。
      • # Python支持运算符连写。 print(2 < 10 > 7) # 等同于 print(2 < 10 and 10 > 7)
    • 逻辑运算
      • 通常与关系运算符结合使用。
      • 或-且-非
        • not
        • and
          • 一假为假，全真为真
        • or
          • 一真为真，全假为假
      • 不同数据类型 的逻辑运算
        • 表示真的数据
          • 非空数据
        • 表示假的数据
          • 空数据类型
        • and 输出结果
          • 从左到右输出数据 真覆盖数据，输出右边的值 假短路，输出左边的假值
        • or 输出结果
          • 从左到右输出数据 真短路，输出左边的真值 假覆盖数据，输出右边的值
        • not 输出结果
          • 一定是布尔值
      • 符合逻辑运算 #优先级由高到底
        • not
        • and
        • or
        • print(not [] or 'hello') # True
        • print(True and False or not True) # False
    • 成员运算
      • in
        • 判断某数据是否在容器中
      • not in
      • print('cj' in 'cjxka') print(1 not in [11, 2, 3])
    • 身份运算符
      • is
        • # 不可变的数据类型，内容相同，对象的内存地址是唯一的。 a = 10 b = 10 print(id(a), id(b)) print(a == b) # 比较内容 print(a is b) # 比较对象的内存地址
        • # 可变数据类型，内容相同，对象的内存地址不一定唯一。 li1 = [0, 1, 2] li2 = [0, 1, 2] print(id(li1), id(li2)) print(li1 == li2) print(li1 is li2) # False li3 = li1 print(id(li1), id(li3)) print(li1 == li3) print(li1 is li3) # True
          • list set dict
      • is not
    • 位运算符
      • 把数字看成二进制然后计算。
      • 按位运算符
        • &
          • 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
          • (a & b) 输出结果 12 ，二进制解释： 0000 1100
        • |
          • 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
          • (a | b) 输出结果 61 ，二进制解释： 0011 1101
        • ^
          • 按位异或运算符：当两对应的二进位相异时，结果为1
          • (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
      • 按位取反运算符
        • ~
          • 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1
          • (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
      • 位移动运算符
        • <<
          • 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。
          • a << 2 输出结果 240 ，二进制解释： 1111 0000
        • >>
          • 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数
          • a >> 2 输出结果 15 ，二进制解释： 0000 1111
  • 复合运算 运算符优先级
    • • 优先级高的运算符首先进行运算。
      • 算数运算符 > 关系运算符 > 逻辑运算符 > 赋值运算符
      • 在实际应用中，运算符的混合不应过于复杂，建议使用()手动控制优先级。
  • 类型转换
    • 分类
      • 隐式类型转换
      • 显式类型转换 str = str(int)

逻辑控制

• 分支语句
  • if 条件： 代码块 elif 条件： 代码块 else： 代码块
    • 条件判断if语句 1. 可以只有if 2. 可嵌套
      • 单分支
        • if 条件： 代码块
        • 处理一种情况，要么执行要么不执行
      • 双分支
        • if 条件： 代码块 else： 代码块
        • 处理两种情况，实现二选一
      • 多分支
        • if 条件： 代码块 elif 条件： 代码块 elif 条件： 代码块 ... else： 代码块
        • 处理多种情况，实现多选一。
      • 嵌套
        • 代码块中可以嵌套以上三种分支语句
        • 注意缩进问题
        • 嵌套层数理论上没有限制，为了可读性和可维护性，建议嵌套层数最多三层。
    • 条件
      • 常量，变量或表达式（大多数）
      • 条件为真则执行，为假则不执行
      • 多条件成立的情况下，只会执行前面的一支。
    • 代码块
      • 四格（Tab）缩进
      • 条件为真则执行代码
    • 三目运算符
      • Python本身不存在。
      • 模拟语法
        • num = 5621 r = '偶数' if num % 2 == 0 else '奇数' print(r)
          • r = True if 条件 else False
        • 等同于
          • if num % 2 == 0： r = '偶数' else: r = '奇数'
            • if 条件: r = True else: r = False
      • 简洁
        • 用一行代码完成判断
  • match score: case 10: print("优秀") case 9: print("良好") case 8: print("及格")
    • 可以作为标识符给变量命名。
• 循环
  • 概念
    • 在生活中，循环指的是一个现象周期性或者重复性的出现
    • 在编程中，在满足条件的情况下，反复执行某一段代码，在编程语言中出现的这种现象被称为循环，这段被重复执行的代码被称为循环体
    • Python中提供的循环语句有：while语句和for语句
  • while 条件: 代码块/循环体 else: 代码块（break后不执行）
    • 死循环或循环次数不确定的情况下使用
    • 条件
      • while中的条件和if中的条件的使用完全相同，都可以是常量，变量或表达式
      • 在条件成立（真数据）的前提下，if中的语句只会执行一次，但是，while中的语句【循环体】会执行若干次
      • 在大多数情况下，书写循环需要考虑的核心问题：控制循环的次数
        • 让循环可以在合适的时机停止下来，否则形成死循环
    • 循环体
    • 注意：
      • a.根据需求，一般情况下，如果规定了次数，一定注意避免书写死循环【n += 1】
      • b.死循环一般结合break使用
      • c.对于循环，一定要搞清楚代码执行的顺序
    • debug:
      • 打断点----》右键----》Debug-----》
      • 分步执行代码，查看代码执行的顺序
        • step over 步过
          • 一段一段执行自己写的代码
        • step into 步入
          • 进入运用的函数
        • 没法回退
    • 循环的else分支
      • 如果while或for中的break执行了，则循环的else分支不会被执行；
      • 如果while或for中的break未被执行，则循环的else分支会在循环条件不成立后被执行
  • for 变量 in 可迭代的数据： 代码块 else: 代码块（break后不执行）
    • 循环次数确定时使用
    • 循化索引
      • i in range()
    • 循环元素
      • 功能：for循环主要用于遍历任何容器， 比如列表，字符串，元组，字典和集合等
      • 遍历：指的是依次访问序列中的每一个元素，获取每个元素值
      • 说明：按照顺序获取容器中的每个数据，赋值给变量名，再执行循环体，如此循环往复，直到取完容器中所有的数据为止
    • # 如果仅仅为了控制次数，定义的变量在循环体中未被使用，则可以使用下划线代替。 for _ in range(1, 101): print("hello world!")
    • 循环的else分支
      • 如果while或for中的break执行了，则循环的else分支不会被执行；
      • 如果while或for中的break未被执行，则循环的else分支会在容器遍历完成后被执行
  • 嵌套循环
    • 循环相互嵌套
    • 在代码执行的过程中，但凡遇到循环语句，都是先把当前循环执行完毕，然后代码才会向下执行
• 跳转语句 （应用于循环语句中）
  • break
    • 结束当前循环
    • 【break书写在哪个循环中，就结束哪个循环，就近原则】
  • continue
    • 结束本次代码进程，直接进行下次循环

数据 010111010101

• 基本数据类型 —— type():查看数据类型 isinstance():判断类型，包含父类。
  • 数字 number
    • int
      • 整型
        • binary 二进制 octal 八进制 hexadecimal 十六进制
      • 1
    • float
      • 浮点型
        • 计算机表示小数有误差
      • 1.0
    • bool
      • 布尔型
        • 本身为int的子类
        • 0 == False
          • 表示空的经转化是false
        • 1 == True
          • 其他值，转化后均为Ture
      • True/Flase
        • False
        • True
    • complex
      • 复数
      • 1+2j
  • 字符串 str
    • 概念和性质
      • Python 中的字符串不能改变。
      • Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
      • Python3中，所有字符串都是Unicode字符串（16位）
    • 定义
      • 单行字符串：Python 中单引号 ' 和双引号 " 使用完全相同。换行或其他操作需要转义
        • str1 = 'str'
        • str1 = "str"
      • 多行字符串：使用三引号(''' 或 """)可以指定一个多行字符串。（可直接写HTML或者SQL，不需要再转义）
        • str1 = ''' multi-line strings '''
    • 级联
      • 按字面意义级联字符串，如 "this " "is " "string" 会被自动转换为 this is string。
    • 序列的 基本用法
      • 除字符串外，列表、元组和字节也属于序列。
      • 拼接、重复
        • 字符串可以用 + 运算符拼接在一起， 用 * 运算符重复。
          • 同类型
        • str1 = '123456789abcde' str2 = '6666''9999' print(str2) print(str1 + str2) print(str1*5)
      • 索引、切片
        • Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
        • 字符串切片 str[start:end]，其中 start（包含）是切片开始的索引，end（不包含）是切片结束的索引。
        • 字符串的切片可以加上步长参数 step，语法格式如下：str[start:end:step]
      • 解构/拆包: 变量数与数据量一致
        • a,b = (1,2)
        • a,b = b,a
          • 互换
      • 遍历
        • 索引遍历（序列）
        • 枚举遍历
    • 容器
      • 查找
        • in
      • 遍历
        • 元素遍历
    • 字符串 内部处理
      • 反斜杠：\
        • 转义符： \xx。
          • \两位数字
          • \字母
          • \特殊字符
        • windows系统文件路径问题 C:\Users\24727\PycharmProjects
          • path = 'C:\\Users\\24727\\PycharmProjects' print(path) path = r'C:\Users\24727\PycharmProjects' print(path)
        • 原始字符串（raw-string）： 使用 r 可以让反斜杠不发生转义。
          • 如 r"this is a line with \n" 则 \n 会显示，并不是换行。
          • 常用于
            • 文件路径
            • 正则表达式
        • 续行符
          • 折行：
      • 格式化字符串 format string：
        • 将多个数据按照指定的格式进行定义，最终得到一个字符串。
          • 占位符数量与数据的数量应保持一致。
        • 三种方式
          • "请输入姓名：占位符" % (占位变量名, )
            • 占位符： 格式字符串
              • %s 占位，任意数据类型
              • %d 整数占位
                • %.nd
                  • 固定长度n，填充0
                • %nd
                  • 固定长度n，填充空格
              • %f 小数占位
                • 默认保留小数点后6位
                • %.nf
                  • 小数点后位数的保留（涉及四舍五入）
                  • n省略表示取整。
              • 优点：可以规定保留的位数。
          • "请输入姓名：{}".format(变量, )
            • 函数
            • 优点：数据的使用更加灵活
            • 数据有自己的位置编号 默认：0, 1, 2, ...
              • print('我叫{0}，今年{0}岁。'.format(name, age)) # 存在位置编号
            • 关键字
              • print('我叫{name}，今年{age}岁'.format(name=name, age=age)) # 使用关键字
            • 其他用法
              • print('数字：{:.2f}'.format(35.111119)) # 保留位数n
              • print('数字：{:.2%}'.format(35.111119)) # 转换为带有两位小数的百分比
              • print('数字：{:>10}m'.format(35.1)) # 总长度为n，数据右对齐，反之，左对齐。
              • print('数字：{:^10}nnn'.format(35.1)) # 总长度为n，数据居中。
              • 空格填充
          • f"请输入姓名：{变量名}"
            • f-string
            • 优点：最简洁方便，使用做多
            • 注意：直接填写字符串识别不来。
              • 单双引号可以岔开写。
                • print(f'我叫{name}，{name}今年{name}岁，{"1"}。')
            • 保留位数
              • print(f'数字：{3.1415926:.2f}')
            • 填充（默认空格）
              • print(f'数字：{3.1:>10}')
              • print(f'数字：{3.1:^10}')
              • 用法类似于format
              • print(f'数字：{3.1:*^10}') # 默认空格填充，可指定填充的字符（unicode）。
    • 不可变数据类型
      • 字符串的系统功能
    • '????'
• 数据集类型
  • 元组：tuple
    • 元组——不可变列表
      • 只有一个元素， 需要在末尾添加个逗号
        • t1 = (10,) print(t1, type(t1)) t1 = (10) print(t1, type(t1))
      • 不支持修改（增、删、改）： 元素对象地址锁定， 可变元素对象（如list）依然可以改变
        • t1 = (1, 2, [1, 2, 3]) t1[-1].append(4) print(t1) # (1, 2, [1, 2, 3, 4])
    • 基本使用
      • 定义
        • (1,2.3)
      • 同列表
    • 元组的系统功能（查）————见Python标准库，同列表
    • 没有拷贝的必要
      • 支持切片
    • 可以与列表相互转换
  • 列表：list
    • 概念和特性
      • 特征
        • 作用：列表相当于是一个容器，可以同时存储多种类型的数据
        • 列表是一个有序的，可以存储重复元素的集合
          • 说明：有序指的就是有顺序 【数据的存放的顺序和底层存储的顺序是相同的】
        • 列表是可变的。
      • 说明： ​ a.列表名其实就是一个变量名【标识符】，注意：尽量不要直接使用list【系统有一个功能list(x)】，使用listxxx或xxxlist ​ b.[]是列表特有的表示方式 ​ c.数据1,数据2,数据3被称为元素【element：元素】 ​ d.列表中的元素会被自动编号，从0开始，该编号被称为索引，下标或者角标 ​ e.索引的取值范围：0 ~ (元素个数 - 1) ​ -1 ~ -元素个数
    • 基本使用
      • 定义
        • list1 = [1,2,3]
      • 容器
        • 序列
          • 索引和切片
            • 索引： 列表元素的访问
              • list1[0]
              • 修改元素
                • list1[0] = '1'
              • 索引越界会报错
            • 切片
              • 切片：根据指定的区间，指定的步长，在列表，元组或字符串等有序集合中进行截取，形成一个新的列表，元组或字符串
              • 语法： xx[start:end:step]，注意：xx表示列表，元组或字符串 start:开始索引，可以省略，默认为0或-1，不省略的情况下包含在内 end:结束索引，可以省略，默认为索引的结束【len - 1 或 -len】,不省略的情况下不包含在内 step：表示步长，可以省略，默认为1
              • 注意：切片之后会得到一个新的列表，对原列表没有任何影响,相当于是列表的拷贝
              • .在切片操作中，只要符合切片的语法，哪怕索引越界都不会报错，区别无非是列表是否为空
                • print(nums[:100]) # [10, 20, 30, 40, 50, 60, 70, 80, 90] print(nums[100:]) # []
              • 规律
                • 步长，正右负左
                • 闭区间元素切片，开区间为空
          • +
            • 列表组合
            • 本质：生成一个新的列表
            • 添加元素
              • list3 += [22222222222222] print(list3)
          • *
            • 复制并组合
            • list3 *= 3 print(list3)
          • 成员运算
            • print(10 in list3)
        • 可以用for循环遍历
          • # 方式一: 元素遍历
            • for i in list5: print(i)
          • # 方式二：索引遍历
            • for i in range(len(list5)): print(i, list5[i])
          • # 方式三：同时获取索引和元素——遍历枚举 （enumerate：枚举，容器中同时存储了索引和元素【元组】）
            • en = enumerate(list5) for i, data in en: print(i, data)
    • 列表的系统功能（增删改查）————见Python标准库
    • 列表推导式 生成列表
      • 列表推导式，就是指的轻量级循环创建列表的方式
        • 适用于简单逻辑需求
      • 列表推导式/列表生成式:是Python特有的语法，通过循环和if语句专门用来创建列表
      • 特点：根据一个已知的Iterable,使用一行代码实现简单的逻辑，生成一个新的列表
        • 本质：添加元素
      • 语法： [新列表中元素的规律 for循环 if判断]
        • list1 = [i * 2 for i in range(99)] print(list1) list2 = [i for i in range(1, 101) if i % 3 == 0] print(list2) list3 = [m + n for m in 'abc' for n in '123'] # 从左到右是依次嵌套的关系。 print(list3)
      • 工作原理：执行for循环，获取已知iterable中的元素，结合if进行判断，最终得到新的列表中元素的规律
    • 二维列表（列表套列表）
      • 二维列表的访问
        • lst[1][0][2]
      • 遍历
        • 遍历元素
        • 遍历索引
      • list1 = [[1, 2], 2, [1, 3, 4]] sub_list = list1[0] print(sub_list) # [1, 2] print(list1[2][1]) # 3 for sub in list1对选项· if type(sub) == list: for num in sub: print(num) else: print(sub) for i in range(len(list1)): for j in range(i): print(list1[i][j])
    • 列表拷贝
      • 应用场景： 删除列表元素
        • 列表的循环删除
          • 直接删除操作会出现删不干净的情况
            • 删除会导致列表变短，索引指向的元素会混乱
          • 安全稳妥的循环删除方式： 将要删除的内容保存在新列表中，循环新列表删除老列表
      • 列表对象的地址问题
        • 不能使用引用赋值
      • 拷贝： 一个列表发生改变 另一个列表不变化
        • 浅拷贝： 切片、list1.copy()、copy.copy(list1)
          • 只拷贝第一层
          • 二维列表中的内层列表仍然是同一个对象
        • 深拷贝： copy.deepcopy(list1)
          • 完全拷贝
            • 可变数据类型的对象发生了变化
          • 建议二维以上的列表使用。
  • 集合：set
    • 概念和特性
      • 集合，无序不可重复，数据要求可以进行哈希计算 （不可变的数据类型可哈希，int、float、bool、str、tuple ）
        • 无索引，无切片
        • 可用来去重
          • list1 = [12, 12, 12, 1, 1, 1] list0 = list(set(list1)) # 转换去重，顺序会被打乱 print(list0)
    • 基本使用
      • 定义
        • set()
          • 空集合，直接{}属于字典这一数据类型
        • {1,2,3}
      • 容器
        • 元素遍历
      • 集合运算
        • 交集 intersection
          • &
        • 并集 union
          • |
        • 位运算符
        • 差集 difference
          • -
            • 减号
    • 可变数据类型
      • 集合的系统功能
        • 见系统类库
      • 拷贝
  • 字典：dict
    • 概念和特性
      • 以键值对的方式存储数据 key必须是可哈希的数据类型
        • 字典中找某个元素时，是根据键查找的（就是冒号:前面的那个值，例如上面代码中的'name'、'id'、'sex'）
        • key只能使用不可变的数据类型
        • 每个字典里的key都是唯一的，如果出现了多个相同的key, 后面的value会覆盖之前的value
      • 键值映射
      • 字典是无序的
        • python 3.7之后输出的结果显示的是有序的，本质上无序
      • 作用：定位或匹配数据
    • 基本使用
      • 定义
        • dic = {key1: value1, key2: value2}
          • cheng_jie = { "name": "程杰", "age": 25, "助理": [{ "name": "承接", "age": 20 }, { "name": "艾琳", "age": 18 }, { "name": "艾利息", "age": 19 }] }
          • dic = {}
            • 空字典
        • dic = dic()
          • 三种方式
          • dict1 = dict(x=1, v=2, b=3) # 关键字参数创建字典，key需要遵守变量的规则命名，关键字转化为字符串。 print(dict1)
          • dict1 = dict([('name', '程杰'), (1, '1'), ('1', '')]) # 二维列表（内层为元组）创建字典 print(dict1)
          • dict1 = dict(zip([1, 2, 'name'], ['cv', 1, 3, 4])) # 将两个列表配对成功的两个元素映射成字典。 print(dict1)
      • 容器
        • 访问
          • 方式一：dict1[key]
            • 通过key访问value
            • key不存在会报错。
          • 方式二：dict1.get(key)
            • key不存在不会报错。 返回None
        • 修改
          • dict1[key] = value
            • key存在时，修改 key不存在时，添加键值对
        • 遍历
          • 默认遍历所有的key
            • for key in dict1: print(key, dict1[key])
          • 遍历所有的value （拿不出key）
            • for value in dict1.values(): print(value)
          • 同时遍历key和value
            • for key, value in dict1.items(): print(key, value)
              • 元组形式输出
              • 拆包
    • 字典内置函数&方法
      • 子主题
    • 拷贝
      • 与列表相同
    • 字典推导式
      • 参考列表推导式
      • 注意：key相同会覆盖
    • 数据类型转换时，转换得到的是key，value被忽略。
  • 字节：bytes
    • 音视频、图片等对应的数字类型
    • b'hello'
      • 字节:b'' b"" b三引号
    • 常用编码格式：
      • utf-8
      • gbk
    • 编码和解码
      • 编码：将字符串类型转换为字节类型，实现方式：bytes()或encode()
      • 解码：将字节类型转换为字符串类型，实现方式：str()或decode()
        • 注意：字符串中的编码和解码的格式一定要保持一致，否则无法操作
• 空值： NoneType
  • None
  • 空，什么都不是 应对字典中什么都没有的情况
  • 是独立的数据类型，与''(空字符串)不等价。

Python进阶

• 高级表达式
  • 推导式
    • 推导式是一种简洁的单行表达式，可以用来创建列表、集合、字典等数据结构。
    • 推导式： 简化代码 分为列表推导式、集合推导式{数据 for循环 if判断}、字典推导式{k:v for循环 if判断} 注意不要将其妖魔化，如嵌套过多
      • [数据 for循环 if判断]
        • lst = [] for i in range(10): lst.append(i)
      • lst = [i for i in range(10) if i % 2 == 0] print(lst)
    • 列表 字典 集合
      • [表达式 for 变量 in 可迭代对象 if 条件]
      • {键表达式: 值表达式 for 变量 in 可迭代对象 if 条件}
      • {表达式 for 变量 in 可迭代对象 if 条件}
      • 嵌套推导式
        • [表达式 for 变量 in 可迭代对象 if 条件 for 变量 in 可迭代对象 if 条件]
          • 相当于嵌套两层
        • 子主题