Python 30个经典代码段，提升代码开发效率

用户11081884

发布于 2026-07-20 19:24:03

1300

Python以其简洁的语法和强大的功能，成为数据科学、Web开发、自动化脚本等领域的首选语言。掌握其核心代码段，能极大提升编程效率和问题解决能力。本文精选了30个经典Python代码段，涵盖基础语法、数据处理、高级特性、并发编程和Web开发等场景，每个代码段都配有说明和示例，助你解锁Python的无限可能。

1. 变量与动态类型

说明： Python是动态类型语言，变量无需声明类型，赋值即定义。

场景： 快速定义和使用各种数据类型。

# 整数
age = 25
# 浮点数
price = 19.99
# 字符串
name = "Charlie"
# 布尔值
is_active = True
print(type(age), type(name))  # 输出: <class 'int'> <class 'str'>

2. 多重赋值与交换

说明： 一行代码内完成多个变量的赋值或交换。

场景： 简化代码，提高可读性。

# 多重赋值
x, y, z = 1, 2, 3
# 交换变量值
a, b = 5, 10
a, b = b, a
print(a, b)  # 输出: 10 5

3. 条件表达式（三元运算符）

说明： 一行代码实现简单的if-else逻辑。

场景： 根据条件为变量赋值。

score = 85
grade = "优秀" if score >= 90 else "良好" if score >= 80 else "需努力"
print(grade)  # 输出: 良好

4. 列表推导式

说明： 简洁高效地创建新列表。

场景： 对可迭代对象进行过滤或转换。

# 生成平方列表
squares = [x**2 for x in range(1, 6)]
print(squares)  # 输出: [1, 4, 9, 16, 25]
# 带条件的推导式
evens = [x for x in range(10) if x % 2 == 0]
print(evens)  # 输出: [0, 2, 4, 6, 8]

5. 字典推导式

说明： 快速创建字典。

场景： 将两个列表组合成字典，或转换现有字典。

keys = ['name', 'age', 'city']
values = ['David', 28, 'London']
person = {k: v for k, v in zip(keys, values)}
print(person)  # 输出: {'name': 'David', 'age': 28, 'city': 'London'}

6. 集合推导式

说明： 快速创建集合，自动去重。

场景： 从序列中提取唯一元素。

numbers = [1, 2, 2, 3, 4, 4, 5]
unique_nums = {x for x in numbers}
print(unique_nums)  # 输出: {1, 2, 3, 4, 5}

7. 生成器表达式

说明： 与列表推导式类似，但返回生成器对象，节省内存。

场景： 处理大规模数据流。

# 使用圆括号
gen = (x**2 for x in range(1000000))
print(next(gen))  # 输出: 0
print(next(gen))  # 输出: 1
# 内存占用远小于列表推导式

8. 使用 enumerate 获取索引和值

说明： 在循环中同时获取元素索引和值。

场景： 遍历序列时需要知道当前位置。

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(f"索引 {index}: {fruit}")
# 输出:
# 索引 0: apple
# 索引 1: banana
# 索引 2: cherry

9. 使用 zip 并行迭代多个序列

说明： 将多个可迭代对象“压缩”在一起，并行迭代。

场景： 同时处理多个相关列表。

names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(f"{name}: {score}分")

10. 使用 any 和 all 进行逻辑判断

说明： any 检查可迭代对象中是否有任意元素为真； all 检查是否所有元素为真。

场景： 快速进行集合级别的条件判断。

checks = [True, False, True]
print(any(checks))  # 输出: True
print(all(checks))  # 输出: False
numbers = [2, 4, 6, 8]
print(all(x % 2 == 0 for x in numbers))  # 输出: True

11. 字符串格式化（f-string）

说明： Python 3.6+引入，最简洁高效的字符串格式化方法。

场景： 构建包含变量的字符串。

name = "Eva"
age = 30
greeting = f"大家好，我叫{name}，今年{age}岁。"
print(greeting)  # 输出: 大家好，我叫Eva，今年30岁。
# 表达式计算
print(f"明年我就{age + 1}岁了。")

12. 字符串分割与连接

说明： split() 用于分割， join() 用于连接。

场景： 解析CSV数据、处理日志文件。

# 分割
csv_line = "apple,banana,cherry"
items = csv_line.split(',')
print(items)  # 输出: ['apple', 'banana', 'cherry']
# 连接
words = ['Hello', 'World']
sentence = ' '.join(words)
print(sentence)  # 输出: Hello World

13. 字符串常用方法

说明： Python字符串提供了丰富的方法。

场景： 数据清洗、用户输入验证。

text = "  Python Programming  "
print(text.strip())        # 去除两端空格: "Python Programming"
print(text.lower())        # 转小写: "  python programming  "
print(text.upper())        # 转大写: "  PYTHON PROGRAMMING  "
print(text.replace('Python', 'Java'))  # 替换: "  Java Programming  "
print("123".isdigit())     # 检查是否全为数字: True
print("abc".isalpha())     # 检查是否全为字母: True

14. 默认参数与关键字参数

说明： 为函数参数指定默认值，调用时可以使用关键字传参。

场景： 提高函数灵活性，简化调用。

def greet(name, greeting="Hello", punctuation="!"):
    return f"{greeting}, {name}{punctuation}"

print(greet("Frank"))                     # 输出: Hello, Frank!
print(greet("Grace", greeting="Hi"))      # 输出: Hi, Grace!
print(greet("Henry", punctuation="."))    # 输出: Hello, Henry.

**15. 可变参数（ *args 和 kwargs ）

说明： *args 接收任意数量的位置参数， **kwargs 接收任意数量的关键字参数。

场景： 编写通用函数或包装器。

def log_info(*args, **kwargs):
    print("位置参数:", args)
    print("关键字参数:", kwargs)

log_info(1, 2, 3, name="Ivy", age=22)
# 输出:
# 位置参数: (1, 2, 3)
# 关键字参数: {'name': 'Ivy', 'age': 22}

16. Lambda匿名函数

说明： 单行小型匿名函数。

场景： 作为参数传递给高阶函数（如 map , filter , sorted ）。

# 简单加法
add = lambda x, y: x + y
print(add(5, 3))  # 输出: 8

# 与map结合
nums = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, nums))
print(squared)  # 输出: [1, 4, 9, 16]

# 与sorted结合，按字符串长度排序
words = ['apple', 'fig', 'banana']
sorted_words = sorted(words, key=lambda w: len(w))
print(sorted_words)  # 输出: ['fig', 'apple', 'banana']

17. 装饰器基础

说明： 在不修改原函数代码的情况下，为其添加新功能。

场景： 日志记录、性能测试、权限验证。

def timer_decorator(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"函数 {func.__name__} 运行耗时: {end - start:.4f}秒")
        return result
    return wrapper

@timer_decorator
def slow_function():
    time.sleep(1)
    return "完成"

slow_function()
# 输出: 函数 slow_function 运行耗时: 1.0010秒

18. 使用 functools.lru_cache 进行缓存

说明： 自动缓存函数结果，避免重复计算。

场景： 递归函数（如斐波那契数列）、计算密集型函数。

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(30))  # 快速计算出结果

19. 上下文管理器与 with 语句

说明： 确保资源（如文件、锁）被正确获取和释放。

场景： 文件操作、数据库连接、线程锁。

# 自定义上下文管理器
class ManagedFile:
    def __init__(self, filename):
        self.filename = filename
    def __enter__(self):
        self.file = open(self.filename, 'w')
        return self.file
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            self.file.close()

with ManagedFile('hello.txt') as f:
    f.write('Hello, World!')
# 文件会自动关闭

20. 使用 collections 模块

说明： 提供有用的专用容器数据类型。

场景： 计数、默认字典、双端队列等。

from collections import Counter, defaultdict, deque

# Counter: 计数
words = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
word_count = Counter(words)
print(word_count)  # 输出: Counter({'apple': 3, 'banana': 2, 'cherry': 1})

# defaultdict: 带默认值的字典
dd = defaultdict(list)
dd['fruits'].append('apple')
dd['fruits'].append('banana')
print(dd['fruits'])  # 输出: ['apple', 'banana']
print(dd['vegetables'])  # 输出: [] (而不是KeyError)

# deque: 双端队列
dq = deque([1, 2, 3])
dq.appendleft(0)
dq.append(4)
print(dq)  # 输出: deque([0, 1, 2, 3, 4])

21. 使用 itertools 进行高效迭代

说明： 提供用于高效循环的迭代器函数。

场景： 排列组合、无限迭代器、分组等。

import itertools

# 排列
perms = list(itertools.permutations([1, 2, 3], 2))
print("排列:", perms)  # 输出: [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

# 组合
combs = list(itertools.combinations([1, 2, 3, 4], 2))
print("组合:", combs)  # 输出: [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

# 无限迭代器
counter = itertools.count(start=10, step=2)
print(next(counter), next(counter), next(counter))  # 输出: 10 12 14

22. 使用 pathlib 进行路径操作

说明： 面向对象的文件系统路径操作库（Python 3.4+）。

场景： 跨平台的文件和目录操作。

from pathlib import Path

# 创建Path对象
p = Path('/home/user/docs/file.txt')
print(p.name)       # 文件名: file.txt
print(p.parent)     # 父目录: /home/user/docs
print(p.suffix)     # 后缀: .txt

# 路径操作
new_p = p.with_name('new_file.txt')
print(new_p)        # 输出: /home/user/docs/new_file.txt

# 检查文件是否存在
if p.exists():
    print("文件存在")

23. JSON序列化与反序列化

说明： 使用 json 模块处理JSON数据。

场景： Web API交互、配置文件读写。

import json

# Python对象 -> JSON字符串
data = {
    "name": "Jack",
    "age": 35,
    "hobbies": ["reading", "hiking"],
    "is_student": False
}
json_str = json.dumps(data, indent=2)
print(json_str)

# JSON字符串 -> Python对象
parsed_data = json.loads(json_str)
print(parsed_data['name'])  # 输出: Jack

# 文件读写
with open('data.json', 'w') as f:
    json.dump(data, f, indent=2)

with open('data.json', 'r') as f:
    loaded_data = json.load(f)

24. 使用 pickle 进行对象序列化

说明： Python特有的对象序列化模块。

场景： 保存和加载Python对象（如机器学习模型）。

import pickle

data = {'a': [1, 2, 3], 'b': ('string', 'tuple'), 'c': {'nested': 'dict'}}

# 序列化到文件
with open('data.pkl', 'wb') as f:
    pickle.dump(data, f)

# 从文件反序列化
with open('data.pkl', 'rb') as f:
    loaded_data = pickle.load(f)

print(loaded_data == data)  # 输出: True

25. 使用 concurrent.futures 进行线程/进程池操作

说明： 高级并发接口，简化并行任务执行。

场景： I/O密集型任务（线程池）、CPU密集型任务（进程池）。

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import time

def task(n):
    time.sleep(1)
    return n * n

# 线程池 (I/O密集型)
with ThreadPoolExecutor(max_workers=3) as executor:
    futures = [executor.submit(task, i) for i in range(5)]
    results = [f.result() for f in futures]
    print("线程池结果:", results)  # 约1秒后输出: [0, 1, 4, 9, 16]

# 进程池 (CPU密集型)
def cpu_task(n):
    return sum(i * i for i in range(n))

with ProcessPoolExecutor(max_workers=4) as executor:
    futures = [executor.submit(cpu_task, i*1000) for i in range(4)]
    results = [f.result() for f in futures]
    print("进程池结果:", results)

26. 使用 asyncio 进行异步I/O

说明： Python原生异步编程支持。

场景： 高并发网络请求、异步数据库操作。

import asyncio
import aiohttp
import time

async def fetch_url(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = [
        ' http://httpbin.org/delay/1',
        ' http://httpbin.org/delay/2',
        ' http://httpbin.org/delay/1'
    ]
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        print(f"获取了 {len(results)} 个页面的数据")

start = time.time()
asyncio.run(main())
print(f"总耗时: {time.time() - start:.2f}秒")  # 约2秒，而非4秒

27. 自定义异常

说明： 创建特定于应用程序的异常类型。

场景： 更精确地处理业务逻辑错误。

class InsufficientFundsError(Exception):
    """余额不足异常"""
    def __init__(self, balance, amount):
        super().__init__(f"余额不足! 当前余额: {balance}, 尝试提取: {amount}")
        self.balance = balance
        self.amount = amount

class BankAccount:
    def __init__(self, balance):
        self.balance = balance
    
    def withdraw(self, amount):
        if amount > self.balance:
            raise InsufficientFundsError(self.balance, amount)
        self.balance -= amount
        return self.balance

account = BankAccount(100)
try:
    account.withdraw(150)
except InsufficientFundsError as e:
    print(f"取款失败: {e}")

28. 使用 else 和 finally 子句

说明： else 在无异常时执行， finally 无论是否异常都会执行。

场景： 资源清理、后续处理。

def divide(x, y):
    try:
        result = x / y
    except ZeroDivisionError:
        print("错误: 除数不能为零!")
        return None
    except TypeError:
        print("错误: 请输入数字!")
        return None
    else:
        print(f"计算成功: {x} / {y} = {result}")
        return result
    finally:
        print("清理完成，释放资源。")

print(divide(10, 2))
print(divide(10, 0))

29. 使用 unittest 进行单元测试

说明： Python标准单元测试框架。

场景： 确保代码质量，防止回归错误。

import unittest

def add(a, b):
    return a + b

class TestMathFunctions(unittest.TestCase):
    def test_add_positive(self):
        self.assertEqual(add(2, 3), 5)
    
    def test_add_negative(self):
        self.assertEqual(add(-1, -1), -2)
    
    def test_add_zero(self):
        self.assertEqual(add(5, 0), 5)
    
    def test_add_type_error(self):
        with self.assertRaises(TypeError):
            add("2", 3)

if __name__ == '__main__':
    unittest.main()

30. 使用 pdb 进行交互式调试

说明： Python内置调试器。

场景： 逐行调试，检查变量状态。

import pdb

def buggy_function(x, y):
    result = x * y
    pdb.set_trace()  # 在此处进入调试器
    # 假设这里有bug
    final_result = result / (y - x)  # 当x==y时会除零
    return final_result

# 调用函数时会进入pdb调试模式
# buggy_function(5, 5)
# 在调试器中可以使用命令:
# n (next) - 执行下一行
# c (continue) - 继续执行直到下一个断点
# p variable - 打印变量值
# q (quit) - 退出调试器

以上30个代码段从基础语法到高级特性，从数据处理到并发编程。掌握这些代码段不仅能提升日常编码效率，更能深入理解Python的设计哲学和强大功能。在实际项目中根据具体需求进行修改和扩展。

“无他，惟手熟尔”！有需要的用起来！

如果你觉得这篇文章有用，欢迎点赞、转发、收藏、留言、推荐❤！

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2026-01-13，如有侵权请联系 cloudcommunity@tencent.com 删除

效率

本文分享自 Nicholas与Pypi 微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度