python3高级特性

1. 装饰器

装饰器是 Python 的一种高阶函数，它可以在不修改函数内部代码的情况下，给函数增加额外的功能。

案例：记录函数执行时间的装饰器

import time  
  
def timing_decorator(func):  
    def wrapper(*args, **kwargs):  
        start_time = time.time()  
        result = func(*args, **kwargs)  
        end_time = time.time()  
        print(f"Function {func.__name__} took {end_time - start_time:.6f} seconds to execute.")  
        return result  
    return wrapper  
  
@timing_decorator  
def my_function():  
    time.sleep(1)  # 模拟耗时操作  
    print("Function executed.")  
  
my_function()

效果图

2. 迭代器

迭代器是一个可以记住遍历位置的对象，它可以从头到尾访问数据集合的元素。

案例：使用迭代器遍历列表

my_list = [1, 2, 3, 4, 5]  
my_iter = iter(my_list)  
print(next(my_iter))  # 输出: 1  
print(next(my_iter))  # 输出: 2  
# ... 可以继续调用 next() 直到 StopIteration 异常

效果图

3. 生成器

生成器是一种特殊的迭代器，它使用 yield 关键字来产生值，并且只在需要时计算下一个值，这可以节省内存。

案例：生成斐波那契数列的生成器

def fibonacci(n):  
    a, b = 0, 1  
    while a < n:  
        yield a  
        a, b = b, a + b  
  
# 使用生成器  
for num in fibonacci(10):  
    print(num)

效果图

4. 高阶函数

高阶函数是接受函数作为参数或返回函数作为结果的函数。

案例：高阶函数实现函数映射

def apply_func(func, lst):  
    return [func(x) for x in lst]  
  
def square(x):  
    return x ** 2  
  
numbers = [1, 2, 3, 4, 5]  
squared_numbers = apply_func(square, numbers)  
print(squared_numbers)  # 输出: [1, 4, 9, 16, 25]

效果图

5. 匿名函数

匿名函数（lambda 函数）是没有名称的简短函数。

案例：使用匿名函数对列表进行排序

my_list = [(1, 'a'), (2, 'c'), (3, 'b')]  
my_list.sort(key=lambda x: x[1])  # 根据元组的第二个元素排序  
print(my_list)  # 输出: [(1, 'a'), (3, 'b'), (2, 'c')]

效果图

6. 偏函数

偏函数是固定了某些参数的新函数，返回一个新函数，这个新函数可以调用原函数，且原函数的某些参数值始终不变。

案例：使用偏函数设置默认参数

from functools import partial  
  
def greet(name, greeting="Hello"):  
    print(f"{greeting}, {name}!")  
  
greet_with_hi = partial(greet, greeting="Hi")  
greet_with_hi("Alice")  # 输出: Hi, Alice!

效果图

7. 切片

切片用于在序列类型（如列表、元组、字符串）上选择一段连续的元素。

案例：使用切片选择字符串中的一部分

s = "Hello, World!"  
substring = s[7:12]  # 选择索引7到11的字符（不包括12）  
print(substring)  # 输出: World

效果图

8. 列表解析式

列表解析式是一种简洁创建列表的方式。

案例：使用列表解析式创建平方数列表

numbers = [1, 2, 3, 4, 5]  
squares = [x**2 for x in numbers]  
print(squares)  # 输出: [1, 4, 9, 16, 25]

效果图

9 元组拆包

元组拆包是将元组中的元素分别赋值给不同的变量。这在处理返回多个值的函数或接收多个值的函数参数时非常有用。

案例：交换两个变量的值

a, b = 1, 2  
print(f"Before swap: a = {a}, b = {b}")  
  
# 使用元组拆包交换值  
a, b = b, a  
print(f"After swap: a = {a}, b = {b}")  # 输出: After swap: a = 2, b = 1

效果图

10 多进程

多进程是指操作系统中同时运行多个进程，每个进程都拥有独立的内存空间和系统资源。Python的multiprocessing模块支持多进程编程。

案例：使用多进程计算平方数

from multiprocessing import Process  
  
def square(n):  
    print(f"The square of {n} is {n**2}")  
  
if __name__ == "__main__":  
    processes = []  
    for i in range(5):  
        p = Process(target=square, args=(i,))  
        processes.append(p)  
        p.start()  
  
    for p in processes:  
        p.join()  # 等待所有进程完成

效果图

11 进程通信

进程通信是指在不同进程之间传递信息或数据。Python的multiprocessing模块提供了Queue、Pipe等方式来实现进程间通信。

案例：使用Queue进行进程通信

from multiprocessing import Process, Queue  
  
def worker(q):  
    result = q.get()  # 从队列中获取任务  
    print(f"Processing {result}")  
    q.put(result * 2)  # 将处理结果放回队列  
  
if __name__ == "__main__":  
    q = Queue()  
    q.put(10)  # 向队列中添加任务  
  
    p = Process(target=worker, args=(q,))  
    p.start()  
    p.join()  
  
    result = q.get()  # 从队列中获取处理结果  
    print(f"Result: {result}")  # 输出: Result: 20

效果图

12 进程锁

进程锁用于同步多个进程对共享资源的访问，以避免竞态条件。multiprocessing模块提供了Lock来实现进程锁。

案例：使用进程锁保护共享资源

from multiprocessing import Process, Lock, Value  
  
def increment(lock, counter, n):  
    for _ in range(n):  
        with lock:  # 使用with语句自动管理锁  
            counter.value += 1  
  
if __name__ == "__main__":  
    lock = Lock()  
    counter = Value('i', 0)  # 创建一个共享整数计数器  
  
    processes = []  
    for _ in range(10):  
        p = Process(target=increment, args=(lock, counter, 1000))  
        processes.append(p)  
        p.start()  
  
    for p in processes:  
        p.join()  
  
    print(f"Final counter value: {counter.value}")  # 输出应该接近10000

效果图

13 进程池

进程池用于限制同时运行的进程数量，这对于管理系统资源非常有用。multiprocessing.Pool类提供了进程池的实现。

案例：使用进程池计算平方数列表

from multiprocessing import Pool  
  
def square(n):  
    return n ** 2  
  
if __name__ == "__main__":  
    with Pool(processes=4) as pool:  # 创建一个包含4个进程的进程池  
        numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
        results = pool.map(square, numbers)  # 使用进程池计算平方数  
  
    print(results)  # 输出: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

效果图

14 多线程

多线程是指在同一个进程中运行多个线程，共享进程的内存空间和系统资源。Python的threading模块支持多线程编程。

案例：使用多线程打印数字

import threading
import time
​
​
# 打印奇数的线程函数
def print_odd_numbers():
    for i in range(1, 6, 2):
        time.sleep(0.5)  # 模拟耗时操作
        print(i)
​
    # 打印偶数的线程函数
​
​
def print_even_numbers():
    for i in range(2, 6, 2):
        time.sleep(0.5)  # 模拟耗时操作
        print(i)
​
    # 创建线程
​
​
odd_thread = threading.Thread(target=print_odd_numbers)
even_thread = threading.Thread(target=print_even_numbers)
​
# 启动线程
odd_thread.start()
even_thread.start()
​
# 等待线程结束
odd_thread.join()
even_thread.join()
​
print("All threads have finished.")

效果图

15 os模块

简单介绍： os模块提供了很多与操作系统交互的功能，如文件操作、目录操作、环境变量获取等。它允许Python程序执行系统相关的操作，如创建和删除文件、读取环境变量等。

案例：列出当前目录下的所有文件和文件夹

import os  
  
# 列出当前目录下的所有文件和文件夹  
for item in os.listdir('.'):  
    print(item)

效果图

17 datetime模块

简单介绍： datetime模块提供了日期和时间的类，用于解析、格式化、操作日期和时间。该模块中的datetime类可以表示一个具体的日期和时间，支持加减运算以及日期时间的比较等。

案例：获取当前日期和时间，并计算一天后的日期

from datetime import datetime, timedelta  
  
# 获取当前日期和时间  
now = datetime.now()  
print("Current date and time:", now)  
  
# 计算一天后的日期  
one_day_later = now + timedelta(days=1)  
print("Date one day later:", one_day_later)

效果图

18 time模块

简单介绍： time模块主要用于处理时间，如获取当前时间戳、将时间戳转换为格式化字符串等。它还提供了程序控制的功能，如sleep用于让程序暂停执行一段时间。

案例：获取当前时间戳，并转换为格式化字符串

import time  
  
# 获取当前时间戳  
timestamp = time.time()  
print("Current timestamp:", timestamp)  
  
# 将时间戳转换为格式化字符串  
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timestamp))  
print("Formatted time:", formatted_time)

效果图

19 base64模块

简单介绍： base64模块提供了Base64编码和解码的功能，通常用于在文本数据中表示、传输、存储二进制数据。它常用于电子邮件的传输编码，以及在XML中存储复杂数据。

案例：对字符串进行Base64编码和解码

import base64  
  
# 对字符串进行Base64编码  
encoded_str = base64.b64encode(b"Hello, World!")  
print("Encoded string:", encoded_str)  
  
# 对Base64编码的字符串进行解码  
decoded_str = base64.b64decode(encoded_str)  
print("Decoded string:", decoded_str.decode('utf-8'))

效果图

20 copy模块

简单介绍： copy模块提供了浅拷贝和深拷贝的功能，用于复制对象。浅拷贝只复制对象本身，而不复制对象内部的子对象；深拷贝则递归地复制对象及其所有子对象。

案例：使用浅拷贝和深拷贝复制列表

import copy  
  
# 原始列表  
original_list = [1, [2, 3], 4]  
  
# 浅拷贝列表  
shallow_copy_list = copy.copy(original_list)  
print("Shallow copy:", shallow_copy_list)  
  
# 修改浅拷贝列表中的子列表，原始列表也会受到影响  
shallow_copy_list[1].append(5)  
print("Original list after shallow copy modification:", original_list)  
  
# 深拷贝列表  
deep_copy_list = copy.deepcopy(original_list)  
print("Deep copy:", deep_copy_list)  
  
# 修改深拷贝列表中的子列表，原始列表不会受到影响  
deep_copy_list[1].append(6)  
print("Original list after deep copy modification:", original_list)

效果图

21 collections模块

简单介绍： collections模块提供了一些特殊的容器数据类型，它们为常见的数据结构提供了更高级别的接口，如namedtuple（具有名称的元组）、deque（双端队列）、Counter（计数器）、OrderedDict（有序字典）和defaultdict（带有默认值的字典）等。

案例：OrderedDict是一个字典子类，它保持元素被插入时的顺序。

from collections import OrderedDict
​
# 创建一个OrderedDict对象
od = OrderedDict()
​
# 添加键值对
od['first'] = 1
od['second'] = 2
od['third'] = 3
​
# 遍历OrderedDict，保持插入顺序
for key, value in od.items():
    print(key, value)
# 输出:
# first 1
# second 2
# third 3

效果图