模块 Module

定义

  • 包含一系列数据、函数、类的文件，通常以.py结尾

作用

  • 让一些相关的数据，函数，类有逻辑的组织在一起，使逻辑结构更加清晰

导入

import

  • 作用：将模块整体导入到当前模块中
  • 使用：模块名.成员
# 语法

import 模块名
import 模块名 as 别名

from import

  • 作用：将模块内的成员导入到当前模块作用域中
  • 使用：直接使用成员名
# 语法

from 模块名 import 成员名
from 模块名 import 成员名 as 别名
from 模块名 import *

被导入代码

"""
    module01.py
"""
def func01():
    print("module01 - func01执行喽")

def func02():
    print("module01 - func02执行喽")

导入代码

# 导入方式1：import 模块名
# 使用：模块名.成员
# 原理：创建变量名记录文件地址,使用时通过变量名访问文件中成员
# 适用性：适合面向过程(全局变量、函数)

import module01
module01.func01()

# 导入方式2.1：from 文件名 import 成员
# 使用：直接使用成员
# 原理：将模块的成员加入到当前模块作用域中
# 注意：命名冲突
# 适用性：适合面向对象(类)

from module01 import func01
def func01():
    print("demo01 - func01")

func01() # 调用的是自己的func01

# 导入方式2.2：from 文件名 import *

from module01 import *
func01()
func02()

时间模块使用

"""
    标准库模块
        time 时间模块
"""
import time

# 人类时间:2021年11月18日 16:32:25
# -- 时间元组(年,月,日,时,分,秒,星期,年的第几天,夏令时)
time_tuple = time.localtime()
print(time_tuple[0])  # 年
print(time_tuple[6])  # 星期
print(time_tuple[-3])  # 星期
print(time_tuple[:3])  # 年月日
print(time_tuple[3:6])  # 时分秒

# 机器时间
# -- 时间戳:从1970年到现在经过的秒数
print(time.time())  # 1637224879.6712253

# 时间元组 <--> 时间戳
# 语法:时间戳 = time.mktime(时间元组)
print(time.mktime(time_tuple))
# 语法:时间元组 = time.localtime(时间戳)
print(time.localtime(1637224879.6712253))

# 时间元组 <--> 字符串
# 语法：字符串 = time.strftime(格式,时间元组)
print(time.strftime("%y/%m/%d %H:%M:%S", time_tuple))
# 2021/11/18 16:51:49
print(time.strftime("%Y/%m/%d %H:%M:%S", time_tuple))
# 2021年11月18日 16时53分32秒　
print(time.strftime("%Y年%m月%d日 %H时%M分%S秒", time_tuple))
# 语法：时间元组 = time.strptime(字符串,格式)
print(time.strptime("2021年11月18日 16时53分32秒", "%Y年%m月%d日 %H时%M分%S秒"))

模块变量

  • doc : 文档字符串。
  • name : 模块自身名字，可以判断是否为主模块

当此模块作为主模块(第一个运行的模块)运行时，name绑定'__main__'，不是主模块，而是被其它模块导入时,存储模块名

# 只有是主模块才会执行该if内的代码
if __name__ == '__main__':
    pass

加载过程和模块分类

  • 在模块导入时，模块的所有语句会执行
  • 如果一个模块已经导入，则再次导入时不会重新执行模块内的语句
  • 内置模块(builtins)，在解析器的内部可以直接使用。
  • 标准库模块，安装Python时已安装且可直接使用。
  • 第三方模块（通常为开源），需要自己安装。
  • 用户自己编写的模块（可以作为其他人的第三方模块）

包package

将模块以文件夹的形式进行分组管理,让一些相关的模块组织在一起，使逻辑结构更加清晰

导入

import

  • 作用：将包中__init__模块内整体导入到当前模块中
  • 使用：包.成员
# 语法

import 包
import 包 as 别名

from import

  • 作用：将包中__init__模块内的成员导入到当前模块作用域中
  • 使用：直接使用成员名
# 语法

from 包 import 成员
from 包 import 成员 as 别名

被导入代码

"""
    package01/
    module01.py
"""

def func01():
    print("func01执行了")

def func02():
    print("func02执行了")

__init__.py

"""
    package01/
    __init__.py
"""
import package01.module01

from package01.module01 import func01

导入代码

"""
    main.py
"""
# 方式1:import 包 as 别名
import package01 as p

p.module01.func01()
p.func02()

# 方式2:from 包 import 成员
from package01 import module01,func02

module01.func01()
func02()

异常处理 Error

运行时检测到的错误,当异常发生时，程序不会再向下执行，而转到函数的调用语句

  • 常见异常类型
  1. 名称异常(NameError)：变量未定义
  2. 类型异常(TypeError)：不同类型数据进行运算
  3. 索引异常(IndexError)：超出索引范围
  4. 属性异常(AttributeError)：对象没有对应名称的属性
  5. 键异常(KeyError)：没有对应名称的键
  6. 异常基类Exception
# 语法
# 作用：将程序由异常状态转为正常流程

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

说明

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

raise 语句

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

class Wife:
    def __init__(self, age):
        self.age = age

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, value):
        if 20 <= value <= 60:
            self.__age = value
        else:
            # 创建异常 -- 抛出 错误信息
            raise Exception("我不要","if 20 <= value <= 60",1001)

# -- 接收 错误信息
while True:
    try:
        age = int(input("请输入你老婆年龄："))
        w01 = Wife(age)
        break
    except Exception as e:
        print(e.args) # ('我不要', 'if 30 <= value <= 60', 1001)