x = 5
y = 10
z = 15

if x < y < z:
    print("x is less than y and y is less than z")

2.  链式赋值

total_regions = region_total_instances = total_instances = 0

3.  三元运算符

x = 10
result = "Greater than 10" if x > 10 else "Less than or equal to 10"

4.  使用args和kwargs传递多个位置参数或关键字参数给函数

def example_function(*args, **kwargs):
    for arg in args:
        # 执行相关操作
    for key, value in kwargs.items():
        # 执行相关操作

5.  使用enumerate函数同时获取索引和值

my_list = ['apple', 'banana', 'orange']
for index, value in enumerate(my_list):
    print(f"Index: {index}, Value: {value}")

6.  使用zip函数同时迭代多个可迭代对象

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
for item1, item2 in zip(list1, list2):
    print(f"Item from list1: {item1}, Item from list2: {item2}")

7.  使用itertools模块进行迭代器和循环的高级操作

import itertools
for item in itertools.chain([1, 2, 3], ['a', 'b', 'c']):
    print(item)

8.  使用collections.Counter进行计数

from collections import Counter
my_list = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
counter = Counter(my_list)
print(counter)  # 输出为Counter({'apple': 3, 'banana': 2, 'orange': 1})

9.  使用any和all函数对可迭代对象中的元素进行逻辑判断

my_list = [True, False, True, True]
print(any(my_list))  # 输出为True
print(all(my_list))  # 输出为False

10.  使用sorted函数对可迭代对象进行排序

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_list = sorted(my_list)
print(sorted_list)  # 输出为[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

11.  使用set进行集合操作

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
print(set1.union(set2))  # 输出为{1, 2, 3, 4, 5, 6, 7}
print(set1.intersection(set2))  # 输出为{3, 4, 5}

12.  上下文管理器

class CustomContextManager:
    def __enter__(self):
        # 在代码块执行之前执行的操作
        # 可以返回一个值，该值将被赋值给as子句中的变量

    def __exit__(self, exc_type, exc_val, exc_tb):
        # 在代码块执行之后执行的操作
        # 可以处理异常，返回True表示异常被处理，False则会重新抛出异常

# 使用自定义上下文管理器
with CustomContextManager() as obj:
    # 在这里执行一些操作

13.  生成器表达式

# 使用生成器表达式计算1到10的平方和
squared_sum = sum(x**2 for x in range(1, 11))
print(squared_sum)

14.  使用str.endswith()方法来检查字符串是否以元组中的任何一个字符串结尾

filename = "example.csv"
if filename.endswith((".csv", ".xls", ".xlsx")):
    # 执行相关操作

同样的用法还有str.startswith()来检查字符串是否以元组中的任何一个字符串开头

15.  else语句与for和while循环结合使用

for item in some_list:
    if condition:
        # 执行相关操作
        break
else:
    # 如果循环自然结束，执行相关操作

16.  静态类型检查

# 使用mypy进行静态类型检查
def add_numbers(a: int, b: int) -> int:
    return a + b

result = add_numbers(5, 10)
print(result)

17.  反射，反射是一种机制，可以在运行时获取、检查和修改对象的属性和方法。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)

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

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

a = 10
b = 20

a, b = b, a

print(a, b)  # 输出: 20 10

19.  可迭代对象解包，它允许你将可迭代对象的元素解包到单独的变量中。这对于同时处理多个值非常有用

# 解包元组
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

20.  深复制和浅复制，当处理复杂的数据结构时，深复制和浅复制允许你创建对象的副本。深复制会创建一个全新的对象，而浅复制会创建一个新对象，但共享内部数据。

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]]

21.  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进行操作

22.  装饰器，通过装饰器来复用函数，简化操作

# 创建一个装饰器函数，用于计算函数执行时间
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()

23.  使用字典来代替冗长的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)

24.  字符串格式化，使用占位符和格式化字符串来构建新的字符串

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."

25.  使用lambda函数进行简单的函数定义

add = lambda x, y: x + y
result = add(2, 3)
# 输出: 5

26.  使用reversed函数反转可迭代对象

numbers = [1, 2, 3, 4, 5]
reversed_numbers = list(reversed(numbers))
# 输出: [5, 4, 3, 2, 1]

27.  使用map函数对可迭代对象中的每个元素应用指定的函数

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
# 输出: [1, 4, 9, 16, 25]

28.  使用filter函数根据指定的条件筛选可迭代对象中的元素

numbers = [1, 2, 3, 4, 5]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
# 输出: [2, 4]

29.  生成器函数，使用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

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

30.  使用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

31.  使用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()

32.  通过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个用法，先这么多，欢迎大伙继续补充。

参考：

• 100个非常有用的Python技巧

• Python高阶函数与装饰器