文章目录
一、开发环境搭建1.1 Python解释器的安装1.2 集成开发环境PyCharm安装 二、基本语法元素2.1 程序的格式框架2.1.1 缩进2.1.2 注释2.1.3 续行符 2.2 语法元素的名称2.2.1 变量2.2.2 保留字2.2.3 标识符 2.3 数据类型2.3.1 二进制与字符编码2.3.2 数值类型2.3.3 字符串类型 2.4 程序的语句元素2.4.1 表达式2.4.2 赋值语句2.4.3 引用2.4.4 其他语句 2.5 基本输入输出函数2.5.1 input( )函数2.5.2 eval( )函数2.5.3 print()函数 2.6转义字符与原字符2.6.1 转义字符2.6.2 原字符 三、运算符3.1 数值运算操作符3.2 数值运算函数3.3 算数运算符3.4 赋值运算符3.5 布尔运算符3.6 比较运算符3.7 位运算 & |3.8 逻辑运算符：and or not3.9 运算符的优先级 四、流程控制4.1 顺序结构4.2 分支结构（选择结构）4.2.1 单分支 if4.2.2 双分支 if...else4.2.3 多分支 if...elif..else4.2.4 嵌套`if`的使用4.2.5 三元表达式4.2.6 pass语句 4.3循环结构4.3.1 range()函数的使用4.3.2 遍历循环for-in4.3.3无限循环while4.3.4循环控制break和continue4.3.5嵌套循环 五、组合数据类型5.1 列表类型5.1.1 列表的定义5.1.2 列表的特点5.1.3 列表的索引5.1.4 列表的切片5.1.5 列表操作函数5.1.6 列表操作方法5.1.7 列表元素的增加操作5.1.8 列表元素的删除操作5.1.9 列表元素的修改操作5.1.10 列表元素的排序操作5.1.11 列表生成式 5.2 字典5.2.1 什么是字典5.2.2 字典示意图5.2.3 字典的原理5.2.4 创建字典的方式5.2.5 字典元素的获取5.2.6 字典的操作函数5.2.7 字典的操作方法5.2.8 字典元素的增删改操作5.2.9 字典视图的获取5.2.10 字典元素的遍历5.2.11 字典的特点5.2.12 字典生成式 5.3 元组5.3.1 什么是元组5.3.2 元组的创建方式5.3.3 元组的遍历 5.4 集合5.4.1 集合操作符5.4.2 常用集合操作函数或方法5.4.3 集合的创建方式5.4.4 集合元素的判断操作5.4.5 集合的新增操作5.4.6 集合的删除操作 六、字符串6.1 字符串的驻留机制6.1.1 字符串6.1.2什么叫字符串的驻留机制6.1.3 字符串驻留机制的几种情况（交互式）6.1.4 强制2个字符串指向同一个对象6.1.5 字符串驻留机制的优缺点 6.2 字符串类型的操作6.2.1 字符串操作符6.2.2 字符串处理函数6.2.3 字符串处理方法6.2.4 字符串的查询操作6.2.5 字符串大小写转换操作6.2.6 字符串内容对齐操作方法6.2.7 字符串的劈分操作6.2.8 判断字符串的方法6.2.9 字符串的替换与合并操作6.2.10 字符串的比较运算6.2.11 字符串的切片操作6.2.12 格式化字符串6.2.13 数值与字符串类型转换函数 6.3 字符串编码转换6.3.1 为什么要进行字符串编码转换6.3.2 编码与解码的方式 七、函数和代码复用7.1 函数的定义7.2 函数的调用7.3 函数的参数传递7.3.1 形式参数与实际参数7.3.2 位置传参与关键字传参7.3.3 可变对象与不可变对象的参数传递7.3.4 个数可变的位置、关键字参数7.3.5 函数参数总结(一）7.3.6 函数参数总结(二） 7.4 函数的返回值7.5 变量的作用域7.6 代码复用7.7 递归函数7.7.1 什么是递归函数7.7.2 递归的组成部分7.7.3 递归的调用过程7.7.4 递归的优缺点 八、异常处理机制8.1 Bub的由来及分类8.1.1 Bug的由来8.1.2 Bug常见类型 8.2 异常处理8.2.1 `try-exception`语句8.2.2 多个`except`语句8.2.3 `try-except-else`结构8.2.4 `try-except-else-finally`结构8.2.5 traceback模块 8.3 Python常见异常类型8.4 PyCharm程序调试8.4.1 断点8.4.2 调试 九、类和对象9.1 两大编程思想9.1.1 面向过程9.1.2 面向对象 9.2 类和对象9.2.1 类9.2.2 对象9.2.3 类的创建9.2.4 对象的创建9.2.5 方法调用9.2.6 为对象动态绑定属性和方法 十、面向对象三大特征10.1封装10.2继承10.2.1 方法重写10.2.2 object类10.2.3 多重继承 10.3多态10.4 类的特殊属性和方法10.4.1 特殊属性10.4.2 特殊方法`__len__()`方法和 `__add__()` 方法`__new__`方法`__init__`方法 10.5 变量的赋值操作10.6 对象的浅拷贝和深拷贝10.6.1 浅拷贝10.6.2 深拷贝 十一、包和模块11.1 Python中的模块11.1.1 什么叫做模块11.1.2 导入模块11.1.3 导入自定义模块11.1.4 以主程序的方式运行 11.2 Python中的包11.3 Python中常用的内置模块11.3.1`sys`模块11.3.2 `time`模块11.3.3 `os`模块11.3.4 `urllib`模块 11.4 第三方模块11.4.1 第三方模块安装11.4.2 第三方模块使用 十二、文件操作12.1 编码格式介绍12.2 文件读写原理12.2.1 文件的读写简称IO操作12.2.2 文件读写流程12.2.3 操作原理: 12.3 文件读写操作12.4 文件的打开开和关闭12.4.1 文件的状态和操作过程12.4.2 文件的打开模式12.4.3 文件的关闭 12.5 文件对象的常用方法12.6 `with`上下文管理12.7 `os`模块12.7.1 `os`模块操作目录相关函数12.7.2 `os.path`模块操作目录相关函数12.7.3 列出指定目录下的所有`.py`文件12.7.4 遍历指定目录下所有的文件以及目录`个人主页`——>[@Flyme awei](https://aweia.blog.csdn.net/)`Python刷题`——>《[牛客题库-Python篇](https://blog.csdn.net/m0_68744965/category_11957439.html)》`Python进阶学习`——>《[Python进阶语法专栏](https://blog.csdn.net/m0_68744965/category_11877203.html)》
一、开发环境搭建
1.1 Python解释器的安装
Python解释器的安装1.2 集成开发环境PyCharm安装
集成开发环境PyCharm安装二、基本语法元素
Python语言基本语法元素2.1 程序的格式框架
程序的格式框架，即段落格式，是Python语法的一部分，可以提高代码的可读性和可维护性。
2.1.1 缩进
Python语言采用严格的缩进来表示程序逻辑。也就是我们所说的Python程序间的包含与层次关系。一般代码不要求缩进，顶行编写且不留空白。在if、while、for、def、class等保留字所在完整语句后通过英文的“:”结尾并在之后行进行缩进，表明后续代码与紧邻无缩进语句的所属关系。
缩进可以用Tab键实现，也可以用多个空格实现（一般是4个空格），但两者不能混用。建议采用4个空格方式书写代码。
2.1.2 注释
注释是代码中的辅助性文字，会被编译器或解释器略去，不被计算机执行，一般用于程序员对代码的说明。Python语言中使用“#”表示一行注释的开始。注释可以在一行中任意位置通过“#”开始，其后面的本行内容被当作注释，而之前的内容依然是Python执行程序的一部分。
注释的作用：
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : 1071505897@qq.com# @Time : 2022/8/2 13:40# 单行注释'''多行注释'''"""多行注释"""2.1.3 续行符
Python程序是逐行编写的，每行代码长度并无限制，但从程序员角度，单行代码太长并不利于阅读。这个时候就可以使用续行符将单行代码分割为多行表达。
Python中的续行符为“\”。续行符之后不允许再存在空格，即续行符后直接换行。
print("云南的城市有{}\n{}\n{}\n{}".format('昆明',\ '曲靖',\ '大理',\ '丽江'))2.2 语法元素的名称
Python语言的基本单位是单词，少部分单词是Python语言规定的，被称为保留字。大部分单词是用户自己定义的，通过命名过程形成了变量或函数，用来代表数据或代码，称为标识符。
2.2.1 变量
变量是保存和表示数据值的一种语法元素，变量的值是可以改变的，通过赋值运算符“=”方式被修改。Python语言中，变量可以随时命名、随时赋值、随时使用。
由三部分组成：
"""标识： id类型： type值： value """多次赋值后将指向新的空间
name = 'hello' # 第一次赋值print(id(name)) # 标识# 2026989330544name = 'world' # 第二次赋值print(id(name))# 20269893171682.2.2 保留字
保留字也称keyword关键字，被编程语言内部定义并保留使用的，每种程序设计语言都有一套保留字，保留字一般用来构成程序的整体框架，Python3.x中一共有35个保留字。
import keyword # 导入关键字模块print(keyword.kwlist) # 调用keyword模块的kwlist方法Python3.x中的35个保留字
andasassertasyncawaitbreakclass continuedefdelelifelseexceptFalse finallyforfrom globalif importin is lambdaNonenonlocalnotorpass raisereturnTruetry while with yield Python二级考试涉及到的保留字一共有22个。选学5个：None、finally、lambda、pass、with。
Python中的保留字也是大小写敏感的。举例：True为保留字，而true则不是保留字。
2.2.3 标识符
标识符可以简单的理解为一个名字，主要用来标识变量、函数、类、模块和其他对象的名称。
标识符的命名规则
字母、数字、下划线不能以数字开头不能是Python中的保留字只允许使用ISO-Latin(ISO-8859-1)字符集中的A-Z和a-z允许使用中文，但不建议注意：标识符对大小写敏感，name和Name是两个不同的名字。 2.3 数据类型
2.3.1 二进制与字符编码
二进制是一套计数方法，每个位置上的数有 2 种可能（0 - 1）；二进制是计算机的执行语言，但是早在计算机出现前就存在这套计数方法，最早可追溯到古埃及。在日常生活中，我们使用的是十进制，每个位置上的数有 10 种可能（0 - 9）。
早期的程序员爸爸为了让计算机能够认识我，将我能够认识的符号和数字对应好，然后做成一张表叫ASCII表，告诉计算机某种符号你应该使用哪个整数表示,A使用了8个位（置）才能装得下我，在计算机中他们叫一个字节。
ASCII码表
| ASCII值 | 控制字符 | ASCII值 | 控制字符 | ASCII值 | 控制字符 | ASCII值 | 控制字符 |
|---|---|---|---|---|---|---|---|
| 0 | NUT | 32 | (space) | 64 | @ | 96 | 、 |
| 1 | SOH | 33 | ！ | 65 | A | 97 | a |
| 2 | STX | 34 | ” | 66 | B | 98 | b |
| 3 | ETX | 35 | # | 67 | C | 99 | c |
| 4 | EOT | 36 | $ | 68 | D | 100 | d |
| 5 | ENQ | 37 | % | 69 | E | 101 | e |
| 6 | ACK | 38 | & | 70 | F | 102 | f |
| 7 | BEL | 39 | , | 71 | G | 103 | g |
| 8 | BS | 40 | ( | 72 | H | 104 | h |
| 9 | HT | 41 | ) | 73 | I | 105 | i |
| 10 | LF | 42 | * | 74 | J | 106 | j |
| 11 | VT | 43 | + | 75 | K | 107 | k |
| 12 | FF | 44 | , | 76 | L | 108 | l |
| 13 | CR | 45 | - | 77 | M | 109 | m |
| 14 | SO | 46 | . | 78 | N | 110 | n |
| 15 | SI | 47 | / | 79 | O | 111 | o |
| 16 | DLE | 48 | 0 | 80 | P | 112 | p |
| 17 | DCI | 49 | 1 | 81 | Q | 113 | q |
| 18 | DC2 | 50 | 2 | 82 | R | 114 | r |
| 19 | DC3 | 51 | 3 | 83 | S | 115 | s |
| 20 | DC4 | 52 | 4 | 84 | T | 116 | t |
| 21 | NAK | 53 | 5 | 85 | U | 117 | u |
| 22 | SYN | 54 | 6 | 86 | V | 118 | v |
| 23 | TB | 55 | 7 | 87 | W | 119 | w |
| 24 | CAN | 56 | 8 | 88 | X | 120 | x |
| 25 | EM | 57 | 9 | 89 | Y | 121 | y |
| 26 | SUB | 58 | : | 90 | Z | 122 | z |
| 27 | ESC | 59 | ; | 91 | [ | 123 | { |
| 28 | FS | 60 | < | 92 | / | 124 | | |
| 29 | GS | 61 | = | 93 | ] | 125 | } |
| 30 | RS | 62 | > | 94 | ^ | 126 | ~ |
| 31 | US | 63 | ? | 95 | — | 127 | DEL |
ASCII码表字符解释
| NUL 空 | VT 垂直制表 | SYN 空转同步 |
|---|---|---|
| SOH 标题开始 | FF 换页键 | ETB 信息组传送结束 |
| STX 正文开始 | CR 回车 | CAN 作废 |
| ETX 正文结束 | SO 移位输出 | EM 纸尽 |
| EOY 传输结束 | SI 移位输入 | SUB 代替 |
| ENQ 请求 | DLE 空格 | ESC 换码 |
| ACK 收到通知 | DC1 设备控制1 | FS 文字分隔符 |
| BEL 报警 | DC2 设备控制2 | GS 组分隔符 |
| BS 退一格 | DC3 设备控制3 | RS 记录分隔符 |
| HT 水平制表符 | DC4 设备控制4 | US 单元分隔符 |
| LF 换行 | NAK 拒绝 | DEL 删除 |
2.3.2 数值类型
Python提供的3种数值类型：
整数类型：与数学中的整数一致，包含正、负、0。一个整数有二进制、八进制、十进制、十六进制4种表示方式。
| 进制 | 基本数 | 逢几进一 | 表示形式 |
|---|---|---|---|
| 十进制 | 0,1,2,3,4,5,6,7,8,9 | 10 | 520 |
| 二进制 | 0,1 | 2 | 0b11010 |
| 八进制 | 0,1,2,3,4,5,6,7 | 8 | 0o520 |
| 十六进制 | 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F | 16 | 0xAF12546 |
浮点数类型：与数学中的小数一致，没有取值范围限制，可正、可负。有两种表示形式，一种是小数点的形式，另外一种是科学计数法。浮点数只有十进制形式。
复数：与数学中的复数一致，采用a+bj的形式表示，存在实部和虚部。
2.3.3 字符串类型
计算机经常处理文本信息，文本信息在程序中使用字符串类型表示。在Python中使用单引号或双引号括起来的一个或多个字符来表示。单引号和双引号的作用相同。
# 字符串类型 被称为不可变的字符序列print('我用python')print("我用python")print('''我用python''')print(type('我用python'))print(type("我用python"))print(type('''我用python'''))字符序列有两种序号体系：
正向递增序号： 有效范围为[0,N-1]，其中N为字符串中字符的个数。最左侧的字符序号为0，依次向右递增，最右侧字符序号为N-1。
反向递减序号：有效范围为[-1,-N]，其中N为字符串中字符的个数。最右侧的字符序与为-1，依次向左递减，最左侧的字符序号为-N。
两种索引可以同时使用，以下代码为对单个字符进行的索引。
s = 'hello word'print(s[0]) # hprint(s[-10]) # h还可以采用[N:M]格式获取字符串的子串，这种操作被称为切片操作。[N:M]获取字符串中从N到M（但不包含M）的连续的子字符串。N和M都表示的是索引序号，可以混合使用正向递增序号和反向递减序号。
s = 'hello word'print(s[0:5]) # helloprint(s[0:-5]) # hello通过Python默认提供的len()函数获取字符串的长度，一个中文字符和一个英文字符的长度都记为1。
print(len(s)) # 102.4 程序的语句元素
2.4.1 表达式
产生或计算新数据值的代码片段称为表达式。类似于数学中的公式，一般由数据和操作符构成。
2.4.2 赋值语句
对变量进行赋值的一行代码被称为赋值语句。在Python中使用一个“=”表示“赋值”，即将等号右侧表达式计算后的结果值赋给左侧的变量。
基本赋值语句语法：变量 = 表达式
同步赋值语句就是同时给多个变量进行赋值。
同步赋值语句语法：
变量1,变量2,......变量N = 表达式1,表达式2,......,表达式N
同步赋值语句应用最多的就是互换变量的值，即交换两个变量的值。
2.4.3 引用
Python程序会经常使用到当前程序之外已有的功能代码，这个过程叫引用。
Python语言中使用import这个保留字引用当前程序以外的功能库。import <功能库名称>
引用功能库之后使用 功能库.函数名()的方式调用基本功能，这种方式简称为“A.B()”方式。
2.4.4 其他语句
除了赋值语句之外，Python还有分支语句和循环语句。先简单介绍一下使用，后面后详细讲解。
分支语句：根据判断条件选择程序执行路径。一般包含单分支结构、双分支结构和多分支结构。
单分支语法结构：
if 条件: 语句块任何能够产生True或False的语句都可以作为条件，当条件为True时，则执行语句块中的内容。
双分支语法结构：
if 条件： 语句块1 else: 语句块2当条件为True时，执行语句块1，当条件为False时，执行语句块2。其中if...else 都是保留字。
循环结构与分支结构一样都是程序控制语句，它的作用是根据判断条件确定一个程序是否再执行一次或者多次。
条件循环的语法结构：
while 条件: 语句块1语句块2当条件为True时，执行语句块1，然后再次判断条件，当条件为False时，退出循环，执行语句块2。
2.5 基本输入输出函数
2.5.1 input( )函数
input()函数是从控制台获得用户的一行输入，无论用户输入什么内容，input()函数都以字符串类型返回。input()函数可以包含一些提示性文字，用来提示用户。
input语法格式：变量=input('提示性文字')
无论用户输入的是数字还是字符，input()函数统一按照字符串类型输出，为了后续能够操作用户输入的信息，需要将输入指定一个变量进行存储。
input()函数的提示性文字不是必须的，可写可不写。
2.5.2 eval( )函数
eval(s)函数将去掉字符串s最外侧的引号，并按照Python语句方式执行去掉引号后的字符内容。
eavl语法格式：变量 = eval(字符串)
变量用来保存对字符串内存进行Python运算的结果。
eval()函数去掉了字符串’1.2’最外侧的引号，结果赋值给a，所以a的类型为float类型。eval()函数去掉了字符串’1.2+3.4’最外侧的引号，对其内容当作Python语句进行运算，运算的结果为4.6，保存到变量a中，所以a的类型是float类型。
当eval()函数处理字符串’python’时，字符串去掉了两边的引号，Python语句将其解释为一个变量，由于这个变量在之前别有定义，因此解释器报错。如果定义变量python并赋值为123，再运行这个语句时就没有问题，如果输出为123。
eval()函数经常和input()函数一起使用，用来获取用户输入的数字。
eval()与input()函数一起使用的语法：变量=eval(input(提示性文字))
用户输入的数字、包括小数和负数，input()解析为字符串，再由eval()去掉字符串引号，将被直接解析为数字保存到变量中。
2.5.3 print()函数
print()函数用于输出运算结果。
def print(self, *args, sep=' ', end='\n', file=None): # known special case of print """ print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) Prints the values to a stream, or to sys.stdout by default. Optional keyword arguments: file: a file-like object (stream); defaults to the current sys.stdout. sep: string inserted between values, default a space. end: string appended after the last value, default a newline. flush: whether to forcibly flush the stream. """ passsep=' '分隔符，默认为一个空格end='\n'结束符，默认以换行结束
print()函数的三种用法：
print(待输出字符串或变量)
对于字符串，print()函数输出后将出掉两侧引号，对于其它类型，则会直接输出。
当print()输出字符串表示时，字符串统一使用单引号表达。在[]中的字符串都使用了双引号，但是在被print()函数打印输出时，输出结果都采用了单引号。
print(变量1,变量2,......,变量N)
{}表示一个槽位，每个槽位对应.format()中的一个变量。 print(输出字符串模板.format(变量1,变量2,......,变量N))
print()函数输出的输出内容
'''可以输出数字 int '''print(2) # 2'''可以输出字符串 str '''print('hello') # hello'''输出含有运算符的表达式 '''print(2+3) # 5print()函数输出的目的地
'''将内容输出到显示器'''print('hello,world') # hello,world'''将内容输出到文件'''# 注意：所指定的盘符存在；使用file = fp;fp = open('E:\\text.txt', 'a')print('hello,world!', file=fp)fp.close()‘整数{}和整数{}的差是：{}’是输出字符串模板，也就是混合字符串输出的样式，大括号{}表示一个槽位，括号中的内容由后面紧跟着的format()方法中的参数按顺序填充。
2.6转义字符与原字符
2.6.1 转义字符
就是反斜杠+想要实现的转义功能首字母。
为什么需要转义字符?
当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转义（转换一个含义）。
\\单引号:\'双引号: \“ print('\\') # \print('\'') # 'print('\"') # "当字符串中包含换行、回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符当字符串中包含换行、回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符。
换行:\n回车:\r水平制表符 : \t退格 :\b # 回车\rprint('hello\rhelloworld') # 将hello覆盖# 换行\nprint('hello\nworld')# 退格\bprint('helloo\bworld')# 水平制表\tprint('hello\tworld\t你好\t好')2.6.2 原字符
原字符：不希望字符串中的转义字符起作用，就使用原字符，就是在字符创之前加上
注意事项，最后一个字符不能是反斜线
# 原字符：不希望字符串中的转义字符起作用，就使用原字符，就是在字符创之前加上 r 或 R# 注意事项，最后一个字符不能是反斜线print(r'hello \n word') # hello \n word三、运算符
Python的运算符3.1 数值运算操作符
Python提供了9个基本的数值运算操作符。
| 操作符及运算 | 描述 |
|---|---|
| x + y | x 与 y 之和 |
| x - y | x 与 y 之差 |
| x * y | x 与 y 之积 |
| x / y | x 与 y 之商，产生结果为浮点数 |
| x // y | x 与 y 之整数商 |
| x % y | x 与 y 之余商，也称之为模运算 |
| - x | x 的负数 |
| + x | x 本身 |
| x**y | x 的 y 次幂 |
3.2 数值运算函数
所谓函数表现为对参数的特定运算。
Python解释器自身提供了一些预先编写好的函数称为内置函数，其中与数值运算相关的函数如下：
| 序号 | 函数 | 描述 |
|---|---|---|
| 1 | abs(x) | x的绝对值 |
| 2 | divmod(x, y) | (x//y, x%y)输出元组形式的商与余数 |
| 3 | pow(x, y) 或 pow(x, y, z) | x**y或(x**y)%z,幂运算 |
| 4 | round(x) 或 round(x, d) | 对x四舍五入保留d位小数,d省去则为四舍五入的整数 |
| 5 | max(x1, x2,...,xn) | n个数中的最大值 |
| 6 | min(x1, x2,...,xn) | n个数中的最小值 |
3.3 算数运算符
'''算数运算符： 加 + 减 - 乘 * 除 / 整除 // 取余 % 幂 **'''print(-9 // -4) # 2print(9 // 4) # 2print(-9 // 4) # -3 一正一负整除公式，商取下整print(9 // -4) # -3print(9 % -4) # -3 公式 余数=被除数-除数*商 9-（-4）*（-3）= -3print(-9 % 4) # 3 -9 - 4*（-3）= 3# 规律:规律就是 取余数是负数 结果就是负数3.4 赋值运算符
赋值运算符：运算顺序从右到左
'''赋值运算符:运算顺序从右到左= a=10+= a+=b a=a+b-= a-=b a=a-b*= a*b a=ab/= a/=b a=a/b//= a//=b a=a//b% a%=b a=a%b'''链式赋值,id相同
'''链式赋值,id相同'''a = b = c = 20print(a, type(a), id(a))print(b, type(b), id(b))print(c, type(c), id(c))print('-------------------------')output:20 <class 'int'> 14072539500364820 <class 'int'> 14072539500364820 <class 'int'> 140725395003648-------------------------参数赋值
'''参数赋值'''a = 20a += 30 # a = a+30print(a) # 50系列解包赋值
'''解包赋值'''a, b, c = 10, 20, 30print(a, id(a))print(b, id(b))print(c, id(c))print('---------交换两个变量的值-----------')a, b = 10, 20print(a, b)a, b = b, aprint(a, b)output:10 14072539500332820 14072539500364830 140725395003968---------交换两个变量的值-----------10 2020 10
3.5 布尔运算符
布尔类型 用来表示真或假
True 表示真False表示假布尔值可以转化为整数 True:1 False:0 Python中一切皆对象，所有对象都有一个布尔值，获取对象布尔值使用内置函数bool()
# Python中一切皆对象，所有对象都有一个布尔值# 获取对象布尔值使用内置函数bool()'''以下对象布尔值为False： False 数值0 None 空字符串 '' 空列表 [] 空字典 {} 空元组 () 空集合 {}'''print(bool(False))print(bool(0))print(bool(0.0))print(bool(None))print(bool(''))print(bool([])) # 空列表print(bool(list()))print(bool({})) # 空字典print(bool(dict()))print(bool(())) # 空元组print(bool(tuple()))print(bool(set())) # 空集合print('-------------以上对象bool值均为False------------')3.6 比较运算符
比较运算符: 比较的值为True 或 False
'''' >大于 <小于 == 等于 比较的是值：value != 不等于 >= 大于等于 <= 小于等于 对象id的比较 is is not '''3.7 位运算 & |
'''位运算符:位与 & 对应位数都是1，结果才为1，否则为0位或 | 对应位数都是0，结果才为0左移运算符 << 高位溢出，低位补0右移运算符 >> 低位溢出，高位补0 '''3.8 逻辑运算符：and or not
True 和 False 二元数值构成了基本的真假逻辑，因此诞生了逻辑运算。
| 运算符 | 描述 |
|---|---|
| and | x and y，与操作 |
| or | x or y，或操作 |
| not | not x，非操作 |
'''and 且 全真为真or 或 有真则真not 非 对bool类型操作数取反 in 在...里 not in 不在...里'''3.9 运算符的优先级
指数运算运算（最高优先级） **算数运算 * / // % + -位运算 << >> & |比较运算符 > < >= <=等于运算符 == !=身份运算符 is is not成员运算符 in not in逻辑运算符 and or not四、流程控制
Python流程控制4.1 顺序结构
程序按照线性顺序依次执行的一种运行方式。
例：把大象装冰箱分几步：
# 把大象装冰箱分几步print('--------程序开始--------')print('1.把冰箱门打开')print('2.把大象装进冰箱')print('3.关上冰箱门')print('--------程序结束--------')4.2 分支结构（选择结构）
程序根据判断条件的布尔值选择性地执行部分代码明确的让计算机知道在什么条件下，该去做什么。
4.2.1 单分支 if
中文语义：如果......就......
语法结构：
if 条件表达式: 条件执行体if条件语句：判断一次，条件为True时执行一次
# if条件语句 判断一次 条件为True时执行一次money = 100s = int(input('请输入取款金额:'))if s <= 100: money = money - s print('取款成功，余额为', money)4.2.2 双分支 if…else
中文语义：如果......不满足......就......
语法结构：
if 条件表达式： 条件执行体else： 条件执行体2双分支结构if...else,二选一执行
'''双分支结构if...else,二选一执行'''# 从键盘输入一个整数，编写程序让计算机判断是奇数还是偶数num = int(input('请输入一个整数:'))if num % 2 == 0: print(num, '是偶数')else: print(num, '是奇数')4.2.3 多分支 if…elif…else
中文语义：如果......就......如果......不满足......就......
语法结构：
if 条件表达式： 条件执行体elif 条件表达式： 条件执行体elif 条件表达式： 条件执行体elif 条件表达式： 条件执行体else: 条件执行体例：
从键盘录入一个整数成绩：
90-100 ： A
80-89 ： B
70-79 ： C
60-69 ： D
0-59 ：E
小于0或大于100 不及格
代码：
num = int(input('从键盘输入一个成绩:'))if 90 <= num <= 100: print('A')elif 80 <= num <= 89: print('B')elif 70 <= num <= 79: print('C')elif 60 <= num <= 69: print('D')elif 0 <= num <= 59: print('E')else: print('不及格')4.2.4 嵌套if的使用
语法结构：
if 条件表达式1: if 内层条件表达式： 内层执行体1 else： 内层执行体2else: 条件执行体
例：商场消费
会员： >=200 8折 >=100 9折 <100 不打折非会员: >=200 9.5折 <100 不打折代码：
answer = input('您是会员吗?y/n')money = float(input('请输入您的购物金额:'))# 外层判断是否是会员if answer == 'y': # 会员 if money >= 200: print('打8折,付款金额为:', money*0.8) elif money >= 100: print('打9折,付款金额为:', money*0.9) else: print('不打折，付款金额为:', money)else: # 非会员 if money >= 200: print('打9.5折,付款金额为:', money*0.95) else: print('不打折，付款金额为:', money)4.2.5 三元表达式
语法结构：x if 判断条件 else y
运算规则：如果判断条件的布尔值为True，条件表达式的返回值为x，否则条件表达式的返回值为False
# 条件表达式 x if 判断条件 else ya = int(input('请输入第一个整数:'))b = int(input('请输入第二个整数:'))'''if a >= b: print(a, '>=', b)else: print(a, '<', b)'''# 条件表达式print(str(a) + '小于' + str(b)) if a < b else (str(a) + '大于' + str(b))4.2.6 pass语句
pass语句什么都不做，只是一个占位符，用在语法上需要语句的地方
def fun(a, b): pass什么时候使用pass语句:先搭建语法结构，还没想好代码怎么写的时候 。
pass语句与哪些语句一起使用：
if语句的条件执行体for-in语句的循环体定义函数def时的函数体 a = 1b = 2if a < b: passfor i in range(10): passdef fun(a, b): pass4.3循环结构
反复做同一件事情的情况，称为循环，Python语言的循环结构包括两种：遍历循环和无限循环。遍历循环使用保留字forin依次提取遍历结构各元素进行处理；无限循环使用保留字while根据判断条件执行程序
4.3.1 range()函数的使用
range():用于生成一个整数序列
创建range对象的三种方式
代码：
# 第一种创建方式 range(stop)range(10)print(range(10)) # range(0,10) 返回值是一个迭代器对象 默认从0开始，默认步长为1print(list(range(10))) # 用于查看range对象中的整数序列 list-->列表# 第二种创建方式 range(start, stop)print(range(0, 10))# 第三种创建方式 range(start,stop,step)print(range(0, 10, 1))range()函数的返回值是一个迭代器对象
range类型的优点 :不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start,stop和step，只有当用到range对象时，才会去计算序列中的相关元素
'''内置函数 range(start(开始)未指定从0开始, stop(结束), step(步长)未指定步长为1)'''r = range(1, 10, 2)print(r)print(list(r)) # 列表 [1, 3, 5, 7, 9]print(tuple(r)) # 元组 (1, 3, 5, 7, 9)print(set(r)) # 字典 {1, 3, 5, 7, 9}in与not in 判断整数序列中是否存在（不存在）指定的整数
'''判断指定整数在序列中是否存在 in， not in'''print(3 in r) # Trueprint(4 in r) # Falseprint(3 not in r) # Falseprint(4 not in r) # Truefor value in range(10): print(value, end=' ')4.3.2 遍历循环for-in
for-in循环
in表达从（字符串、序列等）中依次取值，又称为遍历for-in遍历的对象必须是可迭代对象 for-in的语法结构
for 自定义的变量 in 可迭代对象: 循环体for-in的执行图
# for in循环# in 表达是依次 从 （字符串，序列等） 中依次取值，又称遍历# for in遍历对象必须是可迭代对象'''for in 语法结构'''# for 自定义变量 in 可迭代对象:# 循环体for i in 'hello': print(i, end=' ')print('')for i in range(10): print(i, end=' ')print('')# 在循环体中如果不需要使用到自定义变量，可将自定义变量写为下划线('_')for _ in range(3): # 3表示次数 print('hello')使用for循环 计算1-100之间的偶数和
# 使用for循环 计算1-100之间的偶数和sum = 0for item in range(101): if item % 2 == 0: sum += itemprint('1-100之间的偶数和为:', sum)输出100-999之间的水仙花数
'''输出100-999之间的水仙花数 这个数的个位上的三次方 + 十位上的三次方 + 百位上的三次方 = 这个数'''for item in range(100, 1000): ge = item % 10 shi = item % 100 // 10 # item//10%10 bai = item // 100 if item == ge**3+shi**3+bai**3: print(item)4.3.3无限循环while
语法结构：
while 条件表达式:条件执行体(循环体)四步循环法:
初始化变量条件判断条件执行体（循环体）改变变量打印输出计算0-4之间的累加和
a = 0 # 1.初始化变量s = 0while a <= 4: # 2.条件判断 s += a # 3.条件执行体 a += 1 # 4.改变变量 print(s) # 5.打印输出选择结构的if与循环结构while的区别
If是判断一次，条件为True执行一行while是判断N+1次，条件为True执行N次 4.3.4循环控制break和continue
循环结构有两个辅助循环控制的保留字:break与continue。
break语句 break用来跳出最内层for或while循环，脱离该循环后程序继续执行循环后续代码，通常与 分支结构 if 一起使用。
例：从键盘录入密码，最多录入三次，如果正确就结束循环
# for 循环for _ in range(3): # range()函数可以用作for循环的循环次数 3 表示for执行了3次 pwd = '888' a = input('请输入密码:') if a == pwd: print('密码正确') break else: print('密码错误，请重新输入密码')# while 循环，四步循环法a = 0while a < 3: '''条件执行体(循环体)''' b = '888' pwd = input('请输入密码：') if pwd == b: print('密码正确') break else: print('密码错误') a += 1continue语句 continue语句用来结束当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环，进入下一次循环，通常与分支结构 if 一起使用
例：要求输出1-50-之间所有5的倍数
# for 循环for i in range(1, 51): if i % 5 == 0: print(i)# while 循环a = 1while a <= 50: if a % 5 == 0: print(a) a += 1# continue 语句for item in range(1, 51): if item % 5 != 0: continue print(item)4.3.5嵌套循环
循环结构中又嵌套了另外的完整的循环结构，其中内层循环做为外层循环的循环体执行。
例1：打印一个三行四列矩形
for _ in range(3): for _ in range(4): print('-', end='\t') print()例2：输出乘法口诀表
for i in range(1, 10): for j in range(1, i+1): print(i, 'x', j, '=', i*j, end='\t') print()
五、组合数据类型
5.1 列表类型
Python组合数据类型——序列类型：列表5.1.1 列表的定义
列表类型是包含0个或多个元素的有序序列，属于序列类型。列表可以进行元素的增加、删除、替换、查找等操作。列表没有长度限制，无素类型可以不同，不需要预定长度。
列表类型用中括号[]表示，也可以通过list(x)函数将集合或字符串类型转换成列表类型。list()函数可生成空列表。
列表需要使用中括号[],元素之间使用英文的逗号进行分隔
列表示意图：
列表创建方式
[]方括号 lst = ['hello', 'world', 'java']print(lst)list() lst2 = list(['hello', 'world', 'java'] + ['hello', 'world', 'java'])print(lst2)lst = [i for i in range(1, 11)]print(lst)5.1.2 列表的特点
列表元素按顺序有序排列索引映射唯一一个数据列表可以存储重复数据任意数据类型混存根据需要动态分配内存空间5.1.3 列表的索引
索引是列表的基本操作，用于获得列表第一个元素。该操作沿用序列类型的索引方式，即正向递增序号和反向递减序号，使用中括号作为索引操作符，索引序号不能超过列表的元素范围，否则会产生IndexErrorr的错误。
获取列表中指定元素索引
语法：列表或列表变量.index（'要获取索引的元素',起始位置,结束位置）
如果列表中含有相同元素，只返回相同元素的第一个元素的索引。
# 如果列表中含有相同元素，只返回相同元素的第一个元素的索引lst = ['hello', 'world', 'java', 'hello', 'world', 'java']print(lst.index('java')) # 2print(lst.index('java', 3, 6)) # 5可以使用遍历循环对列表类型的元素进行遍历操作。
语法：for 迭代变量 in 列表名:
# 列表元素的遍历lst = [10, 20, 30, 40, 50, 60, 70, 80]for i in lst: print(i)output:10203040506070805.1.4 列表的切片
切片是列表的基本操作，用于获得列表的一个片段，即获得零个或多个元素。切片后的结果也是列表类型。
切片有两种使用方式：
[N:M]列表或列表变量[N:M:K] 根据索引获取元素值
lst = ['hello', 'world', 'java', 'hello', 'world', 'java']'''获取单个元素'''# 获取列表索引为 2的元素print(lst[2]) # java# 获取列表索引为-3的元素print(lst[-3]) # hello'''获取多个元素 返回值为一个列表'''# lst = [start(默认0开始) : stop（默认最后） : step（默认步长1）]# step 为负数时相反print(lst[0:5:1])# ['hello', 'world', 'java', 'hello', 'world']5.1.5 列表操作函数
| 操作函数 | 描述 |
|---|---|
len(ls) | 列表ls的元素个数（长度） |
min(ls) | 列表ls的最小元素 |
max(ls) | 列表ls的最大元素 |
list(x) | 将x转换为列表类型 |
# -*- coding: utf-8 -*-# @File : 列表操作函数.py# @author: Flyme awei # @email : 1071505897@qq.com# @Time : 2022/8/8 0:15ls = [1, 3, 5, 7, 9]print(len(ls))print(max(ls))print(min(ls))x = (1, 3, 5, 7, 9)print(list(x))
5.1.6 列表操作方法
列表类型的一些常用操作方法：
| 方法 | 描述 |
|---|---|
ls.append(x) | 在列表ls末尾添加一个元素x |
ls.insert(i, x) | 在列表ls的第i个位置增加元素x |
ls.clear() | 删除列表ls所有元素 |
ls.pop(i) | 将列表ls的第i个元素取出并从ls中删除该元素 |
ls.remove(x) | 将列表中出现的第一个元素x删除 |
ls.reverse() | 将列表ls中的元素反转 |
ls.copy() | 生成一个新列表，复制ls中的所有元素 |
5.1.7 列表元素的增加操作
| 方法 | 描述 |
|---|---|
ls.append(x) | 在列表ls末尾添加一个元素x |
ls.insert(i, x) | 在列表ls的第i个位置增加元素x |
ls.extend() | 在列表ls末尾至少添加一个元素 |
| 切片 | 在列表任意位置至少添加一个元素 |
lst = [10, 20, 30]lst1 = ['hello', 'world']print(lst)print("添加元素之前id:", id(lst))# 1. append(要添加的元素) 在列表末尾添加一个元素lst.append(100)print(lst)print("添加元素之后id:", id(lst))# 2. extend() 在列表末尾至少添加一个元素lst.extend(lst1)print(lst)# 3. insert(索引, 要添加的对象)在任意（指定索引）位置添加一个元素lst.insert(4, 'python')print(lst)# 4.切片 在任意位置添加至少一个元素# lst[要切的位置索引 : 结束位置 : 步长默认为以1]=要添加的列表lst[1:5:3] = lst1print(lst)
5.1.8 列表元素的删除操作
| 方法 | 描述 |
|---|---|
ls.remove(x) | 将列表中出现的第一个元素x删除 |
pop() | 删除一个指定索引位置上的元素 |
| 切片 | 一次至少删除一个元素 |
clear() | 清空列表 |
del | 删除列表 |
代码：
lst = [10, 20, 30, 20, 40, 50, 60, 70, 80, 90]# 1. remove(要移除的元素) 从列表中移除一个元素，重复只删一个，元素不存抛异常lst.remove(20)print(lst)# 2. pop(索引) 删除一个指定索引上的元素，不指定索引删除最后一个元素，指定索引不存在抛异常lst.pop(7)print(lst)lst.pop()print(lst)# 3. 切片操作 删除至少一个元素，将产生一个新的列表对象new_lst = lst[1:4] # 索引 1,2,3,产生一个新列表print(new_lst)'''不产生新的列表对象，而是删除原列表中的内容'''lst[1:6] = []print(lst)# 4. clear 清空列表lst.clear()print(lst)# 5. del 删除列表del lst# print(lst)运行结果：
5.1.9 列表元素的修改操作
# 为指定索引的元素赋予一个新值lst = [10, 20, 30, 40]lst[2] = 100print(lst)# 为指定的切片赋予一个新值lst[1:2] = [100, 200, 300]print(lst)
5.1.10 列表元素的排序操作
sort()方法
class list(object): def sort(self, *args, **kwargs): # real signature unknown """ Sort the list in ascending order and return None. The sort is in-place (i.e. the list itself is modified) and stable (i.e. the order of two equal elements is maintained). If a key function is given, apply it once to each list item and sort them, ascending or descending, according to their function values. The reverse flag can be set to sort in descending order. """ pass按升序对列表进行排序，返回None。
排序是原地的(即列表本身被修改)和稳定的(即
保持两个相等元素的顺序)。
如果给出了一个键函数，对每个列表项应用一次，并对它们进行排序，
根据它们的函数值升序或降序。
反向标志可以设置为降序排序。
内置函数sorted()
def sorted(*args, **kwargs): # real signature unknown """ Return a new list containing all items from the iterable in ascending order. A custom key function can be supplied to customize the sort order, and the reverse flag can be set to request the result in descending order. """ pass返回一个新列表，其中包含可迭代对象中的所有项，按升序排列。
可以提供自定义键函数来自定义排序顺序
可以设置reverse标志，以降序请求结果。
# 1.调用 sort()方法，sort()方法默认是 升序 排序，在调用该方法后，列表中的元素会按照从小到大的顺序排列lst = [23, 46, 67, 12, 8, 27]lst.sort()print(lst)# 2.如果我们想让其降序 排序，则可以通过指定关键字参数reverselst = [20, 40, 10, 98, 54]print('排序前的列表', lst)lst.sort(reverse=True)print('排序后的列表', lst)# 升序lst.sort(reverse=False)print('排序后的列表', lst)# 使用内置函数 sorted() 对列表进行排序，将产生一个新的对象lst = [20, 40, 10, 98, 54]print(sorted(lst)) # 未指定升序print(sorted(lst, reverse=True)) # 指定降序
5.1.11 列表生成式
列表生成式： 简称列表生成的公式。
语法格式：lst = [列表元素表达式 for 自定义变量 in 可迭代对象]
例：lst = [i for i in range(1, 11)]
lst = [i for i in range(1, 11)]print(lst)
5.2 字典
Python组合数据类型——映射类型：字典5.2.1 什么是字典
字典：Python内置的数据结构之一，与列表一样是一个可变序列，以键值对的方式存储数据，字典是一个无序的序列。Python语言中的字典使用大括号{ }建立，每个元素是一个键值对。
“键值对”是组织数据的一种重要方式，广泛应用在当代大型信息系统中，如Web系统。键值对的基本思想是将“值”信息关联一个“键”信息，进而通过键信息找对应的值信息，这个过程叫映射。Python语言中通过字典类型实现映射。
5.2.2 字典示意图
5.2.3 字典的原理
字典的原理：Python中的字典是根据key查找value所在的位置
5.2.4 创建字典的方式
在 python中创建一个字典对象，常用的方式有两种。
{ } '''第一种方式，使用花括号{}，语法如下所示使用{}创建字典scores = {'张三': 100, '李四': 98, '王五': 45}'''scores = {'张三': 29, '李四': 10, '王五': 40}print(scores) # {'张三': 29, '李四': 10, '王五': 40}print(type(scores)) # <class 'dict'>dict()。 '''第二种方式，使用内置函数dict()。dict即dictionary(字典)的缩写，语法如下所示。字典名 = dict(键1=值1, 键2=值2)'''dic = dict(name='张三', age=20)print(dic) # {'name': '张三', 'age': 20}d = {}print(d) # {}5.2.5 字典元素的获取
根据键key获取字典的值value
# 1.使用 [] 获取scores = {'张三': 29, '李四': 10, '王五': 40}print('张三' in scores) # Trueprint('张三' not in scores) # Falseprint(scores['张三']) # 29 # 2.使用 get()方法print(scores.get('张三')) # 29print(scores.get('柽柳')) # Noneprint(scores.get('麻子', 99)) # 99是在查找 麻子值的（value）不存在时的一个默认值5.2.6 字典的操作函数
Python内置数据结构：字典dict()类源代码：
class dict(object): """ dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2) """ def clear(self): # real signature unknown; restored from __doc__ """ D.clear() -> None. Remove all items from D. """ pass def copy(self): # real signature unknown; restored from __doc__ """ D.copy() -> a shallow copy of D """ pass @staticmethod # known case def fromkeys(*args, **kwargs): # real signature unknown """ Create a new dictionary with keys from iterable and values set to value. """ pass def get(self, *args, **kwargs): # real signature unknown """ Return the value for key if key is in the dictionary, else default. """ pass def items(self): # real signature unknown; restored from __doc__ """ D.items() -> a set-like object providing a view on D's items """ pass def keys(self): # real signature unknown; restored from __doc__ """ D.keys() -> a set-like object providing a view on D's keys """ pass def pop(self, k, d=None): # real signature unknown; restored from __doc__ """ D.pop(k[,d]) -> v, remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised """ pass def popitem(self, *args, **kwargs): # real signature unknown """ Remove and return a (key, value) pair as a 2-tuple. Pairs are returned in LIFO (last-in, first-out) order. Raises KeyError if the dict is empty. """ pass def setdefault(self, *args, **kwargs): # real signature unknown """ Insert key with a value of default if key is not in the dictionary. Return the value for key if key is in the dictionary, else default. """ pass def update(self, E=None, **F): # known special case of dict.update """ D.update([E, ]**F) -> None. Update D from dict/iterable E and F. If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k] """ pass def values(self): # real signature unknown; restored from __doc__ """ D.values() -> an object providing a view on D's values """ pass def __contains__(self, *args, **kwargs): # real signature unknown """ True if the dictionary has the specified key, else False. """ pass def __delitem__(self, *args, **kwargs): # real signature unknown """ Delete self[key]. """ pass def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __getitem__(self, y): # real signature unknown; restored from __doc__ """ x.__getitem__(y) <==> x[y] """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __init__(self, seq=None, **kwargs): # known special case of dict.__init__ """ dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2) # (copied from class doc) """ pass def __iter__(self, *args, **kwargs): # real signature unknown """ Implement iter(self). """ pass def __len__(self, *args, **kwargs): # real signature unknown """ Return len(self). """ pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self<value. """ pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __ne__(self, *args, **kwargs): # real signature unknown """ Return self!=value. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __reversed__(self, *args, **kwargs): # real signature unknown """ Return a reverse iterator over the dict keys. """ pass def __setitem__(self, *args, **kwargs): # real signature unknown """ Set self[key] to value. """ pass def __sizeof__(self): # real signature unknown; restored from __doc__ """ D.__sizeof__() -> size of D in memory, in bytes """ pass __hash__ = None字典类型的一些通用操作函数
| 操作函数 | 描述 |
|---|---|
dict() | 生成一个字典 |
len(d) | 字典d元素的个数（长度） |
min(d) | 字典d中键的最最小值 |
max(d) | 字典d中键的最最大值 |
5.2.7 字典的操作方法
字典类型有一些操作方法，使用的语法格式为：<字典对象名>.<方法名>(<方法参数>)
| 操作方法 | 描述 |
|---|---|
d.keys() | 返回字典d所有键的信息 |
d.values() | 返回字典d所有值的信息 |
d.items() | 返回字典d所有键值对 |
d.get(key, default) | 键存在则返回相应值，否则返回默认值default |
d.pop(key, default) | 键存在则返回相应值，同时删除键值对，否则返回默认值default |
d.popitem() | 随机从字典中取出一个兼职对，以元组(key, value)的形式返回，同时将该键值对从字典中删除。 |
d.clear() | 删除所有的键值对，清空字典 |
5.2.8 字典元素的增删改操作
scores = {'张三': 29, '李四': 10, '王五': 40}
# key的判断scores = {'张三': 29, '李四': 10, '王五': 40}print('张三' in scores) # Trueprint('张三' not in scores) # True# 字典元素的删除del scores['张三'] # 删除指定的键值对print(scores) # {'李四': 10, '王五': 40}# 清空字典 clear（）方法scores.clear()print(scores) # {}# 新增元素scores['陈六'] = 20print(scores) # {'陈六': 20}# 修改valuescores['陈六'] = 100print(scores) # {'陈六': 100}5.2.9 字典视图的获取
获取所有的键，<字典对象名>.keys()方法 返回值为列表 # 获取所有的键 .keys()方法 返回值为列表scores = {'张三': 29, '李四': 10, '王五': 40}print(scores.keys()) # dict_keys(['张三', '李四', '王五'])print(type(scores.keys())) # <class 'dict_keys'>print(list(scores.keys())) # ['张三', '李四', '王五']<字典对象名>.value()方法，返回值为列表 # 获取所有的值 <字典对象名>.value()方法 返回值为列表dict_values = scores.values()print(dict_values) # dict_values([29, 10, 40])print(type(dict_values)) # <class 'dict_values'>print(list(dict_values)) # [29, 10, 40]<字典对象名>.items()方法 返回值为元组 # 获取所有的键值对 返回值为元组print(scores.items())# dict_items([('张三', 29), ('李四', 10), ('王五', 40)])5.2.10 字典元素的遍历
字典元素的遍历：使用for-in循环
# 字典元素的遍历scores = {'张三': 29, '李四': 10, '王五': 40}for item in scores: print(item, scores[item])
5.2.11 字典的特点
1.键 key 不可以重复，值value可以重复
2.字典中元素是无序的
3.字典会浪费大的内存，是一种使用空间换时间的数据结构，但是查询速度快。
5.2.12 字典生成式
内置函数zip() 用于将可迭代对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表
字典生成式:{key: value for key, value in zip(items,prices)} items = ['Fruits', 'Books', 'Others'] # 键的列表prices = [96, 78, 85] # 值的列表d = {items: prices for items, prices in zip(items, prices)} # 两个列表生成一个字典print(d) # {'Fruits': 96, 'Books': 78, 'Others': 85}# .upper()方法 键字母变大写d = {items.upper(): prices for items, prices in zip(items, prices)} # 两个列表生成一个字典print(d) # {'Fruits': 96, 'Books': 78, 'Others': 85}items = ['Fruits', 'Books', 'Others'] # 键的列表prices = [96, 78, 85] # 值的列表a = dict(zip(items, prices))print(a) # {'Fruits': 96, 'Books': 78, 'Others': 85}
5.3 元组
Python组合数据类型——序列类型：元组5.3.1 什么是元组
元组：Python内置的数据结构之一，是一个不可变序列。
不可变序列与可变序列
不变可变序:字符串、元组不变可变序列：没有增、删，改的操作
# 修改后对象地址会发生改变s = 'hello'print(id(s)) # 2533879685808s = s + 'world'print(id(s)) # 2533879671984print(s) # helloworld列表、字典可变序列：可以对序列执行增、删、改操作，对象地址不发生更改
# 可变序列：可以执行增删改操作，对象地址不发生改变lst = [10, 20, 40]print(id(lst))lst.append(50)print(id(lst))
5.3.2 元组的创建方式
直接小括号() # 1.使用（）t = ('python', 'java')print(t) # ('python', 'java')print(type(t)) # <class 'tuple'>tuple() # 2.使用内置函数tuple()t2 = tuple(('java', 'python'))print(t2) # ('java', 'python')print(type(t2)) # <class 'tuple'>,和小括号() # 3.只包含一个元素，需要使用逗号和小括号(只有一个元素的时候必须加上，)t3 = ('hello', )print(t3) # ('hello',)print(type(t3)) # <class 'tuple'># 空元组创建方式t4 = ()t5 = tuple()print('空元组', t4, t5) # 空元组 () ()print('空列表', [], list()) # 空列表 [] []print('空字典', {}, dict()) # 空字典 {} {}# print('空集合', {}, set())为什么要将元组设计成不可变序列
在多任务环境下，同时操作对象时不需要加锁，因此，在程序中尽量使用不可变序列 。
注意事项：元组中存储的是对象的引用
这样设计的原因是，元组的不可变性保证了数据的完整性，这样如果有多个地方都用到了元组，我们可以保证它的数据不会被改变。并且，相较于列表，元组的读取速度更快，占用的内存空间更小，并且可以作为字典的key去使用。
# 这样设计的原因是，元组的不可变性保证了数据的完整性，这样如果有多个地方都用到了元组，我们可以保证它的数据不会被改变。# 并且，相较于列表，元组的读取速度更快，占用的内存空间更小，并且可以作为字典的key去使用。t = (10, [20, 30], 40)print(t) # (10, [20, 30], 40)print(type(t), id(t)) # <class 'tuple'> 2972759079744print(t[0], type(t[0]), id(t[0])) # 10 <class 'int'> 140726042761152print(t[1], type(t[1]), id(t[1])) # [20, 30] <class 'list'> 2972768483776print(t[2], type(t[2]), id(t[2])) # 40 <class 'int'> 140726042762112t[1].append(100)print(t, id(t)) # (10, [20, 30, 100], 40) 29727590797445.3.3 元组的遍历
元组是可迭代对象，所以可以使用for...in进行遍历
# 元组遍历t = ('hello', 'java', 90)print(t[0])print(t[1])print(t[2])for item in t: print(item, end=' ')
列表类型覆盖了元组类型的所有主要功能。
5.4 集合
Python组合数据类型——集合类型：集合什么是集合
Python内置数据结构之一
与列表，字典一样都属于可变序列
集合是没有value的字典
集合中的元素是无序的，元素不可以重复
5.4.1 集合操作符
| 操作符的运算 | 描述 |
|---|---|
S-T | 返回一个新集合，包括在集合S中但不会在集合T中 |
S&T | 返回一个新集合，包括同时在集合S和T中的元素 |
S^T | 返回一个新集合，包括S和T中的非共同元素 |
S|T | 返回一个新集合，包括集合S和T中的所有元素 |
5.4.2 常用集合操作函数或方法
| 函数或方法 | 描述 |
|---|---|
S.add(x) | 如果数据项x不在S中，将x增加到S |
S.remove(x) | 如果x集合在S中，移除该元素；不在则产生KeyError异常 |
S.clear() | 移除S中的数据项 |
len(S) | 返回集合S的元素个数 |
x in S | 如果x是s的元素，返回True；否则返回False |
x not in S | 如果x是s的元素，返回True；否则返回False |
5.4.3 集合的创建方式
使用{} s = {1, 2, 3, 4, 5, 6, 6}print(s)# {1, 2, 3, 4, 5, 6}set() s1 = set(range(1, 7))print(s1)# {1, 2, 3, 4, 5, 6}print(set('python'))# {'p', 'h', 'n', 'o', 't', 'y'}5.4.4 集合元素的判断操作
| 操作函数 | 描述 |
|---|---|
a in s | 如果a是s的元素，返回True；否则返回False |
a not in s | 如果 a不是s的元素，返回True；否则返回False |
# 判断元素是否在集合中s = {10, 20, 30, 40, 50, 100}print(10 in s) # Trueprint(10 not in s) # False5.4.5 集合的新增操作
# 集合元素的新增操作s = {10, 20, 30, 40, 50, 100}s.add(80) # 添加一个元素print(s) # {100, 40, 10, 80, 50, 20, 30}s.update({66, 77, 88}) # 添加多个元素(一次至少添加一个元素 )print(s)# {66, 100, 40, 10, 77, 80, 50, 20, 88, 30}s.update((11, 22, 33))print(s)# {33, 66, 100, 40, 10, 11, 77, 80, 50, 20, 22, 88, 30}5.4.6 集合的删除操作
# 集合元素的删除操作# 1.调用remove方法，一次删除一个指定元素，元素不存在抛异常s.remove(100)print(s)# {33, 66, 40, 10, 11, 77, 80, 50, 20, 22, 88, 30}# 2.调用discard方法，一次删除一个指定元素，元素不存在不抛异常s.discard(300)print(s)# {33, 66, 40, 10, 11, 77, 80, 50, 20, 22, 88, 30}# 3.调用pop方法，一次只删除一个任意元素s.pop()print(s)# {66, 40, 10, 11, 77, 80, 50, 20, 22, 88, 30}# 4.调用clear方法,清空集合s.clear()print(s)# set()六、字符串
Python基本数据类型字符串操作字符串又称为字符序列，根据字符串的内容多少分为单行字符串和多行字符串。
单行字符串可以由一对单引号' '或一对双引号" "作为边界，单引号和双引号的作用相同。当使用单引号时双引号可以作为字符串的一部分，使用双引号时，单引号可以作为字符串的一部分。
多行字符串由一对三单引号''' '''或三双引号""" """作为边界来表示，二者作用相同。
6.1 字符串的驻留机制
6.1.1 字符串
字符串：Python基本数据类型:是一个不可变序列
6.1.2什么叫字符串的驻留机制
仅保存一份相同且不可变字符串的方法，不同的值会被保存在字符串的驻留池中。
Python的驻留机制会对相同的字符串只保留一份拷贝，后续创建相同的字符串时，不会开辟新的空间，而是把字符串的地址付给新创建的变量。
# -*- coding: utf-8 -*-# @File : demo24.py# @author: Flyme awei# @email : 1071505897@qq.com# @Time : 2022/8/11 16:07a = 'python'b = "python"c = '''python'''print(a, id(a))print(b, id(b))print(c, id(c))
6.1.3 字符串驻留机制的几种情况（交互式）
字符串的长度为1符合标识符的字符串（只包含字母，数字，下划线）字符串只在编译是进行驻留，而非运行时[-5,256]之间的整数数字 >>> s1 = ''>>> s2 = ''>>> s1 is s2True>>>>>> s1 = 'a'>>> s2 = 'a'>>> s1 is s2True>>>>>> s1 = 'abc_def'>>> s2 = 'abc_def'>>> s1 is s2True>>> s1 = 'abc%def'>>> s2 = 'abc%def'>>> s1 == s2True>>> s1 is s2False>>>>>> a = 256>>> b = 256>>> a is bTrue>>> a = 257>>> b = 257>>> a is bFalse>>> a == bTrue>>> 6.1.4 强制2个字符串指向同一个对象
sys中的intern方法强制两个字符串指向同一个对象
'''sys中的intern方法强制两个字符串指向同一个对象'''import sysa = 'abc%'b = 'abc%'print(a is b) # Truea = sys.intern(b)print(id(a), id(b)) # 2989905230512 2989905230512PyCharm对字符串进行了优化处理 。
6.1.5 字符串驻留机制的优缺点
当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。
在需要进行字符串拼接时建议使用 str类型的join方法，而非+ ,因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比"+"效率高 。
6.2 字符串类型的操作
6.2.1 字符串操作符
| 操作符 | 描述 |
|---|---|
+ | x+y,连接两个字符串x和y |
* | x*n或n*x,复制n次字符串x |
in | x in s,如果x是s的字串，返回True,否则返回False |
6.2.2 字符串处理函数
| 函数 | 描述 |
|---|---|
len(x) | 返回字符串x的长度，也可返回其它组合数据类型元素的个数 |
str(x) | 返回任意类型x所对应的字符串形式 |
char(x) | 返回Unicode编码x对应的单字符 |
ord(x) | 返回x表示的Unicode编码 |
hex(x) | 返回整数x对应十六进制的小写形式字符串 |
oct(x) | 返回整数x对应八进制的小写形式字符串 |
6.2.3 字符串处理方法
| 方法 | 描述 |
|---|---|
s.lower() | 字符串s全部转为小写 |
s.upper() | 字符串s全部转为大写 |
s.split(sep=None) | 返回一个列表，由s根据sep被分割的部分构成，省略sep默认以空格分割 |
s.count(sub) | 返回字串sub出现的次数 |
s.replace(old, new) | 返回字符串s的副本，所有old字串被替换为new |
s.center(width, fillchar) | 字符串居中函数，fillchar参数可选 |
s.strip(chars) | 从字符串s中去掉咋其左侧和右侧chars中出现的字符 |
s.join(iter) | 将iter变量的每一个元素增加一个s字符串 |
6.2.4 字符串的查询操作
| 方法名称 | 作用 |
|---|---|
index() | 查找字串substr第一次出现的位置，如果查找的字串不存在，抛ValueError异常 |
rindex() | 查找字串substr最后一次出现的位置，如果查找的字串不存在，抛ValueError异常 |
find() | 查找字串substr第一次出现的位置，如果查找的字串不存在，返回-1 |
rfind() | 查找字串substr最后一次出现的位置，如果查找的字串不存在，返回-1 |
'''index（）查找第一次出现的位置 抛异常rindex（）查找最后一次次出现的位置 抛异常find（）查找第一次出现的位置 不抛异常，返回值为-1rfind（）查找最后一次出现的位置 抛异常'''s = 'hello,hello'print(s.index('o'))print(s.rindex('o'))print(s.find('lo'))print(s.find('ui')) # -1
6.2.5 字符串大小写转换操作
| 方法 | 作用 |
|---|---|
upper() | 把所有的字符串转换为大写字母 |
lower() | 把所有的字符串转换为小写字母 |
swapcase() | 将大写字符转换为小写字符，将小写字符转换为大写字符。 |
capitalize() | 使第一个字符为大写字母，其余字符为小写字母 |
title() | 返回字符串的一个版本，其中每个单词都有标题。更具体地说，单词以大写字母开头，其余都以大写字母开头区分大小写的字符小写。 |
# 字符串的大小写转换# 1.upper（）把字符串中的所有字符转为大写# 2.lower（）把字符串中的所有字符都转换为小写# 3.swap case() 大转小，小转大# 4.capitalize()把第一个字符转为大写，其余字符转为小写# 5.title（）把字符串首字母转换为大写，把剩余的转换为小写s = 'hellopython'print(s.upper()) # 转大写print(s.lower()) # 转换后id改变，会产生一个新的空间print(s.swapcase())print(s.capitalize())print(s.title())
6.2.6 字符串内容对齐操作方法
| 方法 | 作用 |
|---|---|
center(width,'') | 返回一个居中长度为width的字符串。使用指定的填充字符(默认为空格)填充。 |
ljust(width,' ') | 返回长度为width的左对齐字符串。使用指定的填充字符(默认为空格)填充。 |
rjust(width,' ') | 返回长度为width的右对齐字符串。使用指定的填充字符(默认为空格)填充。 |
zfill('int') | 在左侧填充数字字符串，以填充给定宽度的字段。字符串永远不会被截断。 |
'''字符串的对其操作'''# 1.center 居中对齐s = 'hello,python'print(s.center(100, '*'))# 2.ljust 左对齐print(s.ljust(100, '*'))# 3.rjust 右对齐print(s.rjust(100, '*'))# 3.zfill 右对齐，左侧为0填充print(s.zfill(100))
6.2.7 字符串的劈分操作
| 方法 | 作用 |
|---|---|
split() | 返回字符串中的单词列表，使用sep作为分隔符字符串。sep用来分割字符串的分隔符。None(默认值)表示根据任何空格进行分割，并从结果中丢弃空字符串。maxsplit最大分割次数。-1(默认值)表示无限制。 |
rsplit() | 返回字符串中的单词列表，使用sep作为分隔符字符串。sep用来分割字符串的分隔符。None(默认值)表示根据任何空格进行分割，并从结果中丢弃空字符串。maxsplit最大分割次数。-1(默认值)表示无限制。劈叉从绳子的末端开始，一直到前面。 |
# 字符串的劈分操作 split# 1. split从字符串左侧开始分割，默认值为空格字符串，返回值是一个列表# 以通过参数sep指定劈分字符串是劈分符# 通过maxsplit指定劈分字符串的最大劈分次数s = 'hello#world#python'lst = s.split('#')print(lst)s1 = 'hello|world|python'print(s1.split())print(s1.split(sep='|'))print(s1.split())s1 = 'hello|world|python'print(s1.split())print(s1.split(sep='|', maxsplit=1))# 以参数sep 指定劈分字符串是劈分符print('-----------------------')# 2.rsplit 从右侧开始劈分print(s1.rsplit(sep='|', maxsplit=1))
6.2.8 判断字符串的方法
| 方法 | 作用 |
|---|---|
isidentifier() | 判断字符串是合法标识符 |
isspace() | 判断字符串是否全部由空字符串组成（回车，换行，水平制表） |
isalpha() | 判断是否全部由字符组成 |
isdecimal() | 判断是否全部由十进制数字组成 |
isnumeric() | 判断是否全部由数字组成 |
isalnum() | 判断字符串是否全部由字母和数字组成 |
# 1. isidentifier 判断字符串是合法标识符s = 'hello, python'print('1.', s.isidentifier()) # Falseprint('2.', 'hello'.isidentifier()) # True# 2. isspase 判断字符串是否全部由空字符串组成（回车，换行，水平制表）print(' '.isspace())print('-----------------------')# 3. isalpha 判断是否全部由字符组成print('fhaisdfh'.isalpha())# 4. isnumeric 判断是否全部由数字组成print('67867'.isnumeric())# 5. isdecimal 判断是否全部由十进制数字组成print('78'.isdecimal())# 6. iszlnum 判断字符串是否全部由字母和数字组成print('yut6786'.isalnum())
6.2.9 字符串的替换与合并操作
| 方法 | 作用 |
|---|---|
replace() | 返回一个副本，其中所有出现的子字符串old都被new替换。count替换的最大次数。-1(默认值)表示替换所有匹配项。如果给出了可选参数count，则只出现第一个count更换。 |
join() | 连接任意数量的字符串。调用其方法的字符串被插入到每个给定字符串之间。结果以新字符串的形式返回。例如: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs' |
# 1.字符串的替换 replace（）s = 'hello,Python'print(s.replace('Python', 'java'))s1 = 'hello,python,python,python'print(s1.replace('python', 'java', 2)) # 通过第三个参数指定最大替换次数# 2.字符串合并 join（） 将列表或元组中字符串合并成一个字符串lst = ['hello', 'java', 'python']print('|'.join(lst))print(''.join(lst))t = ('hello', 'java', 'python')print(''.join(t))
6.2.10 字符串的比较运算
两个字符串进行比较时，比较的是ordinal value （原始值) ，如果相等则继续比较下一个字符，知道两个字符串不相等
| 运算符 | 含义 |
|---|---|
| > | 大于 |
| < | 小于 |
| == | 等于 |
| >= | 大于等于 |
| <= | 小于等于 |
| != | 不等于 |
# 字符窜的比较# 运算符 > < == <= >= !=print('apple' > 'app') # Trueprint('apple' > 'banana')'''调用内置函数ord可以得到指定字符的ordinal value '''print(ord('a'), ord('b'))print(ord('刘'), ord('张'))'''== 与 is 的区别'''# == 比较的是 value# is 比较的是 ida = b = 'pthon'print(a is b)print(a == b)
6.2.11 字符串的切片操作
对字符串中某个子串或区间的检索称为切片。
语法如下：
字符串或字符串变量[N:M]
切片获取字符串N到M（不包含M）的子字符串，其中，N和M为字符串的索引序号，可以混合使用正向递增序号和反向递减序号。切片要求N和M 都在字符串的索引区间，如果N大于M，则返回空字符串。如果N缺失，则默认将N设为0；如果M缺失，则默认表示到字符串结尾。
# 字符串的切片操作# 字符串是不可变类型 不能进行 增 删 改 操作# 切片将产生新的对象s = 'hello,python'# print(s[start : end : step])print(s[3])print(s[:3])print(s[:3:2])print(s[::-1]) # 默认从字符串最后一个语速开始切，到字符串第一个元素结束
6.2.12 格式化字符串
为什么要格式化字符串在字符串中整合变量是需要使用字符串的格式化方法。
字符串格式化用于解决字符串和变量同时输出的格式安排问题。
%作为占位符
{}作为占位符’'.format()
f ‘我叫%s，今年%d岁了’ %s 占了一个字符串 %d 占了一个整数
s = "python"
<填充><对齐><宽度> | 符号 | 描述 |
|---|---|
{:25}.format(s) | 默认左对齐 |
{:1}.format(s) | 指定宽度为1，不足变量s的宽度，以实际变量宽度为准 |
{:^25}.format(s) | 居中对齐 |
{:>25}.format(s) | 右对齐 |
{:*^25}.format(s) | 居中对齐，填充*号 |
{:+^25}.format(s) | 居中对齐填充+号 |
{:^1}.format(s) | 指定宽度为1，不足变量s的宽度，以实际变量宽度为准 |
<,><.精度><类型>,其中，逗号(,)用于显示数字类型的千分位分隔符。 | 符号 | 描述 |
|---|---|
"{:-^25,}".format(1234567890) | '------1,234,567,890------' |
"{0:-^25}".format(1234567890) | '-------1234567890--------' |
<.精度>有小数点(.)开头。 | 符号 | 描述 |
|---|---|
"{:2f}".format(12345.6788890) | '12345.67' |
"{:25.3f}".format(12345.67890) | ' 12345.679' |
"{:.5}".format("123456789") | '12345’ |
"{:.15)".format('123456789') | '123456789' |
# 格式化字符串name = '张三'age = 20print('我叫%s,今年%d岁了' % (name, age)) # % 作为占位符print('我的名字是{0}，我今年{1}岁了'.format(name, age)) # {} 作为占位符print(f'我叫{name}，今年{age}岁')# 表示宽度 %10dprint('%10d' % 99)# 表示小数点位数 %.nf 精度 :.nprint('%.3f' % 3.78234685) # 三位小数print('{:.3}'.format(3.34638567)) # 三位有效数字
6.2.13 数值与字符串类型转换函数
| 函数 | 描述 |
|---|---|
int(x) | 将x转换为整数，x可以是浮点数或数字类字符串 |
folat(x) | 将x转换为浮点数，x可以是整数或数字类字符串 |
str(x) | 将x转换为整数，x可以是整数或浮点数 |
6.3 字符串编码转换
6.3.1 为什么要进行字符串编码转换
6.3.2 编码与解码的方式
编码：s.encode()将字符串转换为二进制数据(bytes)
解码：s.decode()将bytes类型的数据转换成字符串类型
s = '人生苦短，我用Python！'# 编码print(s.encode(encoding='utf_8')) # utf-8 一个中文占两个字节print(s.encode(encoding='GBK')) # GBK 一个中文占三个字节# 解码byte = s.encode(encoding='GBK') # 编码print(byte.decode(encoding='GBK')) # 解码# 编码和解码格式要相同
七、函数和代码复用
Python函数和代码复用7.1 函数的定义
语法格式：
def 函数名 ([参数列表]): 函数体 return 返回值列表 例：
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/14 17:02def calc(a, b): # 函数定义 c = a + b return c7.2 函数的调用
函数的定义也叫函数“声明”，定义后的函数不能直接运行，需要经过“调用”才能得到运行。
语法格式：
函数名(实际赋值参数列表)# 函数创建def calc(a, b): # 函数定义 c = a + b return c'''函数调用:函数名（实际参数列表）'''d = calc(10, 20) # 函数调用print(d) # 307.3 函数的参数传递
函数的参数在定义时可以指定默认值，当函数被调用时，如果没人传入对应的参数时，则使用函数定义时的默认值替代。
语法格式
def 函数名(非可选参数列表,可选参数列表=默认值): 函数体 return 返回值列表 7.3.1 形式参数与实际参数
函数定义处的参数称为形式参数函数调用处的参数称为实际参数7.3.2 位置传参与关键字传参
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/14 17:02# 函数的参数传递'''1.位置传参 根据形参对应的位置进行参数传递2.关键字实参 根据形参名称进行参数传递'''def calc(a, b): # a b 为函数定义当处的形式参数 c = a + b return ccalc(10, 20) # 10 20 为函数调用处的实际参数# 位置实参print(calc(10, 20)) # =左侧的变量的名称称为关键字参数print(calc(b=10, a=20)) 
7.3.3 可变对象与不可变对象的参数传递
在函数调用过程中，进行参的传递:
如果是不可变对象，函数体的修改不会影响实参的值若果是可变对象，函数体的改变会影响到实参的值# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/14 17:02'''在函数调用过程中，进行参的传递:如果是不可变对象，函数体的修改不会影响实参的值若果是可变对象，函数体的改变会影响到实参的值'''def fun(arg1, arg2): print('arg1=', arg1) print('arg2=', arg2) arg1 = 100 # arg1 的修改为100不会影响n1的值 arg2.append(200) # are2 的修改会影响到n2的值 print('arg1=', arg1) # 100 print('arg2=', arg2) # [10, 20, 200] return arg1, arg2a = 10b = [10, 20]print('a', a) # 10print('b', b) # [10, 20]x = fun(a, b) # 位置传参 arg1，arg2时是函数定义处的形参，n1，n2是函数调用处的实参， 实参和形参的名称可以不一致print(a) # 10print(b) # [10, 20, 200]print(x) # (100, [10, 20, 200])
7.3.4 个数可变的位置、关键字参数
个数可变的位置参数：*arges 参数定义时，可能无法事先确定传递的位置实参的个数，使用可变的位置参数
个数可变的关键字形参：**kwargs 参数定义时，可能无法事先确定传递的位置实参的个数，使用可变的位置参数
在一个函数的定义过程中，既有个数可变的 *arges位置形参，又有个数可变的**kwargs关键字形参，要求把位置形参放在前面
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/14 17:02# 个数可变的位置参数 *arges# 参数定义时，可能无法事先确定传递的位置时参的个数，使用可变的位置参数def fun(*args): # 函数定义时，可变的位置参数 print(args) # 返回值为元组 # print(args[0]) 返回元组的第1个对象fun(10) # (10, )fun(10, 20) # (10, 20)fun(11, 22, 33) # (11, 22, 33)# 个数可变的关键字形参# 参数定义时，可能无法事先确定传递的位置是参的个数，使用可变的位置参数def fun(**kwargs): print(kwargs) # 返回值是 字典fun(a=10) # {'a': 10}fun(a=10, b=20, c=30) # {'a': 10, 'b': 20, 'c': 30}'''def fun2(*args,*a) pass以上程序报错，个数可变的的位置参数值能有一个def fun2(**kwargs) pass个数可变的关键字参数也只能有一个'''# 在一个函数的定义过程中，既有个数可变的位置形参，又有个数可变的关键字形参，要求把位置形参放在前面def fun(*args, **kwargs): pass 
7.3.5 函数参数总结(一）
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/14 17:02def fun(a, b, c): # a,b,c在函数定义处，所以是形式参数 print('a=', a) print('b=', b) print('c=', c)# 函数调用fun(10, 20, 30) # 函数调用时的参数传递，称为位置传参lst = [11, 22, 33]fun(*lst) # 函数调用，将列表中的每个元素都转换为位置实参传递fun(a=100, b=200, c=300) # 函数调用，所以是关键字实参dic = {'a': 111, 'b': 222, 'c': 333}print(fun(**dic)) # 函数调用时，将字典中的键值对都转换为关键字实参传递
7.3.6 函数参数总结(二）
def fun(a, b=10): # a是形式参数 print('b=', b)def fun2(*args): # 个数可变的位置形参 print(args)def fun3(**kwargs): # 个数可变的关键字形参 print(kwargs)# 函数调用fun(10)fun(10, 20)fun2(10, 20, 30)fun3(a=10, b=20)print('--------------------------')def fun4(a, b, *, c, d): # 需求 c,d 只能采用关键字实参传递 print('a=', a) print('b=', b) print('c=', c) print('d=', d)# fun4(10, 20, 30, 40) # 位置实参传递fun4(a=10, b=20, c=30, d=40) # 关键字实参传递print('--------------------------')fun4(10, 20, c=30, d=40) # 前面两个进行位置实参传递，后面两个采用关键字实参传递''' 函数定义时的形参顺序问题'''def fun5(a, b, *, c, d, **kwargs): passdef fun6(*args, **kwargs): passdef fun7(a, b=10, *args, **kwargs): pass
7.4 函数的返回值
return语句用来结束函数并将程序返回到函数调用的位置继续执行。return语句可以出现在函数中的任何部分，同时可以将0个、1个或多个函数运算的结果返回给函数被调用处的变量。
函数的返回值
如果没有返回值(函数执行完毕后，不需要给调用处提供数据)，return可以省略不写若果返回值为1个，直接返回类型原类型如果返回值为多个，返回结果为元组 # -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/14 17:02'''函数的返回值:（1）如果没有返回值(函数执行完毕后，不需要给调用处提供数据)，return可以省略不写（2）若果返回值为1个，直接返回类型原类型（2）如果返回值为多个，返回结果为元组'''def fun(lst): odd = [] even = [] for i in lst: if i % 2: odd.append(i) else: even.append(i) print(odd, even) return odd, even # 没有返回值，可以省略 如果返回值为多个，返回结果为元组lst1 = [12, 34, 45, 57, 67, 78, 89]print(lst1)# 函数调用print(type(fun(lst1)))'''函数定义时，是否需要返回值，视情况而定'''
7.5 变量的作用域
变量的作用域：程序代码能访问该变量的区域
局部变量：在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会变成全局变量
全局变量：函数体外定义的变量，可作用于函数内外
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/14 17:02# 变量的作用域:程序代码能访问该变量的区域'''1.局部变量 在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会变成全局变量2.全局变量 函数体外定义的变量，可作用于函数内外'''def fun(a, b): c = a+b # c,在函数内定义的变称为局部变量 a,b为函数的形参，作用范围也在在函数内部，相当于局部变量 print(c)name = '阿伟' # 函数外部定义的变量，全局变量，函数体内外都可以使用print(name) # 阿伟def fun2(self): print(name)# 函数调用fun2(name) # 阿伟def fun3(): # 函数定义 global age # 函数内部定义的变量，局部变量 使用global声明，变量就变为全局变量 print(age) # 20age = 20fun3() # 函数调用print(age) # 20
7.6 代码复用
函数是程序的一种基本抽象方式，它将一系列代码组织起来通过命名供其他程序使用。函数封装的直接好处是代码复用，任何其他代码只要输入参数即可调用函数，从而避免相同功能的代码在被调用处重复编写。代码复用有另一个好处，当更新函数功能时，所有被调用处的功能都被更新。
程序由一系列代码组成，如果代码是顺序但无组织的，不仅不利于阅读和理解，也很难进行升级和维护。当程序长度在百行以上，如果不划分模块，程序的可读性就已经很糟糕了。解决这一问题最好的方法是将一个程序分割成短小的程序段，每一段程序完成一个小的功能。使用函数对合理划分为功能模块，并基于模块设计程序是一种常用方法，被称为“模块化设计”。
模块化设计是指函数的封装功能将程序划分成主程序、子程序和子程序间关系的表达。模块化设计是使用函数设计的思考方法， 以功能块为基本单位，一般有两个基本要求：
紧耦合：尽可能合理划分功能块，功能块内部耦合紧密；松耦合：模块间关系尽可能简单，功能块之间耦合度低。 使用函数只是模块化设计的必要非充分条件，根据计算需求合理划分函数十分重要。一般来说，完成特定功能或被经常复用的一组语句应该采用函数来封装，并尽可能减少函数间参数和返回值的数量。
7.7 递归函数
7.7.1 什么是递归函数
如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数。
7.7.2 递归的组成部分
递归调用与递归终止条件 。
7.7.3 递归的调用过程
每递归调用一次函数，都会在栈内存分配一个栈帧，每执行完一次函数，都会释放相应的空间。
7.7.4 递归的优缺点
缺点：占用内存多，效率低下；
优点：思路和代码简单。
# 1.使用递归函数计算阶乘def fun(n): # 阶乘函数 if n == 1: return 1 elif n == 2: return 2 else: return n * fun(n-1)print(fun(6)) # 720# 2.斐波那契数列 1 1 2 3 5 8 13 ...def fib(n): # 斐波那契函数 if n == 1: return 1 elif n == 2: return 1 else: return fib(n - 1) + fib(n - 2) # 求斐波那契数列的第 n 项print(fib(6), end=' ') # 8八、异常处理机制
Python异常处理机制 Python程序一般对输入有一定要求，但当实际输入不满足程序要求时，可能会产生程序的运行错误。
8.1 Bub的由来及分类
8.1.1 Bug的由来
世界上第一部万用计算机的进化版-马克2号(Mark II)
1945年9月9日，下午三点。哈珀中尉正领着她的小组构造一个称为“马克二型”的计算机。这还不是一个完全的电子计算机，它使用了大量的继电器，一种电子机械装置。第二次世界大战还没有结束。哈珀的小组日以继夜地工作。机房是一间第一次世界大战时建造的老建筑。那是一个炎热的夏天，房间没有空调，所有窗户都敞开散热。
突然，马克二型死机了。技术人员试了很多办法，最后定位到第70号继电器出错。哈珀观察这个出错的继电器，发现一只飞蛾躺在中间，已经被继电器打死。她小心地用摄子将蛾子夹出来，用透明胶布帖到“事件记录本”中，并注明“第一个发现虫子的实例。”
从此以后，人们将计算机错误戏称为虫子（bug），而把找寻错误的工作称为（debug）。
8.1.2 Bug常见类型
粗心导致的错误1.漏了末尾的冒号： if 循环语句、 else 语句等
2.缩进错误
3.英文符号写为中文符号
4.把字符串str和数字凭借在一起
5.while循环没有定义变量
6.比较运算符 == 和赋值运算符 = 混用
age = int(input('请输入年龄:')) # input函数返回值为str类型if age > 18: print('成年了')1.index索引越界
2.列表方法lst.append
# 索引越界lst = [1, 2, 3, 4]# print(lst[4])print(lst[3]) # 4# append()方法使用不熟练lst = []# lst = append(1, 2, 3)lst.append(1) # 每次只能添加一个元素# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei# @email : Flymeawei@163.com# @Time : 2022/8/15 10:22# 思路不清晰导致的问题 基础知识不牢固，练练练!!!lst = [{'rating': [9.7, 2062397], 'id': '1292052', 'type': ['犯罪', '剧情'], 'title': '肖申克的救赎', 'actors': ['蒂姆·罗宾斯', '摩根·弗里曼']}, {'rating': [9.6, 1528760], 'id': '1291546', 'type': ['剧情', '爱情', '同性'], 'title': '霸王别姬', 'actors': ['张国荣', '张丰毅', '巩俐', '葛优']}, {'rating': [9.5, 1559181], 'id': '1292720', 'type': ['剧情', '爱情'], 'title': '阿甘正传', 'actors': ['汤姆·汉克斯', '罗宾·怀特 ']} ]name = input('请输入你要查询的演员:')for item in lst: # 遍历列表lst -->{} item是一个又一个的字典 act_lst = item['actors'] # 通过item字典中的键actors获取值演员列表 for actor in act_lst: # 遍历演员列表 if name in actor: print(name, '出演了', item['title'])
除零异常
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 10:22a = int(input('请输入第一个整数:'))b = int(input('情书如第二个整数:'))result = a/b # 注意:0不可以做除数print('输出结果为:', result)
解决办法
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 10:22try: a = int(input('请输入第一个整数:')) b = int(input('请输如第二个整数:')) result = a / b # 注意:0不可以做除数 print("{}除{}等于{}".format(a, b, result))except ZeroDivisionError as error: print(error)
8.2 异常处理
Python提供了异常处理机制，可以在异常出现时即时捕获，然后内部“消化”，让程序继续运行
8.2.1 try-exception语句
try: ... 可能会出异常的代码 ... ...except xxx(异常类型): ... 异常处理代码 ... ...# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 10:22try: a = int(input('请输入第一个整数:')) b = int(input('请输如第二个整数:')) result = a / b # 注意:0不可以做除数 print('输出结果为:', result)except ZeroDivisionError: print('对不起，除数不能为0')print('程序结束')
8.2.2 多个except语句
try: ... 可能会出异常的代码 ... ...except Exception1: ... 异常处理代码 ... ...except Exception2: ... 异常处理代码 ... ...except BaseException: ... 异常处理代码 ... ...# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 10:22try: a = int(input('请输入第一个整数:')) b = int(input('请输如第二个整数:')) result = a / b # 注意:0不可以做除数 print('输出结果为:', result)except ZeroDivisionError: print('对不起，除数不能为0')except ValueError: print('对不起，只能输入数字串')print('程序结束')正常输出：
除零异常：ZeroDivisionError
值错误：ValueError
8.2.3 try-except-else结构
如果 try中没有抛出异常，则执行else块；如果try中抛异常，则执行except块，else块不执行。
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 10:22# 如果 try中没有抛出异常，则执行else块，如果try中抛异常，则执行except块try: a = int(input('请输入第一个整数:')) b = int(input('情书如第二个整数:')) result = a / b # 注意:0不可以做除数except BaseException as e: print('出错了', e)else: print('计算结果为', result)
8.2.4 try-except-else-finally结构
finally 无论是否发生异常都会被执行，常用来解释try块中申请的资源
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 10:22'''try except else finally 结构finally 无论是否发生异常都会被执行，能常用来解释try块中申请的资源'''try: a = int(input('请输入第一个整数:')) b = int(input('请输入第二个整数:')) result = a / bexcept BaseException as e: print('出错了', e)else: print('结果为:', result)finally: print('谢谢你的使用')print('程序结束')
8.2.5 traceback模块
使用traceback模块打印异常信息
# -*- coding: utf-8 -*-# @File : 8.trackback模块.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 16:01import tracebacktry: print(520) print(1 / 0)except: traceback.print_exc()
8.3 Python常见异常类型
| 异常 | 描述 |
|---|---|
ZeroDivisionError | 除零异常 |
IndexError | 列表中没有次索引(index) 注:索引从零开始 |
KeyError | 映射中没有这个键 dic['key'] |
NaneError | 未声明/初始化对象 (没有属性) |
SyntaxError | Python语法错误 |
ValueError | 传入无效参数 |
8.4 PyCharm程序调试
先看一段代码：
# -*- coding: utf-8 -*-# @File : PyCharm程序的调试.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 16:46i = 1while i < 2: print(i)
8.4.1 断点
程序运行到此处，暂时挂起，停止执行。此时可以详细观察程序的运行情况，方便做出进一步的判断。
8.4.2 调试
进入调试视图的三种方式：
(1)单击工具栏上的按钮
(2)右键单击编辑区：点击：debug’模块名’
(3)快捷键：shift+F9
九、类和对象
Python类和对象9.1 两大编程思想
9.1.1 面向过程
面向过程:事物比较简单，可以用线性思维取解决（宏观上）
9.1.2 面向对象
面向对象:事物比较复杂，使用简单线性思维无法解决（细节上）
共同点:面向过程和面向对象都是解决实际问题的一种思维方式
二者相辅相成，并不是独立的,解决复杂问题，通过面向对象便于我们从宏观上把握事物之间复杂关系，方便我们分析整个系统；具体到微观操作，仍然使用面向过程来处理
9.2 类和对象
9.2.1 类
类(class):多个类似事物组成的群体统称，能够帮我们快速理解和判断事物的性质。
数据类型:
1.不同数据类型属于不同的类
2.使用内置函数type查看数据类型
9.2.2 对象
对象(object)：类的具体化 Python中一切皆对象，创建对象称为类的实例化
9.2.3 类的创建
创建类的语法：
class 类名: pass类的组成:
self静态方法 使用@staticmethod修饰，使用类名直接访问的方法类方法 使用@calassmethod修饰，使用类名直接访问的方法 类的创建：
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 21:24# 类的创建class Student: # Student 类名 由一个或多个单词组成，每个单词首字母大写，其余字母小写 Student称为类对象 native_pace = '天津' # 类属性 name = '李华' # 直接写在类里的变量（类中方法外的变量），称为 类属性：类中方法外的变量，被该类的所有对象所共享 age = 30 # 类属性 def __init__(self, name, age): # 初始化方法方法 self.name = name # self.name 称为实例属性，进行了一次赋值操作，将局部变量name的值赋给实例属性 self.age = age def eat(self): # 实例方法 方法必须有第一个形参，通常叫做 'self' print('学生在吃饭') @staticmethod # 静态方法 def se(): # 在静态方法中不能写 self print('静态方法') @classmethod # 类方法 def cm(cls): print('类方法')# Python中一切皆对象，类Student也是对象print(id(Student)) # 有内存空间print(type(Student)) # 类型print(Student) # 值
9.2.4 对象的创建
对象的创建又称类的实例化
意义:有了实例 就可以调用类中的内容
语法:
实例名(对象名) = 类名()# 创建对象stu1 = Student('张三', 20) # # 创建Student类的对象 stu1叫做实例对象# 对象三要素print(id(stu1)) # id标识print(type(stu1)) # type类型print(stu1) # value值9.2.5 方法调用
类属性，类方法，静态方法都是使用类名.方法名调用
实例方法采用对象名.方法名调用
# 调用方法stu1.eat() # 对象名.方法名 调用Student类中的eat方法print(stu1.name)print(stu1.age)stu1.eat() # 对象名.方法() stu1-->实际上就是方法定义处的self 调用Student类中的eat方法print('----------类属性的使用方式----------')print(Student.name)stu2 = Student('张三', 20)stu3 = Student('李四', 20)print(Student.native_pace)Student.native_pace = '吉林'print(stu2.native_pace)print(stu3.native_pace)print(stu2.name, stu2.age)print(stu3.name, stu3.age)print('----------类方法的使用方式----------')Student.cm()print('----------静态方法的使用方式----------')Student.se()
9.2.6 为对象动态绑定属性和方法
动态绑定属性：对象名.属性 = "值"
动态绑定方法：对象名.方法名 = 方法名
# -*- coding: utf-8 -*-# @File : 动态绑定属性和方法.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 22:25class Student: def __init__(self, name, age): # 初始化方法 self.name = name # 将局部变量 name的值赋给实例属性self.name,为所有对象所共享 self.age = age # 局部变量 age的值赋给实例属性self.age def eat(self): # 实例方法 print("{}在吃饭".format(self.name))# 创建对象stu1 = Student('张三', 18)stu2 = Student('李四', 20)print(id(stu1)) # 2502200745408print(id(stu2)) # 2502201262576print("------------为对象stu1动态绑定性别属性----------")stu1.gender = '女'print(stu1.name, stu1.age, stu1.gender) #张三 18 女print(stu2.name, stu2.age) # 李四 20stu1.eat()stu2.eat()def fun(): # 在类外面定义函数fun print('定义在类外的称为函数')print("-----------为stu1动态绑定方法-----------")stu1.fun = funstu1.fun()# stu2.fun()
十、面向对象三大特征
Python面向对象三大特征10.1封装
封装：将属性和方法包装到类对象中，在方法内部对属性进行操作，在类对象外部调用方法。
代码实现：
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 23:27# 封装:提高程序的安全性# 将属性和方法包装到类对象中# 在方法内部对属性进行操作，在类对象外部调用方法class Car: def __init__(self, brand): self.brand = brand # 实例属性 @staticmethod def start(): # 静态方法 print('汽车已启动...')car = Car('奥迪A8')car.start()print(car.brand)
如果不希望实例属性在类的外部被使用，可以在前面加上两个下划线"_"
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 23:27class Student: def __init__(self, name, age): self.name = name self.__age = age # 如果不希望实例属性在类的外部被使用，所以在前面加上两个下划线 def show(self): return self.name, self.__age @staticmethod def eat(): print('吃')stu1 = Student('李华', 20)stu1.show() # 调用方法print(dir(stu1)) # 查看对象可以用的属性print('-------------')print(stu1.name, stu1._Student__age) # 在类外部通过_Student__age访问实例属性self.__agestu1.eat()
10.2继承
继承:子类可以继承父类的属性和方法，提高代码的复用性。
如果一个对象没有继承任何类，则默认继承object类
语法格式:
class 子类名(父类1，父类2，...): pass代码实现：
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 23:27class Person(object): def __init__(self, name, age): self.name = name self.age = age def info(self): print(self.name, self.age)class Student(Person): def __init__(self, name, age, stu_nb): super(Student, self).__init__(name, age) # 继承父类的属性 self.stu_nb = stu_nb # 新增属性 def __str__(self): return self.name, self.age, self.stu_nbclass Teach(Person): def __init__(self, name, age, teach_of_year): super(Teach, self).__init__(name, age) self.teach_of_year = teach_of_yearstudent = Student('张三', 20, '1001') # 创建对象teacher = Teach('杨老师', 34, 10)student.info()teacher.info()print(student.__str__())print(student.stu_nb)print(teacher.teach_of_year)
10.2.1 方法重写
如果子类对继承自己父类的某个属性不满意，可以在子类对其（方法体）进行重新编写。
子类重写后的方法通过 super().方法名() 调用父类中被重写的方法。
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 23:27# 如果子类对继承自己父类的某个属性不满意，可以在子类对其（方法体）进行重新编写# 子类重写后的方法通过 super()...方法名() 调用父类中被重写的方法class Person(object): def __init__(self, name, age): self.name = name self.age = age def info(self): print(self.name, self.age)class Student(Person): def __init__(self, name, age, stu_nb): super(Student, self).__init__(name, age) self.stu_nb = stu_nb def info(self): # 方法重写 super().info() # 调用父类中方法 print(f'学号:{self.stu_nb}') # f''格式化字符串class Teach(Person): def __init__(self, name, age, teach_of_year): super(Teach, self).__init__(name, age) self.teach_of_year = teach_of_year def info(self): # 方法重写 super().info() print('教龄{0}'.format(self.teach_of_year)) # 格式化字符串student = Student('张三', 20, '1001')teacher = Teach('杨老师', 34, 10)student.info()print('-----------------')teacher.info()
10.2.2 object类
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 23:27'''object 类是所有类的父类，所有类都有object类的属性和方法内置函数dir（）可以查看指定对象所有属性Object有一个__str__方法，用于返回一个对于”对象的描述对应内置函数str（）通常用于print（）方法，帮我们查看对象的信息，所以经常会对__str__进行重写“'''class Student(object): def __init__(self, name, age): self.name = name self.age = age def __str__(self): # 重写父类object中的方法 return '我的名字是{0}，今年{1}岁了'.format(self.name, self.age)stu = Student('张三', 20)print(dir(stu)) # 查看stu这个对象的所有属性和方法 从object类中继承的print(stu) # 默认调用__str__()这样的方法 输出:我的名字是张三，今年20岁了print(type(stu)) # <class '__main__.Student'> Student类型
10.2.3 多重继承
一个子类可以有多个“直接父类”，这样，就具备了“多个父类”的特点，通过类的特殊属性__mro__ 可以查看类的组织结构。
定义子类时，必须在其构造函数中调用父类的构造函数
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 23:27# 多继承class A(object): passclass B(object): passclass C(A, B): pass10.3多态
多态:多态就是具有多种形态，即便不知道一个变量所引用的对象是什么类型，仍然可以使用这个变量调用方法，在运行过程中根据变量所引用的对象类型，动态决定调用那个对象中的方法。
代码实现：
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 23:27''' 多态:多态就是具有多种形态，即便不知道一个变量所引用的对象是什么类型，仍然可以使用这个变量调用方法，在运行过程中根据变量所引用的对象类型，动态决定调用那个对象中的方法'''# 动态语言多崇尚鸭子类型，当一只鸟走起来向鸭子，游起来以向鸭子，看起来也像鸭子，那么这只鸟及可以被称为鸭子class Animal(object): def eat(self): print('动物会吃')class Dog(Animal): def eat(self): print('够吃骨头')class Cat(Animal): def eat(self): print('猫吃小鱼')class Person: def eat(self): print('人吃五谷杂粮')# 定义一个函数def fun(fun1): fun1.eat() # 调用对象的eat()方法if __name__ == '__main__': # 开始调用函数 fun(Animal()) # Cat继承了Animal Dog继承了Animal fun(Cat()) # Cat 和Dog是重写了父类中的eat方法，调用了自己重写后的内容 fun(Dog()) print('------------------') fun(Person()) # Person 没有继承关系 但是有eat方法，直接调用eat方法
动态语言与静态语言
Python是一门动态语言，可以在创建对象后动态的绑定属性和方法，
静态语言和动态语言关于多态的区别：
静态语言实现多态的三个必要条件(Java)
1. 继承
2. 方法重写
3. 父类引用指向子类对象
动态语言：(Python)
动态语言的多态崇尚 “鸭子类型“ 一只鸟走起来像鸭子，游起来像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为’‘’
10.4 类的特殊属性和方法
10.4.1 特殊属性
| 特殊属性 | 描述 |
|---|---|
__dict__ | 获得类对象或实例对象所绑定的所有属性的方法的字典 |
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 23:27# 特殊属性 __dict__ 获得类对象或实例对象所绑定的所有 属性 或 方法 的字典class A: passclass B: passclass C(A, B): def __init__(self, name, age): # 实例属性 self.name = name self.age = ageif __name__ == '__main__': # 创建C类的对象 x = C('Jack', 20) # x是C类的一个实例对象 print(x.__dict__) # 获得实例对象属性的字典 print(C.__dict__) # 获得类对象的属性和方法的字典 print('-----------------') print(x.__class__) # 输出对象所属的类 print(C.__bases__) # C类父类类型的元组 (<class '__main__.A'>, <class '__main__.B'>) print(C.__base__) # 类的基类 离C类最近的父类 print(C.__mro__) # 查看类的层次结构 print(A.__subclasses__()) # 子类的列表
10.4.2 特殊方法
| 特殊方法 | 描述 |
|---|---|
__len__() | 通过重写 __len__()方法，让内置函数len()的参数可以是自定义类型 |
__add__() | 通过重写__add__()方法，可以让自定义对象具有+的功能 |
__new__() | 用于创建对象 |
__init__() | 对创建的对象进行初始化 |
__len__()方法和 __add__() 方法
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 23:27# 1.特殊方法 __add__()# 通过重写 __add__()方法，可以使自定义对象具有 “+” 的功能a = 20b = 100c = a + b # 两个整数类型的对象的相加操作d = a.__add__(b)print(c)print(d)class Student: sex = '女' # 类属性 def __init__(self, name): # 初始化方法 self.name = name def __add__(self, other): # 重写 __add__()方法 可以使自定义对象具有 “+” 的功能 return self.name + other.name def __len__(self): # 重写 __len__方法 让自定义函数len()的参数可以是自定义类型 return len(self.name)stu1 = Student('Jack')stu2 = Student('李四')s = stu1 + stu2 # 实现了两个对象的加法运算（因为在Student类中 编写__add__()特殊的方法）print(s)# 2.特殊方法 __len__()# 通过重写__len__()方法，让自定义函数len()的参数可以是自定义类型lst = [11, 22, 33, 44]print(len(lst)) # len是内置函数，可以计算列表的一个长度print(lst.__len__()) # 特殊方法print(len(stu1))
__new__方法
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 23:27class Person(object): def __new__(cls, *args, **kwargs): # 创建对象 print('__new__()方法被调用执行了，cls的id值为{0}'.format(id(cls))) obj = super().__new__(cls) # 创建对象 obj print(f'创建对象(obj)的id值为:{id(obj)}') print(Person) # <class '__main__.Person'> print(obj) # <__main__.Person object at 0x000001C8B13D9CA0> return obj def __init__(self, name, age): # 对对象的属性进行初始化 print(f'__init__()被调用执行了，self的id值为{id(self)}') self.nane = name self.age = ageif __name__ == '__main__': print(f'object这个类对象的id为:{id(object)}') print(f'Person这个类对象的id为:{id(Person)}') # 创建Person类的实例对象 p1 = Person('张三', 20) print(f'p1这个Person类的实例对象的id为{id(p1)}')
__init__方法
# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/15 23:27class Person(object): def __new__(cls, *args, **kwargs): # 创建对象 print('__new__()方法被调用执行了，cls的id值为{0}'.format(id(cls))) obj = super().__new__(cls) # 创建对象 obj print(f'创建对象(obj)的id值为:{id(obj)}') return obj def __init__(self, name, age): # 对对象的属性进行初始化 print(f'__init__()被调用执行了，self的id值为{id(self)}') self.nane = name self.age = ageprint(f'object这个类对象的id为:{id(object)}')print(f'Person这个类对象的id为:{id(Person)}')# 创建Person类的实例对象p1 = Person('张三', 20)print(f'p1这个Person类的实例对象的id为{id(p1)}')
10.5 变量的赋值操作
只是多生成了一个变量，实际上还是指向同一个对象
# -*- coding: utf-8 -*-# author : Flyme awei # 开发时间: 2022/7/1 15:32class CPU: passclass Disk: passclass Computer: def __init__(self, cpu, disk): # 给对象的实例属性进行初始化 self.cpu = cpu self.disk = disk# 变量的赋值cp1 = Computer(cpu='CPU', disk='DISK') # 创建CPU类的实例对象cp2 = cp1 # 变量的赋值,一个对象的实例采用两个变量存储，实际上还是指向一个对象print(cp1, id(cp1))print(cp2, id(cp2))
赋值（=），就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。
10.6 对象的浅拷贝和深拷贝
10.6.1 浅拷贝
Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象。
# -*- coding: utf-8 -*-# author : Flyme awei # 开发时间: 2022/7/1 15:32import copyclass CPU: passclass Disk: passclass Computer: def __init__(self, cpu, disk): # 给对象的实例属性进行初始化 self.cpu = cpu self.disk = diskcpu = CPU() # 创建一个 CPU 类的实例对象disk = Disk() # 创建一个Disk 类对象computer = Computer(cpu, disk) # 创建一个Computer类的实例对象# 浅拷贝print(cpu)print(disk)computer2 = copy.copy(computer) # 子对象不拷贝print(computer, computer.cpu, computer.disk)print(computer2, computer2.cpu, computer2.disk)# 类的浅拷贝:# Python的拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝# 因此，源对象与拷贝对象会引用同一个子对象
浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用
（如果用引用的方式修改其中一个对象，另外一个也会修改改变）
哪些是浅拷贝：
完全切片方法；工厂函数，如list()；copy模块的copy()函数。 10.6.2 深拷贝
使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。
# -*- coding: utf-8 -*-# author : Flyme awei # 开发时间: 2022/7/1 15:32import copyclass CPU: passclass Disk: passclass Computer: def __init__(self, cpu, disk): # 给对象的实例属性进行初始化 self.cpu = cpu self.disk = diskcpu = CPU() # 创建一个 CPU 对象disk = Disk() # 创建一个硬盘类对象computer = Computer(cpu, disk) # 创建一个计算机类对象# 深拷贝computer1 = copy.deepcopy(computer)print(computer, computer.cpu, computer.disk)print(computer1, computer1.cpu, computer1.disk)# 类的深拷贝# 使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象# 源对象和拷贝对象所有的子对象也不同
深拷贝：创建一个新的对象，并且递归的复制它所包含的对象。
修改其中一个，另外一个不会改变。因此，新对象和原对象没有任何关联。
例如：{copy模块的deepcopy()函数}
十一、包和模块
Python中的包和模块11.1 Python中的模块
11.1.1 什么叫做模块
1.模块:英文名 modules
2.在Python中 一个拓展名为.py的文件就是一个模块
3.函数与模块的关系：
包含语句包含类class一个模块中可以包含n多个函数def 4.使用模块的好处：
方便其它程序和脚本的导入避免函数名和变量名冲突提高代码的可维护性提高代码的课重用性# -*- coding: utf-8 -*-# @File : demo.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/16 11:58def fun(): # 函数 passclass Student: # 类 a = 'hello' # 类属性 def __init__(self, name): # 初始化方法 self.name_ = name # 实例属性 def __str__(self): # 实例方法 pass @staticmethod def cm(): print('静态方法') @classmethod def cs(cls): print('类方法')a = 10 # 变量b = 20c = a + b # 语句11.1.2 导入模块
创建模块：
新建一个.py文件，名称尽量不要与python自带的标准模块名相同
导入模块:
import 模块名称 as 别名 # 导入模块中所有的from 模块名称 import 函数/变量/类 # 导入模块的指定内容代码实现：
# -*- coding: utf-8 -*-# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/16 11:58import math # 导入关于数学运算的模块print(id(math))print(type(math)) # moduleprint(math)print('----------------')print(math.pi) # 3.14...print(dir(math))print(math.pow(2, 3)) # 幂 2**3=8print(math.e)print(math.ceil(9.435)) # 取上整print(math.floor(9.35)) # 取下整print(math.log(2, 4))from math import pi # 导入模块指定的内容print(pi)11.1.3 导入自定义模块
自定义模块calc
# -*- coding: utf-8 -*-# @File : calc.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/16 11:58def add(a, b): return a+bdef div(a, b): return a/b导入自定义模块 calc
import calc # 导入自定义模块 calcprint(calc.add(10, 20))print(calc.div(8, 2))from calc import add # 自定义导入calc模块的add方法print(add(23, 53))
11.1.4 以主程序的方式运行
在每个模块的定义中都包含了一个记录模块名称的变量__name__,程序可以检查该变量，以确定他们在哪个模块中执行。
如果一个模块不是被导入到其他程序中执行，那么它可能在解释器的顶级模块中执行。
顶级模块__name__变量的值为__main__
语句：
if __name__ = '__main__': pass自定义模块calc2
# -*- coding: utf-8 -*-# @File : calc2.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/16 11:58def add(a, b): return a+bif __name__ == '__main__': print(add(10, 20)) # 只有当点击运行calc2模块时，才会执行运算导入calc2模块
# 顶级模块__name__变量的值为__main__import calc2 # 调用calc2的 add 模块print(calc2.add(100, 200))
11.2 Python中的包
1.包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下
2.包的作用:
代码规范避免模块名称冲突3.包与目录的区别:
包含__init__.py文件的目录称为包目录里通常不包含__init__.py文件 4.包的导入: import 包名.模块名
包package1下面有module_A模块和module_B模块
module_A模块
# -*- coding: utf-8 -*-# @File : module_A.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/16 11:58# 包的导入a = 10module_B模块
# -*- coding: utf-8 -*-# @File : module_B.py# @author: Flyme awei# @email : Flymeawei@163.com# @Time : 2022/8/16 11:58b = 100导入包package1
'''包的导入 import 包名.模块名'''import package1.module_A as ma # 导入包package1中的module_A模块print(ma.a) # 10导入带有包的模块注意事项
1.使用import方式进行导入时，只能跟包名或模块名
import package1import package1.module_Aimport calc2.使用from...import 可以导入包，模块，函数，变量
from package1 import module_A # 导入模块module_Afrom package1.module_A import a # 导入变量aprint(a) # 10
11.3 Python中常用的内置模块
| 模块名 | 描述 |
|---|---|
sys | 与python解释器及环境相关的标准库 |
time | 提供时间相关的各种函数标准库 |
os | 提供访问操作系统服务功能的标准库 |
calendar | 提供与日期相关的各种函数的标准库 |
urllib | 用于读取来自网上(服务器)的数据标准库 |
json | 用于使用JSON序列化和反序列化对象 |
re | 用于在字符串中执行正则表达式匹配和替换 |
math | 提供标准运算函数的标准库 |
decimal | 用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算 |
logging | 提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能 |
'''模块名 描述----------------------------------------------------------1.sys 与python解释器及环境相关的标准库2.time 提供时间相关的各种函数标准库3.os 提供访问操作系统服务功能的标准库4.calendar 提供与日期相关的各种函数的标准库5.urllib 用于读取来自网上(服务器)的数据标准库6.json 用于使用JSON序列化和反序列化对象7.re 用于在字符串中执行正则表达式匹配和替换8.math 提供标准运算函数的标准库9.decimal 用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算10.logging 提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能'''11.3.1sys模块
与python解释器及环境相关的标准库
import sys # 导入与python解释器和环境相关的标准库print(sys.getsizeof(24)) # 字节print(sys.getsizeof(54))print(sys.getsizeof(True))print(sys.getsizeof(False))
11.3.2 time模块
提供与时间相关各种函数的标准库
# time 提供与时间相关各种函数的标准库import timeprint(time.time())print(time.localtime(time.time()))
11.3.3 os模块
提供访问操作系统服务功能的标准库
# 提供访问操作系统服务功能的标准库import os11.3.4 urllib模块
import urllib.requestprint(urllib.request.urlopen('http://www.baidu.com').read())
11.4 第三方模块
11.4.1 第三方模块安装
pip install 模块名
11.4.2 第三方模块使用
import 模块名
import timeimport scheduledef job(): print('哈哈哈哈哈哈哈哈')schedule.every(1).seconds.do(job)while True: schedule.run_pending() time.sleep(1)
十二、文件操作
Python的文件操作12.1 编码格式介绍
常见的字符编码格式
Python的解释器使用的是Unicode（内存）Unicode 定长编码：2个字节表示一个字符
.py文件放在磁盘上使用UTF—8储存（外存）UTF-8 变长编码：UTF-8是Unicode的实现，1-4个字节表示一个字符，英文1个字节，汉字3个字节。
新建demo1.py文件
# -*- coding: utf-8 -*-# @File : demo1.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/17 10:45print("Hello World")记事本打开：
# 不同的编码格式决定了占用磁盘空间的大小# coding:UTF-8 # 中文编码注释# encoding=gbk # 编码格式12.2 文件读写原理
12.2.1 文件的读写简称IO操作
输入input，输出output
12.2.2 文件读写流程
12.2.3 操作原理:
文件操作原理
python操作文件打开或新建文件open读，写文件read、write关闭资源file.close() 12.3 文件读写操作
内置函数open()创建文件对象
通过IO流将磁盘文件中的内容与程序中的对象中的内容进行同步
语法规则
file = open（filename, mode='r', buffering=None, encoding=None）"""file -->被创建的文件对象open -->创建文件对象的函数 filename -->要创建或打开的文件名称mode -->打开模式默认为只读encoding -->字符编码格式 """代码演示：a.txt文件
3.文件读写操作.py文件
# -*- coding: utf-8 -*-# @File : 3.文件读写操作.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time : 2022/8/17 10:45file = open('a.txt', 'r') # r 以只读模式打开文件，文件的指针将会放在文件的开头print(file.readlines()) # 返回值为一个列表file.close()
12.4 文件的打开开和关闭
12.4.1 文件的状态和操作过程
12.4.2 文件的打开模式
文件类型：按文件中数据的组织形式，文件分为以下两大类：
1.文本文件:存储的是普通“字符”文本，默认为Unicode字符集，可以使用记事本程序打开
2.二进制文件:把数据内容以字节进行存储，无法用记事本打开，必须使用专用的文软件打开，举例:MP3音频文件 JPG图片 .doc文档等
常用 的文件打开模式
| 打开模式 | 描述 |
|---|---|
r | 以只读模式打开文件，文件的指针将会放在文件的开头 |
w | 以只写方式打开文件，如果文件不存在就创建，如果文件存在则覆盖原有内容，文件指针放在开头 |
a | 以追加模式打开文件，如果文件不存在则创建，文件指针在开头，如果文件存在，则在文件末尾追加内容，文件指针在原文末尾 |
b | 以二进制方式打开文件，不能单独使用，需要与其它模式一起使用：rb或者wb |
+ | 以读写方式打开文件，不能单独使用，需要与其它模式一起使用，a+ |
'''打开模式 描述--------------------------------------------------------------------------------------------------- r 以只读模式打开文件，文件的指针将会放在文件的开头 w 以只写方式打开文件，如果文件不存在就创建，如果文件存在则覆盖原有内容，文件指针放在开头 a 以追加模式打开文件，如果文件不存在则创建，文件指针在开头，如果文件存在，则在文件末尾追加内容，文件指针在原文末尾 b 以二进制方式打开文件，不能单独使用，需要与其它模式一起使用，rb,或者wb + 以读写方式打开文件，不能单独使用，需要与其它模式一起使用'''代码演示：
file = open('a.txt', 'r') # 只读print(file.readlines())file.close()file = open('b.txt', 'w') # 只写file.write('hello.python')file.close()file = open('c.txt', 'a') # 追加file.write('你好啊')file.close()file1 = open('logo.png', 'rb') # 以二进制读file2 = open('copy_logo.png', 'wb') # 以二进制写a = file1.read()file2.write(a) # 边读边写file1.close()file2.close()file = open('c.txt', 'a+') # 以读写方式打开file.write('java')file.close()
a.txt文件
b.txt文件
c.txt文件
logo.png文件
copy_logo.png文件
12.4.3 文件的关闭
file.close()
12.5 文件对象的常用方法
| 方法名 | 说明 |
|---|---|
read([size]) | 从文件中读取size个字节或字符返回，若省略[size]则读到文件末尾 |
readline() | 从文本中读取一行内容 |
readlines() | 把文本文件中每一行都作为独立的字符串对象，并将这些对象放回列表返回 |
write(str) | 将字符串str内容写进文件 |
writelines(s_list) | 将字符串列表s_list写入文本文件，不添加换行符 |
seek(offset,whence) | 把文件指针移到新的位置，offset表示相对whence的位置；offset:为正往结束方向移动， whence不同的值呆鸟不同的含义；0:从文件开头开始计算； 1:从文件当前位置开始计算 |
tell() | 返回文件指针当前位置 |
flush() | 缓冲区的内容写入文件，但不关闭文件 |
close() | 把缓冲区内容写入文件，同事关闭文件，释放文件对象资源 |
"""方法名 说明----------------------------------------------------------------------------------------1.read([size]) 从文件中读取size个字节或字符返回，若省略[size]则读到文件末尾2.readline() 从文本中读取一行内容3.readlines() 把文本文件中每一行都作为独立的字符串对象，并将这些对象放回列表返回4.write(str) 将字符串内容写进文件5.writelines(s_list) 将字符串列表s_list写入文本文件，不添加换行符6.seek(offset, whence) 把文件指针移到新的位置，offset表示相对whence的位置: offset:为正往结束方向移动， whence不同的值呆鸟不同的含义: 0:从文件开头开始计算 1:从文件当前位置开始计算 2:从文件结尾开始计算7.tell() 返回文件指针当前位置8.flush() 把缓冲区的内容写入文件，但不关闭文件9.close() 把缓冲区内容写入文件，同事关闭文件，释放文件对象资源"""12.6 with上下文管理
with语句可以自动管理上下文资源，不论什么原因跳出with块，都能确保文件正常关闭，以此来达到释放资源的目的
语句:
with open('logo.png', 'rb') as src_file: # open('logo.png', 'rb')称为上下文表达式 src_file.read() （with语句体）"""with open('logo.png', 'rb') as src_file: print(src_file.read()) # 不用写 file.close open('logo.png', 'rb')称为上下文表达式，同时创建一个运行时上下文,自动调用__enter__方法，并将返回值赋给src_file, 实现了特殊方法__enter__(), __exit__()，遵守了上下文管理协议，这句表达式的对象就是上下文管理器，离开运行时上下文，自动调用上下文管理器的特殊方法
# MyContentMgr实现了特殊方法__enter__(), __exit__()，称为该类对象遵守了上下文管理器协议# 该类对象的实例对象 MyContentMgr() 被称为上下文管理器# 类对象MyContentMgr的实例对象 MyContentMgr() 被称为上下文管理器class MyContentMgr(object): def __enter__(self): print('enter方法被调用执行了') return self def __exit__(self, exc_type, exc_val, exc_tb): print('exit方法被调用执行了') return self def show(self): print('show方法被调用执行了')with MyContentMgr() as file: # 相当于file = MyContentMgr() file.show()
with语句复制文件：
# with语句 上下文管理器with open('logo.png', 'rb') as src_file: with open('copy2logo.png', 'wb') as target_file: target_file.write(src_file.read())# 不需要手动写关闭文件过程12.7 os模块
1.OS模块是python内置的与操作系统功能和文件系统相关的模块，该模块中的语句执行结果通常与操作系统有关,在不同操作系统上运行，得到的结果可能不一样.
2.os模块于os.path模块用于对目录或文件进行操作
# 目录操作# os 与操作系统相关的一个模块import os# os.system('notepad.exe') # 打开记事本# os.system('calc.exe') # 打开计算器# 直接打开可执行文件os.startfile('C:\\Program Files\\Microsoft Office\\root\\Office16\\excel.exe') # 打开 Excel程序打开记事本：os.system('notepad.exe')
打开计算器：os.system('calc.exe')
12.7.1 os模块操作目录相关函数
os 模块操作目录相关函数
| 函数 | 说明 |
|---|---|
getcwd() | 返回当前工作目录 |
listdir(path) | 返回指定路径下的文件和目录信息 |
mkdir(path[,mode]) | 创建目录 |
makedirs(path1/path2/...[,mode]) | 创建多级目录 |
rmdir(path) | 删除目录 |
removedirs(path1/path2...) | 删除多级目录 |
chdir(path) | 将path设置为当前工作目录 |
# os 模块操作目录相关函数"""函数 说明----------------------------------------------------------------------------1.getcwd() 返回当前工作目录2.listdir(path) 返回指定路径下的文件和目录信息3.mkdir(path[,mode]) 创建目录4.makedirs(path1/path2/...[,mode]) 创建多级目录5.rmdir(path) 删除目录6.removedirs(path1/path2...) 删除多级目录7.chdir(path) 将path设置为当前工作目录"""代码实现：
import os # 导入与操作系统和文件系统相关的模块print(os.getcwd()) # 返回当前目录print(os.listdir('../chap15 文件')) # 返回指定路径下的文件和目录信息# os.mkdir('new dir') # 创建目录# os.makedirs('A/B/C') # 创建多级内目录# os.rmdir('new dir') # 删除目录# os.removedirs('A/B/C') # 移除多级目录os.chdir('/Python基础语法\\chap14 模块') # 将path设置为当前工作目录print(os.getcwd()) # 返回当前工作目录
12.7.2 os.path模块操作目录相关函数
os.path 模块操作目录相关函数
| 函数 | 说明 |
|---|---|
abspath(path) | 用于获取文件目录的绝对路径 |
exists(path) | 用于判断文件或目录是否存在,如果存在返回True,否则返回False |
join(path,name) | 将目录与目录或者文件名拼接起来 |
splitext() | 分离文件名和拓展名 |
basename(path) | 从一个目录中提取文件名 |
dirname(path) | 从一个目录中提取文件名 |
isdir(path) | 用于判断是否为路径 |
# os.path 模块操作目录相关函数"""函数 说明----------------------------------------------------------------------1.abspath(path) 用于获取文件目录的绝对路径2.exists(path) 用于判断文件或目录是否存在,如果存在返回True,否则返回False3.join(path,name) 将目录与目录或者文件名拼接起来4.splitext() 分离文件名和拓展名5.basename(path) 从一个目录中提取文件名6.dirname(path) 从一个路径中提取文件路径，不包括文件名7.isdir(path) 用于判断是否为路径"""代码实现：
import os.pathprint(os.path.abspath('demo2.py')) # 获取绝对路径print(os.path.exists('demo2.py')) # 用于判断文件或目录是否存在,如果存在返回True,否则返回Falseprint(os.path.join('E:\\python', 'demo13.py')) # 将目录与目录或者文件名拼接起来print(os.path.split('/Python基础语法\\chap15 文件')) # 将目录与文件进行拆分print(os.path.splitext('demo2.py')) # 分开文件和拓展名print(os.path.basename('/Python基础语法\\chap15 文件'))print(os.path.dirname('/Python基础语法\\chap15 文件'))print(os.path.isdir('/Python基础语法\\chap15 文件'))
12.7.3 列出指定目录下的所有.py文件
代码实现：
# 列出指定目录下的所有.py文件import ospath = os.getcwd() # 返回当前工作目录lst = os.listdir(path) # 返回 path路径下的文件和目录信息for filename in lst: if filename.endswith('.py'): # 列出.py文件 endswith-->以什么结尾 print(filename)
12.7.4 遍历指定目录下所有的文件以及目录
代码实现：os.walk(path)
import ospath = os.getcwd()lst_files = os.walk(path) # 遍历指定目录下所有的文件以及目录print(lst_files) # 返回值为一个生成器对象for dir_path, dir_name, file_name in lst_files: # print(dir_path) # print(dir_name) # print(file_name) # print('----------------') for dir_ in dir_name: print(os.path.join(dir_path, dir_)) print('-----------------------------') for file in file_name: print(os.path.join(dir_path, file))Python基础语法到这里就结束啦！喜欢博主的可以给博主点个关注。