2. Python基础教程（续）

2. Python基础教程（续）

2.1 高级数据结构

除了基本的数据类型（如整数、浮点数、字符串、列表等），Python还提供了更多高级数据结构，它们在开发过程中非常有用。

2.1.1 字典（Dictionary）

字典是一个无序的键值对集合。每个键必须是唯一的，值可以是任何数据类型。

• 创建字典：

person = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

• 访问字典中的值：

print(person["name"])  # 输出 "Alice"

• 修改字典中的值：

person["age"] = 31

• 添加新键值对：

person["job"] = "Engineer"

• 删除键值对：

del person["city"]

• 字典的常用方法：

keys = person.keys()      # 获取所有键
values = person.values()  # 获取所有值
items = person.items()    # 获取所有键值对

2.1.2 集合（Set）

集合是一个无序且不重复的元素集合。集合常用于去重和集合运算（如并集、交集等）。

• 创建集合：

fruits = {"apple", "banana", "cherry"}

• 添加元素：

fruits.add("orange")

• 移除元素：

fruits.remove("banana")

• 集合运算：

set1 = {1, 2, 3}
set2 = {3, 4, 5}

print(set1 & set2)  # 交集 {3}
print(set1 | set2)  # 并集 {1, 2, 3, 4, 5}
print(set1 - set2)  # 差集 {1, 2}

2.1.3 列表推导式（List Comprehension）

列表推导式是一种简洁的方法，用来从其他列表、元组等序列创建新的列表。``

• 基本用法：

squares = [x**2 for x in range(10)]
print(squares)  # 输出 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

• 带条件的列表推导式：

even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # 输出 [0, 4, 16, 36, 64]

2.1.4 生成器（Generators）

生成器是一个迭代器，可以在需要时动态生成数据。生成器通过yield语句返回数据，而不是一次性生成所有数据。

• 创建生成器：

def count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1
        
counter = count_up_to(5)
for num in counter:
    print(num)

生成器的优势是节省内存，因为它不会一次性把所有数据加载到内存中，而是按需生成。

---

2.2 Python中的内置函数

Python提供了许多强大的内置函数，能够大大简化开发工作。

2.2.1 常用内置函数

• len()：返回对象（如字符串、列表）的长度`

print(len("Python"))  # 输出 6
print(len([1, 2, 3, 4]))  # 输出 4

• type()：返回对象的类型。

print(type(5))  # 输出 <class 'int'>
print(type("Hello"))  # 输出 <class 'str'>

• max() 和 min()：返回序列中的最大值和最小值。

print(max([1, 2, 3]))  # 输出 3
print(min([1, 2, 3]))  # 输出 1

• sum()：返回序列中所有元素的和。

print(sum([1, 2, 3]))  # 输出 6

• sorted()：返回排序后的列表（默认升序）。

print(sorted([3, 1, 2]))  # 输出 [1, 2, 3]

• range()：生成一个指定范围的整数序列。

for i in range(3):
    print(i)  # 输出 0 1 2

• map()：对可迭代对象的每个元素应用函数，并返回结果的迭代器。

def square(x):
    return x**2

result = map(square, [1, 2, 3])
print(list(result))  # 输出 [1, 4, 9]

• filter()：过滤可迭代对象中的元素，返回符合条件的元素。

def is_even(x):
    return x % 2 == 0

result = filter(is_even, [1, 2, 3, 4, 5])
print(list(result))  # 输出 [2, 4]

---

2.3 面向对象编程（OOP）深入

在前面的教程中，我们已经介绍了面向对象编程的基础。接下来，我们将进一步探讨一些Python面向对象编程的高级特性。

2.3.1 类的继承与多态

Python支持单继承和多继承，允许类继承其他类的属性和方法。

• 多继承：一个子类可以继承多个父类。

class Animal:
    def speak(self):
        print("Animal is speaking")

class Dog(Animal):
    def speak(self):
        print("Dog is barking")

class Cat(Animal):
    def speak(self):
        print("Cat is meowing")

class Pet(Dog, Cat):
    pass

pet = Pet()
pet.speak()  # 输出 "Dog is barking"（多继承时，调用顺序按声明顺序）

2.3.2 类的私有与公有属性

Python中的类并没有严格的私有或公有属性，通常通过使用下划线来标识属性的可见性。

• 私有属性：以双下划线__开头的属性被认为是私有的，外部不能直接访问。

class MyClass:
    def __init__(self):
        self.__private_var = "I am private"
    
    def get_private_var(self):
        return self.__private_var

obj = MyClass()
print(obj.get_private_var())  # 访问私有属性

print(obj.__private_var)    # 报错：AttributeError

• 公有属性：没有下划线开头的属性，可以直接访问。

2.3.3 类的静态方法与类方法

• 静态方法（@staticmethod）：不需要访问类或实例的属性，通常用来执行与类和实例无关的功能。

class MyClass:
    @staticmethod
    def greet():
        print("Hello, World!")
MyClass.greet()  # 静态方法可以通过类调用，不需要实例化

• 类方法（@classmethod）：需要访问类本身，而不是实例。第一个参数是类本身（通常命名为cls）。

python
复制代码
class MyClass:
    @classmethod
    def greet(cls):
        print(f"Hello from {cls.__name__}")
MyClass.greet()  # 输出 "Hello from MyClass"

2.4 Python的迭代器与生成器

2.4.1 迭代器

迭代器是Python中一种实现了迭代协议的对象。它必须实现两个方法：

1. iter()：返回自身，表示该对象是可迭代的。
2. next()：返回序列中的下一个值，如果没有值可返回，抛出StopIteration异常。
   下面是一个简单的迭代器实现：

class MyIterator:
    def __init__(self, start, end):
        self.current = start
        self.end = end

    def __iter__(self):
        return self  # 迭代器本身是可迭代的

    def __next__(self):
        if self.current <= self.end:
            self.current += 1
            return self.current - 1
        else:
            raise StopIteration  # 序列结束，抛出异常


#使用迭代器
iterator = MyIterator(1, 5)
for num in iterator:
    print(num)
    
    
输出:

1
2
3
4
5

在这个例子中，MyIterator类实现了迭代协议，可以按需迭代一个从start到end的范围。

2.4.2 生成器

生成器是一个特殊类型的迭代器，通常通过yield关键字实现。它们以惰性方式生成值，不会一次性将所有数据加载到内存中，因此在处理大量数据时非常高效。

• 生成器示例：

def my_generator(start, end):
    while start <= end:
        yield start
        start += 1

# 使用生成器
generator = my_generator(1, 5)
for num in generator:
    print(num)

输出：

1
2
3
4
5

生成器与迭代器的不同之处在于，生成器使用yield一次返回一个结果，当再次调用next()时，它会从上次yield暂停的地方继续执行。

生成器具有以下优点：

• 延迟计算：生成器在调用时才会生成值，适合处理大量数据。
• 内存效率：生成器不会将所有值存储在内存中，只在需要时计算下一项。

---

2.5 Python中的装饰器

装饰器是Python的一种高级特性，它允许你在不修改函数或类的定义的前提下，为其添加额外的功能。装饰器本质上是一个函数，它接受一个函数作为输入并返回一个新的函数。

2.5.1 函数装饰器

假设你有一个函数，你想要在调用它之前和之后执行一些操作（如打印日志）。装饰器非常适合这种场景。

• 创建装饰器：

def decorator(func):
    def wrapper():
        print("Before the function call.")
        func()
        print("After the function call.")
    return wrapper

@decorator
def greet():
    print("Hello, World!")

greet()  # 输出：
# Before the function call.
# Hello, World!
# After the function call.

在上面的代码中，@decorator语法是一个装饰器语法糖，它将greet函数传递给decorator函数，并用wrapper函数替代greet。

2.5.2 带参数的装饰器

如果你想要让装饰器接受参数，可以通过创建一个外部嵌套函数来实现。
带参数的装饰器：

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def greet():
    print("Hello, World!")

greet()  # 输出三次 "Hello, World!"

在这个例子中，repeat装饰器使得greet函数被调用3次。

装饰器常用于：

• 记录日志
• 性能分析
• 权限验证
• 缓存机制

2.6 Python中的上下文管理器

上下文管理器用于管理资源（如文件、数据库连接、网络连接等）的使用，确保资源在使用后能够正确释放。Python提供了with语句来简化资源管理。

2.6.1 使用with语句

with语句会自动处理资源的获取和释放，常用于文件操作、数据库连接等。

• 文件操作

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

2.6.2 自定义上下文管理器

你还可以使用__enter__和__exit__方法创建自定义上下文管理器。__enter__方法在with语句开始时执行，而__exit__方法在with语句结束时执行。

• 自定义上下文管理器：

class MyContextManager:
    def __enter__(self):
        print("Entering the context")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting the context")
        if exc_type:
            print(f"Exception: {exc_type}, {exc_value}")

with MyContextManager() as cm:
    print("Inside the context")
    # 可以在这里抛出异常
    # raise ValueError("Something went wrong")

输出：

Entering the context
Inside the context
Exiting the context

如果在with语句块中抛出了异常，__exit__方法会处理异常，并且可以决定是否继续抛出异常。

---

2.7 Python的模块与包

Python中的模块是一个包含Python定义和语句的文件。模块使得Python代码更具组织性，可以将相关的功能封装在模块中，从而避免命名冲突。

2.7.1 创建模块

你可以通过简单的文件创建模块。例如，创建一个math_operations.py文件，内容如下：

# math_operations.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

然后，你可以在另一个Python文件中导入这个模块并使用其中的函数：

import math_operations

result = math_operations.add(5, 3)
print(result)  # 输出 8

2.7.2 使用from导入特定函数

如果只需要模块中的某些功能，可以使用from语句导入特定函数或类：

from math_operations import add

result = add(5, 3)
print(result)  # 输出 8

2.7.3 创建包

包是一个包含多个模块的文件夹。每个包都有一个__init__.py文件，标志着该文件夹是一个包。

例如，你可以创建一个名为mypackage的文件夹，其中包含两个模块：module1.py和module2.py。

mypackage/
init.py
module1.py
module2.py

然后在主程序中导入这些模块：

from mypackage import module1, module2

---

总结
到此为止，我们已经深入讨论了Python的一些进阶特性，包括：

• 高级数据结构（字典、集合、生成器等）
• 内置函数的常见用法
• 面向对象编程的高级特性（继承、多态、私有属性等）
• 装饰器、上下文管理器等高级特性
  这些特性能够帮助你编写更高效、更优雅的Python代码，并提高你的编程技能。希望你能够在日常开发中积极实践这些概念，逐步掌握Python编程的精髓。如果你有任何问题，随时欢迎提问！