1.Python基本概念：①Python是一门高级语言，经编译器编译之后变为机器语言才可执行 （Python是脚本语言）； ②Python是一门解释型语言，需要将源代码逐条转换成目标代码，同时逐条运行目标代码，执行解释的计算机程序也称为解释器；③Python特点：明确简单而优雅，库丰富而多样。
2.Python应用领域：①web开发；②数据分析与科学计算；③人工智能与机器学习（常用TensorFlow，Keras，PyTorch）；④自动化测试与运维；⑤网络爬虫（request）；⑥游戏开发！
目前学习工具与平台：pycharm3.8
基本的程序编写流程：IPO程序编写方法
1.input函数：变量名 = input('提示文字') 注意事项：input获取的数据返回为字符串类型
2.注释：单行注释加前缀#，多行注释使用''' '''
3.代码缩进：每行语句开始前的空白区域，因为Python语法较为简洁，没有c语言或者JS一样的多个嵌套的括号，因此嵌套关系常看缩进，需要严格的缩进。（pycharm的提示选项内有格式化选项）
4.print函数：
print(内容) 其完整版其实是
print(内容，...，sep='内容间分隔方式',end='尾部内容',file=写入位置) 注意事项：字符要加引号，变量等不用
5.文件打开与写入：
fp = open(&#', 'w')
#其中的w指的是插入形式（write）
print(chr(28145), file=fp)6.关键字（保留字）：在Python中被赋予特定定义的一些单词，不可作为变量名与对象名等使用，以下为基本的保留字
| and | as | assert | break | class | continue | def |
| del | elif | else | except | finally | for | from |
| False | global | if | import | in | is | lambda |
| nonlocal | not | None | or | pass | raise | return |
| try | True | while | with | yield | await | async |
7.Python标识符命名规则与规范：
①可用中英文，下划线，数字；②第一个不能是数字；③不用关键字；④严格区分大小写；⑤下划线开头的具有特殊意义； ①全部小写的短小单词，以下划线分隔；②包名尽量短小，以点分割；③模块内部类：下划线+Pascal命名法，如MyClass内部的_InnerMyClass；④函数，类的属性和方法的命名，一般全用小写字母，多个单词之间以下划线分隔⑤常量一般全用大写，下划线分隔；⑥以单下划线开头的模块变量与函数受保护，在使用“from xxx import *”语句从模块中导入时，这些模块变量或函数不能被导入；⑦双下划线开头慎用，是类私有的；⑧头尾双下划线是Python专用标识，勿使用此型
8.变量与常量
变量的语法结构： 除了一般的数据结构之外还可赋值为一个方法返回的参数
变量名 = value常量的语法结构：与变量无异，但是命名规则要注意，而且一般直接赋值
9.数值类型
①整数类型：没有小数部分的数值，包含正整数、负整数和0
注：Python中不同进制之前需要引导符号以用于被辨识。十进制无前缀，二进制以0b或0B作为前缀，八进制以0o或者0O作为前缀，十六进制以0x或者0X作为前缀
②浮点数类型：表示带有小数点的数值，计算时注意浮点误差
复数：Python中的复数与数学中形式一致，实数部分以.real表示，虚数部分以.imag表示
# 实部与虚部
x = 123 + 456j
print(x)
al)
print(x.imag)10.字符串类型与操作
①普通字符串，可以表示计算机所能识别的一切字符
②界定符：单引号，双引号，三引号
③转义字符：+字母或符号，具体查表
④原字符：字符串界定符前加r或者R，使转义字符失效变为普通字符
⑤索引：有序的字符序列（字符串）中，某个字符的检索号称为索引（正序从0开始，逆序从-1开始）
⑥切片：对字符串中某个子串或者区间的检索，基本语法结构如下（左闭右开）：
#字符串切片
s = 'hello world'
print(s[0])
print(s[-2])#反向
print('hello world'[2:5:3])#2到5,跨步为3
print(s[:5])#从零开始到第五个
⑦字符串操作：拼接x+y 复制n次x*n 检索x是否为s的子串，返回布尔值x in s
11.布尔类型：True表示1，False表示0（反之，在进行判断时除了0以外其他都视为True）false情况：False或者None，各种数值中的0，空序列，自定义对象的实例，该对象的__bool__()方法返回False或__len__()方法返回0
12.数据类型之间的转换：
①隐式转换：在函数运算以及程序运行过程中内置函数导致的转换（可能类似于JS？有待学习）
②显式转换：使用转换函数转换数据类型
| 函数 | 描述说明 |
| int(x) | 将x转换为整数类型 |
| float(x) | 将x转换为浮点数类型 |
| str(x) | 将x转成字符串 |
| chr(x) | 将整数 x转换为一个字符 |
| ord(x) | 将一个字符x转换为其对应的整数值 |
| hex(x) | 将一个整数 x转换为一个十六进制字符串 |
| oct(x) | 将一个整数 x转换为一个八进制字符串 |
| bin(x) | 将一个整数 x转换为一个二进制字符串 |
13.eval函数：python中的内置函数，去掉语句最外侧的引号后执行该语句（注意，该语法格式为 ：变量名=eval（字符串）与其他函数共用时注意格式与嵌套关系）
num = eval(input('输入算式'))
print('千位为', num // 1000)
print('百位为', num % 1000 // 100)
print('十位为', num % 100 // 10)
print('个位为', num % 10 // 1)14.算术运算符：处理四则运算，优先级为：** 其次 *,/,%,// 其次 -,+ ,具体如下：
| 运算符 | 描述说明 | 示例 | 结果 |
| + | 加法 | 1+1 | 2 |
| - | 减法 | 1-1 | 0 |
| * | 乘法 | 2*3 | 6 |
| / | 除法 | 10/2 | 5.0 |
| // | 整除 | 10//3 | 3 |
| % | 取余 | 10%3 | 1 |
| ** | 幂运算 | 2**4 | 16 |
15.赋值运算符 ：故名思议，具体如下：
| 运算符 | 描述说明 | 示例 | 展开形式 |
| = | 简单的赋值运算 | x=y | x=y |
| += | 加赋值 | x+=y | x=x+y |
| -= | 减赋值 | x-=y | x=x-y |
| *= | 乘赋值 | x*=y | x=x*y |
| /= | 除赋值 | x/=y | x=x/y |
| %= | 取余赋值 | x%=y | x=x%y |
| **= | 幂赋值 | x**=y | x=x**y |
| //= | 整除赋值 | x//=y | x=x//y |
16.比较运算符，依旧看图：
| 运算符 | 描述说明 | 示例 | 展开形式 |
| > | 大于 | 98>90 | True |
| < | 小于 | 98<90 | False |
| == | 等于 | 98==90 | False |
| != | 不等于 | 98!=90 | True |
| >= | 大于或等于 | 98>=98 | True |
| <= | 小于或等于 | 98<=98 | True |
17. 逻辑运算符，与或非三巨头，具体如下：
| 运算符 | 描述说明 | 用法 | 结合方向 |
| and | 逻辑与 | 表达式1 and 表达式2 | 从左到右 |
| or | 逻辑或 | 表达式1 or 表达式2 | 从左到右 |
| not | 逻辑非 | not 表达式 | 从右到左 |
18. 位运算符，将数字看做二进制进行计算与操作。首先以“位与”举例：当两数对应位置都为一时结果为一，否则为零，其他运算符也都如此运算一般，是“按位”进行运算。
①位与（&）：对两个操作数的每个对应位执行逻辑与操作，只有当两个位都为 1 时，结果才为 1，否则为 0。
②位或（|）：对两个操作数的每个对应位执行逻辑或操作，只有当两个位都为 0 时，结果才为 0，否则为 1。
③位异或（^）：对两个操作数的每个对应位执行逻辑异或操作，当两个位不同时，结果为 1，否则为 0。
④位取反（~）：对操作数的每个位执行逻辑非操作，将每个位取反。
⑤左移（<<）：将操作数的二进制表示向左移动指定的位数，并在右侧用零填充。
⑥右移（>>）：将操作数的二进制表示向右移动指定的位数，并在左侧用符号位填充（对于正数是 0，对于负数是 1 注意：填充时空出的位置全部都是填符号位）。
注意：在使用位运算符时，操作数会被转换为整数进行计算。
下为举例，内部过程自己写一手二进制数即可：
#位与
a = 5 # 二进制表示为 0101
b = 3 # 二进制表示为 0011
result = a & b
print(result) # 输出 1，即二进制的 0001#位或
a = 5 # 二进制表示为 0101
b = 3 # 二进制表示为 0011
result = a | b
print(result) # 输出 7，即二进制的 0111#位异或
a = 5 # 二进制表示为 0101
b = 3 # 二进制表示为 0011
result = a ^ b
print(result) # 输出 6，即二进制的 0110#位取反
a = 5 # 二进制表示为 0101
result = ~a
print(result) # 输出 -6，即二进制的 -0110#左移
a = 5 # 二进制表示为 0101
result = a << 2
print(result) # 输出 20，即二进制的 10100#右移
a = 5 # 二进制表示为 0101
result = a >> 2
print(result) # 输出 1，即二进制的 0001
14-18运算符优先级：
①** ②~、+、- ③*、/、%、// ④+、- ⑤<<、>> ⑥& ⑦^ ⑧| ⑨<、<=、>、>=、!=、== 若有赋值运算符则优先级最低（最后运行）
1、程序的组织结构：顺序结构、循环结构、分支（选择）结构
2、if else elif 分支结构语法 。注意：一般else用于最后，指不符合所有情况
num = int(input("请输入一个数字："))if num > 0:print("这个数字是正数")
elif num < 0:print("这个数字是负数")
else:print("这个数字是零")
3、for 与 for else 循环结构语法。其中for else一般用于查找
fruits = ["apple", "banana", "cherry"]for fruit in fruits:print(fruit)-------------------------------------------------fruits = ["apple", "banana", "cherry"]for fruit in fruits:if fruit == "orange":print("找到了橙子")break
else:print("没有找到橙子")
4.while 循环结构语法
limit = 10
number = 1while number <= limit:square = number ** 2print(square)number += 1
5.for in循环结构
size = 5# 上半部分
for i in range(1, size+1):print(" " * (size-i) + "*" * (2*i-1))# 下半部分
for i in range(size-1, 0, -1):print(" " * (size-i) + "*" * (2*i-1))#range（start起始值，stop结束值（不包括该值），step步长）6.程序跳转语句
①break 跳出整个循环结构
②continue 跳出当前这个循环
7.空语句pass，类似于占位符，只是为了语法正确，无意义
索引：本章主要了解序列，索引，序列，列表，元组，字典，集合的概念与其相关操作
序列是一个用于存储多个值的连续空间，每个值都对应一个整数的编号，此编号称为索引。
索引分为正向递增索引（0 至 N-1）与反向递减索引（-1 至-N）
切片操作语法结构：序列名[start:end(不包含该值):step] 返回一个与原始序列类型相同的序列
序列的操作：
| 操作符/函数 | 描述说明 |
| x in s | 如果x是s的元素，结果为True，否则结果为False |
| x not in s | 如果x不是s的元素，结果为True，否则结果为False |
| len(s) | 序列s中元素的个数（即序列的长度) |
| max(s) | 序列s中元素的最大值 |
| min(s) | 序列s中元素的最小值 |
| s.index(x) | 序列s中第一次出现元素x的位置 |
| s.count(x) | 序列s中出现x的总次数 |
删除操作：del 序列名
遍历操作：enumerate函数，如：
for index ,item in enumerate(lst):
输出index和item
序列类型：
①列表类型：由一系列的按特定顺序排列的元素组成，是Python中内置的可变序列，使用[]定义列表或使用内置函数 list（） 创建列表，使用逗号分隔，列表内元素可以是任意的数据类型
| 列表的方法 | 描述说明 |
| lst.append(x) | 在列表lst最后增加一个元素 |
| lst.insert(index,x) | 在列表中第index位置增加一个元素 |
| lst.clear() | 清除列表lst中所有元素 |
| lst.pop(index) | 将列表lst中第index位置的元素取出，并从列表中将其删除 |
| ve(x) | 将列表lst中出现的第一个元素x删除 |
| verse(x) | 将列表lst中的元素反转 |
| py() | 拷贝列表lst中的所有元素，生成一个新的列表 |
列表对象排序：sort方法： 列表名.sort（key = 排序方法,reverse = 排序方式）
内置函数sorted： sorted(排序对象,key = 排序方法,reverse = 排序方式)
列表生成语法结构：lst=[expression for item in range] 或lst=[expression for item in range(n)]。其中expression为表达式，range可为一个对象，此方法将从目标对象中取符合表达式的数据取出作为列表
②元组类型：是Python中内置的不可变有序序列，使用（）定义或元组名=tuple（序列）方法定义，以逗号分隔（当元组中仅有一个元素时逗号也要）其中元组生成式的结果是一个生成器对象，需要转变方可见，或者使用__next__()方法进行提取（提取完了原来的元组就空了）。
新定义标明与对比：
| 元组 | 列表 |
| 不可变序列 | 可变序列 |
| 无法实现添加、删除和修改元素等操作 | append()、insert()、remove()、pop()等方法实现添加和删除列表元素 |
| 支持切片访问元素，不支持修改操作 | 支持切片访问和修改列表中的元素 |
| 访问和处理速度快 | 访问和处理速度慢 |
| 可以作为字典的键 | 不能作为字典的键 |
列表的方法列表的方。其中
③字典类型：由多个键（key）值（value）对构成，他表示索引所使用的键和对应的值构成的成对关系，可使用{}直接创建或者使用映射函数和构造函数构建：zip（key序列，value序列） dict（key=value，...）
字典中的key是无序的，取值时使用d[key]或者d.get[key]取对应值，或者遍历
for key, value in my_dict.items():print(key, "->", value)for element in d.items():key, value = elementprint(key, "->", value)字典相关操作：
| 字典的方法 | 描述说明 |
| d.keys() | 获取所有的key数据 |
| d.values() | 获取所有的value数据 |
| d.pop(key,default) | key存在获取相应的value，同时删除key-value对，否则获取默认值 |
| d.popitem() | 随机从字典中取出一个key-value对，结果为元组类型，同时将该key-value从字典中删除 |
| d.clear() | 清空字典中所有的key-value对 |
④集合类型：与数学中集合的概念一致，是一个无序不重复的元素序列（可用于去重），使用{}定义，以逗号分隔，集合是可变数据类型，但是只能存储不可变数据类型（比如他能存一个元组进去或者删去一个元素，但是不能存储字典和列表）
内置函数set（）创建集合：集合名 = set（可迭代对象）
集合操作:①取交集 A&B；②取并集 A|B； ③取差集 A-B（注意，这里是在A中去掉与B重合部分）； ④取补集 A^B集合的方集合的方法
| 集合的方法 | 描述说明 |
| s.add(x) | 如果x不在集合s中，则将x添加到集合s |
| s.remove(x) | 如果x在集合中，将其删除，如果不在集合中，程序报错 |
| s.clear() | 清除集合中所有元素 |
Python3.11新特性：结构模型匹配 字典合并运算符| 同步迭代
#结构模型匹配，case后可以跟随各种模式
point = (2, 3)match point:case (0, 0):print("原点")case (x, 0):print(f"在 x 轴上，x 坐标为 {x}")case (0, y):print(f"在 y 轴上，y 坐标为 {y}")case (x, y):print(f"在坐标 ({x}, {y})")#字典合并运算符
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}merged_dict = dict1 | dict2print(merged_dict) # 输出 {"a": 1, "b": 3, "c": 4}#同步迭代
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]for name, age in zip(names, ages):print(f"{name} is {age} years old")#将输出相同位置处的元素
#Alice is 25 years old
#Bob is 30 years old
#Charlie is 35 years old字符串是Python中的不可变数据类型，对他的修改实际上是“替换”，以下为课件中给出的字符串基本操作
| 方法名 | 描述说明 |
| str.lower() | 将str字符串全部转成小写字母，结果为一个新的字符串 |
| str.upper() | 将str字符串全部转成大写字母，结果为一个新的字符串 |
| str.split(sep=None) | 把str按照指定的分隔符sep进行分隔，结果为列表类型 |
| unt(sub) | 结果为sub这个字符串在str中出现的次数 |
| str.find(sub) | 查询sub这个字符串在str中是否存在，如果不存在结果为-1，如果存在，结果为sub首次出现的索引 |
| str.index(sub) | 功能与find()相同，区别在于要查询的子串sub不存在时，程序报错 |
| str.startswith(s) | 查询字符串str是否以子串s开头 |
| dswith(s) | 查询字符串str是否以子串s结尾 |
| place(old,news) | 使用news替换字符串s中所有的old字符串，结果是一个新的字符串 |
| (width,fillchar) | 字符串str在指定的宽度范围内居中，可以使用fillchar进行填充 |
| str.join(iter) | 在iter中的每个元素的后面都增加一个新的字符串str |
| str.strip(chars) | 从字符串中去掉左侧和右侧chars中列出的字符串 |
| str.lstrip(chars) | 从字符串中去掉左侧chars中列出的字符串 |
| str.rstrip(chars) | 从字符串中去掉右侧chars中列出的字符串 |
格式化字符串：①使用占位符；②使用f-string方法；③使用str.format（）方法
#占位符方式
name = "Alice"
age = 25# 使用 %s、%d、%f 占位符进行格式化
message = "My name is %s and I am %d years old. My height is %.2f meters." % (name, age, 1.65)print(message)
#结果为：My name is Alice and I am 25 years old. My height is 1.65 meters.#使用f-string
name = "Bob"
age = 30# 使用 f-string 进行格式化
message = f"My name is {name} and I am {age} years old. My height is {1.75:.2f} meters."print(message)
#结果为：My name is Bob and I am 30 years old. My height is 1.75 meters.#使用str.format（）
name = "Charlie"
age = 35# 使用 str.format() 进行格式化
message = "My name is {} and I am {} years old. My height is {:.2f}meters.".format(name,age, 1.80)print(message)
#结果为：My name is Charlie and I am 35 years old. My height is 1.80 meters.
其中，格式化字符串的详细格式由{}中的要求决定，要求语法大致为：①：作为引导符号；②<>^作为对齐方式；③数字作为宽度；④逗号作为数字的千位分隔符；⑤ . + 数字 作为数据精度；⑥整数类型与浮点数类型的代号
字符串的编解码：在网络传输中，内存数据先从本地的字符串（string）编码为二进制进行传输，到达目标地址后再由接收方解码为字符串
Python中的字符串编解码方式：使用encode（）编码，使用decode（）解码。完整格式实例如下：
#encoded_string = de(encoding=#, errors=#)
#其中encoding为编码标准（如UTF-8），errors为编码错误时的处理方式
s = "hello"
encoded_string = s.encode('utf-8')
print(encoded_string)#decoded_string = encoded_string.decode(encoding=#, errors=#)
#参数意义同上
b = b'hello'
decoded_string = b.decode('utf-8')
print(decoded_string)数据验证与正则表达式
1.数据验证方法
| 方法名 | 描述说明 |
| str.isdigit() | 所有字符都是数字(阿拉伯数字) |
| str. isnumeric() | 所有字符都是数字 |
| str. isalpha() | 所有字符都是字母(包含中文字符) |
| str.isalnum() | 所有字符都是数字或字母（包含中文字符) |
| str.islower() | 所有字符都是小写 |
| str.isupper() | 所有字符都是大写 |
| str.istitle() | 所有字符都是首字母大写 |
| str.isspace() | 所有字符都是空白字符（n、t等） |
字符串拼接：①使用str.join（）方法；②直接使用+号拼接；③使用格式化字符串进行拼接；④通过集合的去重性质进行去重拼接
2.正则表达式 （使用时需要导入re模块）
正则匹配流程：定义模式字符串——选定被匹配对象——选定匹配方式进行匹配——接收匹配结果
import redef validate_phone_number(phone_number):pattern = r'^(?(d{3}))?[-.s]?(d{3})[-.s]?(d{4})$'match_result = re.match(pattern, phone_number)if match_result:area_code = up(1)prefix = up(2)line_number = up(3)print(f"Valid US phone number: ({area_code}) {prefix}-{line_number}")else:print("Invalid US phone number")# 测试例子
validate_phone_number('123-456-7890') # Invalid US phone number
validate_phone_number('(123) 456-7890') # Valid US phone number: (123) 456-7890
validate_phone_number('555.123.4567') # Invalid US phone number
①模式字符串：由元字符，限定符与自定义的匹配规则构成的字符串，用于做正则匹配时的规则；
| 元字符 | 描述说明 | 举例 | 结果 |
| . | 匹配任意字符（除n） | ’pnythotn’ | p、y、t、h、o、t、n |
| w | 匹配字母、数字、下划线 | ‘pythonn123’ | p、y、t、h、o、n、1、2、3 |
| W | 匹配非字母、数字、下划线 | ‘pythonn123’ | n |
| s | 匹配任意空白字符 | ‘pythont123’ | t |
| S | 匹配任意非空白字符 | ‘pythont123’ | p、y、t、h、o、n、1、2、3 |
| d | 匹配任意十进制数 | ‘pythont123’ | 1、2、3 |
| 限定符 | 描述说明 | 举例 | 结果 |
| ？ | 匹配前面的字符0次或1次 | colou?r | 可以匹配color或colour |
| + | 匹配前面的字符1次或多次 | colou+r | 可以匹配colour或 |
| * | 匹配前面的字符0次或多次 | colou*r | 可以匹配color或 |
| {n} | 匹配前面的字符n次 | colou{2}r | 可以匹配colouur |
| {n,} | 匹配前面的字符最少n次 | colou{2,}r | 可以匹配colouur或 |
| {n,m} | 匹配前面的字符最小n次，最多m次 | colou{2,4}r | 可以匹配colouur或colouuur或colouuuur |
| 其它字符 | 描述说明 | 举例 | 结果 |
| 区间字符[] | 匹配[]中所指定的字符 | [.?!] [0-9] | 匹配标点符号点、问号，感叹号 匹配0、1、2、3、4、5、6、7、8、9 |
| 排除字符^ | 匹配不在[]中指定的字符 | [^0-9] | 匹配除0、1、2、3、4、5、6、7、8、9的字符 |
| 选择字符｜ | 用于匹配|左右的任意字符 | d{18}|d{15} | 匹配15位身份证或18位身份证 |
| 转义字符 | 同Python中的转义字符 | . | 将.作为普通字符使用 |
| [u4e00-u9fa5] | 匹配任意一个汉字 | ||
| 分组() | 改变限定符的作用 | six|fourth (six|four)th | 匹配six或fourth 匹配sixth或fourth |
②re模块：Python中的内置模块，使用不同函数以进行不同规则的匹配
| 函数 | 功能描述 |
| re.match(pattern,string,flags=0) | 用于从字符串的开始位置进行匹配，如果起始位置匹配成功，结果为Match对象，否则结果为None。 |
| re.search(pattern,string,flags=0) | 用于在整个字符串中搜索第一个匹配的值，如果匹配成功，结果为Match对象，否则结果为None。 |
| re.findall(pattern,string,flags=0) | 用于在整个字符串搜索所有符合正则表达式的值，结果是一个列表类型。 |
| re.sub (pattern,repl,string,count,flags=0) | 用于实现对字符串中指定子串的替换 |
| re.split(pattern,string,maxsplit,flags=0) | 字符串中的split()方法功能相同，都是分隔字符串 |
暂留
1.函数分类：内置函数与自定义函数
自定义函数：def 函数名（参数列表）：函数体 [返回值列表]
def add_numbers(num1, num2):"""计算两个数的和"""sum = num1 + num2return sum # 返回和# 测试函数
result = add_numbers(4, 6)
print("4 + 6 =", result) # 输出：4 + 6 = 10
2.形参与实参
函数的参数传递
#默认值参数演示
def greet(name, greeting="Hello"): # 这里连续赋值，一般不建议这样"""打印问候语"""print(greeting + ", " + name + "!")# 调用函数，并传递一个参数
greet("Alice") # 输出：Hello, Alice!# 调用函数，并传递两个参数
greet("Bob", "Hi") # 输出：Hi, Bob!#个数可变的位置参数举例，参数前面加*
def sum_numbers(*args):"""计算所有数的和"""sum = 0for num in args:sum += numreturn sum# 调用函数，并传递多个参数
result = sum_numbers(1, 2, 3, 4, 5)
print(result) # 输出：15#个数可变的关键字参数举例，参数前面加**
def show_info(**kwargs):"""显示个人信息"""for key, value in kwargs.items():print(key + ": " + value)# 调用函数，并传递多个键值对参数
show_info(name="Alice", age="25", city="New York")
3.变量作用域：①局部变量：在函数定义处的参数和函数内部定义的变量，仅在函数内部作用；
②全局变量：在函数外或使用global关键字修饰的变量，在整个程序内作用。
4.匿名函数lambda：语法为：函数名 = lambda 参数列表：函数体 即没有名字（这里面的“函数名”其实是一个变量）的函数，一般即写即用，只能使用一次。
# 定义一个匿名函数，计算两个数的和
sum = lambda x, y: x + y #这里是把lambda匿名函数的值传给sum这个变量# 调用匿名函数
result = sum(3, 4)
print(result) # 输出：7
5.递归函数：在一个函数的函数体内调用该函数本身的函数。
一个完整的递归操作由两部分组成 ：①递归调用条件；②递归终止条件（一般用if else结构）。
def fibonacci(n):"""计算斐波那契数列的第 n 个数,斐波那契数列：f(n)=f(n-1)+f(n-2) """if n < 2:return nelse:return fibonacci(n-1) + fibonacci(n-2)# 调用递归函数
result = fibonacci(6)
print(result) # 输出：8
6.常用的内置函数
①数据类型转换类
| 函数名称 | 描述说明 |
| bool(obj) | 获取指定对象obj的布尔值 |
| str(obj) | 将指定对象obj转成字符串类型 |
| int(x) | 将x转成int类型 |
| float(x) | 将x转成float类型 |
| list(sequence) | 将序列转成列表类型 |
| tuple(sequence) | 将序列转成元组类型 |
| set(sequence) | 将序列转成集合类型 |
②数学类
| 函数名称 | 描述说明 |
| abs(x) | 获取x的绝对值 |
| divmod(x,y) | 获取x与y的商和余数 |
| max(sequence) | 获取sequence的最大值 |
| min(sequence) | 获取sequence的最小值 |
| sum(iter) | 对可迭代对象进行求和运算 |
| pow(x,y) | 获取x的y次幂 |
| round(x,d) | 对x进行保留d位小数，结果四舍五入 |
③迭代器操作类
| 函数名称 | 描述说明 |
| sorted(iter) | 对可迭代对象进行排序 |
| reversed(sequence) | 反转序列生成新的迭代器对象 |
| zip(iter1,iter2) | 将iter1与iter2打包成元组并返回一个可迭代的zip对象 |
| enumerate(iter) | 根据iter对象创建一个enumerate对象 |
| all(iter) | 判断可迭代对象iter中所有元素的布尔值是否都为True |
| any(iter) | 判断可迭代对象iter中所有元素的布尔值是否都为False |
| next(iter) | 获取迭代器的下一个元素 |
| filter(function,iter) | 通过指定条件过滤序列并返回一个迭代器对象 |
| map(function,iter) | 通过函数function对可迭代对象iter的操作返回一个迭代器对象 |
④常用，其他类
| 函数名称 | 描述说明 |
| format(value,format_spec) | 将value以format_spec格式进行显示 |
| len(s) | 获取s的长度或s元素的个数 |
| id(obj) | 获取对象的内存地址 |
| type(x) | 获取x的数据类型 |
| eval(s) | 执s这个字符串所表示的Python代码 |
玄乎，学完一圈再回来
类是一种用于创建对象的蓝图或模板。它定义了对象的属性（状态）和方法（行为），并允许通过创建类的实例来使用这些属性和方法。类是一种抽象的概念，它描述了对象的共同特征和行为。可以将类看作是一种自定义数据类型，它定义了数据和操作数据的方法。确实抽象...还是用不大明白
对象是指在面向对象编程中的基本概念。对象是类的实例，它具有状态（属性或实例变量）和行为（方法或函数）。类是对象的模板或蓝图，它定义了对象的结构和行为。对象具有如下特点：①状态多样可变；②行为特定；③标识唯一性。
Python中“一切皆对象”
实例化：实例化是指创建一个类的对象。通过调用类的构造方法，可以创建一个对象，并将其分配给一个变量。对象是类的具体实例，它拥有类定义的属性和方法。
类名：类名是类的标识符，用于唯一标识一个类。通常使用驼峰命名法，将每个单词的首字母大写。
属性（属性也称为实例变量或成员变量）：属性是类中的数据，用于存储对象的状态。每个对象都有自己的属性值。你可以在类中定义属性，并使用它们来描述对象的特征。属性可以是任何数据类型，例如整数、浮点数、字符串等。
方法：方法是类中的函数，用于定义对象的行为或操作。方法定义在类中，并与类的实例相关联。通过调用对象的方法，可以执行特定的操作或访问对象的属性。方法可以接受参数，并且可以返回一个值。
构造方法（也称为初始化方法）：构造方法是一种特殊的方法，在创建对象时自动调用。它用于初始化对象的属性，并进行一些必要的设置。构造方法的名称是固定的，即__init__()。在构造方法中，通常会接受参数，并将其用于设置对象的初始状态。
继承：继承是一种类与类之间的关系，它允许一个类派生出另一个类，并继承父类的属性和方法。通过继承，子类可以扩展或修改父类的功能，实现代码的重用和层次化设计。
属性访问：通过点运算符（.）可以访问对象的属性和方法。例如，obj.attribute可以访问对象obj的属性，obj的方法。
类的组成：
①类的属性：直接定义在类之中，在方法之外的变量；
②实例属性：定义在__init__方法中，使用self.修饰（如：self.name = xm）的变量；
③实例方法：定义在类之中的函数：自带参数self；
④静态方法：使用@staticmethod修饰的方法；
⑤类方法：使用装饰器@classmethod修饰的方法。
一、动态绑定属性和方法
Python支持在不改变原来类的定义与方法的情况下动态绑定，此方法只对当前的对象实例作用，不影响其他对象和原来的类
①动态绑定属性：可以通过 w_attribute = value 格式 或者 setattr() 函数 来绑定新属性
②动态绑定方法：可以通过 w_method = newmethod（此处为已经定义好的新函数） 格式绑定新的方法
二、面向对象的特征
封装：封装是将数据和操作（方法）组合在一起形成一个单独的实体的过程。对象通过暴露有限的接口（公共方法）来与外部进行交互，隐藏内部的实现细节。这样可以保护数据的完整性，并提供更好的抽象和模块化。
继承：继承是一种机制，允许你定义一个新的类（子类），从现有的类（父类或基类）继承属性和方法。子类可以继承父类的特性，并可以在其基础上进行扩展、修改或重写。继承提供了代码重用和层次化组织的能力，使得类与类之间建立起了关系。
多态：多态性是指同一种操作或方法可以应用于不同类型的对象，并产生不同的行为。多态性通过方法的重写和方法的重载来实现。方法的重写是指子类对继承自父类的方法进行重新定义，以适应自己的特定需求。方法的重载是指在同一个类中定义多个具有相同名称但参数不同的方法。（即不改就是默认值，改了就是新值）
三、权限控制
通过对属性或者方法的格式的修改来实现权限表示与控制
单下划线开头（protected）：表示受保护的成员，被视为仅供内部使用，允许类本身和子类进行访问（实际上可以被外部代码访问）
双下划线（private）：表示私有的成员，这一类成员只允许定义了该属性或方法的类本身进行访问。即这一类成员其实是为了类里面的其他方法服务的（类似于JS中在函数内创建一个局部变量，仅仅在该函数内有用，当然，他有办法被调用，但是会破坏代码的封装性，不建议）
首尾双下划线：一般表示特殊方法
一、装饰器
装饰器是一种特殊的语法构造，用于修改或扩展函数的行为。装饰器本质上是一个函数，它接受一个函数作为输入，并返回一个新的函数作为输出。这个新的函数通常包装或装饰了原始函数，以便在执行原始函数之前或之后执行一些额外的代码。饰器提供了一种优雅而简洁的方式来修改函数的功能，而无需修改原始函数的定义。它们可以用于实现日志记录、性能分析、输入验证、缓存等功能，以及其他许多横切关注点。
语法：使用@符号，紧跟着装饰器函数的名称。当定义一个函数时，在函数的上方使用装饰器语法，可以将该函数传递给装饰器进行处理。
import timedef timing_decorator(func):def wrapper(*args, **kwargs):start_time = time.time()result = func(*args, **kwargs)end_time = time.time()execution_time = end_time - start_timeprint(f"函数 {func.__name__} 的执行时间为: {execution_time} 秒")return resultreturn wrapper@timing_decorator
def my_function():# 假装这里有一些复杂的操作time.sleep(2)my_function()二、魔术方法（双下方法）
其命名形式为 __方法名__，这些方法在类中具有特殊的用途和行为。这些特殊方法通常被称为魔术方法或双下方法
以下是一些常见的特殊方法：
__str__(self): 当使用 str(obj) 函数或 print(obj) 语句时调用，返回对象的字符串表示。__repr__(self): 当使用 repr(obj) 函数调用时调用，返回对象的“官方”字符串表示，通常是可以用来重建对象的表达式。__len__(self): 当使用 len(obj) 函数调用时调用，返回对象的长度。__getitem__(self, key): 当通过索引访问对象时调用，例如 obj[key]。__setitem__(self, key, value): 当通过索引设置对象的值时调用，例如 obj[key] = value。__delitem__(self, key): 当通过索引删除对象的值时调用，例如 del obj[key]。__iter__(self): 当对象需要进行迭代时调用，返回一个迭代器对象。__next__(self): 当迭代器对象需要获取下一个值时调用，返回序列中的下一个值。__enter__(self) 和 __exit__(self, exc_type, exc_val, exc_tb): 用于实现上下文管理器，定义了进入和退出上下文时的行为。三、迭代器
迭代器是一个用于遍历可迭代对象的对象。他通过实现特定的方法来提供逐个访问元素的功能，而不需要事先将所有元素存储在内存中。
迭代器的两个基本方法：①__iter__方法：返回迭代器对象自身。它允许迭代器在进行迭代时被多次使用。②__next__()方法：返回迭代器中的下一个元素。如果没有更多的元素可供迭代，它会引发 StopIteration 异常。
迭代器的工作方式是，当你对可迭代对象（如列表、字符串或自定义类）调用 iter() 函数时，它将返回一个迭代器对象。然后，你可以使用 next() 函数来逐个获取迭代器中的元素，直到达到迭代结束的条件为止。
#由于知识所限，以下为gpt提供的一个迭代器使用案例
class MyIterator:def __init__(self, data):self.data = dataself.index = 0def __iter__(self):return selfdef __next__(self):if self.index >= len(self.data):raise StopIterationvalue = self.data[self.index]self.index += 1return valuemy_list = [1, 2, 3, 4, 5]
my_iterator = iter(my_list)print(next(my_iterator)) # 输出: 1
print(next(my_iterator)) # 输出: 2
print(next(my_iterator)) # 输出: 3三、私有方法的修饰调用
虽然私有属性和方法不能直接访问，但它们并不是完全无法访问的。Python使用了一种名称修饰（name mangling）的机制，在名称前面添加了一个下划线和类名来改变其实际名称。这样，我们仍然可以通过 _类名__私有属性 或 _类名__私有方法 的方式访问或调用私有成员：
class MyClass:def __init__(self):self.__private_attribute = 42def __private_method(self):print("This is a private method.")def public_method(self):print("This is a public method.")self.__private_method()obj = MyClass()
print(obj.__private_attribute) # 无法直接访问，会引发 AttributeError
obj.__private_method() # 无法直接调用，会引发 AttributeError
obj.public_method() # 可以调用，通过公共方法间接调用私有方法print(obj._MyClass__private_attribute) # 可以通过名称修饰访问私有属性
obj._MyClass__private_method() # 可以通过名称修饰调用私有方法本文发布于:2024-01-30 06:23:47，感谢您对本站的认可！
本文链接：https://www.4u4v.net/it/170656703119862.html
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系，我们将在24小时内删除。
| 留言与评论（共有 0 条评论） |
