从入门到高手的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. 条件判断 - ifelifelse,让程序有逻辑。

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

4. 循环大法好 - forwhile,重复执行任务。

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. 异常处理 - tryexcept, 遇到错误不慌张。

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. 异常链追踪 - raisetry-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. 面向对象继承 - classsuper(), 复用已有功能。

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 infinite_s
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 infinite_s
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, 提供不同访问权限。

def infinite_s
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关键字,简化导入。

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

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

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

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

def infinite_s
matrix = [[1, 2], [3, 4]]  
transposed = [[row[i] for row in matrix] for i in range(2)]  
print(transposed)  # 输出 [[1, 3], [2, 4]]  
41. 元组解包 - 交换变量值。
def infinite_s
a, b = 5, 10  
a, b = b, a  # 元组解包实现变量交换  
print(a, b)  # 输出 10, 5  
42.列表推导式与列表生成式 - 生成器表达式节省内存。
def infinite_s
# 列表推导式  
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
def infinite_s
from collections import defaultdict  
counter = defaultdict(int)  
counter["apple"] += 1  
print(counter)  # 输出 {"apple": 1}  
44.列表和集合的区别- 列表有序,集合无序且不允许重复。
def infinite_s
fruits_list = ["apple", "banana", "apple"]  
fruits_set = {"apple", "banana"}  
print(fruits_list)  # 输出 ["apple", "banana", "apple"]  
print(fruits_set)  # 输出 {"apple", "banana"}  
45.函数返回多个值 - 使用元组或列表。
def infinite_s
def get_name_and_age():  
    return "Alice", 25    
name, age = get_name_and_age()  
print(name, age)  # 输出 Alice 25  
456列表推导式中的条件判断 - 更灵活的控制。
def infinite_s
odds = [x for x in range(10) if x % 2 != 0]  
print(odds)  # 输出 [1, 3, 5, 7, 9]  
47.上下文管理器with - 自动关闭资源。
def infinite_s
with open("file.txt", "r") as file:  
    content = file.read()  
print(content)  
# 文件会在with语句结束后自动关闭  
48.Python的魔术方法__str__ - 自定义对象的字符串表示。
def infinite_s
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.gatherasyncio.wait_for的区别异步任务管理。
  • gather: 并行执行多个任务,等待所有任务完成。
  • wait_for: 等待单个任务完成,其他任务继续运行。
82.asyncio.sleepasyncio.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_forasyncio.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.Queueget_nowait 不阻塞获取队列元素。
if not queue.empty():  
    item = queue.get_nowait()  
else:  
    item = await queue.get()  
96.asyncio.Eventclear清除事件状态。
event.clear()  
await event.wait()  # 现在需要再次调用set()来触发  
97.asyncio.Eventis_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()  

图片

总结

  • 最后希望你编程学习上不急不躁,按照计划有条不紊推进,把任何一件事做到极致,都是不容易的,加油,努力!相信自己!

文末福利

  • 最后这里免费分享给大家一份Python全套学习资料,希望能帮到那些不满现状,想提升自己却又没有方向的朋友,也可以和我一起来学习交流呀。

包含编程资料、学习路线图、源代码、软件安装包等!【[点击这里]】领取!

  • ① Python所有方向的学习路线图,清楚各个方向要学什么东西
  • ② 100多节Python课程视频,涵盖必备基础、爬虫和数据分析
  • ③ 100多个Python实战案例,学习不再是只会理论
  • ④ 华为出品独家Python漫画教程,手机也能学习

可以扫描下方二维码领取【保证100%免费

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值