从入门到高手的99个python案例

大家好，想掌握Python编程语言，从零基础的小白晋升为大神？没问题！接下来我们将以轻松有趣的方式，逐一解锁Python学习路上的99个关键知识点。每一步都将结合实际应用场景、函数功能解析及简洁代码演示，带你深度领略Python的魅力！

1. hello, world! - print() 函数，你的第一个问候，输出文本。

print("Hello, Python World!")

2. 变量小能手 - type() 和 str()，查看和转换数据类型。

x = 5
print(type(x))  # 输出 <class 'int'>
y = str(x)      # 将整数转为字符串

3. 条件判断 - if、elif、else，让程序有逻辑。

age = 20
if age >= 18:
    print("成年人")

4. 循环大法好 - for、while，重复执行任务。

for i in range(5):
    print(i)

5. 列表造房子 - [] 和 append(), 创建并添加元素。

fruits = ["apple", "banana"]
fruits.append("orange")

6. 字典钥匙和门 - {} 和 keys(), 存储键值对。

person = {"name": "Alice", "age": 25}
print(person.keys())

7. 函数是魔法 - def，封装重复代码。

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

8. 异常处理 - try、except, 遇到错误不慌张。

try:
    num = int("abc")
except ValueError:
    print("这不是数字!")

9. 模块大援军 - import, 导入外部库增强功能。

import math
pi = math.pi

10. 字符串艺术 - split() 和 join(), 分割和组合文本。

words = "hello world".split()
print("-".join(words))

11. 文件操作入门 - open() 和 read(), 读写文件内容。

with open("file.txt", "r") as file:
    content = file.read()

12. 列表推导式 - 列表生成器，简洁高效。

squares = [x**2 for x in range(10)]
print(squares)

13. 元组不可变 - () 和 tuple(), 安全存储不可变数据。

coordinates = (1, 2, 3)
print(coordinates[0])  # 输出 1

14. 集合的独特性 - {} 和 set(), 去重神器。

fruits = {"apple", "banana", "apple"}
unique_fruits = set(fruits)
print(unique_fruits)

15. 类与对象 - class, 创建自定义数据结构。

class Dog:
    def __init__(self, name):
        self.name = name
dog = Dog("Rex")

16. 装饰器魔法棒 - @decorator, 动态修改函数行为。

def my_decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

17. 异常链追踪 - raise 和 try-except, 显示异常详情。

try:
    raise ValueError("Custom error")
except ValueError as e:
    print(e)

18. 迭代器解密 - iter() 和 next(), 遍历序列更轻量级。

numbers = [1, 2, 3]
iterator = iter(numbers)
print(next(iterator))  # 输出 1

19. lambda表达式 - 快速创建小型匿名函数。

double = lambda x: x * 2
print(double(5))  # 输出 10

20. 函数式编程 - map()、filter(), 高阶函数处理数据。

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

21. 生成器表达式 - 动态生成值，节省内存。

even_gen = (x for x in range(10) if x % 2 == 0)
print(next(even_gen))  # 输出 0

22. 内置函数大全 - len(), min(), max(), 功能强大。

string = "Python"
print(len(string))  # 输出 6

23. 字典的键值对操作 - keys(), values(), items(), 访问元素。

d = {"name": "Alice", "age": 25}
print(d["name"])  # 输出 "Alice"

24. 列表推导式优化 - 使用三元表达式简化条件。

numbers = [i for i in range(10) if i % 2 == 0 or i % 3 == 0]
print(numbers)

25. 列表切片操作 - [start:end:step], 选择子序列。

fruits = ["apple", "banana", "cherry", "date"]
sliced_fruits = fruits[1:3]
print(sliced_fruits)  # 输出 ["banana", "cherry"]

26. 面向对象继承 - class 和 super(), 复用已有功能。

class Animal:
    def __init__(self, name):
        self.name = name

class Dog(Animal):
    def bark(self):
        print(self.name + " says woof!")

dog = Dog("Rex")
dog.bark()

27. 异常处理实践 - finally 子句, 确保清理工作。

try:
    file.close()
except Exception as e:
    print("Error:", e)
finally:
    print("File closed.")

28. 全局和局部变量 - 在函数内外区别变量。

global_var = "global"
def func():
    local_var = "local"
    print(local_var)  # 输出 "local"

print(global_var)  # 输出 "global"
func()

29. 模块导入优化 - 使用from ... import *, 但需谨慎。

from math import sqrt
print(sqrt(16))  # 输出 4.0

30. 列表和元组的区别 - 元组不可变，列表可变。

t = (1, 2, 3)  # 元组
l = [1, 2, 3]  # 列表
l[0] = 0
print(l)  # 输出 [0, 2, 3]
print(t)  # 输出 (1, 2, 3), 元组不变

31.  列表解析与生成器表达式对比 - 生成器节省内存。

# 列表解析
even_numbers_list = [i for i in range(10) if i % 2 == 0]

# 生成器表达式
even_numbers_generator = (i for i in range(10) if i % 2 == 0)
print(list(even_numbers_generator))  # 输出相同，但生成器更节省内存

32. 函数参数传递 - pass by value vs pass by reference, 对象传递。

def change_list(lst):
    lst.append(4)

original = [1, 2]
change_list(original)
print(original)  # 输出 [1, 2, 4], 实际上是引用传递

33. 列表推导式与map()对比 - 列表推导简洁。

numbers = [1, 2, 3, 4]
squared_list = [x**2 for x in numbers]
squared_map = map(lambda x: x**2, numbers)
print(list(squared_map))  # 输出 [1, 4, 9, 16], 相同结果，但列表推导更易读

34. 迭代器和生成器的应用 - 节省内存和性能。

def infinite_sequence():
    n = 0
    while True:
        yield n
        n += 1

gen = infinite_sequence()
for _ in range(5):
    print(next(gen))  # 输出前5个自然数

35. 装饰器高级用法 - 多装饰器链。

def log_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time} seconds.")
        return result
    return wrapper

@log_time
@count_calls
def fibonacci(n):
    pass  # 实现斐波那契数列

fibonacci(10)

36. 异常处理最佳实践 - 明确异常类型和处理。

def safe_division(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("Can't divide by zero!")
        result = None
    return result

print(safe_division(10, 2))  # 输出 5
print(safe_division(10, 0))  # 输出 Can't divide by zero!

37. 类方法和静态方法 - @classmethod 和 @staticmethod, 提供不同访问权限。

class MyClass:
    @classmethod
    def class_method(cls):
        print(f"This is a class method, {cls}")

    @staticmethod
    def static_method():
        print("This is a static method.")

MyClass.class_method()  # 输出 This is a class method, MyClass
MyClass.static_method()  # 输出 This is a static method.

38. 模块导入的别名 - 使用as关键字，简化导入。

import math as m
print(m.pi)  # 输出 π 的近似值

39. 字符串格式化 - 使用f-string或format(), 易于定制输出。

name = "Alice"
age = 25
print(f"My name is {name}, and I am {age} years old.")

40. 列表推导式嵌套 - 多层次的数据处理。

matrix = [[1, 2], [3, 4]]
transposed = [[row[i] for row in matrix] for i in range(2)]
print(transposed)  # 输出 [[1, 3], [2, 4]]

41. 元组解包 - 交换变量值。

a, b = 5, 10
a, b = b, a  # 元组解包实现变量交换
print(a, b)  # 输出 10, 5

42. 列表推导式与列表生成式 - 生成器表达式节省内存。

# 列表推导式
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# 列表生成式
even_squares_gen = (x**2 for x in range(10) if x % 2 == 0)
print(list(even_squares_gen))  # 输出相同，但生成器更节省内存

43. 字典的键冲突处理 - 使用collections.defaultdict。

from collections import defaultdict
counter = defaultdict(int)
counter["apple"] += 1
print(counter)  # 输出 {"apple": 1}

44. 列表和集合的区别 - 列表有序，集合无序且不允许重复。

fruits_list = ["apple", "banana", "apple"]
fruits_set = {"apple", "banana"}
print(fruits_list)  # 输出 ["apple", "banana", "apple"]
print(fruits_set)  # 输出 {"apple", "banana"}

45. 函数返回多个值 - 使用元组或列表。

def get_name_and_age():
    return "Alice", 25

name, age = get_name_and_age()
print(name, age)  # 输出 Alice 25

46. 列表推导式中的条件判断 - 更灵活的控制。

odds = [x for x in range(10) if x % 2 != 0]
print(odds)  # 输出 [1, 3, 5, 7, 9]

47. 上下文管理器with - 自动关闭资源。

with open("file.txt", "r") as file:
    content = file.read()
print(content)
# 文件会在with语句结束后自动关闭

48. Python的魔术方法__str__ - 自定义对象的字符串表示。

class Person:
    def __str__(self):
        return f"Person: {self.name}"

person = Person(name="Alice")
print(person)  # 输出 Person: Alice

49. 装饰器高级技巧 - 使用functools.wraps保持原函数信息。

from functools import wraps

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time} seconds.")
        return result
    return wrapper

@timer
def my_function():
    pass

my_function()

50. 异常处理和try-except-finally - 控制流程的灵活性。

try:
    div_by_zero = 10 / 0
except ZeroDivisionError:
    print("Can't divide by zero!")
finally:
    print("Execution completed.")

51. 列表和数组比较 - 列表通用，NumPy数组高效。

import numpy as np

normal_list = [1, 2, 3]
np_array = np.array([1, 2, 3])
print(np_array.shape)  # 输出 (3,), 数组有形状信息

52. Python的内置模块datetime - 处理日期和时间。

from datetime import datetime
now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))

53. Python的os模块 - 操作文件和目录。

import os
print(os.getcwd())  # 输出当前工作目录

54. 列表推导式中的条件和循环 - 结合使用。

evens = [x for x in range(10) if x % 2 == 0 for y in range(5) if y % 2 == 0]
print(evens)

55. 迭代器和生成器的使用场景 - 数据处理和节省内存。

# 使用生成器处理大文件
def read_large_file(file_path, chunk_size=1024):
    with open(file_path, "r") as file:
        while True:
            chunk = file.read(chunk_size)
            if not chunk:
                break
            yield chunk

for line in read_large_file("large.txt"):
    process(line)

56. zip()函数 - 同时遍历多个序列。

names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
pairs = zip(names, ages)
print(list(pairs))  # 输出 [('Alice', 25), ('Bob', 30), ('Charlie', 35)]

57. enumerate()函数 - 为列表元素添加索引。

fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

58. itertools模块 - 提供高效迭代工具。

from itertools import product
result = product("ABC", repeat=2)
print(list(result))  # 输出 [('A', 'A'), ('A', 'B'), ('A', 'C'), ..., ('C', 'C')]

59. json模块 - 序列化和反序列化数据。

import json
data = {"name": "Alice", "age": 25}
json_data = json.dumps(data)
print(json_data)

60. 递归函数 - 用于解决分治问题。

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))  # 输出 120

61. os.path模块 - 文件路径处理。

import os.path
path = "/home/user/documents"
print(os.path.exists(path))  # 输出 True 或 False

62. random模块 - 随机数生成。

import random
random_number = random.randint(1, 10)
print(random_number)

63. re模块 - 正则表达式操作。

import re
text = "Today is 2023-04-01"
match = re.search(r"\d{4}-\d{2}-\d{2}", text)
print(match.group())  # 输出 "2023-04-01"

64. requests库 - 发送HTTP请求。

import requests
response = requests.get("https://api.example.com")
print(response.status_code)

65. Pandas库 - 大数据处理。

import pandas as pd
df = pd.DataFrame({"Name": ["Alice", "Bob"], "Age": [25, 30]})
print(df)

66. matplotlib库 - 数据可视化。

import matplotlib.pyplot as plt
plt.plot([1, 2, 3, 4])
plt.show()

67. logging模块 - 日志记录。

import logging
logger = logging.getLogger(__name__)
logger.info("This is an info message")

68. asyncio库 - 异步编程。

import asyncio
async def slow_task():
    await asyncio.sleep(1)
    return "Task completed"

loop = asyncio.get_event_loop()
result = loop.run_until_complete(slow_task())
print(result)

69. contextlib模块 - 非阻塞上下文管理。

from contextlib import asynccontextmanager
@asynccontextmanager
async def acquire_lock(lock):
    async with lock:
        yield

async with acquire_lock(lock):
    # do something

70. asyncio.gather - 异步并发执行。

tasks = [asyncio.create_task(task) for task in tasks_to_run]
results = await asyncio.gather(*tasks)

71. asyncio.sleep - 异步等待一段时间。

await asyncio.sleep(2)  # 程序在此暂停2秒

72. asyncio.wait - 等待多个任务完成。

done, pending = await asyncio.wait(tasks, timeout=10)

73. asyncio.subprocess - 异步执行外部命令。

import asyncio.subprocess as sp
proc = await sp.create_subprocess_exec("ls", "-l")
await proc.communicate()

74. concurrent.futures库 - 多线程/进程执行。

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

with ThreadPoolExecutor() as executor:
    results = executor.map(function, arguments)

75. timeit模块 - 测试代码执行速度。

import timeit
print(timeit.timeit("your_code_here", globals=globals()))

76. pickle模块 - 序列化和反序列化对象。

import pickle
serialized = pickle.dumps(obj)
deserialized = pickle.loads(serialized)

77. logging.handlers模块 - 多种日志输出方式。

handler = RotatingFileHandler("app.log", maxBytes=1000000)
formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
handler.setFormatter(formatter)
logger.addHandler(handler)

78. asyncio.Queue - 异步队列。

queue = asyncio.Queue()
await queue.put(item)
result = await queue.get()

79. asyncio.Event - 异步信号量。

event = asyncio.Event()
event.set()  # 设置信号
await event.wait()  # 等待信号

80. asyncio.Lock - 互斥锁，防止并发修改。

async with await asyncio.Lock():  # 获取锁后执行
    critical_section()

81. asyncio.gather和asyncio.wait_for的区别 - 异步任务管理。

• gather: 并行执行多个任务，等待所有任务完成。

• wait_for: 等待单个任务完成，其他任务继续运行。

82. asyncio.sleep和asyncio.sleep_after - 异步延时和定时任务。

• sleep: 直接暂停当前协程。

• sleep_after: 定义一个延迟后执行的任务。

83. aiohttp库 - HTTP客户端库。

import aiohttp
async with aiohttp.ClientSession() as session:
    async with session.get("https://example.com") as response:
        data = await response.text()

84. asyncio.shield - 防止被取消任务中断。

async def task():
    await shield(some_long_running_task())

# 如果外部取消任务，task将继续运行，不会影响内部任务
asyncio.create_task(task())

85. asyncio.run - 简化异步程序执行。

asyncio.run(main_coroutine())

86. asyncio.iscoroutinefunction - 检查是否为协程函数。

if asyncio.iscoroutinefunction(some_function):
    await some_function()

87. asyncio.all_tasks - 获取所有任务。

tasks = asyncio.all_tasks()
for task in tasks:
    task.cancel()

88. asyncio.wait_for和asyncio.timeout - 设置超时限制。

try:
    result = await asyncio.wait_for(some_task, timeout=5.0)
except asyncio.TimeoutError:
    print("Task timed out")

89. asyncio.sleep_timeout - 异步睡眠并设置超时。

await asyncio.sleep_timeout(10, asyncio.TimeoutError)

90. asyncio.current_task - 获取当前正在执行的任务。

current_task = asyncio.current_task()
print(current_task)

91. asyncio.sleep的超时支持 - asyncio.sleep现在接受超时参数。

try:
    await asyncio.sleep(1, timeout=0.5)  # 如果超过0.5秒还没完成，则会抛出TimeoutError
except asyncio.TimeoutError:
    print("Sleep interrupted")

92. asyncio.shield的高级用法 - 可以保护整个协程。

@asyncio.coroutine
def protected_coroutine():
    try:
        await some_task()
    except Exception as e:
        print(f"Error occurred: {e}")
        # 使用shield保护，即使外部取消任务，也会继续处理错误

asyncio.create_task(protected_coroutine())

93. asyncio.wait的回调函数 - 使用回调函数处理完成任务。

done, _ = await asyncio.wait(tasks, callback=handle_completed_task)

94. asyncio.gather的返回值 - 可以获取所有任务的结果。

results = await asyncio.gather(*tasks)

95. asyncio.Queue的get_nowait - 不阻塞获取队列元素。

if not queue.empty():
    item = queue.get_nowait()
else:
    item = await queue.get()

96. asyncio.Event的clear - 清除事件状态。

event.clear()
await event.wait()  # 现在需要再次调用set()来触发

97. asyncio.Event的is_set - 检查事件是否已设置。

if event.is_set():
    print("Event is set")

98. asyncio.subprocess.PIPE - 连接到子进程的输入/输出管道。

proc = await asyncio.create_subprocess_exec(
    "python", "-c", "print('Hello from child')", stdout=asyncio.subprocess.PIPE
)
output, _ = await proc.communicate()
print(output.decode())

99. asyncio.run_coroutine_threadsafe - 在子线程中执行协程。

loop = asyncio.get_running_loop()
future = loop.run_coroutine_threadsafe(some_async_coroutine(), thread_pool)
result = await future.result()

好了，今天就这些了，希望对大家有帮助。都看到这了，点个赞再走吧～