python | zPytC

type

status

summary

date

slug

python常用函数：

all()

用于判断给定的可迭代参数 iterable 中的所有元素是否全部为 True。如果是，则返回 True，否则返回 False。

示例：all([True, True, 1]) 返回 True，因为所有元素都被视为 True。

any()

用于判断给定的可迭代参数 iterable 中是否至少有一个元素为 True。如果是，则返回 True，否则返回 False。

示例：any([False, False, 1]) 返回 True，因为存在一个元素（1）被视为 True。

dir()

用于返回对象的属性列表。如果不传递参数，默认返回当前局部符号表的列表。

示例：dir([1, 2, 3]) 返回列表对象的所有属性和方法。

id()

返回对象的唯一标识符，这个标识符在整个 Python 程序的运行过程中不会改变。

示例：id(123) 返回整数 123 的内存地址。

int()

将给定的参数转换为整数。如果参数是浮点数，则会截断小数部分。

示例：int(3.9) 返回 3。

len()

返回对象（如列表、元组、字典等）的长度。

示例：len([1, 2, 3]) 返回 3。

list()

将可迭代对象转换为列表。

示例：list((1, 2, 3)) 返回 [1, 2, 3]。

locals()

返回当前局部符号表的字典，包括在该作用域内定义的所有局部变量。

示例：在函数内部调用 locals() 可以获取该函数的局部变量。

max()

返回给定的可迭代对象或两个或多个参数中的最大值。

示例：max(1, 2, 3) 返回 3。

min()

返回给定的可迭代对象或两个或多个参数中的最小值。

示例：min(1, 2, 3) 返回 1。

open()

打开一个文件，并返回文件对象。可以指定不同的模式，如只读（'r'）、写入（'w'）等。

示例：open('example.txt', 'r') 打开 example.txt 文件以便读取。

print()

用于打印输出。可以接受多个参数，并将它们转换为字符串后输出。

示例：print("Hello, World!") 输出 Hello, World!。

round()

返回浮点数四舍五入后的结果。可以指定小数点后保留的位数。

示例：round(3.14159, 2) 返回 3.14。

sum()

计算可迭代对象（如列表、元组）中所有元素的总和。

示例：sum([1, 2, 3]) 返回 6。

type()

返回对象的类型。

示例：type(123) 返回 <class 'int'>。

vars()

返回对象的 __dict__ 属性，即对象的命名空间字典。如果对象没有 __dict__ 属性，则返回 None。

示例：vars(some_object) 返回 some_object 的命名空间字典。

zip()

将多个可迭代对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

示例：zip([1, 2, 3], ['a', 'b', 'c']) 返回 [(1, 'a'), (2, 'b'), (3, 'c')]。

这些函数在Python编程中非常常用，掌握它们的用法对于编写高效的代码非常有帮助。

python模块化编程:

模块和包：

第三方开源模块：

requests，numpy等

pip install 包

os&sys模块常用方法：

sys.path获取环境变量中的path

sys.argv获取命令行参数

os.listdir()获取目录，os.remove()删除一个文件

时间处理模块（time）：

datetime模块：

1.时间表达

2.时间运算

3.时间替换

随机数random模块：

模块常用方法如上

excel处理模块：

openpyxl模块：

openpyxl 是一个用于读写 Excel 2010 xlsx/xlsm/xltx/xltm 文件的 Python 库。它支持读取和写入 Excel 文件、操作单元格、设置样式、处理公式等。以下是 openpyxl 中一些常用的操作 Excel 文件的用法：

1. 安装 `openpyxl`

在使用 openpyxl 之前，需要先安装它：

bash复制

pip install openpyxl

2. 打开和保存 Excel 文件

Python复制

from openpyxl import load_workbook, Workbook

# 打开一个现有的 Excel 文件
wb = load_workbook('example.xlsx')

# 创建一个新的 Excel 文件
wb = Workbook()
wb.save('new_example.xlsx')

3. 操作工作表

获取工作表

Python复制

# 获取默认的工作表
ws = wb.active

# 获取指定名称的工作表
ws = wb['Sheet1']

# 创建新的工作表
wb.create_sheet('NewSheet')

获取工作表名称

Python复制

print(wb.sheetnames) # 输出所有工作表名称

4. 操作单元格

写入数据

Python复制

# 写入单个单元格
ws['A1'] = 'Hello'
ws['B1'] = 42

# 写入多行数据
rows = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
for row in rows:
    ws.append(row)

读取数据

Python复制

# 读取单个单元格
cell_value = ws['A1'].value
print(cell_value)

# 遍历工作表中的所有行和列
for row in ws.iter_rows(min_row=1, max_col=3, max_row=3, values_only=True):
    print(row)

5. 设置单元格样式

设置字体

Python复制

from openpyxl.styles import Font

# 设置字体样式
font = Font(name='Arial', size=14, bold=True, italic=True, color='FF0000')
ws['A1'].font = font

设置单元格颜色

Python复制

from openpyxl.styles import PatternFill

# 设置单元格背景颜色
fill = PatternFill(start_color='FFFF00', end_color='FFFF00', fill_type='solid')
ws['A1'].fill = fill

设置对齐方式

Python复制

from openpyxl.styles import Alignment

# 设置单元格对齐方式
alignment = Alignment(horizontal='center', vertical='center')
ws['A1'].alignment = alignment

6. 处理公式

Python复制

# 设置公式
ws['A1'] = 10
ws['A2'] = 20
ws['A3'] = '=SUM(A1:A2)'

# 计算公式结果
wb.save('example.xlsx')  # 公式计算需要保存后重新加载
wb = load_workbook('example.xlsx', data_only=True)
print(ws['A3'].value)  # 输出公式的结果

7. 插入图片

Python复制

from openpyxl.drawing.image import Image

# 插入图片
img = Image('example.png')
ws.add_image(img, 'A1')
wb.save('example.xlsx')

8. 数据验证

Python复制

from openpyxl.worksheet.datavalidation import DataValidation

# 添加数据验证
dv = DataValidation(type="list", formula1='"Dog,Cat,Bird"', allow_blank=True)
ws.add_data_validation(dv)
dv.add('A1')

9. 合并和拆分单元格

Python复制

# 合并单元格
ws.merge_cells('A1:C1')
ws['A1'] = 'Merged Cells'

# 拆分单元格
ws.unmerge_cells('A1:C1')

10. 保存文件

Python复制

wb.save('example.xlsx')

总结

openpyxl 提供了非常强大的功能来操作 Excel 文件，包括读写数据、设置样式、处理公式、插入图片等。通过这些功能，可以轻松实现对 Excel 文件的各种操作。

python发送邮件：

smtplib模块发送邮件：smtp是一个邮件发送规则，

1.登录邮件服务器

2.构建符合服务器规则的内容（email模块）

3.发送

初使用python爬虫：

1.豆瓣用户数据信息爬取：

import requests：下载网页

page_obj = requests.get(url,headers = headers)

bs4_obj = bs4.BeautifulSoup(page_obj.text,”lxml”)

comment_eles = bs4_obj.find_all(”div”,attrs = {”class”:reply-doc})

这段代码的目的是从一个网页中获取内容，并使用BeautifulSoup库解析HTML，提取特定的评论元素。不过，代码中存在一些错误和不规范的地方。下面我将逐行解释代码的功能，并指出其中的问题。

代码解释

1. `page_obj = requests.get(url, headers=headers)`

功能：使用 requests 库向指定的 url 发送一个HTTP GET请求，并传递自定义的请求头 headers。

返回值：page_obj 是一个 Response 对象，包含了服务器返回的响应内容（如HTML、状态码等）。

问题：

如果 url 或 headers 未定义，代码会报错。
最好添加异常处理（如 try-except）来捕获可能的网络请求错误。

2. `bs4_obj = bs4.BeautifulSoup(page_obj.txt, "lxml")`

功能：使用 BeautifulSoup 解析 page_obj 中的HTML内容，并将其转换为一个 BeautifulSoup 对象，方便后续的HTML解析。

参数：

page_obj.txt：应该是 page_obj.text，text 是 Response 对象的属性，用于获取响应的文本内容（即HTML代码）。
"lxml"：指定使用 lxml 解析器来解析HTML。

问题：

page_obj.txt 是错误的写法，应该是 page_obj.text。
如果没有安装 lxml 解析器，代码会报错。可以改用Python内置的 html.parser，如 bs4.BeautifulSoup(page_obj.text, "html.parser")。

3. `comment_eles = bs4_obj.final_all("div", attrs={"class": "reply-doc"})`

功能：从解析后的 BeautifulSoup 对象中查找所有符合特定条件的HTML元素。

"div"：指定查找的标签类型为 <div>。
attrs={"class": "reply-doc"}：指定查找的 <div> 标签需要具有 class="reply-doc" 的属性。

返回值：comment_eles 是一个包含所有匹配元素的列表（如果没有找到匹配的元素，则返回空列表）。

问题：

final_all 是错误的写法，应该是 find_all。
attrs={"class": "reply-doc"} 中的 class 是Python的保留关键字，如果类名中包含特殊字符（如空格），需要使用 class_ 代替 class，如 attrs={"class_": "reply-doc"}。

修正后的代码

代码功能总结

发送HTTP请求获取网页内容。

使用 BeautifulSoup 解析HTML。

查找所有 class="reply-doc" 的 <div> 标签，并提取其内容。

注意事项

依赖库：确保已安装 requests 和 bs4 库。可以通过以下命令安装：

异常处理：在实际开发中，建议添加异常处理逻辑，以应对网络请求失败或解析错误的情况。

类名处理：如果类名中包含特殊字符（如空格），需要使用 class_ 代替 class。

希望这段解释对你有帮助！如果还有其他问题，欢迎继续提问。

💡

什么是正则表达式？

正则表达式（Regular Expression，简称 regex 或 regexp）是一种用于匹配和处理文本的强大工具。它通过定义一种模式（pattern），可以用来搜索、替换、提取或验证字符串中的特定内容。

正则表达式的核心思想是：

用特定的符号和语法来描述字符串的规则。

通过模式匹配，快速找到符合规则的文本。

正则表达式的应用场景

文本搜索：在大量文本中查找符合特定模式的字符串。

数据验证：验证用户输入是否符合格式要求（如邮箱、电话号码、密码等）。

文本替换：将符合模式的文本替换为指定内容。

数据提取：从文本中提取特定部分（如提取网页中的链接或日期）。

文本分割：根据模式将文本分割成多个部分。

正则表达式在哪些编程语言中存在？

正则表达式是一种通用的工具，几乎在所有主流编程语言中都得到了支持。以下是一些常见的编程语言及其正则表达式的实现方式：

编程语言	正则表达式支持库/模块	示例代码
Python	`re` 模块	`import re; re.findall(r'\\d+', 'abc123')`
JavaScript	内置支持（`RegExp` 对象）	`const regex = /\\d+/g; 'abc123'.match(regex)`
Java	`java.util.regex` 包	`Pattern.compile("\\\\d+").matcher("abc123").find()`
C#	`System.Text.RegularExpressions` 命名空间	`Regex.Match("abc123", @"\\d+")`
PHP	`preg_*` 函数族	`preg_match('/\\d+/', 'abc123', $matches)`
Ruby	内置支持（`Regexp` 类）	`'abc123'.scan(/\\d+/)`
Perl	内置支持（正则表达式是核心特性）	`my $str = 'abc123'; $str =~ /\\d+/`
Go	`regexp` 包	`regexp.MustCompile(`\d+`).FindString("abc123")`
Rust	`regex` 库	`let re = Regex::new(r"\\d+").unwrap(); re.find("abc123")`

正则表达式的基本语法

正则表达式由普通字符（如字母、数字）和特殊字符（称为 元字符）组成。以下是一些常用的元字符：

元字符	描述
`.`	匹配任意单个字符（除换行符外）
`*`	匹配前面的字符 0 次或多次
`+`	匹配前面的字符 1 次或多次
`?`	匹配前面的字符 0 次或 1 次
`\\d`	匹配数字（等价于 `[0-9]`）
`\\w`	匹配字母、数字或下划线（等价于 `[a-zA-Z0-9_]`）
`\\s`	匹配空白字符（包括空格、制表符、换行符等）
`^`	匹配字符串的开头
`$`	匹配字符串的结尾
`[]`	匹配括号内的任意一个字符（如 `[abc]` 匹配 `a`、`b` 或 `c`）
`()`	分组，用于提取或捕获匹配的内容
`	`
`{n}`	匹配前面的字符恰好 n 次
`{n,m}`	匹配前面的字符至少 n 次，至多 m 次

正则表达式的使用示例

以下是几种常见编程语言中使用正则表达式的示例：

1. Python

2. JavaScript

3. Java

4. C#

总结

正则表达式是一种强大的文本处理工具，用于匹配、搜索、替换和提取字符串。

它几乎在所有主流编程语言中都得到了支持，语法基本一致。

学习正则表达式的关键是掌握其元字符和语法规则，并通过实践熟悉其使用场景。

如果你有更多关于正则表达式的问题，欢迎继续提问！

🔑

python中的动态传参：

在 Python 中，动态传参是一种非常灵活的特性，允许函数接受任意数量的参数。这种特性在处理不确定数量的输入时非常有用。Python 提供了两种主要的动态传参方式：

args：用于传递任意数量的位置参数（非关键字参数）。

*kwargs：用于传递任意数量的关键字参数（键值对参数）。

下面详细介绍这两种方式及其用法。

1. `args`：动态传递位置参数

作用：允许函数接受任意数量的位置参数。

特点：

参数会被打包成一个元组（tuple）。
args 是约定俗成的名称，可以替换为其他名称，但是必须的。

适用场景：当函数需要处理不确定数量的非关键字参数时。

示例：

解释：

args 将所有传入的位置参数打包成一个元组 (1, 2, 3) 或 (10, 20, 30, 40)。

在函数内部，可以通过遍历 args 来处理这些参数。

2. `*kwargs`：动态传递关键字参数

作用：允许函数接受任意数量的关键字参数。

特点：

参数会被打包成一个字典（dict）。
kwargs 是约定俗成的名称，可以替换为其他名称，但 * 是必须的。

适用场景：当函数需要处理不确定数量的关键字参数时。

示例：

解释：

*kwargs 将所有传入的关键字参数打包成一个字典 {'name': 'Alice', 'age': 25, 'city': 'New York'}。

在函数内部，可以通过遍历 kwargs.items() 来处理这些键值对。

3. 结合使用 `args` 和 `*kwargs`

作用：允许函数同时接受任意数量的位置参数和关键字参数。

特点：

args 必须在 *kwargs 之前。
可以同时处理位置参数和关键字参数。

示例：

4. 动态传参的实际应用

示例 1：包装函数

动态传参常用于包装函数，将参数传递给另一个函数。

示例 2：装饰器

动态传参是装饰器的核心特性之一。

示例 3：继承与构造函数

在类的继承中，动态传参可以用于灵活处理父类的构造函数。

5. 动态传参的解包

除了在函数定义中使用 *args 和 **kwargs，还可以在函数调用时使用 * 和 ** 对参数进行解包。

示例：

总结

args：用于传递任意数量的位置参数，打包成元组。

*kwargs：用于传递任意数量的关键字参数，打包成字典。

动态传参使函数更加灵活，适用于处理不确定数量的参数。

动态传参常用于包装函数、装饰器、继承等场景。

掌握动态传参可以让你的 Python 代码更加简洁和强大！如果还有其他问题，欢迎继续提问。

python中的名称空间和作用域

在 Python 中，名称空间（Namespace） 和 作用域（Scope） 是两个非常重要的概念，它们决定了变量、函数和对象的可见性和生命周期。理解它们对于编写高效、可维护的代码至关重要。

1. 名称空间（Namespace）

什么是名称空间？

名称空间是一个从名称到对象的映射。简单来说，它是一个存储变量名和对象之间关系的系统。

Python 中的名称空间类似于字典，其中键是变量名，值是对应的对象。

名称空间的类型

Python 中有以下几种名称空间：

内置名称空间（Built-in Namespace）：

包含 Python 内置的函数和对象（如 print、len、int 等）。

在 Python 解释器启动时创建，程序结束时销毁。

全局名称空间（Global Namespace）：

包含模块级别定义的变量、函数和类。

在模块被导入时创建，程序结束时销毁。

局部名称空间（Local Namespace）：

包含函数或方法内部定义的变量。

在函数或方法调用时创建，函数或方法结束时销毁。

名称空间的示例

在这个例子中：

x 属于全局名称空间。
y 属于 foo 函数的局部名称空间。

2. 作用域（Scope）

什么是作用域？

作用域是名称空间在程序中的可见范围。它决定了在程序的哪些部分可以访问某个名称空间中的变量。

Python 使用 LEGB 规则 来确定变量的作用域。

LEGB 规则

Python 的作用域遵循 LEGB 规则，即：

L（Local）：局部作用域，例如函数或方法内部。

E（Enclosing）：嵌套函数的外层函数作用域。

G（Global）：全局作用域，模块级别。

B（Built-in）：内置作用域，Python 内置的函数和对象。

作用域的示例

输出：

在这个例子中：

x 是全局变量。
y 是外层函数 outer 的局部变量。
z 是内层函数 inner 的局部变量。
inner 函数可以访问全局、外层和局部作用域中的变量。

3. 名称空间与作用域的关系

名称空间是变量名和对象的映射。

作用域是名称空间的可见范围。

每个作用域对应一个名称空间。

4. 全局变量与局部变量

全局变量

在函数外部定义的变量是全局变量。

全局变量在整个模块中可见。

局部变量

在函数内部定义的变量是局部变量。

局部变量只在函数内部可见。

示例

5. `global` 和 `nonlocal` 关键字

`global` 关键字

用于在函数内部修改全局变量。

如果不使用 global，函数内部会创建一个同名的局部变量。

示例：

`nonlocal` 关键字

用于在嵌套函数中修改外层函数的变量。

如果不使用 nonlocal，内层函数会创建一个同名的局部变量。

示例：

6. 名称空间的生命周期

内置名称空间：Python 解释器启动时创建，程序结束时销毁。

全局名称空间：模块导入时创建，程序结束时销毁。

局部名称空间：函数或方法调用时创建，函数或方法结束时销毁。

7. 名称空间与作用域的实际应用

示例 1：避免变量冲突

示例 2：闭包

总结

名称空间是变量名和对象的映射，分为内置、全局和局部名称空间。

作用域是名称空间的可见范围，遵循 LEGB 规则。

使用 global 和 nonlocal 可以在函数内部修改全局或外层函数的变量。

理解名称空间和作用域有助于编写高效、可维护的代码。

希望这个解释能帮助你更好地理解 Python 中的名称空间和作用域！如果还有其他问题，欢迎继续提问。

通用装饰器：

迭代器

在 Python 中，迭代器（Iterator） 是一种用于遍历集合（如列表、元组、字典等）的对象。它提供了一种统一的方式来访问集合中的元素，而不需要了解集合的内部结构。迭代器是 Python 中实现迭代协议的核心。

1. 什么是迭代器？

迭代器是一个实现了迭代协议的对象。

迭代协议要求对象实现以下两个方法：

__iter__()：返回迭代器对象本身。

__next__()：返回集合中的下一个元素。如果没有更多元素，则抛出 StopIteration 异常。

迭代器是惰性计算的，即每次只生成一个元素，而不是一次性生成所有元素。

2. 迭代器的特点

只能向前：迭代器只能向前遍历集合，不能回退或重置。

一次性：迭代器遍历完集合后，不能再次使用。如果需要重新遍历，必须重新创建迭代器。

节省内存：由于迭代器是惰性计算的，它不会一次性加载所有数据到内存中，适合处理大型数据集。

3. 迭代器的使用

示例 1：使用内置迭代器

Python 中的许多内置对象（如列表、元组、字符串、字典等）都是可迭代对象（Iterable），可以通过 iter() 函数获取它们的迭代器。

示例 2：使用 `for` 循环遍历迭代器

for 循环会自动处理迭代器的创建和 StopIteration 异常。

输出：

4. 自定义迭代器

可以通过实现 __iter__() 和 __next__() 方法来自定义迭代器。

示例：自定义一个简单的迭代器

输出：

5. 迭代器与可迭代对象的区别

可迭代对象（Iterable）：

实现了 __iter__() 方法，返回一个迭代器。
例如：列表、元组、字符串、字典、集合等。

迭代器（Iterator）：

实现了 __iter__() 和 __next__() 方法。
例如：通过 iter() 函数获取的迭代器，或自定义的迭代器。

示例：可迭代对象与迭代器的关系

6. 迭代器的优势

节省内存：迭代器是惰性计算的，适合处理大型数据集。

通用性：迭代器提供了一种统一的遍历方式，适用于各种集合类型。

灵活性：可以通过自定义迭代器实现复杂的遍历逻辑。

7. 内置的迭代器工具

Python 提供了一些内置的工具来简化迭代器的使用：

itertools 模块：

提供了许多用于操作迭代器的函数，如 count、cycle、repeat、chain、zip_longest 等。

示例：

生成器（Generator）：

生成器是一种特殊的迭代器，使用 yield 关键字定义。

示例：

8. 迭代器的实际应用

示例 1：遍历文件内容

示例 2：处理大型数据集

总结

迭代器是实现了 __iter__() 和 __next__() 方法的对象。

迭代器是惰性计算的，适合处理大型数据集。

可以通过 iter() 函数获取可迭代对象的迭代器，也可以通过自定义类实现迭代器。

迭代器与生成器、itertools 模块等工具结合使用，可以极大地提高代码的效率和灵活性。

希望这个解释能帮助你更好地理解 Python 中的迭代器！如果还有其他问题，欢迎继续提问。

生成器

在 Python 中，生成器（Generator） 是一种特殊的迭代器，它允许你按需生成值，而不是一次性生成所有值。生成器非常适合处理大型数据集或无限序列，因为它们可以节省内存并提高性能。

1. 什么是生成器？

生成器是一个函数或表达式，使用 yield 关键字返回值。

每次调用生成器时，它会从上次暂停的地方继续执行，直到遇到下一个 yield 或函数结束。

生成器是惰性计算的，只有在需要时才会生成值。

2. 生成器的特点

惰性计算：生成器按需生成值，不会一次性加载所有数据到内存中。

节省内存：适合处理大型数据集或无限序列。

只能遍历一次：生成器是一次性的，遍历完后不能再次使用。

简洁高效：生成器的代码通常比普通迭代器更简洁。

3. 生成器的创建

方法 1：生成器函数

使用 def 定义函数，并在函数中使用 yield 返回值。

示例：

输出：

方法 2：生成器表达式

类似于列表推导式，但使用圆括号 () 而不是方括号 []。

示例：

输出：

4. 生成器的工作原理

当调用生成器函数时，它不会立即执行，而是返回一个生成器对象。

每次调用 next() 或使用 for 循环遍历生成器时，函数会从上次暂停的地方继续执行，直到遇到 yield。

当函数执行完毕或遇到 return 时，生成器会抛出 StopIteration 异常。

示例：

5. 生成器的优势

节省内存：生成器按需生成值，适合处理大型数据集。

简洁高效：生成器的代码通常比普通迭代器更简洁。

无限序列：生成器可以表示无限序列（如斐波那契数列）。

6. 生成器的实际应用

示例 1：生成斐波那契数列

输出：

示例 2：读取大文件

7. 生成器与普通函数的区别

特性	生成器函数	普通函数
返回值	使用 `yield` 返回值	使用 `return` 返回值
执行方式	惰性计算，按需生成值	立即执行，返回结果
内存占用	节省内存	可能占用大量内存
状态保存	保存局部变量和执行状态	不保存状态

8. 生成器的高级用法

`yield from`

用于将另一个生成器的值直接传递给当前生成器。

示例：

输出：

生成器与协程

生成器可以用于实现简单的协程（Coroutine），通过 send() 方法向生成器发送数据。

示例：

9. 生成器的注意事项

只能遍历一次：生成器是一次性的，遍历完后不能再次使用。

惰性计算：生成器只有在需要时才会生成值，因此不适合需要立即获取所有结果的场景。

性能优化：在处理大型数据集时，生成器可以显著减少内存占用。

总结

生成器是一种特殊的迭代器，使用 yield 关键字返回值。

生成器是惰性计算的，适合处理大型数据集或无限序列。

生成器的代码通常比普通迭代器更简洁高效。

生成器可以用于实现协程、读取大文件、生成无限序列等场景。

希望这个解释能帮助你更好地理解 Python 中的生成器！如果还有其他问题，欢迎继续提问。

各种推导式：

1.列表推导式：

[结果 for循环 if条件]

list = [i for i in range(1,11)]

list2 = [i for i in range(1,11) if i%2==1]

list3 = [i**2 for i in range(1,11) ]

list4 = [”python x %s” % i for i in range(1,11)]

2.字典推导式：{key : value for if}

lst = {i:lst[i] for in range(1,11) if i%2 == 0}

3.集合推导式{key for if}

s = {itme for item in lst}

4.生成器推导式：

s = (item for item in range(1,5) if item >1)

lambda

f = lambda n:n**n

类似javascript中的 n ⇒ n**n(如果javascript中存在**)

lambda a,b : a+b

但是其实python中的lambda比javascript中的lambda能力弱很多，python中的lambda只是在写很简单的函数的时候能增强效率，但是在写大一点的函数就很有局限性了

pickle模块

json模块

shutil模块

loggin模块

异常处理模块

traceback和loggin模块的结合使用记录错误日志

zipfile模块

python中的正则表达式

正则表达式（Regular Expression，简称 regex 或 regexp）是一种强大的工具，用于匹配、查找和操作文本。Python 通过内置的 re 模块提供了对正则表达式的支持。以下是 Python 中正则表达式的基本用法和常见操作。

1. 导入 `re` 模块

在使用正则表达式之前，需要先导入 re 模块：

2. 基本匹配

使用 re.match() 或 re.search() 来匹配字符串。

re.match()：从字符串的起始位置匹配，如果起始位置不匹配则返回 None。

re.search()：扫描整个字符串，返回第一个匹配的结果。

示例：

3. 常用正则表达式符号

以下是正则表达式中常用的符号和语法：

符号	描述
`.`	匹配任意字符（除了换行符 `\\n`）
`\\d`	匹配数字（等价于 `[0-9]`）
`\\D`	匹配非数字（等价于 `[^0-9]`）
`\\w`	匹配字母、数字或下划线（等价于 `[a-zA-Z0-9_]`）
`\\W`	匹配非字母、数字或下划线（等价于 `[^a-zA-Z0-9_]`）
`\\s`	匹配空白字符（包括空格、制表符、换行符等）
`\\S`	匹配非空白字符
`[]`	匹配括号内的任意一个字符（例如 `[abc]` 匹配 `a`、`b` 或 `c`）
`[^]`	匹配不在括号内的任意字符（例如 `[^abc]` 匹配非 `a`、`b`、`c` 的字符）
`*`	匹配前面的字符 0 次或多次
`+`	匹配前面的字符 1 次或多次
`?`	匹配前面的字符 0 次或 1 次
`{n}`	匹配前面的字符恰好 n 次
`{n,}`	匹配前面的字符至少 n 次
`{n,m}`	匹配前面的字符至少 n 次，至多 m 次
`^`	匹配字符串的开头
`$`	匹配字符串的结尾
`	`
`()`	分组，捕获匹配的内容

4. 查找所有匹配

使用 re.findall() 查找字符串中所有匹配的子串。

示例：

5. 替换字符串

使用 re.sub() 替换字符串中的匹配部分。

示例：

6. 分组捕获

使用 () 进行分组，并通过 group() 方法获取捕获的内容。

示例：

7. 编译正则表达式

如果需要多次使用同一个正则表达式，可以将其编译为 re.Pattern 对象，以提高效率。

示例：

8. 贪婪与非贪婪匹配

正则表达式默认是贪婪匹配（尽可能匹配更多的字符）。可以通过 ? 实现非贪婪匹配（尽可能匹配更少的字符）。

示例：

9. 常用函数总结

函数	描述
`re.match(pattern, string)`	从字符串开头匹配正则表达式，返回匹配对象或 `None`。
`re.search(pattern, string)`	扫描整个字符串，返回第一个匹配对象或 `None`。
`re.findall(pattern, string)`	返回所有匹配的子串列表。
`re.sub(pattern, repl, string)`	替换字符串中所有匹配的子串。
`re.compile(pattern)`	将正则表达式编译为 `re.Pattern` 对象，便于重复使用。

10. 示例：验证邮箱地址

11. 示例：提取 URL

python中list,dict,tuple中的增删改查：

在 Python 中，列表（List）、字典（Dict） 和 元组（Tuple） 是三种常用的数据结构。它们各自有不同的特性和操作方法。以下是它们的增删改查操作详解：

1. 列表（List）

列表是一个有序、可变的序列，可以存储任意类型的元素。

（1）增加元素

append()：在列表末尾添加一个元素。

insert()：在指定位置插入一个元素。

extend()：将另一个列表的元素添加到当前列表末尾。

示例：

（2）删除元素

remove()：删除列表中第一个匹配的元素。

pop()：删除指定位置的元素（默认删除最后一个）。

del：通过索引删除元素。

clear()：清空整个列表。

示例：

（3）修改元素

通过索引直接修改元素。

示例：

（4）查找元素

索引：通过索引访问元素。

index()：查找某个元素的索引。

in 关键字：判断元素是否在列表中。

示例：

2. 字典（Dict）

字典是一个无序、可变的键值对集合，键必须是唯一的。

（1）增加元素

直接通过键赋值。

示例：

（2）删除元素

pop()：删除指定键的元素。

popitem()：删除最后一个键值对（Python 3.7+ 有序）。

del：通过键删除元素。

clear()：清空整个字典。

示例：

（3）修改元素

通过键直接修改值。

示例：

（4）查找元素

通过键访问值。

get()：安全访问值（键不存在时返回默认值）。

in 关键字：判断键是否在字典中。

示例：

3. 元组（Tuple）

元组是一个有序、不可变的序列，通常用于存储不可修改的数据。

（1）增加元素

元组是不可变的，无法直接增加元素。但可以通过拼接创建新元组。

示例：

（2）删除元素

元组是不可变的，无法直接删除元素。但可以通过切片创建新元组。

示例：

（3）修改元素

元组是不可变的，无法直接修改元素。但可以通过切片创建新元组。

示例：

（4）查找元素

索引：通过索引访问元素。

index()：查找某个元素的索引。

in 关键字：判断元素是否在元组中。

示例：

总结

操作	列表（List）	字典（Dict）	元组（Tuple）
增加	`append()`、`insert()`	直接赋值	拼接创建新元组
删除	`remove()`、`pop()`	`pop()`、`del`	无法直接删除
修改	通过索引修改	通过键修改	无法直接修改
查找	索引、`index()`、`in`	通过键访问、`get()`、`in`	索引、`index()`、`in`

通过掌握这些基本操作，你可以灵活使用列表、字典和元组来处理各种数据需求！

python常用函数：

python模块化编程:

时间处理模块（time）：

datetime模块：

随机数random模块：

excel处理模块：

1. 安装 openpyxl

bash复制

2. 打开和保存 Excel 文件

Python复制

3. 操作工作表

获取工作表

Python复制

获取工作表名称

Python复制

4. 操作单元格

写入数据

Python复制

读取数据

Python复制

5. 设置单元格样式

设置字体

Python复制

设置单元格颜色

Python复制

设置对齐方式

Python复制

6. 处理公式

Python复制

7. 插入图片

Python复制

8. 数据验证

Python复制

9. 合并和拆分单元格

Python复制

10. 保存文件

Python复制

总结

python发送邮件：

初使用python爬虫：

代码解释

1. page_obj = requests.get(url, headers=headers)

2. bs4_obj = bs4.BeautifulSoup(page_obj.txt, "lxml")

3. comment_eles = bs4_obj.final_all("div", attrs={"class": "reply-doc"})

修正后的代码

代码功能总结

注意事项

什么是正则表达式？

正则表达式的应用场景

正则表达式在哪些编程语言中存在？

正则表达式的基本语法

正则表达式的使用示例

1. Python

2. JavaScript

3. Java

4. C#

总结

python中的动态传参：

1. args：动态传递位置参数

示例：

解释：

2. *kwargs：动态传递关键字参数

示例：

解释：

3. 结合使用 args 和 *kwargs

示例：

4. 动态传参的实际应用

示例 1：包装函数

示例 2：装饰器

示例 3：继承与构造函数

5. 动态传参的解包

示例：

总结

python中的名称空间和作用域

1. 名称空间（Namespace）

什么是名称空间？

名称空间的类型

名称空间的示例

2. 作用域（Scope）

什么是作用域？

1. 安装 `openpyxl`

1. `page_obj = requests.get(url, headers=headers)`

2. `bs4_obj = bs4.BeautifulSoup(page_obj.txt, "lxml")`

3. `comment_eles = bs4_obj.final_all("div", attrs={"class": "reply-doc"})`

1. `args`：动态传递位置参数

2. `*kwargs`：动态传递关键字参数

3. 结合使用 `args` 和 `*kwargs`

5. `global` 和 `nonlocal` 关键字

`global` 关键字

`nonlocal` 关键字

示例 2：使用 `for` 循环遍历迭代器

`yield from`

1. 导入 `re` 模块