Python 关键字总结

• as

  • 给变量起别名

    • original_variable = 42
      alias_variable = original_variable as new_variable
      print(new_variable)  # 输出 42
      

  • 导入模块并给模块起别名

    • import math as m
      print(m.sqrt(25))  # 输出 5.0
      

  • 入模块的一部分并给它们起别名

    • from math import sqrt as square_root
      print(square_root(25))  # 输出 5.0
      

  • 在异常处理中使用 "as"

    • try:
          # 一些可能引发异常的代码
          result = 10 / 0
      except ZeroDivisionError as error:
          print(f"发生了除以零的错误: {error}")
      

• ---

  assert

  • 是一个用于测试布尔表达式的关键字。它通常用于调试和测试代码，确保某个条件为真。如果条件不满足，assert 语句将引发 AssertionError 异常。
  • 一般用法：

    • assert condition, message
      

       
      • condition 是一个布尔表达式，如果为 True，则不会发生任何事情；如果为 False，则会引发 AssertionError 异常。
      • message（可选）是一个字符串，用于在发生断言错误时显示一条自定义消息。它可以帮助你更容易地理解为什么断言失败。

• ---

  async、await

  • async：用于定义异步函数和异步上下文。异步编程允许你编写并发执行的代码，以便更有效地处理I/O密集型操作，例如网络请求或文件读写。
  • await ：用于在异步函数内等待一个异步操作的完成，通常是一个异步函数或异步协程。当 await 遇到时，它会暂停当前异步函数的执行，允许事件循环执行其他任务，直到异步操作完成。例如，在上述示例中的 await asyncio.sleep(1) 就是等待1秒钟的异步操作。
  • 定义异步函数
    • 使用 async 关键字可以定义异步函数，这些函数使用 await 来等待异步操作完成。异步函数在执行过程中可以暂停，并让事件循环（event loop）执行其他任务，然后再继续执行。

      • import asyncio
        
        async def async_function():
            print("开始异步任务")
            await asyncio.sleep(1)  # 模拟异步操作
            print("异步任务完成")
        
        asyncio.run(async_function())
        

---

• del

  • 它可以用于删除变量、元素、属性等不同类型的对象。以下是 del 的常见用法。
  • 删除变量：

    • x = 10
      del x
      # 现在 x 不再存在，尝试访问它将引发 NameError 异常
      

  • 删除列表中的元素：

    • my_list = [1, 2, 3, 4, 5]
      del my_list[2]  # 删除索引为2的元素（值为3）
      # 现在 my_list 变为 [1, 2, 4, 5]
      

  • 删除整个列表或其他容器：

    • my_list = [1, 2, 3, 4, 5]
      del my_list  # 删除整个列表
      # 现在 my_list 不再存在，尝试访问它将引发 NameError 异常
      

  • 删除字典中的键值对：

    • my_dict = {"name": "Alice", "age": 30}
      del my_dict["age"]  # 删除键 "age" 对应的值
      # 现在 my_dict 变为 {"name": "Alice"}
      

  • 删除对象属性：

    • class MyClass:
          def __init__(self):
              self.x = 10
      
      obj = MyClass()
      del obj.x  # 删除对象的属性 x
      

  • 删除切片：

    • my_list = [1, 2, 3, 4, 5]
      del my_list[1:3]  # 删除切片 [2, 3]
      # 现在 my_list 变为 [1, 4, 5]
      

  • 删除多个对象

    • x = 10
      y = 20
      z = 30
      del x, y, z  # 删除多个变量
      

---

• global

  • 当你在函数内部定义一个变量时，默认情况下，它是局部的，只在函数内部可见。如果你需要在函数内部访问或修改全局变量，可以使用 global 关键字。
  • 访问、修改、创建全局变量：在函数内部，通过声明 global x，我们可以访问全局变量 x

    • x = 10  # 全局变量
      
      def my_function():
          global x  # 声明 x 为全局变量
          print(x)  # 访问全局变量 x
      
      my_function()  # 输出 10
      

• lambda

  • lambda 是一个用于创建匿名函数（无需使用 def 来定义函数名称）的关键字。

  • lambda arguments: expression
    

    lambda 关键字后面跟着参数列表，参数之间使用逗号分隔。冒号后面是一个表达式，表达式的结果将作为这个匿名函数的返回值。

  • add = lambda x, y: x + y
    result = add(3, 5)
    print(result)  # 输出 8
    

• nonlocal

  • 用于在嵌套函数中访问和修改嵌套作用域（non-local scope）的变量。通常，嵌套函数中的变量会被认为是局部变量，但有时你可能需要在内部函数中访问并修改外部函数的局部变量，这时就可以使用 nonlocal 关键字。
  • 与global的区别：global 用于全局作用域，nonlocal 用于封闭作用域。它们都允许在内部函数中访问和修改外部作用域的变量，但是 global 操作全局作用域，而 nonlocal 操作封闭作用域。

  • def outer_function():
        x = 10
        
        def inner_function():
            nonlocal x
            x = 20
        
        inner_function()
        print(x)  # 输出 20，因为内部函数修改了外部函数中的变量 x
    
    outer_function()
    

  • 当你在内部函数中使用 nonlocal 关键字声明一个变量时，Python 将知道你想要操作的是封闭作用域中的变量，而不是创建一个新的局部变量。
  • 修改封闭作用域变量的值后，这个变化将在内部函数外部函数中持续存在。

• raise

  • 使用 raise 关键字来触发特定类型的异常，以便在代码中处理错误情况。
  • 引发标准异常：用 raise 关键字可以引发Python标准库中已定义的异常，例如 ValueError、TypeError、RuntimeError 等。在这个示例中，如果除数为零，就会引发一个 ValueError 异常，然后在 try...except 块中捕获并处理异常.

    • def divide(x, y):
          if y == 0:
              raise ValueError("除数不能为零")
          return x / y
      
      try:
          result = divide(10, 0)
      except ValueError as e:
          print(f"发生了异常: {e}")
      

  • 自定义异常：可以自定义异常类，并使用 raise 关键字引发自定义异常。自定义异常通常是从内置异常类继承而来的。

    • class MyCustomError(Exception):
          pass
      
      def my_function(value):
          if value < 0:
              raise MyCustomError("值不能为负数")
      
      try:
          my_function(-5)
      except MyCustomError as e:
          print(f"发生了自定义异常: {e}")
      

  • 使用 raise 关键字重新引发异常：有时候，你可能希望在捕获异常后再次引发它，以便让上层代码处理。可以使用 raise 关键字不带参数来重新引发当前异常。

    • def process_data(data):
          try:
              # 处理数据的代码
              result = data / 0
          except ZeroDivisionError:
              print("除以零错误")
              raise  # 重新引发当前异常
      
      try:
          process_data(42)
      except ZeroDivisionError as e:
          print(f"捕获到异常: {e}")
      

• map

  • 用于将一个函数应用于可迭代对象（如列表、元组等）的每个元素，生成一个新的可迭代对象，其中包含了函数应用后的结果。

    • map(function, iterable, ...)
      

    • function 是一个函数或函数名称，用于处理可迭代对象的每个元素。
    • iterable 是一个或多个可迭代对象，包含了要应用函数的元素。
    • map() 返回一个迭代器，可以使用 list() 函数将其转换为列表或使用 for 循环遍历其内容。

  • 使用 map() 对列表中的元素进行平方操作：

    • numbers = [1, 2, 3, 4, 5]
      squared_numbers = map(lambda x: x ** 2, numbers)
      squared_numbers_list = list(squared_numbers)
      print(squared_numbers_list)  # 输出 [1, 4, 9, 16, 25]
      

    • 使用 map() 处理多个可迭代对象的元素：

      • list1 = [1, 2, 3]
        list2 = [10, 20, 30]
        result = map(lambda x, y: x + y, list1, list2)
        result_list = list(result)
        print(result_list)  # 输出 [11, 22, 33]