Python之模块、包、异常

Python之模块、包、异常

1、模块module

模块是 Python 程序架构的一个核心概念。Python中模块就是一个.py文件，模块中可以定义函数，变量，类。模块可以被其他模块引用

创建模块文件

创建文件：utils.py

# 定义变量 
name = '张三'

# 定义函数
def sum(a,b):
    return a+b

# 定义类
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return 'name:{},age:{}'.format(self.name,self.age)

导入模块中的功能

整体导入模块

# 导入模块
import utils

# 使用模块中功能
print(utils.name)
# 调用模块中的sum方法
result = utils.sum(10,20)
# 创建模块utils中的Person类对象
p = utils.Person('张三',30)

导入模块中全部功能

from utils import *

# 使用name
print(name)
# 调用sum函数
result = sum(10,20)
# 创建Person对象
p = Person('林青霞',60)

导入模块中的部分功能

模块的导入冲突

如果两个模块中有同名的变量、函数或者类，同时引入就可能出现冲突

部分导入冲突

from hello import name
from hi import name

print(name)

同时引入name的话，输出的name是hi中的name，是有顺序的（后导入的覆盖先导入的）

局部引入冲突解决方案
可以通过as 给功能起别名

from hello import name as hello_name
from hi import name as hi_name

print(hello_name)
print(hi_name)

全部导入冲突

from hello import *
from hi import *

print(name)

全部引入冲突解决方案
直接引入模块，通过模块名.去引用

import hello
import hi

print(hello.name)
print(hi.name)

模块的内置变量__name__

__name__是模块中的内置变量,每个模块都有这个属性
创建hello.py

print(__name__)

直接运行hello.py,结果为:

__main__

其它模块导入hello.py

import hello

结果为：模块名

hello

__name__的特点

• 如果将当前模块作为启动项，__name__值为__main__
• 如果当前模块当作依赖引入，__name__值不为__main__，为依赖的模块名称

__name__作用

python没有入口函数的概念,可以通过__name__的功能进行测试

def sum(m,n):
    return m+n

if __name__ == '__main__':
    a = 10
    b =20
    result = sum(a,b)
    print(result)

主程序的代码放在if __name__ == '__main__':里。这样当前模块即可以独立测试运行，也可以被其他文件导入使用。如果不添加此if判断，别的地方导入当前文件模块时，会运行一些不需要的代码。

2、包 package

包就是个文件夹，用来放模块的，限定了模块的命名空间

包的作用

• 用来管理模块的
• 让业务更清晰化
• 解决一些命名的问题

引入包中模块的功能方法一

import 包名.模块名

import pkg.hello

#访问模块中的属性
print(pkg.hello.name)

#访问模块中的函数
pkg.hello.say()

#访问模块中的类
nice = pkg.hello.Nice()

引入包中模块的功能方法二（推荐）

from 包名 import 模块名

from pkg import hello

#访问模块中的属性
print(hello.name)

#访问模块中的函数
hello.say()

#访问模块中的类
nice = hello.Nice()

引入包中模块的功能方法三（推荐）

from 包名.模块名 import 属性，函数，类

from pkg.hello import name
from pkg.hello import say
from pkg.hello import Nice

#访问模块中的属性
print(name)

#访问模块中的函数
say()

#访问模块中的类
nice = Nice()

引入包中模块的功能方法四

from 包名.模块名 import *

from pkg.hello import *

#访问模块中的属性
print(name)

#访问模块中的函数
say()

#访问模块中的类
nice = Nice()

3、内置模块

sys模块

• sys.argv 获得启动时的参数
• sys.path 获取加载的环境
• sys.exit()程序退出

time模块

time模块，包含和时间相关信息
time.time()获取当前时间戳，单位是秒，(相对于1970年1月1日的0点0时0分0秒)

import time
result = time.time() # 获取当前时间
print(result)

time.sleep(秒)阻断程序

import time

# print('程序开始')
# 睡眠3秒钟
time.sleep(3)
# print('程序结束')

datetime模块

datetime获取日期
datetime.datetime.now().year
datetime.datetime.now().month
datetime.datetime.now().day

import datetime
# 获取当前年
year = datetime.datetime.now().year
# 获取月
month = datetime.datetime.now().month
# 获取日期
day = datetime.datetime.now().day
print(year)
print(month)
print(day)

# 格式化日期时间
now = datetime.datetime.now()
str_time = datetime.datetime.strftime(now, "%Y-%m-%d %H:%M:%S")
#将字符时间格式化
str_time2="2024.03.08 15|39|28"
print(datetime.datetime.strptime(str_time2,"%Y.%m.%d %H|%M|%S"))

计算排序

aaa = [2, 4, 1, 2, 3, 6]
# 列表最大值
print(max(aaa))
# 列表最小值
print(min(aaa))
# 列表和
print(sum(aaa))
# 列表长度
print(len(aaa))
#列表排序，sorted并不会修改原来数组的内容
list_sort=sorted(aaa)
print(aaa) 
print(list_sort) 
# 列表倒序
print(sorted(aaa, reverse=True))

math模块

math是数学相关的库

import math
# 幂
print(math.pow(10, 2))
# 向下取整
print(math.floor(1.8234234234234))
# 向上取整
print(math.ceil(1.1234234234234))
# 四舍五入
print(round(1.6234234234234))

# sin  传入弧度值  pi 3.14 180度
print(math.sin(1.57))

random模块

import random

# 随机整数
print(random.randint(10, 20))
# 随机小数 [0, 1) 左闭右开
print(random.random())
# 随机浮点类型数据
print(random.uniform(1.3, 8.5))

# 从列表中随机获取元素
lst = [10,20,30]

print(random.choice(lst))

# 随机返回列表 choices返回单个元素的列表 [10]或[20]或[30]
print(random.choices(lst))

4、异常

异常捕获

使用try except捕获异常

try:
    代码
except:
    出现异常的代码

代码:

try:
    result = a / b
    print('没有异常',result)
except:# 如果代码有异常会执行 ,没有异常并不会执行
    print('出现了异常')

可以捕获异常的类型

try:
    result = a/b
    print('没有异常',result)
except Exception as error:# 如果代码有异常会执行 ,没有异常并不会执行
    print('出现了异常',error)

a=int(input("请输入a"))
b=int(input("请输入b"))

try:
    print(a/b)
except ZeroDivisionError as e: #捕获除0异常
    print(e)

finally

try语句中使用finally，finally中代码不论有没有出现异常都会执行
格式：

try:
    逻辑代码
finally:
    无论是否出现异常，都会执行

例如：

try:
    a = 1 / 0
    print("异常之后的代码", a)
finally:
    print("finally里的代码")

程序出现异常也会执行finally中的代码

try except else finally语法

格式:

try:
    逻辑代码
except Exception as error:
    print(error)
else:
    没有出现异常的逻辑
finally:
    无论是否出现异常，都会执行

自定义异常

除了系统已经定义好的异常，也可以自己定义异常
所有的异常都继承自Exception，异常的继承关系如下：

自定义异常的格式：

class 自定义异常名(Exception):

    def __init__(self, msg):
        self.msg = msg

    def __str__(self):
        return self.msg

代码：

class MyException(Exception):
    def __init__(self,msg):
        self.msg=msg

    def __str__(self):
        return self.msg



a=int(input("请输入a"))
b=int(input("请输入b"))

try:
    print(a/b)
    raise  MyException("抛出了一个自定义异常")
except Exception as e:
    print(e)

raise的作用是抛出异常
抛出异常如果没有通过try except处理，程序会停止

多重捕获

try:
    a = 1 / 0

    b = [1, 2]
    c = b[4]
except IndexError as error:
    print("indexerror 错误逻辑")
except ZeroDivisionError as error:
    print(error)
except (IndexErrorZero,DivisionError) as error
	print(error)

可以通过多个except捕获不同的异常分别处理

返回值问题

import random

def hello():
    try:
        b = [1]
        b[random.randint(0, 1)]

        print("--0")
        return 0
    except Exception as error:
        print("--1")
        return 1
    finally:
        print("--2")
        return 2

print(hello())

如果finally中有return语句,则返回的结果为finally中的return数据