try…except 异常处理

在 Python 中，可以使用 try…except 语句来捕获和处理异常。 try 语句用来执行一段可能会抛出异常的代码块，如果代码块中发生了异常，就会跳转到 except 语句块中处理异常。

例子如下：

try:
    # 尝试执行可能会抛出异常的代码
    result = 10 / 0
except ZeroDivisionError as e:
    # 处理 ZeroDivisionError 异常
    print("除数不能为0:", e)

代码中，我们尝试将 10 除以 0，这会抛出一个 ZeroDivisionError 异常。在 except 语句中，我们使用 as 关键字来给异常命名为 e，并打印错误信息。

在 except 块中，还可以使用 else 语句处理未发生异常的情况。如果 try 块中的代码没有抛出异常，就会执行 else 块中的代码。下面是一个带有 else 块的 try…except 语句的例子：

try:
    # 尝试执行可能会抛出异常的代码
    result = 10 / 2
except ZeroDivisionError as e:
    # 处理 ZeroDivisionError 异常
    print("除数不能为0:", e)
else:
    # 处理未发生异常的情况
    print("结果为:", result)

代码中，我们尝试将 10 除以 2，这不会抛出异常。因此，程序会执行 else 块中的代码，打印计算结果。

除了使用 except 处理特定的异常类型外，还可以使用 except Exception 来处理所有类型的异常。

Exception 是所有异常类的基类，因此可以捕获任何异常。

使用 except Exception 处理所有类型的异常的例子如下：

try:
    # 尝试执行可能会抛出异常的代码
    result = 10 / 0
except Exception as e:
    # 处理所有类型的异常
    print("发生了异常:", e)

代码中，我们使用 except Exception 处理任何类型的异常，并打印错误信息。

在 try…except 块中，还可以使用 finally 语句来执行一些清理工作。无论是否发生异常，都会执行 finally 块中的代码。

下面是一个带有 finally 块的 try…except 语句的例子：

try:
    # 尝试执行可能会抛出异常的代码
    f = open("example.txt", "r")
    content = f.read()
except IOError:
    # 处理 IOError 异常
    print("无法打开文件")
else:
    # 处理未发生异常的情况
    print(content)
finally:
    # 关闭文件
    f.close()

代码中，我们使用 try 块尝试打开一个文件并读取其中的内容。如果打开文件失败会抛出 IOError 异常，在 except 块中处理异常。如果打开文件成功，就会处理未发生异常的情况，在 else 块中输出文件内容。无论是否发生异常，程序都要执行 finally 块中的代码，以确保文件被关闭。

函数

在 Python 中，可以使用 def 语句来定义函数。 def 语句的基本语法如下：

def function_name(arguments):
    # function body
    return value

其中，function_name 是函数名，arguments 是传递给函数的参数列表。函数体是函数要执行的一系列语句。如果函数需要返回值，可以使用 return 语句将结果返回。下面是一个定义函数和调用函数的例子：

def add(a, b):
    """求和函数"""
    result = a + b
    return result
# 调用函数
sum = add(3, 5)
print(sum)

代码中，我们使用 def 关键字定义了一个名为 add 的函数，该函数接受两个参数并返回它们的和。在程序的主体部分，我们调用了该函数，将 3 和 5 作为参数传递给它，并将其返回值赋给变量 sum。最后，我们打印出 sum 的值，结果为 8。

在 Python 中，还可以使用 *args 和 **kwargs 参数来接受可变数量的位置参数和关键字参数。*args 表示接受任意数量的位置参数，**kwargs 表示接受任意数量的关键字参数。下面是一个使用 *args 和 **kwargs 参数的例子：

def func(*args, **kwargs):
    """可变参数函数"""
    print("位置参数:", args)
    print("关键字参数:", kwargs)
# 调用函数
func(1, 2, 3, a=4, b=5)

代码中，我们定义了一个名为 func 的函数，并使用 *args 和 **kwargs 参数来接受任意数量的位置和关键字参数。在函数体中，我们打印出这些参数的值。在程序的主体部分，我们调用该函数，传递了一组位置参数和关键字参数。

在 Python 中，还可以使用 lambda 表达式来定义匿名函数。lambda 表达式的语法如下：

lambda arguments: expression

其中，arguments 是传入的参数列表，expression 是表达式，执行该表达式并将结果返回。下面是一个使用 lambda 表达式的例子：

# 定义匿名函数
square = lambda x: x ** 2
# 调用函数
print(square(3))   # 9

上述代码中，我们使用 lambda 表达式定义了一个名为 square 的匿名函数，该函数接受一个参数并返回该参数的平方。在程序的主体部分，我们使用该函数计算 3 的平方，并打印出结果。

模块和包

在 Python 中，模块是指一个包含 Python 代码的文件。模块可以包含函数、类、变量以及可执行的代码。在 Python 中，每一个文件都可以作为一个模块来使用。要使用一个模块，可以使用 import 语句导入该模块。下面是一个导入模块的例子：

import math
# 计算正弦值
x = math.sin(3.14 / 2)
print(x)

上述代码中，我们使用 import 语句导入了 Python 的 math 模块。在程序的主体部分，我们调用了 math 模块中的 sin() 函数，并计算了 π/2 的正弦值，结果为 1.0。

在 Python 中，还可以使用 from…import 语句从模块中导入部分内容。这样可以避免使用长名称的标识符。下面是一个使用 from…import 语句导入部分内容的例子：

from math import sin, pi
# 计算正弦值
x = sin(pi / 2)
print(x)

代码中，我们使用 from…import 语句仅导入了 math 模块中的 sin() 函数和 pi 变量。在程序的主体部分，我们调用了这些导入的函数和变量，并计算了 π/2 的正弦值，结果为 1.0。

在 Python 中，还可以使用包来组织模块。包是指一个包含模块和子包的文件夹，其中还包括一个名为 __init__.py 的空文件，该文件必须存在。要使用一个包中的模块，可以使用 import 语句导入该模块，格式为：

import package_name.module_name

下面是一个使用包的例子：

my_package/
    __init__.py
    module1.py
    module2.py

我们可以使用以下语句来导入 my_package 包中的 module1 模块：

import my_package.module1
# 调用函数
my_package.module1.my_function()

如果想从 my_package 包中导入多个模块，可以使用以下语句：

from my_package import module1, module2
# 调用函数
module1.my_function()
module2.my_function()

代码中，我们使用 from…import 语句从 my_package 包中导入了 module1 和 module2 两个模块，并分别调用了这两个模块中的函数。

类和面向对象编程

在 Python 中，类是一种用于定义对象的模板。类包含数据属性和方法，它们定义了对象的特征和行为。要定义一个类，可以使用 class 语句。下面是一个定义类的例子：

class MyClass:
    """一个简单的类"""
    def __init__(self, name):
        self.name = name
    def say_hello(self):
        print(f"Hello, {self.name}")
# 创建对象
my_object = MyClass("World")
# 调用方法
my_object.say_hello()

代码中，我们定义了一个名为 MyClass 的类，并使用 __init__() 方法创建了一个对象。这个方法会在对象创建时被自动调用，并将对象本身作为第一个参数传入（通常被命名为 self）。在 __init__() 方法中，我们使用 self.name 来初始化对象的 name 属性。

MyClass 类还包含一个 say_hello() 方法，该方法向控制台打印出一条问候语，其中包含对象的 name 属性。在程序的主体部分，我们使用 MyClass 创建了一个名为 my_object 的对象，并调用了该对象的 say_hello() 方法，输出了一条问候语。

在 Python 中，还可以使用继承来创建一个类。子类继承父类的数据属性和方法，并允许子类添加自己的数据属性和方法。下面是一个使用继承的例子：

class MyChildClass(MyClass):
    """一个简单的子类"""
    def say_goodbye(self):
        print(f"Goodbye, {self.name}!")
# 创建对象
my_child_object = MyChildClass("World")
# 调用方法
my_child_object.say_hello()
my_child_object.say_goodbye()

代码中，我们定义了一个名为 MyChildClass 的子类，并使用 MyClass 作为其父类。MyChildClass 子类包含一个 say_goodbye() 方法，该方法向控制台打印出一条告别语，其中包含对象的 name 属性。

在程序的主体部分，我们使用 MyChildClass 创建了一个名为 my_child_object 的对象，并调用了该对象的 say_hello() 和 say_goodbye() 方法，输出了一条问候语和一条告别语。

在 Python 中，还可以使用装饰器来扩展类和方法的功能。装饰器可以在运行时修改、增强或包装函数或类的功能。下面是一个使用装饰器的例子：

def my_decorator(function):
    def wrapper(*args, **kwargs):
        print("Before function is called.")
        result = function(*args, **kwargs)
        print("After function is called.")
        return result
    return wrapper
@my_decorator
class MyDecoratedClass:
    def __init__(self, name):
        self.name = name
    def say_hello(self):
        print(f"Hello, {self.name}")
# 创建对象
my_decorated_object = MyDecoratedClass("World")
# 调用方法
my_decorated_object.say_hello()

代码中，我们定义了一个名为 my_decorator 的装饰器，并使用它来装饰了 MyDecoratedClass 类。在程序的主体部分，我们创建了一个名为 my_decorated_object 的对象，并调用了该对象的 say_hello() 方法，输出了一条问候语。在调用 MyDecoratedClass 类的构造函数和 say_hello() 方法时，会自动调用 my_decorator 装饰器中定义的代码，输出 Before function is called 和 After function is called。

完结

下一篇文章 Python网络爬虫 基础进阶到实战 , 如有兴趣给个关注加订阅