1. 程序结构

• 模块：包含一系列数据、函数、类的文件，通常以.py结尾。
  • 作用：让一些相关的数据，函数，类有逻辑的组织在一起，使逻辑结构更加清晰。有利于多人合作开发。
  • 导入：将某模块整体导入到当前模块中
  • 语法：import 模块名 import 模块名 as 别名
  • 使用：模块名.成员
  • from import
  • 语法：from 模块名 import 成员名[as 别名1]
    1. 作用：将模块内的一个或多个成员导入到当前模块的作用域
    2. 使用：直接使用成员名。
• 模块变量
  1. __ doc __变量：文档字符串
  2. __ name __ 变量：模块自身名字，可以判断是否为主模块。当此模块作为主模块（第一个运行的模块）运行时， _ name __绑定_ _main __,不是主模块，而是被其它模块导入时，存储模块名。

• 加载过程
  • 1. 在模块导入时，模块的所有语句会执行。
  • 2. 如果一个模块已经导入，则再次导入时不会重新执行模块内的语句。

• 分类
  • 1. 内置模块(builtins)，在解析器的内部可以直接使用。
  • 2. 标准库模块，安装python时已安装且可直接使用。
  • 3. 第三方模块(通常为开源)，需要自己安装。
  • 4. 用户自己编写的模块(可以作为其他人的第三方模块)

• 包 Package
  • 定义：将模块以文件 夹的形式进行分组管理。
  • 作用：让一些相关的模块组织在一起，使逻辑结构更加清晰
  • __ init __.py文件 是包内必须存在的文件 会在包加载时自动调用。
  • 作用：记录import 包 语句需要导入的模块搜索顺序： sys.path 提供的路径导入搜索路径 按照列表顺序搜索，如果前面搜索到，立即停止。 列表第一个元素永远是项目根目录(主模块所在文件夹) 将文件夹标记蓝色，实质就是添加到系统路径中import sys

2. 异常处理

现象：当异常发生时，程序不会再向下执行，而转到函数的调用语句。​

2.1 异常：运行时检测到的错误

常见异常类型：​
    1. --名称异常(NameError):变量未定义
    2. -- 类型异常(TypeError):不同类型数据运行运算
    3. --索引异常(IndexError)：超出索引范围
    4. --异性异常(AttributeErro)：对象没有对应名称的属性
    5. --键异常(KeyErro)：没有对应名称的键
    6. --异常基类Exception

2.2 处理

 try:​
      可能触发异常的语句​
  except 错误类型1 [as 变量 1]：​
  except 错误类型2 [as 变量2]：​
       处理语句2​
   else:​
       未发生异常的语句​
   finally:​
       无论是否发生异常的语句

作用：将程序由异常状态转为正常流程
​说明：
  as 子句是用于绑定错误对象的变量，可以省略​
  except子句可以有一个或多个，用来捕获某种类型的错误。​
  else子句最多只能有一个​
  finally子句最多只能有一个，如果没有except子句，必须存在。​
  如果异常没有被捕获到，会向上层(调用处)继续传递，直到程序终止运行。

raise 语句

1. 作用：抛出一个错误，让程序进入异常状态。  
2. 目的：在程序调用层数较深时，向主调函数传递错误信息要层层return比较麻烦，所以人为抛出异常，可以直接传递错误信息。

3. 迭代

  • 每次对过程的重复称为一次“迭代”，而每次迭代得到的结果会作为下次迭代的初始值。例如：循环获取容器中的元素。

3.1 可迭代对象 iterable

1. 定义：具有__ iter__ 函数的对象，可以返回迭代器对象。​
2. 语法：​
      -- 创建：​
       class 可迭代对象名称：​
         def __ iter __ (self):​
             return 迭代器​
      --使用：​
       for 变量名 in 可换代对象：​
         语句
3. 原理：
         迭代器 = 可换代对象.__ iter __()​
         while True:​
             try:​
               print(迭代器.__ netxt __())​
         except StopIteration:​
             break     

3.2 迭代器对象

       1. 定义：可以被next()函数调用并返回下一个值的对象。​
       2. 语法：​
          class 换代器类名：​
              def __ init __ (self,聚合对象)​
                 self.聚合对象=聚合对象​
              def __ next __ (self):​
                 if 没有元素：​
                     raise StopIteration​
              return 聚合对象元素​
        3. 说明：​
          -- 聚合对象通常是容器对象。​
        4. 作用：使用者只需通过一种方式，便可简洁明了的获取聚合对象中各个元素，而无需了解其内部结构。

4. 生成器（generator）

1. 定义:能够动态(循环一次计算一次返回一次)提供数据的可迭代对象。
2. 作用：在循环过程中，按照某种算法推算数据，不必创建容器存储完整的结果，从而节省内存空间。数据量越大，优势越明显。
3. 以上作用也称之为延迟操作或惰性操作，通俗的讲就是在需要的时候才计算结果，而不是一次构建出所有结果 。

4.1 生成器函数

4.2 内置生成器

枚举函数 enumerate

1. 语法：​
    for 变量 in enumerate(可迭代对象)：​
        语句​
    for 索引，元素 in enumerate(可换代对象)：​
2.语句作用：
    遍历可迭代对象时，可以将索引与元素组合为一个元组。

ZIP

1. 语法： for item in zip(可迭代对象1，可迭代对象2....)： 语句
2. 作用：将多个可迭代对象中对应的元素组合成一个个元组，生成的元组个数由最小的可迭代对象决定。

4.3 生成器表达式

1. 定义：用推导式形式创建生成器对象。
2. 语法：变量 = （表达式 for 变量 in 可迭代对象 [if 真值表达式]）

5. 函数式编程

定义：用一系列函数解决问题。
-- 函数可以赋值给变量，赋值后变量绑定函数。
-- 允许将函数作为参数传入另一个函数。
-- 允许函数返回一个函数。
高阶函数：将函数作为参数或返回值的函数。

5.1 函数作为参数

1. 将核心逻辑传入方法体，使该方法的适用性更广，体现了面向对象的开闭原则。函数式编程思想：
2. 解决的问题：多个函数，主体逻辑相同，核心算法不同
3. 思想：
   1. “封装”-分：将不同的核心算法单独定义到函数中，将主体逻辑也定义到单独函数中。
   2. “继承”-隔：使用参数在主体逻辑函数中隔离不同的核心算法函数
   3. “多态”-做：将来再增加新的核心算法，只需按主体逻辑函数中使用参数的规则定义新函数

lambda 表达式

• 定义：
  • 是一种匿名方法。
• 作用：
  • 作为参数传递语法简洁，优雅，代码可读性强。
  • 随时创建和销毁，减少程序耦合度。
• 语法：
  • -- 定义：
    • 变量 = lambda 形参：方法体
  • -- 调用
    • 变量（实参）
• 说明：
  • -- 形参没有可以不填
  • -- 方法体只能有一条语句，且不支持赋值语句

内置高阶函数

  1. map(函数，可迭代对象)：使用可迭代对象中的每个元素调用函数，将返回值作为新可迭代对象元素；返回值为新可迭代对象。
  2. filter(函数，可迭代对象)：根据条件筛选可迭代对象中的元素，返回值为新可迭代对象。
  3. sorted(可迭代对象，key = 函数，reverse=bool值)：排序，返回值为排序结果。
  4. max(可迭代对象，key=函数)：根据函数获取可迭代对象的最大值。
  5. min(可迭代对象，key=函数)：根据函数获取可迭代对象的最小值。

5.2 函数作为返回值

逻辑连续，当内部函数被调用时，不脱离当前的逻辑。

5.1 闭包

1. 三要素：-- 必须有一个内嵌函数。-- 内嵌函数必须引用外部函数中变量。-- 外部函数返回值必须是内嵌函数。
2. 语法-- 定义： def 外部函数名(参数) 使用外部变量 return 内部函数名-- 调用： 变量 = 外部函数(参数) 变量(参数)
3. 定义：是由函数及其相关的引用环境组全面民的实体。​
4. 优点：内部函数可以使用外部变量。
5. 缺点：内部变量一直存于内存中，不会在调用结束后释放，占用内存。
6. 作用：实现python装饰器。5.2 函数装饰器decorator
7. 定义：在不改变原数了数的调用以及内部代码情况下，为其添加新功能的函数。
8. 语法
   def 函数装饰器名称(func):
   def wrapper(*args,**kwargs):
   需要添加的新功能
   return func(*args,**kwargs)
   return wrapper原函数 = 内嵌函数
   @ 函数装饰器名称def 原函数名称(参数)： 函数体原函数(参数)
9. 本质：使用“@函数装饰器名称”修饰原函数，等同于创建与原函数名称相同的变量，关联内嵌函数；故调用原函数时执行内嵌函数。
   原函数名称 = 函数装饰器名称(原函数名称)
10. 装饰器链：一个函数可以被多个装饰器修饰，执行顺序为从近到远。