Python语法与用法演示

此思维导图是本人学习python所做的笔记，里面包含详细的语法规则，以及用法演示的截图，希望能给你带来帮助！

Python基础语法

• （零）学前认识
  • 计算机组成
    • 学习目标：了解CPU的作用，以及重点了解内存的作用。有助于对后面知识点的消化吸收。
    • 组成结构图
    • CPU（中央处理器）
      • 作用
        • 处理指令或运算数据
    • 内存（临时存储数据）
      • 作用
        • 内存存储的是CPU要处理的数据。因为内存的读写速度远远高于硬盘的读写速度，CPU会把硬盘的数据调取到内存中再处理，数据处理好后，再把数据存储到硬盘里，以便提高处理效率。
  • Python简介
    • Python是当下最流行、最火爆的编程语言之一。
      • 原因
        • 简单、易学、适应人群广。
        • 免费、开源
        • 应用领域广泛（web开发、自动化运维、自动化测试、网络爬虫、数据分析、人工智能、机器学习等）
    • 课程基于Python3.7来讲解 （企业一般要求不低于3.5）
    • Python是一门动态解释型语言。
      • 编译型：先解释后执行；解释型：边解释边执行（运行速度慢）。
      • 动态类型语言：代码运行期间才检查数据类型；静态类型语言：变量的类型需要在编译之前就确定。
  • 课程介绍
    • • 重点部分：数据序列、函数、面向对象
• （一）开发环境介绍及安装
  • Python解释器
    • 解释器的作用
      • 将代码翻译成0和1，让电脑运行。
    • Python解释器的种类
      • CPython
        • 官方基于C语言开发的解释器，工作中、本课程中用的都是这个。
          • 备注
            • C语言是公认效率最高的语言。
      • IPython
        • 基于CPython的一种交互式解释器。
      • 其他解释器
    • Python解释器的下载安装
      • 下载
        • 官方下载地址：https://www.python.org/downloads/release/python-372/
        • 打开网址后下拉，单击红框部分即可下载。
      • 安装
        • 下载完后，双击刚下载好的文件。
        • 点击截图中相应的位置即可安装， 安装成功后点击【Close】。
          • • 注意：AppDate文件夹默认情况下是隐藏的，显示方法如右图
        • 右图中的大红框就是我们下载好的Python解释器。
        • 验证解释器是否安装成功（了解即可）
          • 键盘同时按下Win+R打开运行对话框，输入“cmd”点击确定。在弹出的对话框里输入“Python3”，弹出右边截图红框中内容则表示安装成功。
  • PyCharm
    • PyCharm的作用
      • PyCharm是一种Python IDE（集成开发环境），带有一整套可以帮助用户在使用Python语言开发时提高效率的工具，不必在开发时频繁切换软件。
      • 集成的功能
        • Project管理、智能提示、语法高亮、代码跳转、调试代码、解释代码(解释器）、框架和库、……
      • 版本
        • Python Charm分为专业版( professional)和社区版( community)，专业版集成了一些框架和库，在基础语法上用不到，加上专业版需收费，故本教程以社区版为基准进行操作和讲解。
    • PyCharm的下载安装
      • 下载
        • 官方下载地址：https://www.jetbrains.com/pycharm/download/#section=windows
      • 安装
        • 双击刚下载的文件，在弹出的对话框上点击【运行】，在弹出的“你要允许此应用对你的设备进行更改吗？”对话框上点击【是】。安装位置可以自己选择，接着在弹出的新页面点击【Next】，该页面跳转后继续点击【Next】，接着如右图所示操作。
          • • 接着单击【Next】，单击【Install】，等待进度条完成后点击【Finish】即可完成安装。
    • PyCharm的使用
      • 注：首次运行PyCharm时，在弹出的第一个界面上勾选选项框并点击【Continue】，弹出的第二个界面上有两个选项，任意点击一个即可。
      • 新建项目
        • 双击运行PyCharm，点击右图红框部分。
          • • 在自己电脑任意位置新建一个项目根目录（该文件夹尽量用英文命名，因为以后要上传到服务器的）
              • 项目根目录（存放代码的位置）选择到刚刚创建的英文名称文件夹里，如右图的①。
              • 解释器版本选择第二个（第一个是虚拟解释器，目前不需要），操作如右图的②。
              • • • 备注
                    • 如果不小心创建了虚拟项目，直接把项目删掉重新创建即可。
      • 新建文件
        • 操作如右图（其中黄框部分需右键点击，黄框的地址就是箭头所指部分之前新建的文件的地址）。
          • • 接着输入文件名[该文件如果将来要上传到服务器，不能用中文命名（为方便学习，Python基础语法这一章暂用中文命名）]，和选择文件类型，按回车键。
      • 书写代码
      • 运行代码
      • 操作如右图
        • • 程序运行结果展示 :
      • PyCharm基本设置
        • 界面、字体设置
          • 界面设置面板位置：
            • • 界面主题、字体设置：
                • • 代码字体、字号设置：
                    • • 设置Ctrl+滚轮调节代码字体：
        • 修改解释器
          • 操作如右图：
      • PyCharm项目管理
        • 学习目的
          • 提高同时维护多个项目的效率
        • 操作步骤
          • 新建项目
            • • • 注：一般只需新建一个文件和把项目根目录选择到该新文件，不需要再选择解释器版本。
          • 打开项目
            • 注：要有至少两个项目时，才能展示出打开项目的效果
            • 操作：【File】-【Open】-选择文件
              • • 三种打开方式
                  • This Window
                    • 在此PyCharm窗口里关闭旧项目，打开新项目。
                  • New Window
                    • 打开多个PyCharm窗口（桌面菜单栏有多个PyCharm窗口）。
                  • Attach
                    • 多个项目在同一个PyCharm窗口里。
          • 关闭项目
            • 关闭一个或多个项目
              • 操作：【File】-【Close Project】或【Close Projects in Current Window】
      • 注意
        • 不要混淆新建项目和新建文件
  • PyCharm交互式开发环境
    • 打开位置
      • 打开PyCharm，点击窗口最底端的【Python Console】。
    • 特点
      • ①快速展示结果。即使不加print，也能输出。
      • ②代码只写入内存，不写入硬盘。
      • ③按键盘方向键的“↑”可直接复制上一次代码。
    • 关闭方法
      • 最小化
        • Python Console窗口右上角的【－】
      • 清空内存
        • 方法一：Python Console窗口左上角的【×】
        • 方法二：PyCharm窗口左上角【File】-【Close Project】
    • 备注：建议只用来测试极简单的程序，因为写入的代码只保留到内存中，不保留在硬盘里。
  • teamviewer远程控制
    • 作用
      • 让老师帮忙解决遇到的很难的问题。
• （二）基础知识
  • 注释
    • 注释的作用
      • 对程序中的某些代码进行注释说明，增加程序的可读性。（注释内容不会被解释器执行）
    • 分类
      • 单行注释
        • # 单行注释
          • 注： ①为美观好看，“#”后面空一格再写文字； ②一般只在某行代码非常简单的情况下才在其后面进行注释。
            • 快捷键：Ctrl+/
        • 或
          • 代码 # 单行注释
      • 多行注释
        • ''' 多行注释1 多行注释2 '''
          • 注：多行注释通常是用在对多行代码、代码块、代码段的解释说明。
        • 或
          • """ 多行注释3 多行注释4 """
  • 变量、标识符、关键字
    • 变量的作用
      • 给数据所在的内存地址起名字，以便对数据进行操作。 (Python 没有常量，习惯用全字母大写的变量代替常量)
    • 变量的定义
      • 单变量定义
        • 变量 = 值
          • 例
            • myName = 'Tom'
      • 多变量定义
        • 值相同
          • 变量1， 变量2 = 值1， 值2
            • num1, str1, list1 = 1, 'abc', [1,2,3] print(num1, str1, list1)
              • 输出： 1 abc [1, 2, 3]
                • 备注：各变量的类型可以不同。
          • 变量1 = 值1; 变量2 = 值2
        • 值不同
          • 变量1 = 变量2 = 值
    • 变量的命名
      • 变量的命名规则
        • 变量的命名要满足标识符命名规则。
        • 标识符命名规则
          • 需同时满足以下条件： ①由数字、字母、下划线（或汉字）组成； ②不能以数字开头； ③严格区分大小写； ④不能使用内置关键字。
            • 内置关键字
              • • 输出关键字：
      • 变量的命名习惯
        • ①见名知义：变量的名字要有意义； ②大驼峰：每个单词首字母都大写，如MyName； ③小驼峰：第一个单词以外的单词首字母大写，如myName； ④下划线：单词之间使用下划线，如my_name。
    • 变量的使用
      • 例
        • myName = 'Tom' print(myName)
          • 注：第二行就是对变量的使用。
  • bug和Debug
    • 认识bug
      • 释义
        • 程序中的错误、漏洞。
      • 错误信息反馈
        • 通过面板下方的红色字体可以知道错误代码错在哪里。
    • Debug工具
      • 释义
        • Debug工具是PyCharm IDE中集成的用来调试程序的工具，可以用来查看程序执行的细节和流程，或用来调解bug。
      • 使用步骤
        • 打断点
          • 在要调试的代码块的第一行打断点即可（只需打一个断点）。
        • Debug调试
        • 函数的Debug调试按钮
  • 认识数据类型
    • 常用数据类型分类
      • number（数值型）【不可变】
        • int（整型）
        • float（浮点型）
        • 高精度浮点数
          • Decimal(数值)
            • from decimal import Decimal
              • 说明
                • 建议把整型或者字符串传给Decimal，不要用浮点数据，因为浮点数据本身就不准确。
        • complex（复数）
      • bool（布尔型）
        • True（真）
        • False（假）
      • str（字符串）【不可变】
        • 注：用单引号 / 双引号。
      • list（列表） 【可变】
        • 变量 = [数值1， 数值2， 数值3]
      • tuple（元组）【不可变】
        • 变量 = (数值1， 数值2， 数值3)
      • set（集合） 【可变】
        • 变量 = {数值1， 数值2， 数值3}
      • dict（字典） 【可变】
        • 变量 = {'name': 'Tom'，'age': 18 }
          • 称为键值对
    • 数据类型检测
      • type(要检测的变量)
        • 例
          • num1 = 1 num2 = 1.0 print(type(num1)) print(type(num2)) greeting = 'hello world!' print(type(greeting))
            • 输出： <class 'int'> <class 'float'> <class 'str'>
    • 数据类型判断
      • type(数据) == 类型
        • 例
      • isinstance(数据, 类型)
        • 例
  • 输出
    • 格式化输出
      • % 输出
        • 格式化符号
          • • 备注
              • 无符号整数只能是正整数。
        • 单个变量
          • print('... 格式化符号 ...' % 变量)
            • 例
              • weight = 57.2 print('我的体重是%f公斤' % weight) print('我的体重是%.1f公斤' % weight) stu_id=5 print('我的学号是%03d' % stu_id)
                • 输出： 我的体重是57.200000公斤 我的体重是57.2公斤 我的学号是005
        • 多个变量
          • print('... 格式化符号1 ... 格式化符号2 ...' % (变量1, 变量2))
            • 例
              • name = 'Jared' age = 21 print('我是%s，我马上%d岁了' %(name, age + 1))
                • 输出： 我是Jared，我马上22岁了
        • %s 表示所有类型
          • print('... %s ... %s ...' % (变量1, 变量2))
            • 例
              • name = 'Jared' score = 92.5 age = 21 print('我是%s，我马上%d岁了' %(name, age + 1)) print('我是%s，我马上%s岁了, 我的成绩是%s分' %(name, age + 1, score))
                • 输出： 我是Jared，我马上22岁了 我是Jared，我马上22岁了, 我的成绩是92.5分
      • f'' 输出
        • print(f'... {变量} ...')
          • 例
            • name = 'Jared' age = 21 print('我是%s，我马上%d岁了' %(name, age + 1)) print(f'我是{name}，我马上{age + 1}岁了')
              • 输出： 我是Jared，我马上22岁了 我是Jared，我马上22岁了
          • 注意
            • python3.6以后的版本才支持 f-string 去格式化字符串
      • {}.format() 输出
        • print('...{}...{}...'.format(变量1, 变量2))
      • 总结
        • ① %03d 表示输出的整数显示三位数，不足以0补全，超出则原样输出； ② %f 默认输出小数点后六位，%.1f 则表示只输出后一位； ③ 想在print(' ')里输出“%”则需要写入“%%”（使用“\%”则得不到百分号）； ④ %s 可以表示所有的输出类型。 ⑤ f-格式化中的“{}”表示占位符，如想输出“{”则需写'{{'来取消占位符。如图：
      • 拓展
        • 字符串对齐
          • 详见【容器】章节的【字符串】
    • 转义字符
      • \n：换行 \t：水平制表符，一个tab的距离，对齐 \' ：单引号 \"：双引号 \b：退格 \\：取消转义功能 r'字符串'：取消字符串里的“\”的转义功能
        • 例
          • print('hello\nworld')
            • 输出： hello world
              • 备注：“\”叫反斜杠，“/”叫斜杠
    • print结束符
      • print('A、print会默认换行') print('B、效果同上', end='\n') print('C、加上tab，不换行', end='\t') print('D、end后面可加其他内容', end='...') print('E、end后面加内容且换行', end='...\n') print('F、end后面也可用双引号', end="...内容...")
        • 输出： A、print会默认换行 B、效果同上 C、加上tab，不换行 D、end后面可加其他内容...E、end后面加内容且换行... F、end后面也可用双引号...内容...
  • 输入
    • 语法
      • 变量 = input('提示信息')
        • password = input('请输入密码：') print(f'您输入的密码是{password}')
          • 输出： 请输入密码：123456 您输入的密码是123456
    • 特点
      • ①程序执行到input时，用户输入后，程序才会继续执行； ②input接收输入数据后，一般存储到变量中，以方便使用； ③input会默认把接收的任意数据都当做字符串处理。
  • 数据类型转换
    • • 举例
        • 转换为整型
          • num = input('请输入：') print(type(num)) print(type(int(num)))
            • 输入1，输出： 请输入：1 <class 'str'> <class 'int'>
        • 列表、元组转换
          • list1 = [1, 2, 3] print(tuple(list1)) tuple1 = (4, 5, 6) print(list(tuple1))
            • 输出： (4, 5, 6) [1, 2, 3]
        • 将字符串转换回原本类型
          • str1 = '1' print(type(str1)) print(type(eval(str1)))
            • 输出： <class 'str'> <class 'int'>
  • 运算符
    • 算术运算符
      • • 备注
          • 参与运算的有小数结果一定是浮点型；除法得到的结果都是浮点型。
          • 取余也叫取模。
          • 优先级顺序 (从上 到下)
            • ( ) ** * 、/ 、// 、% + 、-
          • 四舍五入
            • 计算机是转换成二进制进行计算的，只有0和1，所以计算的时候偶尔会出错。
              • 例
    • 赋值运算符
      • 单变量赋值
      • 多变量赋值
        • 值相同
          • 变量1 = 变量2 = 值
        • 值不同
          • 变量1， 变量2， 变量3 = 值1， 值2， 值3
            • num1, str1, list1 = 1, 'abc', [1,2,3] print(num1, str1, list1)
              • 输出： 1 abc [1, 2, 3]
                • 备注：各变量的类型可以不同。
    • 复合赋值运算符
      • • 优先级
          • 如果复合运算符右侧还有算术表达式，会先运算右边的表达式。
            • 例
              • a = 10 a *= 2 + 3 print(a)
                • 输出： 50
    • 比较运算符
    • 逻辑运算符
      • bool 表达式间的逻辑运算
        • • print(1 < 2 and 3 > 2) print(not 1 < 2) print(not True)
            • 输出： True False False
      • bool、数字、字符串间的逻辑运算
        • and：第一个为False则返回第一个bool/数字/字符串，第一个为True则返回最后一个bool/数字/字符串。 （系统必须判断到最后一个表达式才知道真假） or：第一个为True则返回第一个bool/数字/字符串，第一个为False则返回最后一个bool/数字/字符串。 （系统可能只需判断第一个表达式就知道真假）
          • 例
            • print(True and 5) # 5 print('abc' or False) # abc print(0 or 1) # 1
      • 备注
        • 建议使用括号，方便阅读，避免歧义。
          • 例
            • print(（1 < 2） and （3 > 2）)
  • 常用快捷键
    • Ctrl+Z : 撤销√ Ctrl+shift+Z : 反撤销√ Shift 两次 : 万能搜索框 Ctrl + / : 单行注释√ Ctrl + D : 复制粘贴一行√ Ctrl + Y : 删除一行√ Ctrl + Alt + L : 标准格式化代码√ Ctrl + Alt + T : 添加try/catch代码 Ctrl + Shift + 上下键 : 选中代码移动 Ctrl + Shift + U : 切换代码大小写 Ctrl + F 查找√ Ctrl + R 替换 Ctrl + Shift + F : 全局查找 Ctrl + Shift + i : 快捷查看方法实现的内容 Ctrl + Q : 查看文档描述 Ctrl + H : 查看类的继承关系 Ctrl + U : 查看父类 Shift + F10 : 跑代码√ Shift + Tab : 多行退格 Alt + Enter : 导入模块√
  • 其他
    • 交换变量的值
      • 方法一
        • 借助第三个变量来存储数据
          • 例
      • 方法二
        • a, b = b, a
          • 例
    • 随机数
      • 使用步骤
        • ①导入random模块。
          • import random
        • ②使用random模块中的随机整数功能。
          • random.randint(最小整数,最大整数)
          • random.random()
            • 返回 [0,1) 之间的一个小数。
            • 拓展
              • 返回[0,100)之间的一个小数。
              • random.random() + random.randint(0, 99)
          • random.choice(列表)
            • 随机返回列表中的一个元素。
              • 例
                • print(random.choice(['石头', '剪刀', '布'])) # 剪刀 print(random.choice('ABCD')) # C
          • random.shuffle(列表)
            • 打乱这个列表中元素的顺序（不会返回新列表，因为列表是可变型数据）。
    • 程序运行时间
      • import time start = time.time() 代码块 end = time.time() print("final is in ",end-start)
        • 备注
          • 会使程序变慢。
          • time.clock()（cpu时间，程序在cpu上断断续续执行的各个时间片段的总和。python3已经停用time.clock()） time.time()（上墙时间）
    • 程序暂停执行
      • time.sleep(秒数)
        • 例
    • 获取当前时间
      • t = time.localtime() date = f'{t.tm_year}-{t.tm_mon}-{t.tm_mday}'
      • from datetime import date now_date = date.today()
        • 或
          • from datetime import datetime now_date = datetime.now()
      • import time # 24小时制（年-月-日 时:分:秒） print (time.strftime('%Y-%m-%d %H:%M:%S')) # 12小时制 print (time.strftime('%I:%M:%S'))
        • %D：带年月的日期
      • datetime.strftime(时间对象)
        • 时间对象转字符串
      • datetime.strptime(时间字符串)
        • 时间字符串转对象
    • 获取n天后(前)的日期
      • from datetime import date import datetime that_day = date.today() + datetime.timedelta(n)
        • n也可以小于0。
    • Python行业书写规范：PEP8
      • 快捷键
        • ctrl + alt + L
    • 文件另存为
      • 【File】-【Save As...】
• （三）程序逻辑结构
  • 选择语句
    • if 语句
      • 1、单分支选择结构
        • if 条件表达式: 条件成立时执行的代码（块）
          • a = 2 if a > 1: print('条件成立则执行代码1') print('条件成立与否，该代码都执行')
            • 输出： 条件成立则执行代码1 条件成立与否，该代码都执行
      • 2、双分支选择结构
        • if 条件表达式: 条件成立时执行的代码（块） else: 条件不成立时执行的代码（块）
      • 3、多分支选择结构
        • if 条件表达式1: 条件1成立时执行的代码（块） elif 条件表达式2: 条件2成立时执行的代码（块） ...... else: 以上条件都不成立时执行的代码（块）
      • 4、嵌套分支选择结构
        • if 条件表达式1: 条件1成立时执行的代码（块） if 条件表达式2: 条件2成立时执行的代码（块）
      • 说明
        • ①条件成立则执行 if 下方缩进的代码，不成立则不执行缩进的代码。 ②if 下面需要缩进四个空格（或一个tab键），PyCharm会自动缩进。
      • 案例：石头剪刀布
    • 三目运算符
      • 条件成立执行的表达式 if 条件表达式 else 条件不成立执行的表达式
        • # 计算输入的两数值的差 a = float(input('请输入数值a：')) b = float(input('请输入数值b：')) c = (a - b) if (a > b) else (b - a) print(f'你输入两值的差是：{c}')
          • 输出： 请输入数值a：0.3 请输入数值b：1 你输入两值的差是：0.7
  • 循环语句
    • 计数器的书写习惯
      • 下面例子中的变量 i 就是计数器，一般习惯从0开始。
    • while 循环
      • while 条件表达式: 条件成立重复执行的代码块
        • i = 0 while i < 3: print('狼来了！') i += 1
          • 输出： 狼来了！ 狼来了！ 狼来了！
            • i = 1 s = 0 while i <= 100: s += i i += 1 print(f'从1累加到100的结果是：{s}')
              • 输出： 从1累加到100的结果是：5050
              • 备注：这里的 i 不只是作为计数器，所以不从0开始。
      • while循环嵌套
        • while 条件表达式: 条件成立重复执行的代码块 while 条件表达式: 条件成立重复执行的代码块
          • 打印正方形
            • • 打印三角形
                • • 打印九九乘法表
      • while...else
        • while 条件表达式: 条件成立重复执行的代码块 else: 循环正常结束后执行的代码块
          • break 和 continue对此语句的作用
            • break 对 while...else 的作用
              • 如果 break 终止了循环，else 下方缩进的代码块将不会执行。
            • continue 对 while...else 的作用
              • 如果 continue 跳过了一次/多次循环，循环也算是正常结束的，else 下方缩进的代码块还会执行。
    • for 循环
      • for 临时变量 in 序列名: 条件成立重复执行的代码块
        • str1 = 'Hi你好' for i in str1: print(i)
          • 输出： H i 你 好
        • for循环的临时变量可以有多个
          • 例
            • • 备注
                • 截图中的 key 和 value 即临时变量。
      • for...else
        • for 临时变量 in 序列名: 条件成立重复执行的代码块 else: 循环正常结束后执行的代码块
          • break 和 continue对此语句的作用
            • break 对 for...else 的作用
              • 如果 break 终止了循环，else 下方缩进的代码块将不会执行。
            • continue 对 for...else 的作用
              • 如果 continue 跳过了一次/多次循环，循环也算是正常结束的，else 下方缩进的代码块还会执行。
            • 例
  • 跳转语句
    • break
      • 作用
        • ①终止当前循环的执行。
        • ②只会出现在循环语句当中。
        • ③终止switch语句的执行。
        • 例
      • 注意
        • 若出现在嵌套循环里，则只会退出所在的那一层循环。
    • continue
      • 作用
        • ①提前终止本轮循环，不执行本轮循环剩下的代码，进行下一轮循环。
        • ②只会出现在循环语句当中。
      • 注意
        • 在continue之前一定要修改计数器，否则会进入死循环。
        • 在嵌套循环里，continue只会提前终止所在的那一层循环。
      • 例
• （四）容器
  • 1、字符串 (不可变数据)
    • 认识字符串
      • 字符串的重要性
        • 字符串是Python中最常用的数据类型。（后面要学的文件读写操作中，读取、写入的都是字符串类型；将来学爬虫时，从网页爬取的数据都是字符串类型的。）
      • 代码
        • str1 = 'I\'m Jared' str2 = "I'm Linda" str3 = ' ' ' I'm Jared Rose ' ' ' str4 = " " " I'm Jared. Nice to meet you! " " "
          • 备注
            • ①要书写英文缩写I'm，可以用\'，或者用双引号和三引号（如str2）。
            • ②三引号在敲代码时如果换行，则输出时也换行。
    • 字符串输入 / 输出 （知识点回顾）
      • 字符串输出
        • print('......')
        • 变量 = 值 print('... %s等格式化符号 ...' % 变量)
        • 变量 = 值 print(f'... {变量} ...')
      • 字符串输入
        • 变量 = input('提示信息')
    • 下标
      • 介绍
        • 字符串的内容会被分配到编号从0开始的内存中，可以使用这些编号来精准地找到这些字符。这些编号叫做“下标”或“索引”或“索引值”。
      • 语法
        • 字符串名[下标]
          • 例
            • str1 = '你好aa' i = 0 while i < 6: print(str1[i]) i += 1
              • 输出： 你 好 a a
          • 注意
            • 下标从0开始。
            • 下标 [-1] 表示最后一个。
    • 切片
      • 介绍
        • 指对操作对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
      • 语法
        • 序列[开始位置下标:结束位置下标:步长]
          • 说明
            • ①不包括下标结束位置的数据，即 [ a , b ） ②三个位置都空着，则表示原本的字符串。 ③如果不写开始下标，则默认为0。 ④如果不写结束下标，则默认全选。 ⑤步长是选取间隔，如果只有一个冒号（两个位置）或不写步长，则默认步长为1。 ⑥下标的负数表示倒着数，-1表示最后一个字符，-2表示倒数第二个数据，以此类推。 ⑦如果步长为负数（表示倒叙选取），则必须开始下标>结束下标（或不写下标）。（下标方向和步长方向必须一致，否则输出内容为空，不报错）
              • 例
    • 长度
      • 字符串序列.len()
        • 作用
          • 返回字符串的长度。
    • 查找
      • 字符串序列.find(子串, 开始位置下标, 结束位置下标)
        • 作用
          • 返回某个子串在字符串中出现的位置。字符串中无此子串则返回 -1。
        • 备注
          • 省略开始和结束下标则表示在整个字符串序列中查找。
        • 例
        • .rfind()
          • 用法、功能、返回结果相同，但查找方向为从右开始。（下标仍是从左开始计算）
      • 字符串序列.index(子串, 开始位置下标, 结束位置下标)
        • 作用
          • 返回某个子串在字符串中出现的位置。
        • 备注
          • 用法和 find 一样，区别是查找不到子串则程序报错。
        • .rindex()
          • 用法、功能、返回结果相同，但查找方向为从右开始。（下标仍是从左开始计算）
      • 字符串序列.count(子串, 开始位置下标, 结束位置下标)
        • 作用
          • 返回某个子串在字符串中出现的次数。
        • 备注
          • 用法和 find 一样，区别是找不到则返回0。
    • 替换
      • 字符串序列.replace(旧子串, 新子串, 替换次数)
        • 作用
          • 返回子串替换后的新的字符串，但原本的字符串不会改变。
        • 备注
          • 不写替换次数则代表全部替换。
        • 例
    • 分割
      • 字符串序列.split(分割字符, 分割次数)
        • 作用
          • 使用分割符号来分割字符串，并返回一个列表，分割后的字符串放在列表里。
        • 备注
          • 返回的是一个列表，且会丢失分割符号。
        • 例
    • 合并
      • 连接符.join(多个字符串组成的序列)
        • 作用
          • 将列表里的字符串合并成一个字符串。
        • 例
      • 字符串1 + 字符串2
    • 大小写转换
      • 字符串序列.capitalize()
        • 作用
          • 将字符串第一个字符转大写。（其他部分都转为小写）
      • 字符串序列.title()
        • 作用
          • 将字符串每个单词首字母转大写。
      • 字符串序列.upper()
        • 作用
          • 将字符串所有字母小写转大写。
      • 字符串序列.lower()
        • 作用
          • 将字符串所有字母大写转小写。
      • 例
        • my_str = 'hello world and itcast and itcastcpp and Python' print(my_str.capitalize()) print(my_str.title()) print(my_str.upper()) print(my_str.lower())
          • 输出： Hello world and itcast and itcastcpp and python Hello World And Itcast And Itcastcpp And Python HELLO WORLD AND ITCAST AND ITCASTCPP AND PYTHON hello world and itcast and itcastcpp and python
    • 删除空白字符
      • 字符串序列.strip()
        • 作用
          • 删除字符串两侧空白字符。
      • 字符串序列.lstrip()
        • 作用
          • 删除字符串左侧空白字符。
      • 字符串序列.rstrip()
        • 作用
          • 删除字符串右侧空白字符。
    • 字符串对齐
      • 字符串序列.center(指定长度, 填充字符)
        • 作用
          • 居中对齐，并以 填充。
      • 字符串序列.ljust(指定长度, 填充字符)
        • 作用
          • 左对齐，并以 填充。
      • 字符串序列.rjust(指定长度, 填充字符)
        • 作用
          • 右对齐，并以 填充。
      • 例
      • 备注
        • 不写填充字符则默认以空格填充。
    • 判断开头 / 结尾
      • 字符串序列.startswith(子串, 开始位置下标, 结束位置下标)
        • 作用
          • 判断字符串是否是以某子串开头, 是则返回 True，否则返回 False。
      • 字符串序列.endswith(子串, 开始位置下标, 结束位置下标)
        • 作用
          • 判断字符串是否是以某子串结尾, 是则返回 True，否则返回 False。
      • 例
    • 判断内容的类型
      • 字符串序列.isalpha()
        • 判断字符串是否至少有一个字符且所有字符都是字母。
      • 字符串序列.isdigit()
        • 判断字符串是否至少有一个字符且所有字符都是正整数。
      • 字符串序列.isalnum()
        • 判断字符串是否至少有一个字符且所有字符都是正整数/字母。
      • 字符串序列.isspace()
        • 判断字符串是否至少有一个字符且所有字符都是空格（不是空白）。
      • 返回值
        • 返回 bool 值。
      • 备注
        • 判断是否为小数/负数，要用分割字符串等方法来判断。
      • 英语单词
        • alphabet：字母；digit：数字。
  • 2、列表 (可变型数据)
    • 介绍
      • 作用
        • 可以一次性存储多个数据，且每个数据的类型可以不同。 (工作时尽量使列表中的数据类型相同，以便后期控制数据。)
    • 定义
      • 列表名 = [数据1, 数据2, 数据3, ……]
    • 查找
      • 通过下标查找
        • 列表名[下标]
          • 例
      • 通过函数查找
        • 列表名.index(数据, 开始位置下标, 结束位置下标)
          • 作用
            • 数据存在于该列表则返回该数据的下标，不存在则报错。
      • 统计次数
        • 列表名.count(数据)
          • 作用
            • 统计该数据在该列表中出现的次数。
      • 判断是否存在
        • 数据 in 列表名
          • 作用
            • 判断指定的数据是否在某个列表中。返回 bool 值。
        • 数据 not in 列表名
          • 作用
            • 判断指定的数据是否在某个列表中。返回 bool 值。
        • 例
        • 备注
          • in / not in 函数属于公共操作。
    • 切片
      • 列表名[开始位置下标:结束位置下标:步长]
        • 备注
          • 用法及作用与字符串类似。
            • 例
    • 长度
      • len(列表名)
        • 作用
          • 返回列表的长度。
        • 备注
          • len()函数属于公共操作。
    • 增加
      • 列表名.append(数据)
        • 作用
          • 列表结尾追加整个序列。 (如果追加的是一个序列，则会追加整个序列到列表。)
            • 例
      • 列表名.extend(元素列表)
        • 作用
          • 在列表尾部追加拆开的序列。(只能添加序列)
            • 例
              • • 备注
                  • Bob 是字符串，同时也是序列。
        • 元素列表
          • 可以是列表、元组、集合、字典(若是字典则只将 key 视为元素)。
        • 备注
          • 单词 ext(extension)：扩展
      • 列表名.insert(位置下标, 数据)
        • 作用
          • 在列表当中指定的位置添加数据。
            • 例
      • 列表名 += [数据]
    • 删除
      • del 列表 / 指定下标的数据
        • 或
          • del(列表 / 指定下标的数据)
            • 作用
              • 删除列表 / 指定下标的数据。
                • 例
      • 提取
        • 列表名.pop(指定的下标)
          • 作用
            • .pop操作会让原列表减少指定的数据（可变型） 并会有返回值，返回被删除的数据。
              • 例
          • 备注
            • 不写下标则默认删除最后一个数据。
      • 列表名.remove(指定的数据)
        • 作用
          • 删除指定的数据。
            • 例
      • 列表名.clear()
        • 作用
          • 清空列表（只保留一个空的列表）。
    • 更改
      • 列表名[下标] = 新数据
        • 例
    • 倒序
      • 列表名.reverse()
        • 作用
          • 将列表中的数据顺序倒序。
            • 例
    • 排序
      • 列表名.sort(key=None, reverse=False)
        • 备注
          • （括号内是默认状态，也可以不写）
          • reverse 表示排序规则，reverse = True 即降序，reverse = False 即升序(默认)。
          • key=None 在之后学字典会学到，暂时忽略。
        • 例
      • sorted(容器, key=None)
        • 作用
          • 返回容器数据按顺序排序后的列表。
    • 去重
      • list(set(列表名))
        • 例
    • 复制数据
      • 复制数据的必要性
        • 数据的录入、爬取、收集来之不易，对原始数据的保留很有必要，工作中对数据修改特别是删除之前，往往会先复制保留一份。
      • 语法
        • 列表名.copy()
          • 作用
            • 返回一个一样的列表。
    • 遍历
      • 释义
        • 遍历简单来说就是按顺序依次访问数据。
      • 用 while 循环
      • 用 for 循环
      • 例
        • • 用 for 循环更简洁。
    • 列表嵌套
      • 列表名 = [[数据1, 数据2 ], [数据3, 数据 4]]
    • 拆包
      • 变量1， 变量2 = [数据1， 数据2]
        • 例
    • 案例
      • 1、开学之初，为便于校长辨认，在年级列表中，给每个同学名称的后面加上班级后缀。
      • 2、一段时间之后，校长对学生的辨认完毕，在年级列表中，去掉每个同学名称后面的班级后缀。
      • 3、考试临近，将上述9名同学打乱分配到3个考室中，每3人一个考室。
  • 3、元组 (不可变型数据) 不能修改
    • 特点
      • 元组及其内部首层的数据不能修改（常应用在身份证等地方）（元组内的多个数据的类型可以不同）
    • 定义
      • 多数据元组
        • 元组名 = (数据1 ,数据2)
      • 单数据元组
        • 元组名 = (单个数据 , )
          • 注意
            • 单数据元组里如果不加逗号，则这个变量的类型会变为该数据本身的类型。例如 tuple1 = (10) ，tuple1属于整型。
      • 空数据元组
        • 元组名 = ()
      • tuple方法
        • 变量名 = tuple([数据])
          • 例
    • 查找
      • 通过下标查找
        • 元组名[下标]
          • 例
            • print(tuple1[0])
      • 通过函数查找
        • 列表名.index(数据, 开始位置下标, 结束位置下标)
          • 作用
            • 数据存在于该元组则返回该数据的下标，不存在则报错。
    • 统计次数
      • 列表名.count(数据)
        • 作用
          • 统计该数据在该元组中出现的次数。
    • 长度
      • len(元组名)
        • 返回该元组的长度。
    • 数据修改
      • 元组里的首层数据不能修改。
        • 例
      • 可以修改元组里列表、字典的数据。
        • 例
    • 是否存在
      • 数据 in 元组
        • 作用
          • 判断数据是否存在于元组中，并返回 bool 值。
    • 切片
      • 元组名[开始位置下标:结束位置下标:步长]
        • 备注
          • 用法及作用与字符串类似。
    • 拆包
      • 变量1， 变量2 = 元组
        • 例
      • 或
        • (变量1, 变量2) = 元组
  • 4、字典 (可变型数据) 键值对
    • 特点
      • 字典里的数据以键值对的形式出现，字典不支持下标，即字典的数据和数据顺序无关，后期无论数据顺序如何变化，只需按照对应的键的名字即可查找到特定的数据。
        • 备注
          • 键名也叫key值。
          • 键可以是字符串、数字、元组类型，不能是列表、字典、集合类型。
    • 定义
      • 有数据字典
        • 字典名 = {键1: 值1, 键2: 值2}
          • 例
        • 字典名 = dict(键1=值1, 键2=值2)
          • 备注
            • 键名不用加引号。
              • 例
      • 空字典
        • 字典名 = { }
        • 字典名 = dict()
    • 长度
      • len(字典名)
        • 返回该字典的长度（每个键值对的长度是1，而不是2）。
    • 新增数据
      • 字典名[键名] = 值
    • 更改数据
      • 字典名[键名] = 值
      • 字典名.update({键: 值})
        • 有相同的键名就覆盖，没有相同的键名就新增。
    • 删除数据
      • 删除键值对
        • del 字典名[键名]
        • del(字典名[键名])
        • 字典名.pop(键名)
          • 备注
            • 键名不存在则报错。
      • 删除字典
        • del 字典名
          • 或
            • del(字典名)
      • 清空字典
        • 字典名.clear()
          • 例
    • 查找数据
      • 字典名[键名]
        • 备注
          • 如果该键名(即key)不存在则报错。
      • 字典名.get(键名, 默认值)
        • 注意
          • 如果该键名不存在则返回第二个参数(默认值)，如果省略第二个参数则返回None。
            • 例
      • 字典名.keys()
        • 作用
          • 查找该字典的所有key，返回该字典的可迭代对象（可以用for遍历的对象）。
            • 例
      • 字典名.values()
        • 作用
          • 查找该字典的所有value，返回该字典的可迭代对象。
            • 例
      • 字典名.items()
        • 作用
          • 返回该字典的所有key和value（即键值对） 组成的元组，返回该字典的可迭代对象。
            • 例
    • 遍历
      • 遍历key
        • for i in 字典名.key
        • for i in 字典名
      • 遍历value
        • for i in 字典名;print(字典名[i])
        • for i in 字典名.value
      • 遍历元素（键值对）
      • 方法
      • 遍历键值对（并拆包）
        • 方法
    • 拆包
      • 字典拆包
        • 变量1， 变量2 = 字典
        • 变量1， 变量2 = 字典名.values()
        • 例
    • 有序字典
      • from collections import OrderedDict
      • 有序字典名 = OrderedDict()
  • 5、集合 (可变类型) 去重、无序
    • 特点
      • 集合会自动去除重复的数据。且集合里的数据没有顺序，不支持下标。 (集合里不能有列表和字典，可以有元组)
        • 例
    • 语法
      • 有数据的集合
        • 集合名 = {单个/多个数据}
        • 或
          • 集合名 = set(单个数据)
      • 空集合
        • 集合名 = set()
          • 备注
            • 不能用“集合名 = {}”来创建空集合，因为“{}”是空字典的创建方法。
    • 增加单个数据
      • 集合名.add(单个数据)
        • 例
          • set.add(100)
    • 增加数据序列
      • 集合名.update([数据1, 数据2, 数据3])
        • 例
    • 删除数据
      • 集合名.remove(存在的数据)
        • 备注
          • remove用来删除集合中指定的已有的数据，如果该数据不存在则报错。
      • 集合名.discard(数据)
        • 备注
          • discard用来删除集合中指定的数据，如果该数据不存在，不报错。
      • 集合名.pop()
        • 作用
          • pop用来随机删除集合中的某个数据，并返回被删除的数据。
    • 是否存在
      • 数据 in 集合名
        • 作用
          • 判断指定的数据是否在某个集合中，在则返回 True，否则返回 False。
      • 数据 not in 集合名
        • 作用
          • 判断指定的数据是否在某个集合中，在则返回 False，否则返回 True。
      • 例
• （五）公共的方法
  • 运算
    • 容器 + 相同类型的容器
      • 作用
        • 合并容器的内容（只支持字符串、列表、元组）。
    • 容器 * 数字
      • 作用
        • 复制容器的内容（只支持字符串、列表、元组）。
    • 例
  • 是否存在
    • 数据 in 容器
      • 作用
        • 判断数据是否存在于容器中，返回 bool 值。
    • 数据 not in 容器
      • 作用
        • 判断数据是否存在于容器中，返回 bool 值。
    • • 支持字符串、列表、元组、字典、集合。
        • 例
  • 长度
    • len(目标)
      • 备注
        • 这里的目标可以是整个容器，也可以是容器中的某个数据。
  • 删除
    • del 目标
      • 或
        • del(目标)
          • 备注
            • 这里的目标可以是整个容器，也可以是容器中的某个数据。
  • 切片
    • 作用
      • 截取容器的一部分。字符串、列表、元组都支持切片操作，字典、集合不支持。
    • 语法
      • 序列[开始位置下标:结束位置下标:步长]
        • 说明
          • ①不包括下标结束位置的数据，即 [ a , b ） ②三个位置都空着，则表示原本的字符串。 ③如果不写开始下标，则默认为0。 ④如果不写结束下标，则默认全选。 ⑤步长是选取间隔，如果只有一个冒号（两个位置）或不写步长，则默认步长为1。 ⑥下标的负数表示倒着数，-1表示最后一个字符，-2表示倒数第二个数据，以此类推。 ⑦如果步长为负数（表示倒叙选取），则必须开始下标>结束下标（或下标空着）。（下标方向和步长方向必须一致，否则输出内容为空，不报错）
            • 例
  • 最值
    • 最大
      • max(目标)
        • 作用
          • 返回容器中元素最大值。
    • 最小
      • min(目标)
        • 作用
          • 返回容器中元素最小值。
    • 备注
      • 支持所有容器。 (也可用于求字符串首字母 ASCLL码 的最值)
  • 等差数组
    • range(开始数字, 结束数字, 步长)
      • 作用
        • 生成从开始到结束数字组成的可迭代对象，供 for 循环使用。 (类型是<class 'range'>)
      • 注意
        • 不包含结束位数字，即 [a, b) 。开始数字默认为0，步长默认为1，可省略。
      • 例
        • for i in range(1, 6, 2): print(i)
          • 输出： 0 2 4
  • 枚举函数
    • enumerate(可遍历对象, start=0)
      • 作用
        • 一般配合 for 循环一起使用，返回若干个由可遍历对象的数据下标及数据组成的元组。
      • 备注
        • start参数用来设置遍历数据的下标起始值，默认为0。
        • 这里的迭代器是一个可遍历对象，可以是字符串、列表、集合等。
      • 例
        • • 例
  • 类型转换
    • 转成列表
      • list(目标序列)
        • 作用
          • 将某个序列转成列表。
        • 注意
          • list()会将str序列的每个字符都分开
            • 例
    • 转成元组
      • tuple(目标序列)
        • 作用
          • 将某个序列转成元组。
    • 转成集合
      • set(目标序列)
        • 作用
          • 将某个序列转成集合（会自动去重）。
    • 例
    • 转成字典
      • 数据.dict()
        • Django中数据转为dict的方法。
  • 推导式
    • 释义
      • 推导式也叫生成式，是 Python 中一种更高效更简洁的处理序列方式，能简化代码。
    • 注意
      • 在推导式的代码中，读与写都从 for 循环开始。
    • 列表推导式
      • 作用
        • 用一个表达式创建 / 控制一个有规律的列表。
      • 语法
        • 列表名 = [xx for xx in range()]
      • 简单用法
        • 例
          • • 例
      • 带 if 的推导式
        • 例
          • • 例
      • 多 for 循环的推导式
        • 例
    • 字典推导式
      • 作用
        • 把列表快速合并为字典，或者是提取字典中的目标数据。
      • 语法
        • 字典名 = {xx1: xx2 for ... in ...}
      • 两个列表合并为一个字典
        • 例
      • 提取字典中的目标数据
        • 例
    • 集合推导式
      • 语法
        • 集合名 = {xx for xx in ...}
      • 例
• （六）函数
  • 作用
    • 将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用这个函数的名称即可完成对应的需求，更高效的实现代码重用。(工作中经常需要使用函数)
  • 使用步骤
    • ①定义函数
      • def 函数名(形参): 代码块
    • ②调用函数
      • 函数名(实参)
        • 参数可以省略。
      • 注意
        • 如果不调用函数，函数里的代码不会执行。
    • 例
  • 打断点
  • 函数的说明文档
    • 书写方法一
      • def 函数名 (参数): ' ' ' 说明文档 ' ' ' 代码块
        • 备注
          • 说明文档只能在函数缩进位置的第一行书写。
            • 例
    • 书写方法二
      • def 函数名 (参数): ' ' ' 说明信息块 ' ' ' 代码块
        • 备注
          • 只需敲完多行注释后多敲一个回车键即可弹出说明文档的其余信息。
            • 例
    • 查看方法
      • help(函数名)
        • 作用
          • 查看函数的说明文档（对某函数解释说明的信息）。
  • 参数
    • 分类一
      • 形参
        • 定义函数时定义的参数是形参。
      • 实参
        • 调用函数时传入的参数是实参。
      • 例
    • 分类二
      • 位置参数
        • 作用
          • 调用函数时根据函数定义的参数位置来传递参数。
        • 注意
          • 传递和定义参数的顺序及个数必须一致。
        • 例
      • 关键字参数
        • 作用
          • 通过“键=值”的形式加以指定，可以让函数更加清晰，容易使用，同时也清除了参数的顺序需求。
        • 注意
          • 函数调用时，如果也有位置参数，位置参数必须在关键字参数的前面，但关键字参数之间不分先后顺序。
        • 例
      • 缺省参数
        • 作用
          • 缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传递该默认参数的值。也可给缺省参数传递值，以修改默认参数。
        • 注意
          • 函数定义和调用时，所有位置参数必须出现在默认参数前。
        • 例
      • 不定长参数
        • 作用
          • 不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数(包括0个)的场景。将参数组包(收集零散数据并返回一个整体)来进行参数传递。
        • 分类
          • 包裹位置参数
            • 语法
              • def 函数名(*args)
            • 备注
              • 传进的所有参数都会被 args 变量收集，它会根据传进参数的位置合并为一个元组。
            • 例
          • 包裹关键字参数
            • 语法
              • def 函数名(**kwargs)
            • 备注
              • 接收数目不确定的“键=值”参数，并合并为一个元组。
            • 例
          • 备注
            • args 和 kwargs 是Python底层代码用的名称，也可以改成其他字符。
          • 拓展
            • “*列表”“*元组”“**字段”分别表示对列表、元组、字典进行拆包。
      • 参数混用顺序
        • 形参和实参都要遵守以下顺序： 位置参数、不定长位置参数、关键字参数（缺省参数）、不定长关键字参数
          • 例
  • 返回值 return
    • 作用
      • 调用函数后，函数返回的结果。
    • 语法
      • return 表达式
        • 备注
          • 退出当前函数。 (函数体内return下方的代码不会执行)
            • 例
    • 返回值分类
      • 无返回值
        • return
          • 备注
            • 相当于循环里的 break
      • 单返回值
        • return 数据1
      • 多返回值
        • return 数据1, 数据2, 数据3
          • 备注
            • return可以连接列表、元组、字典，以返回多个值。若多个数据不加括号，则默认返回元组。
              • 例
                • • 例
      • 将返回值作为参数传递
        • 例
    • 将函数返回值拆包
      • 元组拆包
        • 变量1, 变量2 = 多返回值的函数
          • 例
      • 字典拆包
        • 变量1, 变量2 = 多返回值的字典
          • 例
  • 变量的作用域
    • 释义
      • 变量的作用域是指变量生效的范围，主要分为全局变量和局部变量。
    • 局部变量
      • 释义
        • 局部变量是定义在函数体内部临时保留的变量，只在函数体内部生效，函数体执行完时局部变量立即销毁，故在函数体外部访问则报错。
          • 例
            • • 例
    • 全局变量
      • 释义
        • 全局变量是定义在函数体外的变量，在函数体内、外都能生效。
    • 函数体内操作全局变量
      • global 全局变量名 全局变量名 = 数据
        • 说明
          • 在函数体内部如果想对全局变量进行操作，应先声明其为全局变量。
            • 例
      • 备注
        • 如果在函数体内不加global函数而企图直接修改全局变量，实际上是临时生成一个和全局变量名称一样的局部变量，真实的全局变量并没有被改变。
          • 例
  • 嵌套调用
    • 说明
      • 函数嵌套调用是指一个函数里面又调用了另外一个函数。
      • 例
        • • 例
  • 递归函数
    • 应用
      • ①日常开发中，如果要遍历一个文件夹下面所有的文件，可以用递归的方法来快速高效地实现。
      • ②后续的有高级算法的课程中，用递归的方法能很轻松地实现某些功能。
      • 递归在Python基础课中几乎不需要用，但却是Python的基础知识点。
    • 特点
      • ①函数定义中调用自身。
      • ②必须要有出口。
        • 例
    • 例
      • • 例
          • • 例
              • • 例
    • 执行流程
    • 递归深度
      • 超过递归深度
        • 例
      • 打印递归深度
        • import sys print(sys.getrecursionlimit())
          • 输出：1000
      • 更改递归深度
        • import sys sys.setrecursionlimit(5000) print(sys.getrecursionlimit())
          • 输出:5000
  • lambda (匿名函数)
    • 作用
      • 如果一个函数有一个返回值，并且只有一句代码，则可以使用 lambda 简化代码。(def定义函数占用的内存空间大于 lambda 的)
    • 语法
      • lambda 参数列表: 要返回的表达式或值
        • 注意
          • ① lambda 表达式的参数可有可无，函数的参数在 lambda 表达式中完全适用。 lambda的参数列表和def定义函数的参数列表写法和作用完全相同。 ② lambda 表达式能接收任何数量的参数，但只能返回一个表达式的值。 ③ 若打印存储 lambda 的变量名，则返回 lambda 表达式的十六进制内存地址，若加上括号，则形成函数调用，可打印返回值。
        • 例
          • • 例
    • 参数
      • 无参数
        • fn1 = lambda: 要返回的表达式或值 print(fn1())
          • 例
            • fn1 = lambda: 10 print(fn1())
              • 输出： 10
      • 单个参数
        • fn1 = lambda 形参: 要返回的表达式或值 print(fn1(实参))
          • 例
            • fn1 = lambda a: a print(fn1('hello world'))
              • 输出： hello world
      • 默认参数 (缺省参数)
        • fn1 = lambda 形参1, 形参2=值: 要返回的表达式或值 print(fn1(实参1, 实参2))
          • 例
            • fn1 = lambda a, b, c=100: a + b + c print(fn1(10, 20))
              • 输出： 130
      • 可变参数
        • 包裹位置参数
          • fn1 = lambda *args: 要返回的表达式或值 print(fn1(实参1, 实参2))
            • 例
            • 备注
              • 返回的是一个元组。
        • 包裹关键字参数
          • fn1 = lambda **kwargs: 要返回的表达式或值 print(fn1(实参1, 实参2))
            • 例
              • fn1 = lambda **kwargs: kwargs print(fn1(name = 'Jared', age = 20))
                • 输出： {name: 'Jared', age: 20}
            • 备注
              • 接收数目不确定的“键=值”参数，并返回一个字典。
    • 应用
      • 带判断的lambda
        • 例
      • 结合sort函数进行排列
        • 例
          • • 备注
              • i 表示列表里要进行排序的数据，即列表里的字典。
        • 例
  • 高阶函数
    • 释义
      • 把一个函数(叫函数变量)当做另外一个函数的参数传入，这样的函数叫做高阶函数。
    • 先学两个简单函数
      • 绝对值
        • abs(数值)
          • 例
            • print(abs(-6.4))
              • 输出：6.4
      • 四舍五入
        • round(数值)
          • 例
            • print(round(0.9))
              • 输出：1
    • 高阶函数的思路
      • 函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。
        • 例
          • • 备注
              • 想实现俩数的绝对值相加则将函数abs传入；想实现俩数的约值相加则将函数round传入。
    • 内置高阶函数
      • map(func, lst)
        • 作用
          • 将函数 func 依次作用到 list 的每个元素中，并将结果组成新的迭代器返回，返回结果可用list()转换为列表(否则只能打印到地址)。
        • 例
          • • 例
      • reduce(func, lst)
        • 作用
          • 功能函数 func 计算的结果继续和序列的下一个元素做累计运算。
        • 注意
          • 这里的函数func必须有且只有两个参数。
        • 例
      • filter(func, lst)
        • 用于过滤序列，过滤掉不符合条件的元素，只剩下符合条件的元素，返回一个 filter 对象，返回结果可用list()转换为列表。
        • 例
      • 备注
        • 这些func指函数名，lst指列表序列。
  • 其他
    • 数据类型
      • 可变类型
        • 包括
          • 列表、字典、集合（中括号、大括号）
        • 特点
          • 数据能够直接进行修改。
      • 不可变类型
        • 包括
          • 数字型、字符串、元组
        • 特点
          • 数据不能直接进行修改。
      • 地址
        • id(变量/数据)
          • 作用
            • 返回变量在内存中的十进制地址。
        • 可变数据类型 (地址里的数据可变)
          • 可变数据类型的值发生改变时，更改的是内存里的数据。
            • 例
        • 不可变数据类型 (地址里的数据不可变)
          • 不可变数据类型的值发生改变时，不会改变内存里的数据，而是开辟新的地址来储存数据。
            • 例
        • 例
      • 引用
        • Python中，数据都是靠引用来传递的。变量名是数据所存储在的地址的引用，是某块内存的名字。（可简单理解为：引用就是变量名）引用可以当做实参传递到函数里。
    • 案例：学员管理系统
      • (略)
• （七）文件操作
  • 文件读写
    • 打开
      • 文件对象 = open('目标文件名', '访问模式', encoding='utf-8')
        • 备注
          • ① 目标文件名name 是要打开的文件名的字符串（可以包含文件所在的具体路径）。
          • ② 访问模式mode 用于设置文件的访问模式（只读、写入、追加等），不写则默认为 ' r ' 。
          • ③ 目标文件可以是多个变量拼接而成的。
            • 例
        • 编码转换
          • encoding='utf-8'
            • 作用
              • utf-8是编码通用转换格式，国际编码(万国码)，识别所有语言的文字以及标点符号。 (encoding：编码)
            • 例
    • 写入
      • 文件对象.write('要写入的内容')
    • 读取
      • 文件对象.read(读取长度)
        • 作用
          • 从文件中读取一定长度的数据(rb模式则读取一定字节个数，r模式则读取一定字符数)，不写则默认读文件的取所有数据。
        • 例
          • • 备注
              • 读取文件时，换行符也会占用一个位置。
      • 文件对象.readlines()
        • 作用
          • 按照行的方式读取整个文件的内容，并且返回一个列表，每个元素都是整一行的数据(每行结尾都有"/n")。
        • 例
      • 文件对象.readline
        • 作用
          • 逐次读取每一行的内容，下一次操作则读取下一行内容，以此类推。
        • 备注
          • 读取的最后一行肯定是空字符串。
        • 例
      • 注意
        • 从 .txt、.py 等文件中读取出来的数据都是str类型，想要其他类型则需要转换。
        • 从空白的数据文件(.date等文件)中读取内容并用eval()函数转换数据类型前，应该先在数据文件中写入“[]”，否则报错。
    • 移动指针
      • 文件对象.seek(偏移量, 起始位置)
        • 作用
          • 移动文件指针。
        • 备注
          • 起始位置：0（文件开头）、1（当前位置）、2（文件结尾）
            • 注意
              • 当起始位置是1或2时，偏移量必须是0
          • 偏移量的单位是字节，表示文件指针在起始位置向后偏移的距离。
            • 例
              • 子主题
          • 若偏移量和起始位置都是0，可以写成：文件对象.seek(0)
        • 注意
          • 若文件刚书写完，指针会在结尾，需要调用seek函数把指针往前移动才能打印输出文件内容。
          • .seek() 函数对 'a' 也有效。
        • 例
    • 关闭
      • 文件对象.close()
        • 例
        • 备注
          • 文件不关闭则会占用内存。
          • 一般习惯最先打开的文件最后关闭（习惯问题）。
    • 注意
      • 写入 / 读取时需注意数据类型的转换
        • 从文件中读取的数据默认是str类型(即使引号里面是其他数据类型)，需要用eval()函数将数据还原成本来的类型；反之，将数据写入.date文件之前，要先将数据转为str类型。
          • 例
            • • 注：例图中第一个红色下划线处如用list()代替eval()，则会将读取出来的str的每个字符都分开。
  • 访问模式
    • r
      • 以只读方式打开文件。不支持写入操作，文件不存在则报错。不写mode则默认为此模式。
    • rb
      • 以二进制格式打开文件用于只读。不支持写入操作，文件不存在则报错。不写mode则默认为此模式。
    • r+
      • 以读写方式打开文件。文件不存在则报错。
    • rb+
      • 以二进制格式打开文件用于读写。文件不存在则报错。
    • w
      • 以只写方式打开文件。文件不存在则新建文件再写入（不写入则默认将文件内容清空），文件已存在则覆盖文件原来的内容。
    • wb
      • 以二进制格式打开文件用于只写。文件不存在则新建文件再写入（不写入则默认将文件内容清空），文件已存在则覆盖文件原来的内容。
    • w+
      • 以读写方式打开文件。文件不存在则新建文件再写入（不写入则默认将文件内容清空），文件已存在则覆盖文件原来的内容。
    • wb+
      • 以二进制格式打开文件用于读写。文件不存在则新建文件再写入（不写入则默认将文件内容清空），文件已存在则覆盖文件原来的内容。
    • a
      • 以追加写入方式打开文件。文件不存在则新建文件再写入，文件已存在则在尾部追加内容。
    • ab
      • 以二进制格式打开文件用于追加。文件不存在则新建文件再写入，文件已存在则在尾部追加内容。
    • a+
      • 以追加写入 或读取方式打开文件。文件不存在则新建文件再读写，文件已存在则在尾部追加内容 或从尾部开始读取（读不出数据）。
    • ab+
      • 以二进制格式打开文件用于追加写入 或读取。文件不存在则新建文件再读写，文件已存在则在尾部追加内容 或从尾部开始读取（读不出数据）。
    • 总结
      • r 模式不能新建文件，w 和 a 能新建文件。
      • 带“b”表示以二进制格式操作文件(任何文件都可以二进格式打开)，带“+”表示可读可写。
      • r 和 w 的文件指针在开头，a 的文件指针在结尾（为了追加），a+ 和 ab+ 读取的数据是空白。
      • w 模式下，如果不执行写入的操作，则默认以空白覆盖原有内容。
    • 备注
      • JPG、PNG、MP3、MP4等文件需要以二进制格式打开（open里要删除encoding='utf-8'）。
  • 文件备份
    • ①接受用户输入的文件名
    • ②规划备份文件名
    • 例
    • ③备份文件写入数据
      • 例
  • 文件(夹)操作函数
    • 模块
      • 导入模块
        • import os
          • 作用
            • 在Python中操作文件和文件夹要借助os模块里的相关功能。
      • 使用模块
        • os.函数名()
    • 删除文件
      • os.remove('路径+文件')
        • 备注
          • .py文件也可以删除自身。
    • 移动 / 重命名文件(夹)
      • os.rename('文件(夹)路径或文件(夹)名', '新文件(夹)路径或文件(夹)名')
        • 备注
          • 和执行该代码的.py文件在同一文件夹下的文件(夹)可以不写文件路径，只写文件名。
          • 文件(夹)路径用“/”或“\”都可以。
          • 无法将文件移到不同的磁盘驱动器。
          • 重命名和移动文件(夹)的操作可以同时进行。
    • 创建目录
      • os.mkdir('文件夹名字')
    • 删除目录
      • os.rmdir('文件夹名')
    • 备注
      • 文件夹名字可以带上路径，不带路径则默认在执行该代码的.py文件的文件夹下创建/删除。
    • 获取当前目录
      • os.getcwd()
        • 作用
          • 返回当前.py文件所在的目录路径。
        • 例
    • 改变默认目录
      • os.chdir('要设为默认的目录')
        • 作用
          • 创建文件夹时，默认路径是该.py文件所在的目录下，通过os.chdir()则可以改变默认目录。
        • 例
    • 获取目录 / 文件列表
      • os.listdir('目录')
        • 作用
          • 获取某文件夹下所有文件(夹)的名称，返回一个列表。
        • 备注
          • 小括号里可以填路径，也可以留空（表示获取当前目录）。
    • 判断是否是文件
      • os.path.isfile('路径+文件')
    • 判断是否是目录
      • os.path.isdir('路径+目录')
    • 例
    • 判断是否存在
      • os.path.exists('路径' + '文件')
        • 备注
          • 该代码可以用代码 文件 in os.listdir('路径') 来代替。
  • 路径拼接函数
    • os.path.join()
  • 案例
    • 文件批量重命名
      • 添加字符
      • 删除字符
        • • 备注
            • 执行代码前需要先删除.idea文件： (因为它没有Python_前缀给程序删)
• 中/大括号 的是可变类型