上一篇文章
Python中那些简单又好用的特性和用法
发出后，群里的小伙伴又给补充了几个好用的用法，结合生产实用经验汇总整理如下，各位看官如有需要请自取

  1. 反射，反射是一种机制，可以在运行时获取、检查和修改对象的属性和方法。Python提供了一些内置的函数和属性，可以用于实现反射操作

dir()函数：返回对象的所有属性和方法的列表

class MyClass:
    def __init__(self):
        self.name = "运维咖啡吧"
        self.age = 25

my_obj = MyClass()
print(dir(my_obj))

getattr()函数：获取对象的属性或方法

class MyClass:
    def __init__(self):
        self.name = "运维咖啡吧"
        self.age = 25

my_obj = MyClass()
name = getattr(my_obj, "name")
print(name)

setattr()函数：设置对象的属性或方法

class MyClass:
    def __init__(self):
        self.name = "运维咖啡吧"
        self.age = 25

my_obj = MyClass()
setattr(my_obj, "name", "blog.ops-coffee.cn")
print(my_obj.name)

hasattr()函数：检查对象是否具有指定的属性或方法

class MyClass:
    def __init__(self):
        self.name = "运维咖啡吧"
        self.age = 25

my_obj = MyClass()
has_name = hasattr(my_obj, "name")
print(has_name)

这些函数和属性可以帮助你在运行时动态地访问和修改对象的属性和方法。反射为编写更灵活和通用的代码提供了一种机制，可以根据需要操作对象的属性和方法

  1. 交换变量，这是一种非常常见和方便的操作，可以在需要时快速交换变量的值
a = 10
b = 20

a, b = b, a

print(a, b)  # 输出: 20 10
  1. 可迭代对象解包，它允许你将可迭代对象的元素解包到单独的变量中。这对于同时处理多个值非常有用
# 解包元组
a, b, c = (1, 2, 3)
print(a, b, c)   # 输出: 1 2 3

# 解包列表
x, y, z = [4, 5, 6]
print(x, y, z)   # 输出: 4 5 6
  1. 深复制和浅复制，当处理复杂的数据结构时，深复制和浅复制允许你创建对象的副本。深复制会创建一个全新的对象，而浅复制会创建一个新对象，但共享内部数据。
import copy

# 创建一个列表
original_list = [1, 2, [3, 4]]

# 浅复制
shallow_copy = copy.copy(original_list)

# 深复制
deep_copy = copy.deepcopy(original_list)

# 修改原始列表中的嵌套列表
original_list[2][0] = 5

print(original_list)   # 输出: [1, 2, [5, 4]]
print(shallow_copy)    # 输出: [1, 2, [5, 4]]
print(deep_copy)       # 输出: [1, 2, [3, 4]]
  1. with语句的多个上下文管理器：在一个with语句中，你可以同时使用多个上下文管理器，以便在代码块执行前后执行多个操作
class CustomContextManager1:
    def __enter__(self):
        print("Entering CustomContextManager1")

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Exiting CustomContextManager1")

class CustomContextManager2:
    def __enter__(self):
        print("Entering CustomContextManager2")

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Exiting CustomContextManager2")

# 使用多个上下文管理器
with CustomContextManager1(), CustomContextManager2():
    # 在这里执行一些操作

比较常用的是一次打开多个文件进行操作，例如同时打开文件1和文件2，读取文件1内容处理后写入文件2

with open("file1.txt") as file1, open("file2.txt") as file2:
    # 在这里可以使用file1和file2进行操作
  1. 装饰器，通过装饰器来复用函数，简化操作
# 创建一个装饰器函数，用于计算函数执行时间
import time

def calculate_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"函数 {func.__name__} 执行时间为: {end_time - start_time} 秒")
        return result
    return wrapper

# 应用装饰器到函数
@calculate_time
def long_running_function():
    time.sleep(2)

long_running_function()
  1. 使用字典来代替冗长的if/else判断，提升代码可读性
def operation_add(a, b):
    return a + b

def operation_subtract(a, b):
    return a - b

def operation_multiply(a, b):
    return a * b

def operation_divide(a, b):
    return a / b

# 定义一个操作字典，将操作名映射到对应的函数上
operations = {
    "add": operation_add,
    "subtract": operation_subtract,
    "multiply": operation_multiply,
    "divide": operation_divide
}

# 使用字典进行操作选择和调用相应的函数
result = operations["multiply"](2, 3)
print("结果:", result)
  1. 字符串格式化，使用占位符和格式化字符串来构建新的字符串
name = "Alice"
age = 25
message = "My name is {} and I am {} years old.".format(name, age)
# 输出: "My name is Alice and I am 25 years old."
  1. 使用
    lamba
    函数进行简单的函数定义
add = lambda x, y: x + y
result = add(2, 3)
# 输出: 5
  1. 使用
    reversed
    函数反转可迭代对象
numbers = [1, 2, 3, 4, 5]
reversed_numbers = list(reversed(numbers))
# 输出: [5, 4, 3, 2, 1]
  1. 使用
    map
    函数对可迭代对象中的每个元素应用指定的函数
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
# 输出: [1, 4, 9, 16, 25]
  1. 使用
    filter
    函数根据指定的条件筛选可迭代对象中的元素
numbers = [1, 2, 3, 4, 5]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
# 输出: [2, 4]
  1. 生成器函数，使用
    yield
    关键字来生成一个值，并且在每次生成值后暂停执行，等待下一次调用
# 下面是一个简单的生成器函数示例，用于生成斐波那契数列
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()
print(next(fib))  # 输出：0
print(next(fib))  # 输出：1
print(next(fib))  # 输出：1

生成器函数可以一次生成一个值，而不是一次生成所有值，这使得生成器函数非常适合处理大量数据或无限序列

  1. 使用
    functools
    模块中的
    partial
    函数进行函数参数固定：partial函数可以固定函数的部分参数，生成一个新的函数
from functools import partial

def power(x, y):
    return x ** y

square = partial(power, y=2)
cube = partial(power, y=3)

print(square(5))  # 输出 25
print(cube(5))  # 输出 125
  1. 使用
    try...else
    语句在
    try
    块没有引发异常时执行特定的代码
try:
    # 可能会引发异常的代码
    result = 10 / 2
except ZeroDivisionError:
    # 如果发生ZeroDivisionError异常
    print("除数不能为零！")
else:
    # 如果没有发生异常
    print("结果为:", result)

类似的还有try...finally无论是否发生异常，都会执行

try:
    # 可能会引发异常的代码
    f = open('example.txt', 'r')
    # 其他操作
except IOError:
    # 如果发生IOError异常
    print("无法打开文件")
else:
    # 如果没有发生异常
    print(f.read())
finally:
    # 无论是否发生异常，都会执行的清理代码
    f.close()
  1. 通过
    signal
    解耦代码
import signal
import os

# 定义一个事件处理函数
def handle_event(signum, frame):
    if signum == signal.SIGUSR1:
        print("接收到用户定义信号1，执行事件A")
        # 执行事件A的逻辑
    elif signum == signal.SIGUSR2:
        print("接收到用户定义信号2，执行事件B")
        # 执行事件B的逻辑
    else:
        print(f"接收到未知信号: {signum}")

# 注册事件处理函数
signal.signal(signal.SIGUSR1, handle_event)  # 注册处理用户定义信号1的事件处理函数
signal.signal(signal.SIGUSR2, handle_event)  # 注册处理用户定义信号2的事件处理函数

# 模拟发送事件信号
def send_event1():
    # 发送用户定义信号1
    print("发送用户定义信号1")
    os.kill(os.getpid(), signal.SIGUSR1)

def send_event2():
    # 发送用户定义信号2
    print("发送用户定义信号2")
    os.kill(os.getpid(), signal.SIGUSR2)

# 执行事件
send_event1()  # 执行事件1
send_event2()  # 执行事件2

两篇文章一共总结了32个用法，先这么多，欢迎大伙继续补充

标签: none

添加新评论