python引入模块的五种方式与内置模块_python引用模块的方法

模块

自定义模块

模块的定义与分类

模块的定义

简而言之，模块就是一些常用功能的集合，我们把一些常用的函数、变量或者方法写到一个python文件中，那么这个python文件就是模块，使用模块可以避免我们重复造轮子

模块的分类

内置模块

内置模块也称为标准库，它是pyhton解释器自带的预先定义好的方法或者变量，有点类似java中jdk自带的函数库。

第三方模块

其他个人或者机构写的一些好用的工具方法，开源出来

自定义模块

我们在项目中定义的一些模块

模块导入的五种方式

1、import 模块名

2、from 模块名 import 方法名

3、from 模块名 import *

4、import 模块名 as 别名

5、from 模块名 import 方法名 as 别名

创建一个python文件 a.py

print('我是a.py模块')
name = '小明'


def func():
    print(f'my name is {name}')

1
2
3
4
5
6
7

import的使用

导入模块的关键字,注意并不是所有的python文件都能被导入，需要遵守一定的命名规则，不能以数字开头

import a

a.func()
print(a.name)

# 执行输出如下
我是a.py模块
my name is 小明
小明
1
2
3
4
5
6
7
8
9

注意：import可以在程序中的任意位置使用，第一次使用import关键字导入模块后，会将模块加载到内存中，后续针对同一模块的import不会重新执行模块内的语句。

第一次导入模块执行的三件事

• 创建一个以模块的名称空间
• 执行这个名称空间里面的代码
• 可以通过 模块名 '.'的方式引用模块内的变量、方法等。

为模块起别名

# import xx  as  xx
import a as model_a

model_a.func()
print(model_a.name)

1
2
3
4
5
6

导入多个模块

# 可以这样写，但是不推荐
import requests, json

# 推荐写法
import requests
import json

1
2
3
4
5
6
7

from …import…

from a import name, func

print(name)
func()

# 输出：
我是a.py模块
小明
my name is 小明
1
2
3
4
5
6
7
8
9

import与from…import导入的对比

• import需要通过点的方式来引用模块中的元素
• from…import是将原模块中的变量直接引入到现有空间，不需要通过点的方式来引用
• 但是from…imort导入的这种方式会存在变量名冲突的问题

from a import name, func # 也支持as
# from a import name as my_name

name = '小花'
print(name) # 小花
1
2
3
4
5

name = '小花'
from a import name, func

print(name) # 小明

1
2
3
4
5

执行文件有与模块同名的变量或者函数名，会有覆盖效果

from … import *

把模块中所有的不是以下划线（_）开头的名字都导入到当前位置

python文件的两种功能

一个编写好的python文件可以有两种用途：用作脚本；用作模块

• 脚本：一个文件就是整个程序，用来被执行
• 模块：文件中存放着一堆功能，用来被导入使用

在python中，为我们提供了一个全局变量 name

当文件被当做脚本时执行时：name 等于’main’

当文件被当做模块导入时：name 等于 模块名

模块搜索路径

模块的引用也是按照一定的顺序进行引用的

这个顺序是：先从内存中已经加载好的模块寻找，如果没找到则从内置模块中查找，如果内置模块也找不到，那么接下来就去sys.path中路径包含的模块中寻找。如果还找不到就会报错

这也提醒我们自己模块的名字不要和内置的冲突

内置模块

Json模块

python中对象序列化模块主要有两种：一种是json,一种是pickle,那json是支持不同种语言之间传递的，而pickle只能在python中使用

序列化

dumps（）

import json

data = {
    'orderSource': '1',
    'productCode': '518005',
    'orderId': 'TEST_AS20200827CN',
    'mailCode': '',
    'volume': '100.2',
    'length': '10.1',
    'width': '10.1',
    'height': '10.1',
    'mailWeight': 100,
    'mailValue': 20.4,
    'valueType': 'USD',
    'batteryFlag': 0,
    'innerType': '1',
    'remark': '这是商品描述'
}

str = json.dumps(data)
print(type(str)) # <class 'str'>
print(str)

# {"orderSource": "1", "productCode": "518005", "orderId": "TEST_AS20200827CN", "mailCode": "", "volume": "100.2", "length": "10.1", "width": "10.1", "height": "10.1", "mailWeight": 100, "mailValue": 20.4, "valueType": "USD", "batteryFlag": 0, "innerType": "1", "remark": "\u8fd9\u662f\u5546\u54c1\u63cf\u8ff0"}
# 发现乱码了
# 解决办法：不使用ascii编码
str = json.dumps(data, ensure_ascii=False)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

反序列化

loads（）

import json

data = {
    'orderSource': '1',
    'productCode': '518005',
    'orderId': 'TEST_AS20200827CN',
    'mailCode': '',
    'volume': '100.2',
    'length': '10.1',
    'width': '10.1',
    'height': '10.1',
    'mailWeight': 100,
    'mailValue': 20.4,
    'valueType': 'USD',
    'batteryFlag': 0,
    'innerType': '1',
    'remark': '这是商品描述'
}

str = json.dumps(data)
dic = json.loads(str)
print(type(dic)) # <class 'dict'>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

另外说明，json还有一对方法：dump（）与load（），这一对表示的是将对象序列化至json文件，或者从json文件中反序列化成对象。

import json

data = {
    'orderSource': '1',
    'productCode': '518005',
    'orderId': 'TEST_AS20200827CN',
    'mailCode': '',
    'volume': '100.2',
    'length': '10.1',
    'width': '10.1',
    'height': '10.1',
    'mailWeight': 100,
    'mailValue': 20.4,
    'valueType': 'USD',
    'batteryFlag': 0,
    'innerType': '1',
    'remark': '这是商品描述'
}

f = open(file='test.json', mode='w', encoding='utf-8')
json.dump(data, f)  # dump方法接收一个文件句柄
f.close()

#  问题：如果这样操作的话，中文在序列化的时候会变成\u xxx的乱码
#  解决办法： json.dump(data, f,ensure_ascii=False)  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

其他参数说明：

• ensure_ascii：默认为True,所有非ASCII码字符显示为\uxxxx序列，设置为False显示正常

• separators：实际上是一个（item_separator,dict_separator）的一个元组，默认就是（‘，’，‘：’）

• sort_keys： 将数据根据keys的值进行排序

json序列化存储多个数据到同一个文件中

import json

data1 = {
    'orderSource': '1',
    'productCode': '518005',
    'orderId': 'TEST_AS20200827CN',
    'mailCode': '',
    'volume': '100.2',
    'length': '10.1',
    'width': '10.1',
    'height': '10.1',
    'mailWeight': 100,
    'mailValue': 20.4,
    'valueType': 'USD',
    'batteryFlag': 0,
    'innerType': '1',
    'remark': '这是商品描述'
}

data2 = {
    'orderSource': '1',
    'productCode': '518005',
    'orderId': 'TEST_AS20200827CN',
    'mailCode': '',
    'volume': '100.2',
    'length': '10.1',
    'width': '10.1',
    'height': '10.1',
    'mailWeight': 100,
    'mailValue': 20.4,
    'valueType': 'USD',
    'batteryFlag': 0,
    'innerType': '1',
    'remark': '这是商品描述'
}
f = open(file='test', mode='a')
str1 = json.dumps(data1)
f.write(str1 + '\n')
str2 = json.dumps(data2)
f.write(str2 + '\n')
f.close()

# 读文件
f2 = open(file='test', mode='r')
for i in f2:
    print(i)
f2.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

time模块

提供时间的相关方法

# 计算一段代码执行的时间
import time

start = time.time()  # 获取当前的时间戳

x = 1
for i in range(1, 20000):
    x *= i
print(x)

end = time.time()
print(f'代码执行时长为：{end - start}毫秒')


1
2
3
4
5
6
7
8
9
10
11
12
13
14

## 程序睡眠
time.sleep(3) # 休息3秒
1
2

计算代码耗时的优化

# 计算一段代码的执行时间
import time

def countTime(fn):
    start = time.time()
    fn()
    end = time.time()
    print(f'执行执行耗时为：{end - start}毫秒')


def test():
    x = 1
    for i in range(1, 20000):
        x *= i
    print(x)


countTime(test)  # 注意:这里的test是方法的名字，不能加括号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

使用装饰器模式来计算代码的执行时长

# 计算一段代码的执行时间
import time


def cal_time(fn):
    def inner():
        start = time.time()
        fn()
        end = time.time()
        print(f'执行代码耗时：{end - start}ms')

    return inner


@cal_time # 添加注解
def demo():
    x = 1
    for i in range(1, 200):
        x *= i
    print(x)


demo()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

装饰器模式的简单使用

# 装饰器模式的使用


# 如何在不改变源代码的情况下在增加一个需求，10点以后不能玩游戏
# 使用装饰器
def can_paly(fn):
    def inner(name, game, *args, **kwargs):
        time = kwargs.get('clock', 23)  # 如果拿不到就返回一个默认的值23
        if time > 22:
            print('太晚了，不能打游戏')
            return
        fn(name, game)

    return inner


@can_paly
def paly_game(name, game):
    print(f'{name}正在玩{game}')


# paly_game('张三', '王者荣耀')
# paly_game('李四', '吃鸡')

paly_game('张三', '王者荣耀', clock=18)
paly_game('李四', '吃鸡', clock=23)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

os模块

os模块是与操作系统交互的一个接口,它提供的功能多与工作目录，路径，文件等相关。

import os

# 当前执行这个python文件的工作目录相关的工作路径
os.getcwd() # 获取当前工作目录，即当前python脚本工作的目录路径   
os.chdir("..")  # 改变当前脚本工作目录；相当于shell下cd  
os.curdir  # 返回当前目录: ('.')  
os.pardir  # 获取当前目录的父目录字符串名：('..') 
​
# 和文件夹相关 
os.makedirs('dirname1/dirname2')    #可生成多层递归目录
os.removedirs('dirname1') # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推 
os.mkdir('dirname')   # 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')   # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname 
 os.listdir('dirname')   # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印 
​
# 和文件相关
os.remove()  # 删除一个文件  
os.rename("oldname","newname")  # 重命名文件/目录  
os.stat('path/filename')  # 获取文件/目录信息 
​
# path系列，和路径相关
os.path.abspath(path) # 返回path规范化的绝对路径  
os.path.split(path) # 将path分割成目录和文件名二元组返回 
os.path.dirname(path) # 返回path的目录。其实就是os.path.split(path)的第一个元素  
os.path.basename(path) # 返回path最后的文件名。如何path以／或\结尾，那么就会返回空
os.path.split(path)
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False  ***
os.path.isabs(path)  如果path是绝对路径，返回True  **
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False  ***
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False  ***
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 ***
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间  **
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间  **
os.path.getsize(path) 返回path的大小 ***
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

sys模块

系统相关模块

import sys

 sys.exit(100)    # 终止程序，和内置函数exit功能一样
 print(sys.path) # 结果是一个列表，表示查找模块的路径
 sys.stdin # 接收用户的输入，和input相关
 sys.stdout # 标准输出（可以改变默认输出位置，不在控制台了）
 sys.stderr # 改变错误输出的默认位置（默认控制台）

1
2
3
4
5
6
7
8

math模块

与数学运算相关

import math

print(math.factorial(7))  # 求阶乘 5040
print(math.floor(12.51))  # 向下取整 12
print(math.ceil(15.01))  # 向上取整 16
print(math.pow(2, 10))  # 幂运算 1024.0
print(round(10.32, 1)) # 内置函数，四舍五入 10.3
1
2
3
4
5
6
7

random模块

生成随机数

import random

print(random.randint(1, 2))  # random(a,b) 用来生成[a,b]的随机整数
print(random.random())  # 生成[0,1）的随机浮点数，左闭区右开区间
print(random.randrange(1, 9))  # 生成[a,b)的随机整数
print(random.choice(['张珊', '李四', '王五']))  # 在可迭代对象中随机取出一个
print(random.sample(['张珊', '李四', '王五'], 2)) # 在可迭代对象中随机取出n个

1
2
3
4
5
6
7
8

datetime模块

主要用来显示日期时间，这里主要涉及date类，用来显示日期；time类,用来显示时间；datetime类，用来显示日期时间，timedelta类，用来计算时间

import datetime as dt

print(dt.datetime.now())  # 获取当前时间
print(dt.date(2020, 8, 18))  # 创建一个日期
print(dt.time(22, 28, 45))  # 创建一个时间
print(dt.datetime.now() + dt.timedelta(3))  # 计算三天以后的日期时间

1
2
3
4
5
6
7

time模块

import time

print(time.time())  # 获取当前时间戳
print(time.strftime('%Y-%m-%d %H:%M:%S'))  # 按照指定格式输出时间 2020-08-18 22:34:13
time.sleep(3)  # 让程序休眠三秒
print(time.ctime(1592273965))  # 传入时间戳,返回一个日期时间
1
2
3
4
5
6

hashlib模块

Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等。摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。

md5

单向加密，不可逆，不能解密

import hashlib

md5 = hashlib.md5('salt'.encode('utf-8')) # 加盐
content = 'how to use md5 in python'
md5.update(content.encode('utf-8'))
print(md5.hexdigest()) # cdbbdefc48242586611e311f84e921b0
1
2
3
4
5
6

sha

单向加密

import hashlib

# sha
sha256 = hashlib.sha256()
content = 'how to use sha256 in python'
sha256.update(content.encode('utf-8'))
print(sha256.hexdigest()) # de6ef92ca557ecda3b6d4dfd685f820ce133a12b3523fe243a0cb4d5af877a36
1
2
3
4
5
6
7

uuid模块

唯一

import uuid

print(uuid.uuid1())

# python模块中暂时没有uuid2
"""
uuid3和uuid5是将传入的字符串根据指定的算法算出来的，是固定的
"""
print(uuid.uuid3(uuid.NAMESPACE_DNS, 'pihao'))
print(uuid.uuid5(uuid.NAMESPACE_DNS, 'pihao'))
print(uuid.uuid4())  # 随机生成，使用的最多
1
2
3
4
5
6
7
8
9
10
11