Python3 实例（二） | 菜鸟教程（二十）

**Python3 实例（二）**

在前一篇文章中，我们已经学习了 Python3 的基本语法和一些常用的函数库。现在，我们将继续深入探索 Python3 的更多特性和实践。

###1. 文件操作文件操作是编程中非常重要的一部分。在 Python3 中，可以使用 `open()` 函数来打开文件，`read()` 函数来读取文件内容，`write()` 函数来写入文件内容，`close()` 函数来关闭文件。

下面是一个简单的示例代码：

# 打开一个文件file = open('example.txt', 'w')

# 写入一些内容file.write('Hello, World!')

# 关闭文件file.close()

在上面的代码中，我们使用 `open()` 函数打开了一个名为 `example.txt` 的文件，并将其模式设置为 `'w'`，表示我们要写入文件。然后，我们使用 `write()` 函数写入了一些内容。最后，我们使用 `close()` 函数关闭了文件。

###2. 字典和集合Python3 中有两个重要的数据结构：字典（dict）和集合（set）。

**字典**

字典是一种键值对的数据结构，使用 `{}` 表示。下面是一个简单的示例代码：

# 创建一个字典person = {'name': 'John', 'age':30}

# 访问字典中的值print(person['name']) # 输出：John# 更新字典中的值person['age'] =31print(person) # 输出：{'name': 'John', 'age':31}

在上面的代码中，我们创建了一个名为 `person` 的字典，其中包含两个键值对：`name` 和 `age`。然后，我们访问了字典中的值，并更新了其中的一个值。

**集合**

集合是一种无序的数据结构，使用 `set()` 函数创建。下面是一个简单的示例代码：

# 创建一个集合fruits = {'apple', 'banana', 'orange'}

# 添加元素到集合中fruits.add('grape')
print(fruits) # 输出：{'apple', 'banana', 'orange', 'grape'}

# 删除元素从集合中fruits.remove('banana')
print(fruits) # 输出：{'apple', 'orange', 'grape'}

在上面的代码中，我们创建了一个名为 `fruits` 的集合，其中包含三个元素。然后，我们添加了一些元素到集合中，并删除了一些元素。

###3. 模块和包Python3 中有两个重要的概念：模块（module）和包（package）。

**模块**

模块是一种 Python 文件，使用 `.py` 结尾。下面是一个简单的示例代码：

# mymodule.pydef greet(name):
 print(f'Hello, {name}!')

在上面的代码中，我们创建了一个名为 `mymodule` 的模块，其中包含一个名为 `greet` 的函数。

**包**

包是一种 Python 文件夹，使用 `__init__.py` 文件来标记。下面是一个简单的示例代码：

# mypackage/
# __init__.pyfrom . import module1, module2# module1.pydef func1():
 print('This is func1!')

# module2.pydef func2():
 print('This is func2!')

在上面的代码中，我们创建了一个名为 `mypackage` 的包，其中包含两个模块：`module1` 和 `module2`。我们使用 `__init__.py` 文件来标记包的开始。

###4. 异常处理Python3 中有多种异常类型，可以使用 `try`-`except`语句来捕捉和处理异常。

下面是一个简单的示例代码：

# try-except语句try:
 x =1 /0except ZeroDivisionError:
 print('Error: cannot divide by zero!')

在上面的代码中，我们使用 `try`-`except`语句来捕捉一个 `ZeroDivisionError` 异常，并输出错误信息。

###5. 类和对象Python3 中有两个重要的概念：类（class）和对象（object）。

**类**

类是一种模板，用于定义对象的行为和属性。下面是一个简单的示例代码：

# Person classclass Person:
 def __init__(self, name, age):
 self.name = name self.age = age def greet(self):
 print(f'Hello, my name is {self.name} and I am {self.age} years old!')

# 创建一个对象person = Person('John',30)

# 访问对象的属性和方法print(person.name) # 输出：Johnperson.greet() # 输出：Hello, my name is John and I am30 years old!

在上面的代码中，我们定义了一个名为 `Person` 的类，其中包含两个属性：`name` 和 `age`，以及一个方法：`greet()`。然后，我们创建了一个对象，并访问了对象的属性和方法。

###6. 函数式编程Python3 中有多种函数式编程的方式，可以使用 lambda 表达式、map 函数、filter 函数等来实现。

下面是一个简单的示例代码：

# 使用 lambda 表达式numbers = [1,2,3,4,5]
squared_numbers = list(map(lambda x: x **2, numbers))
print(squared_numbers) # 输出：[1,4,9,16,25]

# 使用 filter 函数even_numbers = list(filter(lambda x: x %2 ==0, numbers))
print(even_numbers) # 输出：[2,4]

在上面的代码中，我们使用 lambda 表达式和 map 函数来实现一个平方函数，然后使用 filter 函数来实现一个过滤函数。

###7. DecoratorPython3 中有一个重要的概念：装饰器（decorator）。装饰器是一种特殊的函数，可以在函数执行前或后添加一些逻辑。

下面是一个简单的示例代码：

# decoratordef my_decorator(func):
 def wrapper(*args, **kwargs):
 print('Before calling the function')
 result = func(*args, **kwargs)
 print('After calling the function')
 return result return wrapper@my_decoratordef add(a, b):
 return a + bresult = add(2,3)
print(result) # 输出：5

在上面的代码中，我们定义了一个名为 `my_decorator` 的装饰器，然后使用它来装饰一个名为 `add` 的函数。最后，我们调用装饰后的函数，并输出结果。

###8. GeneratorPython3 中有一个重要的概念：生成器（generator）。生成器是一种特殊的函数，可以在执行时产生一系列的值，而不是一次性生成所有值。

下面是一个简单的示例代码：

# generatordef my_generator():
 for i in range(5):
 yield ig = my_generator()
for value in g:
 print(value) # 输出：0,1,2,3,4

在上面的代码中，我们定义了一个名为 `my_generator` 的生成器，然后使用它来产生一系列的值。最后，我们遍历生成器，并输出结果。

###9. AsyncioPython3 中有一个重要的库：asyncio。asyncio 库提供了一种异步编程的方式，可以在执行时并发地处理多个任务。

下面是一个简单的示例代码：

# asyncioimport asyncioasync def my_task():
 print('Task started')
 await asyncio.sleep(1)
 print('Task finished')

async def main():
 tasks = [my_task() for _ in range(3)]
 await asyncio.gather(*tasks)

asyncio.run(main())

在上面的代码中，我们定义了一个名为 `my_task` 的异步任务，然后使用它来创建多个任务。最后，我们使用 `asyncio.gather` 函数来并发地执行这些任务。

###10. ConcurrencyPython3 中有多种 concurrency 库，可以使用它们来实现并发编程。

下面是一个简单的示例代码：

# concurrent.futuresimport concurrent.futuresdef my_task(x):
 print(f'Task {x} started')
 await asyncio.sleep(1)
 print(f'Task {x} finished')

with concurrent.futures.ThreadPoolExecutor() as executor:
 futures = [executor.submit(my_task, x) for x in range(3)]
 for future in futures:
 future.result()

在上面的代码中，我们使用 `concurrent