# Python learning records **Repository Path**: dubo_git/python-learning-records ## Basic Information - **Project Name**: Python learning records - **Description**: python学习记录 - **Primary Language**: Python - **License**: MulanPSL-2.0 - **Default Branch**: master - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 0 - **Forks**: 0 - **Created**: 2023-09-13 - **Last Updated**: 2023-09-20 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README # Python3 学习记录 ### 介绍 记录自己的Python学习记录 ## 学习大纲 ### 第一阶段：基础知识 1. **安装和设置** - 安装Python环境 - 设置开发环境（如IDE、文本编辑器） 2. **基本语法和数据类型** - 变量和数据类型（数字、字符串、列表、元组、字典、集合） - 运算符和表达式 - 控制流程（条件语句、循环） 3. **函数和模块** - 定义和调用函数 - 参数和返回值 - 模块导入和使用 4. **文件操作** - 打开、读取、写入文件 - 文件对象的方法 5. **异常处理** - 异常的基本概念 - try、except、finally块的使用 6. **面向对象编程（OOP）** - 类和对象的定义 - 属性和方法 - 继承和多态 ### 第二阶段：进阶主题 7. **数据结构和算法** - 列表、字典、集合等数据结构的高级使用 - 常用算法（排序、搜索等） 8. **模块和包的高级用法** - 面向对象的模块设计 - 创建和管理自定义包 9. **文件操作和IO高级处理** - 使用上下文管理器（with语句） - 二进制文件、CSV文件、JSON文件等的处理 10. **并发和多线程** - 线程的基本概念 - 使用 threading 模块管理线程 11. **网络编程** - Socket编程基础 - 使用 requests 进行HTTP请求 ### 第三阶段：高级主题 12. **装饰器和生成器** - 装饰器的基本概念 - 生成器和迭代器 13. **元类** - 类型和类的关系 - 自定义元类的使用 14. **函数式编程** - 高阶函数、匿名函数（lambda） - map、filter、reduce等函数 15. **模块的高级使用** - 使用 importlib 动态导入模块 - 使用 import hook 修改模块的导入行为 16. **单元测试和文档** - 使用 unittest 进行单元测试 - 编写文档（使用 Sphinx） ### 第四阶段：实践和项目 17. **实践项目** - 开始一个小项目，应用所学知识 18. **版本控制和团队协作** - 使用Git进行版本控制 - 与团队协作开发 19. **Web开发基础** - 使用框架（如Django、Flask）进行Web开发 20. **数据科学和人工智能** - 使用Python进行数据分析、机器学习等 ## 学习笔记 ### 1. 基础知识 #### 变量和数据类型 - [数据类型](https://m.runoob.com/python3/python3-data-type.html) **Python3 中常见的数据类型有：** Number（数字） String（字符串） bool（布尔类型） List（列表） Tuple（元组） Set（集合） Dictionary（字典） **Python3 的六个标准数据类型中：** 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）； 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。 **Python数据类型转换:** 有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。 以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。 | **函数** | **描述** | |-----------------------|----------------------------------| | int(x [,base]) | 将x转换为一个整数 | | float(x) | 将x转换到一个浮点数 | | complex(real [,imag]) | 创建一个复数 | | str(x) | 将对象 x 转换为字符串 | | repr(x) | 将对象 x 转换为表达式字符串 | | eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 | | tuple(s) | 将序列 s 转换为一个元组 | | list(s) | 将序列 s 转换为一个列表 | | set(s) | 转换为可变集合 | | dict(d) | 创建一个字典。d 必须是一个 (key, value)元组序列。 | | frozenset(s) | 转换为不可变集合 | | chr(x) | 将一个整数转换为一个字符 | | ord(x) | 将一个字符转换为它的整数值 | | hex(x) | 将一个整数转换为一个十六进制字符串 | | oct(x) | 将一个整数转换为一个八进制字符串 | **Python 的字符串内建函数:** | 序号 | 方法及描述 | |----|-------------------------------------------------------------------------------------------------------| | 1 | capitalize() | | | 将字符串的第一个字符转换为大写 | | 2 | center(width, fillchar) | | | 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 | | 3 | count(str, beg= 0,end=len(string)) | | | 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 | | 4 | bytes.decode(encoding="utf-8", errors="strict") | | | Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。 | | 5 | encode(encoding='UTF-8',errors='strict') | | | 以 encoding 指定的编码格式编码字符串，如果出错默认报一个 ValueError 的异常，除非 errors 指定的是 'ignore' 或者 'replace' | | 6 | endswith(suffix, beg=0, end=len(string)) | | | 检查字符串是否以 suffix 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束，如果是，返回 True，否则返回 False。 | | 7 | expandtabs(tabsize=8) | | | 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 | | 8 | find(str, beg=0, end=len(string)) | | | 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回 -1 | | 9 | index(str, beg=0, end=len(string)) | | | 跟 find() 方法一样，只不过如果 str 不在字符串中会报一个异常。 | | 10 | isalnum() | | | 如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False | | 11 | isalpha() | | | 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False | | 12 | isdigit() | | | 如果字符串只包含数字则返回 True 否则返回 False.. | | 13 | islower() | | | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False | | 14 | isnumeric() | | | 如果字符串中只包含数字字符，则返回 True，否则返回 False | | 15 | isspace() | | | 如果字符串中只包含空白，则返回 True，否则返回 False. | | 16 | istitle() | | | 如果字符串是标题化的(见 title())则返回 True，否则返回 False | | 17 | isupper() | | | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False | | 18 | join(seq) | | | 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 | | 19 | len(string) | | | 返回字符串长度 | | 20 | ljust(width[, fillchar]) | | | 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 | | 21 | lower() | | | 转换字符串中所有大写字符为小写. | | 22 | lstrip() | | | 截掉字符串左边的空格或指定字符。 | | 23 | maketrans() | | | 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 | | 24 | max(str) | | | 返回字符串 str 中最大的字母。 | | 25 | min(str) | | | 返回字符串 str 中最小的字母。 | | 26 | replace(old, new [, max]) | | | 把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。 | | 27 | rfind(str, beg=0,end=len(string)) | | | 类似于 find()函数，不过是从右边开始查找. | | 28 | rindex( str, beg=0, end=len(string)) | | | 类似于 index()，不过是从右边开始. | | 29 | rjust(width[, fillchar]) | | | 返回一个原字符串右对齐,并使用 fillchar(默认空格）填充至长度 width 的新字符串 | | 30 | rstrip() | | | 删除字符串末尾的空格或指定字符。 | | 31 | split(str="", num=string.count(str)) | | | 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串 | | 32 | splitlines([keepends]) | | | 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 | | 33 | startswith(substr, beg=0,end=len(string)) | | | 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。 | | 34 | strip([chars]) | | | 在字符串上执行 lstrip()和 rstrip() | | 35 | swapcase() | | | 将字符串中大写转换为小写，小写转换为大写 | | 36 | title() | | | 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) | | 37 | translate(table, deletechars="") | | | 根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 | | 38 | upper() | | | 转换字符串中的小写字母为大写 | | 39 | zfill (width) | | | 返回长度为 width 的字符串，原字符串右对齐，前面填充0 | | 40 | isdecimal() | | | 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 | ### 2. 数据结构 #### 列表、元组、集合、字典 #### Python3 列表 序列是 Python 中最基本的数据结构。 序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。 Python 有 6 个序列的内置类型，但最常见的是列表和元组。 列表都可以进行的操作包括索引，切片，加，乘，检查成员。 此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。 列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。 列表的数据项不需要具有相同的类型 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。 索引 ![img.png](resources/img/list/访问列表中的值.png) 反向索引 ![img.png](resources/img/list/反向索引.png) 通过索引截取列表 ![img.png](resources/img/list/索引截取列表.png) ##### Python列表函数&方法 ##### Python包含以下函数: | 序号 | 函数 | 描述 | |----|-----------|-----------| | 1 | len(list) | 列表元素个数 | | 2 | max(list) | 返回列表元素最大值 | | 3 | min(list) | 返回列表元素最小值 | | 4 | list(seq) | 将元组转换为列表 | ##### Python包含以下方法: | 序号 | 方法 | 描述 | |----|------------------------------------|-----------------------------------| | 1 | list.append(obj) | 在列表末尾添加新的对象 | | 2 | list.count(obj) | 统计某个元素在列表中出现的次数 | | 3 | list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） | | 4 | list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 | | 5 | list.insert(index, obj) | 将对象插入列表 | | 6 | list.pop([index=-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 | | 7 | list.remove(obj) | 移除列表中某个值的第一个匹配项 | | 8 | list.reverse() | 反向列表中元素 | | 9 | list.sort(key=None, reverse=False) | 对原列表进行排序 | | 10 | list.clear() | 清空列表 | | 11 | list.copy() | 复制列表 | #### Python3 元组 Python 的元组与列表类似，不同之处在于元组的元素不能修改。 元组使用小括号 ( )，列表使用方括号 [ ]。 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。 ![img.png](resources/img/tuple/tuple.png) 元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。 ![img.png](resources/img/tuple/元组索引.png) ##### 元组运算符 与字符串一样，元组之间可以使用 +、+= 和 * 号进行运算。这就意味着它们可以组合和复制，运算后会生成一个新的元组。 | Python 表达式 | 结果 | 描述 | |----------------------------------------|------------------------------|------------------------------------| | len((1, 2, 3)) | 3 | 计算元素个数 | | a = (1, 2, 3) b = (4, 5, 6) c = a + b | (1, 2, 3, 4, 5, 6) | 连接，c 就是一个新的元组，它包含了 a 和 b 中的所有元素。 | | a = (1, 2, 3) b = (4, 5, 6) a += b | (1, 2, 3, 4, 5, 6) | 连接，a 就变成了一个新的元组，它包含了 a 和 b 中的所有元素。 | | ('Hi!',) * 4 | ('Hi!', 'Hi!', 'Hi!', 'Hi!') | 复制 | | 3 in (1, 2, 3) | True | 元素是否存在 | | for x in (1, 2, 3): print (x, end=" ") | 1 2 3 | 迭代 | ##### 元组内置函数 | 序号 | 方法及描述 | 实例 | |----|-----------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------| | 1 | len(tuple)
计算元组元素个数。 | >>> tuple1 = ('Google', 'Runoob', 'Taobao')
>>> len(tuple1)
3 | | 2 | max(tuple)
返回元组中元素最大值。 | >>> tuple2 = ('5', '4', '8')
>>> max(tuple2)
'8' | | 3 | min(tuple)
返回元组中元素最小值。 | >>> tuple2 = ('5', '4', '8')
>>> min(tuple2)
'4' | | 4 | tuple(iterable)
将可迭代系列转换为元组。 | >>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'Runoob', 'Baidu') | #### Python3 字典 字典是另一种可变容器模型，且可存储任意类型对象。 字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中。 **注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。** ![img.png](resources/img/dict/dict.png) 键必须是唯一的，但值则不必。 值可以取任何数据类型，但键必须是不可变的，如字符串，数字。 一个简单的字典实例： ```python tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'} ``` ![img.png](resources/img/dict/dict1.png) ##### 字典键的特性 字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。 两个重要的点需要记住： 1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。 2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。 ##### Python字典内置方法： | 序号 | 方法及描述 | 示例 | |----|--------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------| | 1 | `len(dict)`
计算字典元素个数。 | 例：
```python >>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(tinydict) 3``` | | 2 | `str(dict)`
返回字典的字符串形式，可打印。 | 例：
```python >>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(tinydict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"``` | | 3 | `type(variable)`
返回输入变量的类型，或者如果变量是字典，则返回字典类型。 | 例：
```python >>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(tinydict) ``` | ##### Python字典内置方法 | 序号 | 函数及描述 | |----|---------------------------------------------------------------------------------| | 1 | `dict.clear()`
删除字典内所有元素 | | 2 | `dict.copy()`
返回一个字典的浅复制 | | 3 | `dict.fromkeys(seq, val=None)`
创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 | | 4 | `dict.get(key, default=None)`
返回指定键的值，如果键不在字典中返回default设置的默认值 | | 5 | `key in dict`
如果键在字典dict里返回true，否则返回false | | 6 | `dict.items()`
以列表返回一个视图对象 | | 7 | `dict.keys()`
返回一个视图对象 | | 8 | `dict.setdefault(key, default=None)`
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default | | 9 | `dict.update(dict2)`
把字典dict2的键/值对更新到dict里 | | 10 | `dict.values()`
返回一个视图对象 | | 11 | `dict.pop(key[,default])`
删除字典key（键）所对应的值，返回被删除的值 | | 12 | `dict.popitem()`
返回并删除字典中的最后一对键和值 | #### Python3 集合 集合（set）是一个无序的不重复元素序列。 集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。 可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。 **创建格式：** parame = {value01,value02,...} 或者 set(value) 示例： ```python set1 = {1, 2, 3, 4} # 直接使用大括号创建集合 set2 = set([4, 5, 6, 7]) # 使用 set() 函数从列表创建集合 ``` **注意：**创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。 ```python # 集合的基本操作 # 1、添加元素 # 语法格式如下： # s.add( x ) # 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作 this_set = set(("Google", "Runoob", "Taobao")) this_set.add("Facebook") print(this_set) # {'Taobao', 'Facebook', 'Google', 'Runoob'} # 还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下： # s.update( x ) # x 可以有多个，用逗号分开。 this_set1 = set(("Google", "Runoob", "Taobao")) this_set1.update({1, 3}) print(this_set1) # {1, 3, 'Google', 'Taobao', 'Runoob'} this_set1.update([1, 4], [5, 6]) print(this_set1) # {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'} this_set1.update({11: 100, 2: 200, 3: 300}) # 字典添加到集合是添加的键 print(this_set1) # {'Google', 1, 2, 3, 4, 5, 6, 'Taobao', 11, 'Runoob'} ``` ##### 集合内置方法完整列表 | 方法 | 描述 | |-------------------------------|-------------------------------------------------| | add() | 为集合添加元素 | | clear() | 移除集合中的所有元素 | | copy() | 拷贝一个集合 | | difference() | 返回多个集合的差集 | | difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 | | discard() | 删除集合中指定的元素 | | intersection() | 返回集合的交集 | | intersection_update() | 返回集合的交集。 | | isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 | | issubset() | 判断指定集合是否为该方法参数集合的子集。 | | issuperset() | 判断该方法的参数集合是否为指定集合的子集 | | pop() | 随机移除元素 | | remove() | 移除指定元素 | | symmetric_difference() | 返回两个集合中不重复的元素集合。 | | symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 | | union() | 返回两个集合的并集 | | update() | 给集合添加元素 | ### 3. 运算符 - [运算符](https://m.runoob.com/python3/python3-basic-operators.html) #### Python 语言支持以下类型的运算符: 算术运算符 比较（关系）运算符 赋值运算符 逻辑运算符 位运算符 成员运算符 身份运算符 运算符优先级 #### Python算术运算符 以下假设变量 a=10，变量 b=21： | 运算符 | 描述 | 示例 | |-----|---------------------------|--------------------------------| | + | 加 - 两个对象相加 | `a + b` 输出结果 31 | | - | 减 - 得到负数或是一个数减去另一个数 | `a - b` 输出结果 -11 | | * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | `a * b` 输出结果 210 | | / | 除 - x 除以 y | `b / a` 输出结果 2.1 | | % | 取模 - 返回除法的余数 | `b % a` 输出结果 1 | | ** | 幂 - 返回x的y次幂 | `a**b` 为10的21次方 | | // | 取整除 - 往小的方向取整数 | `9//2` 输出结果 4, `-9//2` 输出结果 -5 | #### Python 比较运算符 以下假设变量 a 为 10，变量 b 为20： | 运算符 | 描述 | 示例 | |-----|-----------------------------------------------------------------------|----------------------| | == | 等于 - 比较对象是否相等 | `(a == b)` 返回 False。 | | != | 不等于 - 比较两个对象是否不相等 | `(a != b)` 返回 True。 | | > | 大于 - 返回x是否大于y | `(a > b)` 返回 False。 | | < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 | `(a < b)` 返回 True。 | | >= | 大于等于 - 返回x是否大于等于y。 | `(a >= b)` 返回 False。 | | <= | 小于等于 - 返回x是否小于等于y。 | `(a <= b)` 返回 True。 | #### Python赋值运算符 以下假设变量a为10，变量b为20： | 运算符 | 描述 | 示例 | |-----|---------------------------------------|-----------------------------------------------------------------------------------------------------------------------------| | = | 简单的赋值运算符 | `c = a + b` 将 a + b 的运算结果赋值为 c | | += | 加法赋值运算符 | `c += a` 等效于 `c = c + a` | | -= | 减法赋值运算符 | `c -= a` 等效于 `c = c - a` | | *= | 乘法赋值运算符 | `c *= a` 等效于 `c = c * a` | | /= | 除法赋值运算符 | `c /= a` 等效于 `c = c / a` | | %= | 取模赋值运算符 | `c %= a` 等效于 `c = c % a` | | **= | 幂赋值运算符 | `c **= a` 等效于 `c = c ** a` | | //= | 取整除赋值运算符 | `c //= a` 等效于 `c = c // a` | | := | 海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。 | 在这个示例中，赋值表达式可以避免调用 len() 两次:
`if (n := len(a)) > 10:`
` print(f"List is too long ({n} elements, expected <= 10)")` | #### Python位运算符 按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下： 下表中变量 a 为 60，b 为 13二进制格式如下： a = 0011 1100 b = 0000 1101 ----------------- a&b = 0000 1100 a|b = 0011 1101 a^b = 0011 0001 ~a = 1100 0011 | 运算符 | 描述 | 实例 | |-----|----------------------------------------------------|------------------------------------------------------| | & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | `(a & b)` 输出结果 12 ，二进制解释： 0000 1100 | | \| | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | `(a \| b)` 输出结果 61 ，二进制解释： 0011 1101 | | ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | `(a ^ b)` 输出结果 49 ，二进制解释： 0011 0001 | | ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 | `(~a )` 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 | | << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 | `a << 2` 输出结果 240 ，二进制解释： 1111 0000 | | \>> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 | `a >> 2` 输出结果 15 ，二进制解释： 0000 1111 | #### Python逻辑运算符 Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20: | 运算符 | 逻辑表达式 | 描述 | 实例 | |-----|-----------|------------------------------------------------------|--------------------------| | and | `x and y` | 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 | `(a and b)` 返回 20。 | | or | `x or y` | 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 | `(a or b)` 返回 10。 | | not | `not x` | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | `not(a and b)` 返回 False。 | #### Python成员运算符 除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。 | 运算符 | 描述 | 实例 | |--------|-----------------------------------|--------------------------------------------| | in | 如果在指定的序列中找到值返回 True，否则返回 False。 | `x` 在 `y` 序列中 , 如果 `x` 在 `y` 序列中返回 True。 | | not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | `x` 不在 `y` 序列中 , 如果 `x` 不在 `y` 序列中返回 True。 | #### Python身份运算符 身份运算符用于比较两个对象的存储单元 | 运算符 | 描述 | 实例 | |--------|-------------------|--------------------------------------------------------------------| | is | 判断两个标识符是不是引用自一个对象 | `x is y`，类似 `id(x) == id(y)` , 如果引用的是同一个对象则返回 True，否则返回 False | | is not | 判断两个标识符是不是引用自不同对象 | `x is not y`，类似 `id(x) != id(y)`。如果引用的不是同一个对象则返回结果 True，否则返回 False | #### Python运算符优先级 以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级。 运算符均指二元运算，除非特别指出。 相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）： | 描述 | 表达式示例 | |-------------------|-------------------------------------------------------------------------------| | 圆括号的表达式 | `(expressions...)`, `[expressions...]`, `{key: value...}`, `{expressions...}` | | 读取，切片，调用，属性引用 | `x[index]`, `x[index:index]`, `x(arguments...)`, `x.attribute` | | await 表达式 | `await x` | | 乘方(指数) | `**` | | 正，负，按位非 NOT | `+x`, `-x`, `~x` | | 乘，矩阵乘，除，整除，取余 | `*`, `@`, `/`, `//`, `%` | | 加和减 | `+`, `-` | | 移位 | `<<`, `>>` | | 按位与 AND | `&` | | 按位异或 XOR | `^` | | 按位或 OR | ` |` | | 比较运算，包括成员检测和标识号检测 | `in`, `not in`, `is`, `is not`, `<`, `<=`, `>`, `>=`, `!=`, `==` | | 逻辑非 NOT | `not x` | | 逻辑与 AND | `and` | | 逻辑或 OR | `or` | | 条件表达式 | `if -- else` | | lambda 表达式 | `lambda` | | 赋值表达式 | `:=` | ```python a = 20 b = 10 c = 15 d = 5 e = 0 e = (a + b) * c / d # ( 30 * 15 ) / 5 print("(a + b) * c / d 运算结果为：", e) e = ((a + b) * c) / d # (30 * 15 ) / 5 print("((a + b) * c) / d 运算结果为：", e) e = (a + b) * (c / d) # (30) * (15/5) print("(a + b) * (c / d) 运算结果为：", e) e = a + (b * c) / d # 20 + (150/5) print("a + (b * c) / d 运算结果为：", e) ``` 以上实例输出结果： (a + b) * c / d 运算结果为： 90.0 ((a + b) * c) / d 运算结果为： 90.0 (a + b) * (c / d) 运算结果为： 90.0 a + (b * c) / d 运算结果为： 50.0 ### 4. 流程控制 - [条件控制](https://m.runoob.com/python3/python3-conditional-statements.html) Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。 可以通过下图来简单了解条件语句的执行过程: ![img.png](resources/img/process_control/process_control01.png) 代码执行过程： ![img.png](resources/img/process_control/process_control02.png) #### if 语句 Python中if语句的一般形式如下所示： if condition_1: statement_block_1 elif condition_2: statement_block_2 else: statement_block_3 如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句 如果 "condition_1" 为False，将判断 "condition_2" 如果"condition_2" 为 True 将执行 "statement_block_2" 块语句 如果 "condition_2" 为False，将执行"statement_block_3"块语句 Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。 注意： 1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。 3、在 Python 中没有 switch...case 语句，但在 Python3.10 版本添加了 match...case，功能也类似，详见下文。 #### match...case Python 3.10 增加了 match...case 的条件判断，不需要再使用一连串的 if-else 来判断了。 match 后的对象会依次与 case 后的内容进行匹配，如果匹配成功，则执行匹配到的表达式，否则直接跳过，_ 可以匹配一切。 语法格式如下： match subject: case : case : case : case _: case _: 类似于 C 和 Java 中的 default:，当其他 case 都无法匹配时，匹配这条，保证永远会匹配成功。 ```python def http_error(status): match status: case 400: return "Bad request" case 404: return "Not found" case 418: return "I'm a teapot" case _: return "Something's wrong with the internet" mystatus = 400 print(http_error(400)) ``` 以上是一个输出 HTTP 状态码的实例，输出结果为： Bad request 一个 case 也可以设置多个匹配条件，条件使用 ｜ 隔开，例如： ... case 401|403|404: return "Not allowed" #### Python3 循环语句 Python 中的循环语句有 for 和 while。 Python 循环语句的控制结构图如下所示： ![img.png](resources/img/process_control/loop.png) ##### while 循环 Python 中 while 语句的一般形式： while 判断条件(condition)： 执行语句(statements)…… 执行流程图如下： ![img.png](resources/img/process_control/while_loop.png) 同样需要注意冒号和缩进。另外，在 Python 中没有 do..while 循环。 以下实例使用了 while 来计算 1 到 100 的总和： ```python n = 100 sum = 0 counter = 1 while counter <= n: sum = sum + counter counter += 1 print("1 到 %d 之和为: %d" % (n, sum)) ``` 执行结果如下： 1 到 100 之和为: 5050 ###### 无限循环 我们可以通过设置条件表达式永远不为 false 来实现无限循环，实例如下： ```python var = 1 while var == 1: # 表达式永远为 true num = int(input("输入一个数字 :")) print("你输入的数字是: ", num) print("Good bye!") ``` 执行以上脚本，输出结果如下： 输入一个数字 :5 你输入的数字是: 5 输入一个数字 : ... 你可以使用 CTRL+C 来退出当前的无限循环。 无限循环在服务器上客户端的实时请求非常有用。 ###### while 循环使用 else 语句 如果 while 后面的条件语句为 false 时，则执行 else 的语句块。 语法格式如下： while : else: expr 条件语句为 true 则执行 statement(s) 语句块，如果为 false，则执行 additional_statement(s)。 循环输出数字，并判断大小： ```python count = 0 while count < 5: print(count, " 小于 5") count = count + 1 else: print(count, " 大于或等于 5") ``` 执行以上脚本，输出结果如下： 0 小于 5 1 小于 5 2 小于 5 3 小于 5 4 小于 5 5 大于或等于 5 ##### for 语句 Python for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。 for循环的一般格式如下： for in : else: 流程图： ![img.png](resources/img/process_control/for_loop.png) ```python sites = ["Baidu", "Google", "Runoob", "Taobao"] for site in sites: print(site) ``` 以上代码执行输出结果为： Baidu Google Runoob Taobao ##### break 和 continue 语句及循环中的 else 子句 break 执行流程图： ![img.png](resources/img/process_control/break.png) continue 执行流程图： ![img.png](resources/img/process_control/continue .png) while 语句代码执行过程： ![img.png](resources/img/process_control/while_process.png) for 语句代码执行过程： ![img.png](resources/img/process_control/for_process.png) **break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。 continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。** ##### pass 语句 Python pass是空语句，是为了保持程序结构的完整性。 pass 不做任何事情，一般用做占位语句，如下实例 ```python while True: pass # 等待键盘中断 (Ctrl+C) ``` ```python for letter in 'Runoob': if letter == 'o': pass print('执行 pass 块') print('当前字母 :', letter) print("Good bye!") ``` 执行以上脚本输出结果为： 当前字母 : R 当前字母 : u 当前字母 : n 执行 pass 块 当前字母 : o 执行 pass 块 当前字母 : o 当前字母 : b Good bye! ##### end 关键字 关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符，实例如下： ```python # Fibonacci series: 斐波纳契数列 # 两个元素的总和确定了下一个数 a, b = 0, 1 while b < 1000: print(b, end=',') a, b = b, a + b ``` 执行以上程序，输出结果为： 1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987, ### 5.迭代器与生成器 #### 迭代器 迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。 迭代器是一个可以记住遍历的位置的对象。 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。 迭代器有两个基本的方法：iter() 和 next()。 字符串，列表或元组对象都可用于创建迭代器： ```python list = [1, 2, 3, 4] it = iter(list) # 创建迭代器对象 1 print(next(it)) # 输出迭代器的下一个元素 2 print(next(it)) ``` 迭代器对象可以使用常规for语句进行遍历： ```python list = [1, 2, 3, 4] it = iter(list) # 创建迭代器对象 for x in it: print(x, end=" ") # 1 2 3 4 ``` 也可以使用 next() 函数： ```python import sys # 引入 sys 模块 list = [1, 2, 3, 4] it = iter(list) # 创建迭代器对象 while True: try: print(next(it)) except StopIteration: sys.exit() ``` 执行以上程序，输出结果如下： 1 2 3 4 ##### 创建一个迭代器 把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。 如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行。 更多内容查阅：Python3 面向对象 __iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。 __next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。 创建一个返回数字的迭代器，初始值为 1，逐步递增 1： ```python class MyNumbers: def __iter__(self): self.a = 1 return self def __next__(self): x = self.a self.a += 1 return x myclass = MyNumbers() myiter = iter(myclass) print(next(myiter)) print(next(myiter)) print(next(myiter)) print(next(myiter)) print(next(myiter)) ``` 执行输出结果为： 1 2 3 4 5 ##### StopIteration StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。 在 20 次迭代后停止执行： ```python class MyNumbers: def __iter__(self): self.a = 1 return self def __next__(self): if self.a <= 20: x = self.a self.a += 1 return x else: raise StopIteration myclass = MyNumbers() myiter = iter(myclass) for x in myiter: print(x) ``` #### 生成器 在 Python 中，使用了 yield 的函数被称为生成器（generator）。 yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。 跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。 当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回。 然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。 调用一个生成器函数，返回的是一个迭代器对象。 下面是一个简单的示例，展示了生成器函数的使用： ```python def countdown(n): while n > 0: yield n n -= 1 # 创建生成器对象 generator = countdown(5) # 通过迭代生成器获取值 print(next(generator)) # 输出: 5 print(next(generator)) # 输出: 4 print(next(generator)) # 输出: 3 # 使用 for 循环迭代生成器 for value in generator: print(value) # 输出: 2 1 ``` 以上实例中，countdown 函数是一个生成器函数。它使用 yield 语句逐步产生从 n 到 1 的倒数数字。在每次调用 yield 语句时，函数会返回当前的倒数值，并在下一次调用时从上次暂停的地方继续执行。 通过创建生成器对象并使用 next() 函数或 for 循环迭代生成器，我们可以逐步获取生成器函数产生的值。在这个例子中，我们首先使用 next() 函数获取前三个倒数值，然后通过 for 循环获取剩下的两个倒数值。 生成器函数的优势是它们可以按需生成值，避免一次性生成大量数据并占用大量内存。此外，生成器还可以与其他迭代工具（如for循环）无缝配合使用，提供简洁和高效的迭代方式。 执行以上程序，输出结果如下： 5 4 3 2 1 ### 6. 函数 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。 函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。 #### 定义一个函数 你可以定义一个由自己想要功能的函数，以下是简单的规则： 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。 函数内容以冒号 : 起始，并且缩进。 return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。 ![img.png](resources/img/function/function01.png) ##### 语法 Python 定义函数使用 def 关键字，一般格式如下： def 函数名（参数列表）: 函数体 ##### 函数调用 定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。 这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。 ##### 参数传递 在 python 中，类型属于对象，对象有不同类型的区分，变量是没有类型的： ```python a = [1, 2, 3] a = "Runoob" ``` 以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。 ##### 可更改(mutable)与不可更改(immutable)对象 在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。 python 函数的参数传递： 不可变类型：类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。 可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响 python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。 ## 其他说明 这里可以添加其他你想要说明的内容。 ## 联系方式 如果你想和我交流，可以通过以下方式联系我： - 邮箱：2571033186@qq.com