Python高手必知的18个简洁代码片段

1. 使用列表推导式简化循环

列表推导式是Python中最强大的特性之一。它允许你在一行代码内创建列表。

# 假设我们有一个数字列表  
numbers = [1, 2, 3, 4, 5]  
  
# 我们想要得到这个列表中所有数字的平方  
squares = [num ** 2 for num in numbers]  
  
print(squares)  # 输出: [1, 4, 9, 16, 25]  

解释： 这里我们使用了列表推导式 [num ** 2 for num in numbers] 来代替传统的循环方式，使代码更简洁。

2. 字典推导式生成新字典

字典推导式同样可以简化生成新字典的过程。

# 假设我们有一个字典  
original_dict = {'a': 1, 'b': 2, 'c': 3}  
  
# 我们想要得到一个新字典，其中所有的值都加1  
new_dict = {key: value + 1 for key, value in original_dict.items()}  
  
print(new_dict)  # 输出: {'a': 2, 'b': 3, 'c': 4}  

解释： 通过 {key: value + 1 for key, value in original_dict.items()} 这种形式，我们轻松地生成了一个新字典。

3. 列表切片

列表切片可以帮助你快速获取列表的一部分。

# 偶数位置的元素  
even_positions = numbers[::2]  
  
# 反转列表  
reversed_numbers = numbers[::-1]  
  
print(even_positions)  # 输出: [1, 3, 5]  
print(reversed_numbers)  # 输出: [5, 4, 3, 2, 1]  

解释： numbers[::2] 表示从第一个元素开始，每隔一个元素取一个值；numbers[::-1] 表示从最后一个元素开始，逆序取出所有元素。

4. 使用zip函数合并多个列表

当你需要同时遍历多个列表时，zip 函数是一个好帮手。

names = ['Alice', 'Bob', 'Charlie']  
ages = [25, 30, 35]  
  
# 合并两个列表  
combined = list(zip(names, ages))  
  
print(combined)  # 输出: [('Alice', 25), ('Bob', 30), ('Charlie', 35)]  

解释： zip(names, ages) 将两个列表打包成一个元组列表。

5. 使用enumerate增强for循环

当需要同时访问列表中的元素及其索引时，enumerate 函数可以派上用场。

for index, name in enumerate(names):  
    print(f"Index {index}: {name}")  
  
# 输出:  
# Index 0: Alice  
# Index 1: Bob  
# Index 2: Charlie  

解释： enumerate(names) 返回一个枚举对象，每次迭代都会返回当前元素及其索引。

6. 三元条件表达式简化if-else语句

有时候，简单的条件判断可以用一行代码搞定。

age = 20  
status = "adult" if age >= 18 else "minor"  
  
print(status)  # 输出: adult  

解释： "adult" if age >= 18 else "minor" 是一个三元条件表达式，相当于 if age >= 18: status = "adult" else: status = "minor"。

7. 使用any和all函数简化逻辑判断

any 和 all 函数可以用来简化对集合的逻辑判断。

# 检查是否至少有一个元素为真  
if any([False, False, True]):  
    print("At least one element is True")  
  
# 检查是否所有元素都为真  
if all([True, True, True]):  
    print("All elements are True")  

解释： any 函数只要集合中有任何一个元素为真，就返回 True；all 函数只有当集合中所有元素都为真时才返回 True。

8. 使用set进行去重

如果你需要去除列表中的重复元素，set 类型是个不错的选择。

items = [1, 2, 2, 3, 4, 4, 5]  
unique_items = list(set(items))  
  
print(unique_items)  # 输出: [1, 2, 3, 4, 5]  

解释： set(items) 会自动去除重复元素，再将其转换回列表即可。

9. 使用lambda函数定义匿名函数

在某些情况下，你可能需要定义一个一次性使用的简单函数。

# 定义一个匿名函数，计算两个数的和  
add = lambda x, y: x + y  
  
print(add(3, 5))  # 输出: 8  

解释： lambda x, y: x + y 定义了一个接受两个参数 x 和 y 的匿名函数，并返回它们的和。

10. 使用sorted函数排序

sorted 函数可以用来对列表进行排序，支持自定义排序规则。

# 对数字列表按降序排序  
desc_sorted = sorted(numbers, reverse=True)  
  
# 自定义排序规则  
def custom_sort(item):  
    return item % 3  
  
custom_sorted = sorted(numbers, key=custom_sort)  
  
print(desc_sorted)  # 输出: [5, 4, 3, 2, 1]  
print(custom_sorted)  # 输出: [3, 1, 4, 2, 5]  

解释： sorted(numbers, reverse=True) 以降序排序；sorted(numbers, key=custom_sort) 根据自定义函数排序。

11. 使用with语句管理资源

with 语句可以安全地打开文件或连接数据库等，自动处理资源释放。

# 打开一个文件并读取内容  
with open('example.txt', 'r') as file:  
    content = file.read()  
  
print(content)  

解释： with open('example.txt', 'r') as file: 会在执行完代码块后自动关闭文件。

12. 使用map函数批量处理数据

map 函数可以将一个函数应用于一个或多个序列中的所有元素。

# 计算每个元素的平方  
squared = map(lambda x: x ** 2, numbers)  
  
# 转换为列表  
squared_list = list(squared)  
  
print(squared_list)  # 输出: [1, 4, 9, 16, 25]  

解释： map(lambda x: x ** 2, numbers) 会对 numbers 中的每个元素应用平方操作。

13. 使用filter函数筛选元素

filter 函数可以筛选出满足条件的元素。

# 筛选出大于2的元素  
filtered = filter(lambda x: x > 2, numbers)  
  
# 转换为列表  
filtered_list = list(filtered)  
  
print(filtered_list)  # 输出: [3, 4, 5]  

解释： filter(lambda x: x > 2, numbers) 会筛选出 numbers 中大于2的元素。

14. 使用f-string格式化字符串

f-string 是一种新的字符串格式化方法，简洁易用。

name = "Alice"  
age = 25  
  
# 使用f-string格式化字符串  
message = f"{name} is {age} years old."  
  
print(message)  # 输出: Alice is 25 years old.  

解释： f"{name} is {age} years old." 直接在字符串中嵌入变量名，非常方便。

15. 使用try-except捕获异常

异常处理可以让程序更加健壮，避免因错误而崩溃。

try:  
    result = 10 / 0  
except ZeroDivisionError:  
    print("Cannot divide by zero!")  
  
# 输出: Cannot divide by zero!  

解释： try-except 结构可以捕获并处理特定类型的异常。

16. 使用*和**解包参数

解包参数可以让你更加灵活地传递参数给函数。

# 解包列表  
def add_many(*args):  
    return sum(args)  
  
nums = [1, 2, 3, 4, 5]  
result = add_many(*nums)  
  
print(result)  # 输出: 15  
  
# 解包字典  
def profile(**kwargs):  
    print(kwargs)  
  
details = {"name": "Alice", "age": 25}  
profile(**details)  
  
# 输出: {'name': 'Alice', 'age': 25}  

解释： *nums 解包列表；**details 解包字典。

17. 使用生成器节省内存

生成器是一种特殊的迭代器，可以按需生成数据，节省内存。

# 定义一个生成器函数  
def count_up_to(max):  
    count = 1  
    while count <= max:  
        yield count  
        count += 1  
  
# 使用生成器  
for number in count_up_to(5):  
    print(number)  
  
# 输出:  
# 1  
# 2  
# 3  
# 4  
# 5  

解释： yield 关键字使得函数成为一个生成器。

18. 使用@property装饰器实现属性访问

@property 装饰器可以让你像访问属性一样访问方法。

class Person:  
    def __init__(self, age):  
        self._age = age  
  
    @property  
    def age(self):  
        return self._age  
  
    @age.setter  
    def age(self, value):  
        if value < 0:  
            raise ValueError("Age cannot be negative!")  
        self._age = value  
  
p = Person(25)  
print(p.age)  # 输出: 25  
p.age = 30  
print(p.age)  # 输出: 30  

解释： @property 装饰器使得 age 方法可以像属性一样被访问和修改。

19. 使用上下文管理器

上下文管理器可以确保在特定上下文中执行特定的操作，并在完成后自动清理资源。除了 with 语句外，还可以使用 contextlib 模块中的 contextmanager 装饰器。

from contextlib import contextmanager  
  
@contextmanager  
def open_file(file_name, mode):  
    try:  
        f = open(file_name, mode)  
        yield f  
    finally:  
        f.close()  
  
# 使用上下文管理器打开文件  
with open_file('example.txt', 'r') as file:  
    content = file.read()  
  
print(content)  

解释： open_file 函数通过 @contextmanager 装饰器成为上下文管理器。在 with 语句中使用它可以确保文件在使用完毕后自动关闭。

20. 使用itertools模块简化迭代操作

itertools 模块提供了许多用于高效迭代的工具，例如 chain、repeat 和 combinations。

import itertools  
  
# 将多个列表合并成一个  
list1 = [1, 2, 3]  
list2 = [4, 5, 6]  
  
merged = list(itertools.chain(list1, list2))  
  
print(merged)  # 输出: [1, 2, 3, 4, 5, 6]  
  
# 无限重复一个元素  
inf_repeated = itertools.repeat('A')  
  
# 获取前5个重复元素  
first_five = list(itertools.islice(inf_repeated, 5))  
  
print(first_five)  # 输出: ['A', 'A', 'A', 'A', 'A']  
  
# 获取所有组合  
combinations = list(itertools.combinations([1, 2, 3], 2))  
  
print(combinations)  # 输出: [(1, 2), (1, 3), (2, 3)]  

解释：

itertools.chain(list1, list2) 将多个列表合并成一个。

itertools.repeat('A') 无限重复 'A' 元素。

itertools.combinations([1, 2, 3], 2) 获取 [1, 2, 3] 中所有长度为2的组合。

21. 使用collections模块优化数据结构

collections 模块提供了许多高效的数据结构，如 Counter、defaultdict 和 deque。

from collections import Counter, defaultdict, deque  
  
# 统计列表中元素出现的次数  
words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']  
word_count = Counter(words)  
  
print(word_count)  # 输出: Counter({'apple': 3, 'banana': 2, 'orange': 1})  
  
# 使用默认值为0的字典  
d = defaultdict(int)  
d['a'] = 1  
d['b'] = 2  
print(d['a'])  # 输出: 1  
print(d['c'])  # 输出: 0  
  
# 使用双端队列  
queue = deque()  
queue.append(1)  
queue.append(2)  
queue.append(3)  
  
print(queue)  # 输出: deque([1, 2, 3])  
  
queue.popleft()  
print(queue)  # 输出: deque([2, 3])  

解释：

Counter(words) 统计列表中元素出现的次数。

defaultdict(int) 创建一个默认值为0的字典。

deque 创建一个双端队列，可以方便地进行插入和删除操作。

22. 使用functools模块简化函数操作

functools 模块提供了许多用于函数操作的工具，如 partial 和 lru_cache。

import functools  
  
# 部分函数  
def power(base, exponent):  
    return base ** exponent  
  
square = functools.partial(power, exponent=2)  
cube = functools.partial(power, exponent=3)  
  
print(square(4))  # 输出: 16  
print(cube(4))  # 输出: 64  
  
# 使用缓存装饰器  
@functools.lru_cache(maxsize=None)  
def fibonacci(n):  
    if n <= 1:  
        return n  
    return fibonacci(n - 1) + fibonacci(n - 2)  
  
print(fibonacci(30))  # 输出: 832040  

解释：

functools.partial(power, exponent=2) 创建一个部分函数 square。

functools.partial(power, exponent=3) 创建一个部分函数 cube。

@functools.lru_cache(maxsize=None) 装饰器缓存递归函数的结果，提高性能。

23. 使用multiprocessing模块实现多进程

multiprocessing 模块可以让你轻松实现多进程编程，提高程序的并发能力。

import multiprocessing  
  
def worker(num):  
    print(f"Worker {num}")  
  
if __name__ == "__main__":  
    jobs = []  
    for i in range(5):  
        p = multiprocessing.Process(target=worker, args=(i,))  
        jobs.append(p)  
        p.start()  
  
    for j in jobs:  
        j.join()  

解释：

multiprocessing.Process(target=worker, args=(i,)) 创建一个进程对象。

p.start() 启动进程。

j.join() 等待进程结束。

24. 使用asyncio模块实现异步编程

asyncio 模块支持异步编程，可以让你编写非阻塞的代码。

import asyncio  
  
async def my_coroutine():  
    print("Start")  
    await asyncio.sleep(1)  
    print("End")  
  
async def main():  
    task = asyncio.create_task(my_coroutine())  
    await task  
  
asyncio.run(main())  
  
# 输出:  
# Start  
# End  

解释：

async def my_coroutine(): 定义一个协程函数。

await asyncio.sleep(1) 模拟异步操作。

asyncio.run(main()) 运行主协程。

25. 使用logging模块记录日志

logging 模块可以让你方便地记录程序的日志信息。

import logging  
  
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')  
  
logging.debug('This is a debug message')  
logging.info('This is an info message')  
logging.warning('This is a warning message')  
logging.error('This is an error message')  
logging.critical('This is a critical message')  

解释：

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s') 设置日志级别和格式。

logging.debug, logging.info, logging.warning, logging.error, logging.critical 分别记录不同级别的日志信息。

26. 使用decorator模式增强函数功能

装饰器是一种常用的代码增强方式，可以不改变原有函数的情况下添加新功能。

def my_decorator(func):  
    def wrapper():  
        print("Something is happening before the function is called.")  
        func()  
        print("Something is happening after the function is called.")  
    return wrapper  
  
@my_decorator  
def say_hello():  
    print("Hello!")  
  
say_hello()  
  
# 输出:  
# Something is happening before the function is called.  
# Hello!  
# Something is happening after the function is called.  

解释：

@my_decorator 装饰器在原有函数前后添加额外的功能。

def wrapper(): 定义一个新的包装函数。

27. 使用type hinting增强代码可读性

类型提示可以让你的代码更具可读性和可维护性。

from typing import List, Tuple  
  
def greet(name: str) -> str:  
    return f"Hello, {name}!"  
  
def process_data(data: List[int]) -> Tuple[int, int]:  
    total = sum(data)  
    count = len(data)  
    return total, count  
  
print(greet("Alice"))  # 输出: Hello, Alice!  
print(process_data([1, 2, 3, 4, 5]))  # 输出: (15, 5)  

解释：

def greet(name: str) -> str: 指定函数的输入和输出类型。

def process_data(data: List[int]) -> Tuple[int, int]: 指定函数的输入和输出类型。

实战案例：自动化数据分析脚本

假设你需要编写一个脚本来处理一个CSV文件中的数据，统计其中的各项指标，并输出结果。我们可以使用上述技巧来实现这个任务。

import csv  
import statistics  
from collections import Counter  
from typing import List  
  
def read_csv(file_path: str) -> List[List[str]]:  
    with open(file_path, 'r') as file:  
        reader = csv.reader(file)  
        data = [row for row in reader]  
    return data  
  
def analyze_data(data: List[List[str]]) -> None:  
    # 提取第二列数据  
    values = [float(row[1]) for row in data[1:]]  
  
    # 计算平均值、中位数和众数  
    mean_value = statistics.mean(values)  
    median_value = statistics.median(values)  
    mode_value = statistics.mode(values)  
  
    # 统计各值出现的次数  
    value_counts = Counter(values)  
  
    print(f"Mean: {mean_value}")  
    print(f"Median: {median_value}")  
    print(f"Mode: {mode_value}")  
    print(f"Value Counts: {value_counts}")  
  
if __name__ == "__main__":  
    file_path = 'data.csv'  
    data = read_csv(file_path)  
    analyze_data(data)  

解释： 1. read_csv(file_path: str) -> List[List[str]]: 读取CSV文件并返回数据列表。 2. analyze_data(data: List[List[str]]) -> None: 分析数据并输出结果。 3. values = [float(row[1]) for row in data[1:]]: 提取第二列数据并转换为浮点数。 4. 使用 statistics.mean, statistics.median, statistics.mode 计算各项统计指标。 5. 使用 Counter(values) 统计各值出现的次数。

好了，今天的分享就到这里了，我们下期见。

作者：孤独的根号三|