本文精选50个Python实用代码片段，涵盖基本操作、数据结构、算法、文件处理等常见场景。每个片段都配有说明和代码示例，帮助快速掌握提升效率的Python编程技巧。
1. 变量值交换
利用Python的元组解包特性，无需临时变量即可交换两个变量的值。
a, b = 1, 2
a, b = b, a # 交换变量值
print(a, b) # 输出: 2 1
2. 链式比较
Python支持直观的链式比较语法，让条件判断更简洁。
x = 5
print(1 < x < 10) # 输出: True
3. 三元运算符
使用条件表达式实现简洁的一行if-else逻辑。
age = 20
status = "成年" if age >= 18 else "未成年"
print(status) # 输出: 成年
4. 字符串反转
通过切片操作可以轻松反转字符串。
text = "Python"
reversed_text = text[::-1]
print(reversed_text) # 输出: nohtyP
5. 列表元素去重
利用集合（set）的唯一性特性快速去除列表中的重复元素。
items = [1, 2, 2, 3, 4, 4, 5]
unique_items = list(set(items))
print(unique_items) # 输出: [1, 2, 3, 4, 5]
6. 列表推导式
列表推导式是生成新列表的优雅且高效的方式，也是Python的核心语法糖之一。
squares = [x**2 for x in range(10)]
print(squares) # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
7. 条件列表推导式
在推导式中加入if条件，进行过滤操作。
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares) # 输出: [0, 4, 16, 36, 64]
8. 列表扁平化
使用嵌套循环的列表推导式将多维嵌套列表展平为一维列表。
nested_list = [[1, 2], [3, 4], [5, 6]]
flat_list = [item for sublist in nested_list for item in sublist]
print(flat_list) # 输出: [1, 2, 3, 4, 5, 6]
9. 查找列表最大最小值
使用内置的max()和min()函数。
numbers = [3, 1, 4, 1, 5, 9, 2]
max_val = max(numbers)
min_val = min(numbers)
print(f"最大值: {max_val}, 最小值: {min_val}")
10. 列表排序
使用list.sort()方法进行原地排序，或sorted()函数生成新列表。
data = [5, 2, 8, 1, 9]
data.sort() # 升序排序
print(data) # 输出: [1, 2, 5, 8, 9]
data.sort(reverse=True) # 降序排序
print(data) # 输出: [9, 8, 5, 2, 1]
11. 字典推导式
与列表推导式类似，用于快速生成字典。
squares_dict = {x: x**2 for x in range(5)}
print(squares_dict) # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
12. 字典合并
使用 ** 解包操作符合并多个字典（Python 3.5+）。
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
merged = {**dict1, **dict2}
print(merged) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
13. 字典键值反转
通过字典推导式交换键和值的位置。
original = {'a': 1, 'b': 2, 'c': 3}
reversed_dict = {v: k for k, v in original.items()}
print(reversed_dict) # 输出: {1: 'a', 2: 'b', 3: 'c'}
14. 字典默认值
使用collections.defaultdict避免键不存在时的KeyError。
from collections import defaultdict
word_count = defaultdict(int)
words = ['apple', 'banana', 'apple', 'orange']
for word in words:
word_count[word] += 1
print(dict(word_count)) # 输出: {'apple': 2, 'banana': 1, 'orange': 1}
15. 有序字典
使用collections.OrderedDict保持键的插入顺序（Python 3.7+中普通dict也已有序）。
from collections import OrderedDict
ordered = OrderedDict()
ordered['z'] = 1
ordered['a'] = 2
ordered['m'] = 3
print(list(ordered.keys())) # 输出: ['z', 'a', 'm']
16. 字符串拼接
使用str.join()方法高效拼接字符串列表。
words = ['Hello', 'World', 'Python']
sentence = ' '.join(words)
print(sentence) # 输出: Hello World Python
17. 字符串分割
使用str.split()方法根据指定分隔符分割字符串。
text = "apple,banana,orange"
fruits = text.split(',')
print(fruits) # 输出: ['apple', 'banana', 'orange']
18. 字符串替换
使用str.replace()方法进行简单替换。
text = "I like Java"
new_text = text.replace("Java", "Python")
print(new_text) # 输出: I like Python
19. 字符串格式化
使用f-string进行直观高效的字符串格式化（Python 3.6+）。
name = "Alice"
age = 25
message = f"{name} is {age} years old"
print(message) # 输出: Alice is 25 years old
20. 检查字符串开头结尾
使用str.startswith()和str.endswith()方法。
filename = "document.pdf"
is_pdf = filename.endswith('.pdf')
is_doc = filename.startswith('doc')
print(f"PDF文件: {is_pdf}, 文档文件: {is_doc}")
21. 可变参数
使用 *args 接收任意数量的位置参数。
def sum_numbers(*args):
return sum(args)
result = sum_numbers(1, 2, 3, 4, 5)
print(result) # 输出: 15
22. 关键字参数
使用 **kwargs 接收任意数量的关键字参数。
def create_profile(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
create_profile(name="John", age=30, city="New York")
23. Lambda函数
创建匿名函数，常用于简单的操作或作为高阶函数的参数。
square = lambda x: x**2
print(square(5)) # 输出: 25
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared) # 输出: [1, 4, 9, 16, 25]
24. 函数缓存
使用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(10)) # 输出: 55
25. 装饰器示例
装饰器是修改或增强函数行为的强大工具。
def timer(func):
import time
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(f"函数 {func.__name__} 执行时间: {end-start:.2f}秒")
return result
return wrapper
@timer
def slow_function():
time.sleep(1)
slow_function()
26. 读取文件内容
使用with语句管理文件对象，确保资源正确释放。
with open('example.txt', 'r', encoding='utf-8') as file:
content = file.read()
print(content)
27. 逐行读取文件
直接迭代文件对象，高效处理大文件。
with open('example.txt', 'r', encoding='utf-8') as file:
for line in file:
print(line.strip())
28. 写入文件
以写入模式打开文件并写入数据，这是处理数据持久化的基础，后续可能涉及数据库操作。
data = ["第一行", "第二行", "第三行"]
with open('output.txt', 'w', encoding='utf-8') as file:
for line in data:
file.write(line + '\n')
29. JSON文件读写
使用json模块处理JSON格式数据。
import json
# 写入JSON
data = {"name": "John", "age": 30}
with open('data.json', 'w') as f:
json.dump(data, f)
# 读取JSON
with open('data.json', 'r') as f:
loaded_data = json.load(f)
print(loaded_data)
30. CSV文件处理
使用csv模块读写CSV格式文件。
import csv
# 写入CSV
with open('data.csv', 'w', newline='') as file:
writer = csv.writer(file)
writer.writerow(['Name', 'Age', 'City'])
writer.writerow(['Alice', 25, 'New York'])
writer.writerow(['Bob', 30, 'London'])
# 读取CSV
with open('data.csv', 'r') as file:
reader = csv.reader(file)
for row in reader:
print(row)
31. 基本异常处理
使用try-except结构捕获和处理特定异常。
try:
result = 10 / 0
except ZeroDivisionError:
print("不能除以零!")
32. 多个异常处理
捕获多种不同类型的异常。
try:
# 可能出错的代码
number = int("abc")
except ValueError:
print("值错误!")
except Exception as e:
print(f"其他错误: {e}")
33. finally子句
无论是否发生异常，finally块中的代码都会执行，常用于资源清理。
try:
file = open('test.txt', 'r')
content = file.read()
except FileNotFoundError:
print("文件不存在!")
finally:
file.close() # 确保文件被关闭
34. 自定义异常
通过继承Exception类创建自定义异常类型，使错误处理更清晰。
class NegativeNumberError(Exception):
pass
def check_positive(number):
if number < 0:
raise NegativeNumberError("数字不能为负")
return number
try:
check_positive(-5)
except NegativeNumberError as e:
print(e)
35. 上下文管理器
实现了__enter__和__exit__方法的对象，可用于with语句。
class Timer:
def __enter__(self):
import time
self.start = time.time()
return self
def __exit__(self, *args):
self.end = time.time()
print(f"耗时: {self.end-self.start:.2f}秒")
with Timer():
# 需要计时的代码
import time
time.sleep(1)
36. 获取当前时间
使用datetime模块获取和格式化当前时间。
from datetime import datetime
now = datetime.now()
print(f"当前时间: {now}")
print(f"格式化时间: {now.strftime('%Y-%m-%d %H:%M:%S')}")
37. 时间差计算
计算两个datetime对象之间的差值。
from datetime import datetime, timedelta
start = datetime(2024, 1, 1)
end = datetime(2024, 1, 10)
difference = end - start
print(f"相差天数: {difference.days}")
38. 时间戳转换
在时间戳和datetime对象之间进行转换。
import time
from datetime import datetime
timestamp = time.time()
print(f"当前时间戳: {timestamp}")
dt = datetime.fromtimestamp(timestamp)
print(f"转换后的时间: {dt}")
39. 时区处理
使用pytz库处理不同时区的时间。
from datetime import datetime
import pytz
utc_time = datetime.now(pytz.utc)
beijing_time = utc_time.astimezone(pytz.timezone('Asia/Shanghai'))
print(f"北京时间: {beijing_time}")
40. 日期解析
将格式化的字符串解析为datetime对象。
from datetime import datetime
date_string = "2024-01-15 14:30:00"
parsed_date = datetime.strptime(date_string, '%Y-%m-%d %H:%M:%S')
print(f"解析后的日期: {parsed_date}")
41. 生成器表达式
使用圆括号创建生成器表达式，在迭代时动态生成值，节省内存。
# 生成器节省内存
large_sum = sum(x for x in range(1000000))
print(f"总和: {large_sum}")
42. 迭代器协议
通过实现__iter__和__next__方法创建自定义迭代器。
class CountDown:
def __init__(self, start):
self.current = start
def __iter__(self):
return self
def __next__(self):
if self.current <= 0:
raise StopIteration
self.current -= 1
return self.current + 1
for num in CountDown(5):
print(num)
43. 自定义上下文管理器
除了使用with语句，也可以自己创建上下文管理器类。
class FileManager:
def __init__(self, filename, mode):
self.filename = filename
self.mode = mode
self.file = None
def __enter__(self):
self.file = open(self.filename, self.mode)
return self.file
def __exit__(self, exc_type, exc_val, exc_tb):
if self.file:
self.file.close()
with FileManager('test.txt', 'w') as f:
f.write('Hello, World!')
44. 属性装饰器
使用@property装饰器定义获取方法，@xxx.setter定义设置方法，实现可控的属性访问。
class Person:
def __init__(self, name):
self._name = name
@property
def name(self):
return self._name
@name.setter
def name(self, value):
if not value:
raise ValueError("姓名不能为空")
self._name = value
person = Person("Alice")
print(person.name)
person.name = "Bob"
print(person.name)
45. 类方法与静态方法
@classmethod的第一个参数是类本身(cls)，@staticmethod则与普通函数无异。
class Calculator:
@staticmethod
def add(x, y):
return x + y
@classmethod
def multiply(cls, x, y):
return x * y
print(Calculator.add(5, 3)) # 输出: 8
print(Calculator.multiply(5, 3)) # 输出: 15
46. 进度条显示
使用tqdm库为循环添加直观的进度条，这在处理长时间任务时非常有用，也是运维脚本中的常见需求。
from tqdm import tqdm
import time
for i in tqdm(range(100)):
time.sleep(0.1) # 模拟耗时操作
47. 内存使用监控
使用sys.getsizeof()获取对象占用的内存大小（近似值）。
import sys
def show_memory_usage(var_name, variable):
size = sys.getsizeof(variable)
print(f"{var_name} 占用内存: {size} 字节")
large_list = list(range(100000))
show_memory_usage("large_list", large_list)
48. 执行时间测量
使用timeit模块精确测量一小段代码的执行时间。
import timeit
code_to_test = """
sum_result = sum(range(1000))
"""
execution_time = timeit.timeit(code_to_test, number=1000)
print(f"执行时间: {execution_time:.4f} 秒")
49. 环境变量读取
使用os模块访问和设置环境变量。
import os
# 读取环境变量
python_path = os.getenv('PYTHONPATH')
print(f"Python路径: {python_path}")
# 设置环境变量（当前进程）
os.environ['MY_VAR'] = 'my_value'
50. 命令行参数解析
使用sys.argv处理简单参数，或使用argparse模块构建功能丰富的命令行接口，这是开发脚本和工具的基础。
import sys
# 简单参数解析
if len(sys.argv) > 1:
print(f"接收到的参数: {sys.argv[1:]}")
else:
print("没有提供参数")
# 使用argparse进行高级解析
import argparse
parser = argparse.ArgumentParser(description='示例程序')
parser.add_argument('--name', type=str, help='你的姓名')
parser.add_argument('--age', type=int, help='你的年龄')
args = parser.parse_args()
if args.name and args.age:
print(f"你好 {args.name}, 你 {args.age} 岁了")
掌握并熟练运用以上50个代码片段，能够显著提升Python编程效率与代码质量，覆盖从基础语法到文件处理、异常管理等多个核心场景。
发表于 15 小时前
|
查看: 2|
回复: 0
