代码收藏家 python常用代码-自用
文章目录
python
1、三元表达式
# <expression1> if <condition> else <expression2>
x = 10
y = 20
# 使用三元表达式判断 x 和 y 的大小，并赋值给 result
result = "x 大于 y" if x > y else "x 小于或等于 y"
print(result) # 输出: x 小于或等于 y
2、列表生成式
# [expression for item in iterable if condition]
# expression：要计算并添加到新列表中的表达式。
# item：从可迭代对象中获取的元素。
# iterable：一个可迭代对象，例如列表、字符串、范围等。
# condition（可选）：过滤条件，只有满足条件的元素才会被包含在新列表中。
# 例子
# 创建一个包含 1 到 10 的平方的列表
squares = [x**2 for x in range(1, 11)]
print(squares) # 输出: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# 创建一个包含 1 到 10 中偶数的平方的列表
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(even_squares) # 输出: [4, 16, 36, 64, 100]
# 嵌套循环：创建一个包含 (i, j) 元组的列表，其中 i 是 1 到 3，j 是 1 到 2
pairs = [(i, j) for i in range(1, 4) for j in range(1, 3)]
print(pairs) # 输出: [(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2)]
# 带有多个条件的列表生成式（两个if相当于用and连接）
filtered_list = [x for x in range(20) if x % 2 == 0 if x % 3 == 0]
# 等价于下面
filtered_list = [x for x in range(20) if (x % 2 == 0 and x % 3 == 0)]
print(filtered_list) # 输出: [0, 6, 12, 18]
# 带有多个条件的列表生成式使用or连接
custom_list = [x for x in range(20) if x % 2 == 0 or if x % 5 == 0]
custom_list = [x for x in range(20) if (x % 2 == 0 or x % 5 == 0)]
print(custom_list) # 输出: [0, 2, 4, 5, 6, 8, 10, 12, 14, 15, 16, 18, 20]
# 从一个字符串中提取字母并转换为大写
text = "Hello, World!"
uppercase_letters = [char.upper() for char in text if char.isalpha()]
print(uppercase_letters) # 输出: ['H', 'E', 'L', 'L', 'O', 'W', 'O', 'R', 'L', 'D']
3、判断一个序列是不是另一个序列的子序列
def is_subsequence(a, b):
b = iter(b)
return all(i in b for i in a)
print(is_subsequence([1, 3], [0, 1, 2, 3])) # 输出: True
print(is_subsequence([1, 4], [0, 1, 2, 3])) # 输出: False
定义函数
def is_subsequence(a, b): 定义一个名为 is_subsequence 的函数，接受两个参数 a 和 b
创建迭代器
b = iter(b)：将 b 转换为一个迭代器。这样做的目的是为了在检查 b 中是否存在元素时，可以消耗掉 b 中的元素。换句话说，一旦某个元素在 b 中被找到，之后的查找会从该元素后面开始，而不是从头开始
检查子序列
return all(i in b for i in a)：
a 中的每个元素 i。i，它检查是否在迭代器 b 中。all() 函数会返回 True 当且仅当生成器表达式中的所有检查都返回 True。也就是说，只有当 a 中的每个元素都能在 b 中找到时，is_subsequence 才会返回 True4、 GIL 全局解释器锁（Global Interpreter Lock，简称 GIL）
Python 的全局解释器锁（Global Interpreter Lock，简称 GIL）是一个机制，用于确保在任何时刻只有一个线程可以执行 Python 字节码。这一设计主要是为了简化 CPython 的内存管理并避免多线程环境下的数据竞争和崩溃。但使用线程时的时候仍需要自己加锁来管理内存。
GIL 工作原理
单线程运行： GIL 使得 CPython 解释器在执行字节码时只允许一个线程运行。这意味着即使在多核处理器上，Python 程序也不能利用多个 CPU 核心进行并行计算。
线程切换： 当一个线程需要执行一段时间的操作（如 I/O 操作），GIL 会被释放，允许其他线程获取 GIL 并执行。这种切换通常发生在 I/O 阻塞、时间片到期等情况下。这样，虽然 GIL 限制了 CPU 密集型操作的并行性，但对于 I/O 密集型操作，多个线程仍然可以有效共享时间。
影响：
注： NumPy 的许多核心功能是用 C 和 Fortran 编写的，这些底层库可以在执行计算时释放 GIL。这意味着在进行大量数值计算时，NumPy 可以利用多核 CPU 的优势，特别是在调用外部库（如 BLAS 或 LAPACK）进行矩阵运算时
5、装饰器
简单装饰器
接收一个函数并返回一个函数# 外层函数（Decorator Function）：这个函数接受被装饰的函数作为参数
def decorator(func):
# 内层函数（Wrapper Function）：这个函数用于包装或增强被装饰的函数的行为。它通常会接受任意的参数，并在适当的时候调用原始函数。
def wrapper():
print("在函数执行前做点什么")
# 调用原始函数
func()
print("在函数执行后做点什么")
return wrapper
@decorator
def say_hello():
print("Hello!")
say_hello()
装饰器工厂
返回装饰器的函数。这种结构让你可以在创建装饰器时传递参数，从而控制装饰器的行为。最外层函数接收装饰器的配置参数，内层函数则是实际的装饰器，它接收一个函数并返回一个增强版的函数。# 简单装饰器本身不支持在装饰器应用时直接传递参数来控制其行为
def decorator_with_args(prefix):
def decorator(func):
def wrapper(*args, **kwargs):
print(prefix, "在函数执行前做点什么")
result = func(*args, **kwargs)
print(prefix, "在函数执行后做点什么")
return result
return wrapper
return decorator
@decorator_with_args("LOG:")
def say_hello():
print("Hello!")
say_hello()
类装饰器
类装饰器是使用类来实现装饰器的功能。类装饰器利用了类的 __call__ 方法，这使得类的实例可以被当作函数调用，使用类装饰器的优势在于它能够利用面向对象编程的特性，如继承、封装等，来构建更复杂的装饰器逻辑。
普通的装饰器用类方法实现
class CountCalls:
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
print("在函数执行前做点什么")
result = self.func(*args, **kwargs)
print("在函数执行后做点什么")
return result
@CountCalls
def say_hello():
print("Hello!")
say_hello()
装饰器工厂用类装饰器实现
from functools import wraps
class CountCalls:
def __init__(self, prefix):
self.prefix = prefix
def __call__(self, func):
# 将一些重要的元数据从原始函数（即被装饰的函数 func）复制到包装函数（即装饰器内部定义的函数 wrapper）。这些元数据包括函数的名称 __name__、文档字符串 __doc__、以及其他由用户定义的属性。
@wraps(func)
def wrapper(*args, **kwargs):
print(self.prefix, "在函数执行前做点什么")
result = func(*args, **kwargs)
print(self.prefix, "在函数执行后做点什么")
return result
return wrapper
@CountCalls(prefix='LOG:')
def say_hello():
print("Hello!")
say_hello()
当函数执行失败时按照传入参数重试
import logging
import time
from functools import wraps
from time import sleep
class Retry:
"""
类装饰器，当函数执行抛出异常时，按照max_retries和wait_time重试
"""
def __init__(self, max_retries=3, wait_time=2):
self.max_retries = max_retries
self.wait_time = wait_time
def __call__(self, func):
@wraps(func)
def wrapper(*args, **kwargs):
attempts = 0
while attempts < self.max_retries:
try:
return func(*args, **kwargs)
except Exception as e:
attempts += 1
logging.error(f"Error occurred: {e}. Retrying {attempts}/{self.max_retries}...")
time.sleep(self.wait_time) # 等待惩罚时间
if attempts == self.max_retries:
logging.error("Max retries reached. Giving up.")
return wrapper
@Retry(max_retries=5, wait_time=1)
def say_hello():
print("Hello!")
sleep(0.2)
raise Exception("手动抛出异常")
say_hello()
# Hello!
# ERROR:root:Error occurred: 手动抛出异常. Retrying 1/5...
# Hello!
# ERROR:root:Error occurred: 手动抛出异常. Retrying 2/5...
# Hello!
# ERROR:root:Error occurred: 手动抛出异常. Retrying 3/5...
# Hello!
# ERROR:root:Error occurred: 手动抛出异常. Retrying 4/5...
# Hello!
# ERROR:root:Error occurred: 手动抛出异常. Retrying 5/5...
# ERROR:root:Max retries reached. Giving up.
作者：吃不到的烤鱼
