10个鲜为人知的Python技巧,助你提升编程技能!

from collections import defaultdict

# 没有使用defaultdict
word_count = {}
for word in words:
    if word in word_count:
        word_count[word] += 1
    else:
        word_count[word] = 1


# 使用defaultdict
word_count = defaultdict(int)
for word in words:
    word_count[word] += 1
print(word_count)

{'apple': 3, 'banana': 2, 'orange': 1}
defaultdict(<class 'int'>, {'apple': 3, 'banana': 2, 'orange': 1})

from pathlib import Path

# 创建Path对象
p = Path('/usr/bin')

# 检查路径是否存在
print(p.exists())

# 遍历目录
for child in p.iterdir():
    print(child)

# 组合路径
q = p / 'local' / 'bin'
print(q)

True
/usr/bin/zip
/usr/bin/python3
/usr/bin/grep
/usr/bin/tar
...
/usr/bin/zcat
/usr/bin/unzip
...
/usr/bin/curl
/usr/bin/wget
...
/usr/bin/local/bin

# 不使用enumerate
i = 0
for element in iterable:
    print(i, element)
    i += 1

# 使用enumerate
for i, element in enumerate(iterable):
    print(i, element)

0 apple
1 banana
2 orange
0 apple
1 banana
2 orange

names = ['Alice', 'Bob', 'Charlie']
scores = [85, 90, 95]

# 不使用zip
for i in range(len(names)):
    print(names[i], scores[i])

# 使用zip
for name, score in zip(names, scores):
    print(name, score)

Alice 85
Bob 90
Charlie 95
Alice 85
Bob 90
Charlie 95

import itertools

# 无限计数
for i in itertools.count(10, 2):
    if i > 20:
        break
    print(i)

# 笛卡尔乘积
for item in itertools.product([1, 2], ['a', 'b']):
    print(item)

10
12
14
16
18
20
(1, 'a')
(1, 'b')
(2, 'a')
(2, 'b')

# 不使用with
file = open('example.txt', 'r')
try:
    data = file.read()
finally:
    file.close()

# 使用with
with open('example.txt', 'r') as file:
    data = file.read()

from collections import namedtuple

# 定义一个namedtuple
Point = namedtuple('Point', ['x', 'y'])

# 创建一个实例
p = Point(10, 20)

print(p.x, p.y)

10 20

# 不使用列表表达式
squares = []
for x in range(10):
    squares.append(x**2)

# 使用列表表达式
squares = [x**2 for x in range(10)]

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

import functools

# 定义一个函数来使用递归计算斐波那契数列
@functools.lru_cache(maxsize=None)  # 无限制地缓存所有结果
def fibonacci(n):
    # 基本情况：斐波那契(0)为0，斐波那契(1)为1
    if n < 2:
        return n
    # 递归情况：斐波那契(n)是斐波那契(n-1)和斐波那契(n-2)的总和
    return fibonacci(n - 1) + fibonacci(n - 2)

# 使用大量输入测试该函数，以查看性能优势
if __name__ == "__main__":
    import time

    # 计算不使用记忆的斐波那契数35
    start_time = time.time()
    print(f"Fibonacci(35) without memoization: {fibonacci(35)}")
    print(f"Time taken without memoization: {time.time() - start_time} seconds")

    # 重置缓存以进行比较
    fibonacci.cache_clear()

    # 使用记忆法计算35的斐波那契
    start_time = time.time()
    print(f"Fibonacci(35) with memoization: {fibonacci(35)}")
    print(f"Time taken with memoization: {time.time() - start_time} seconds")

    # 显示缓存信息
    print(f"Cache info: {fibonacci.cache_info()}")

Fibonacci(35) without memoization: 9227465
Time taken without memoization: 0.00012087821960449219 seconds
Fibonacci(35) with memoization: 9227465
Time taken with memoization: 0.000007867813110351562 seconds
Cache info: CacheInfo(hits=68, misses=36, maxsize=None, currsize=36)

# 带有一次性变量的循环
for _ in range(5):
    print("Hello, World!")

# 用一次性变量拆包
a, _, b = (1, 2, 3)
print(a, b)

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
1 3