Python学习【第十一篇】模块(1)

模块

模块让你能够有逻辑地组织你的Python代码段。

把相关的代码分配到一个模块里能让你的代码更好用，更易懂。

模块也是Python对象，具有随机的名字属性用来绑定或引用。

简单地说，模块就是一个保存了Python代码的文件，能起代码归类的作用。模块能定义函数，类和变量。模块里也能包含可执行的代码。

Python之所以应用越来越广泛，在一定程度上也依赖于其为程序员提供了大量的模块以供使用。

在python中称之为模块，而在其他语言中称之为类库，在使用模块的时候需要【先导入】后【使用】。

import s1
import lib.com

s1.f1()
lib.com.f1()

# 输出
this is s1.py
lib/com.py

模块分为三种：

• 自定义模块
• 第三方模块
• 内置模块

自定义模块

在Python中，每个Python文件都可以作为一个模块，模块的名字就是文件的名字。

模块的名称很重要，在创建模块名时，一定不要和内置模块重名。

写一个自己的模块（模块文件要和代码文件在同一目录下）

#vim moudle_test.py

#!/usr/bin/env python3
def f1():
    print ('自定义 moudle')

# 调用
#vim test.py
#!/usr/bin/env python3

# 导入自定义模块
import moudle_test
moudle_test.f1()

导入模块有以下几种方法：

import module
from module.xx.xx import xx
from module.xx.xx import xx as rename
from module.xx.xx import *

import：

import s1

s1.f1()
# 输出
this is s1.py

from：

from s1 import login

login()

# 输出
this is s1.login()

# 从文件夹中导入模块
from lib import commons

# 取别名
from src import commons as src_commons

单模块推荐使用import，如果是嵌套在文件下推荐使用from xxx import xxx，也可以加as 来设置别名

导入模块其实就是告诉Python解释器去解释哪个py文件

• 导入一个py文件，解释器解释该py文件
• 导入一个包，解释器解释该包下的__init__.py文件【py2.7】

那么问题来了，导入模块时是根据哪个路径作为基准进行的呢？

import sys

for item in sys.path:
    print(item)

如果sys.path路径列表没有你想要的路径，可以通过sys.path.append('路径')添加。

通过os模块可以获取各种目录，例如：

import sys
import os

pre_path = os.path.abspath('../')
sys.path.append(pre_path)

第三方模块

非Python本身自带的模块，就是所谓的第三方模块，那如下载使用第三方模块呢：

1.pip3

pip3 install requests

2.源码

• 下载源码包
• 解压
• python3 setup.py install

内置模块

在介绍内置模块之前先补习一个知识点，就是python模块中特殊变量('*'开头的为常用)：

__doc__   　  获取文件的注释

__cached__   获取字节码存放的位置

*__file__         获取当前py文件所在的路径

*__name__     特性：只有执行当前文件时，当前文件的特殊变量__name__ == "__main__",一般在主文件里这么写

__package__ 获取文件在哪个包里面

from bin import admin
    print(admin__package__)

# 输出
bin

sys模块

用于提供对Python解释器相关的操作：

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
sys.stdin          输入相关
sys.stdout         输出相关
sys.stderror       错误相关

 import sys,time

 def view_bar(num,total):
     rate = num / total
     rate_num = int(rate * 100)
     r = '\r%s>%d%%' % ("="*num, rate_num )  # \r回到当前行的首个位置
     sys.stdout.write(r)
     sys.stdout.flush()

 if __name__ == '__main__':
     for i in range(0, 101):
         time.sleep(0.1)
         view_bar(i,100)

进度条

更多猛击这里

subprocess模块

The subprocess module allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes. This module intends to replace several older modules and functions:

os.system
os.spawn*

subprocess模块提供了丰富的系统操作功能，将来可能替换旧的模块和函数，比如说os.system/os.spawn*

call

执行命令，返回状态码：

import subproces

# 如果shell = False，那么传入的参数就是个列表
ret = subprocess.call(["ls", "-l"], shell=False)

# 如果shell = True，那么就可以直接传入字符串
ret = subprocess.call("ls -l", shell=True)

check_call

执行命令，如果状态码是0，则返回0，否则抛出异常：

import subprocess

subprocess.check_call(["ls", "-l"])
subprocess.check_call("exit 1", shell=True)

check_output

执行命令，如果状态码是0，则返回结果，否则抛出异常：

subprocess.check_output(["echo", "Hello World!"])
subprocess.check_output("exit 1", shell=True)

subprocess.Popen(...)

用于执行复杂的系统命令

参数：

• args：shell命令，可以是字符串或者序列类型（如：list，元组）
• bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲
• stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
• preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
• close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。
• 所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
• shell：同上
• cwd：用于设置子进程的当前目录
• env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
• universal_newlines：不同系统的换行符不同，True -> 同意使用 \n
• startupinfo与createionflags只在windows下有效
• 将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等

执行普通的命令：

import subprocess

ret1 = subprocess.Popen(["mkdir","t1"])
ret2 = subprocess.Popen("mkdir t2", shell=True)

终端输入的命令分为两种：

• 输入即可得到输出，如：ifconfig
• 输入进行某环境，依赖再输入，如：python

跳转到某个目录后再执行：

import subprocess

obj = subprocess.Popen("mkdir t3", shell=True, cwd='/home/dev',)

import subprocess

obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
obj.stdin.write("print(1)\n")
obj.stdin.write("print(2)")
obj.stdin.close()

cmd_out = obj.stdout.read()
obj.stdout.close()
cmd_error = obj.stderr.read()
obj.stderr.close()

print(cmd_out)
print(cmd_error)

import subprocess

obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
obj.stdin.write("print(1)\n")
obj.stdin.write("print(2)")

out_error_list = obj.communicate()
print(out_error_list)

import subprocess

obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
out_error_list = obj.communicate('print("hello")')
print(out_error_list)

os模块

系统相关的模块都在os 模块里：

os.getcwd()                 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")         改变当前脚本工作目录；相当于shell下cd
os.curdir                   返回当前目录: ('.')
os.pardir                   获取当前目录的父目录字符串名：('..')
os.makedirs('dir1/dir2')    可生成多层递归目录
os.removedirs('dirname1')   若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')         生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')         删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')       列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()                 删除一个文件
os.rename("oldname","new")  重命名文件/目录
os.stat('path/filename')    获取文件/目录信息
os.sep                      操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep                  当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep                  用于分割文件路径的字符串
os.name                     字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")   运行shell命令，直接显示
os.environ                  获取系统环境变量
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.abspath()
# 获取绝对路径
os.path.abspath(__file__) 

os.path.dirname()
# 获取某个文件的上级目录
os.path.dirname(os.path.abspath(__file__))
# 获取某个文件的上一级上一级目录
os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

更多猛击这里

hashlib模块

用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法：

import md5
hash = md5.new()
hash.update('admin')
print hash.hexdigest()

md5-废弃

import sha

hash = sha.new()
hash.update('admin')
print hash.hexdigest()

sha-废弃

import hashlib

# ######## md5 ########
hash = hashlib.md5()
# help(hash.update)
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
print(hash.digest())

######## sha1 ########

hash = hashlib.sha1()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha256 ########

hash = hashlib.sha256()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha384 ########

hash = hashlib.sha384()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha512 ########

hash = hashlib.sha512()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

以上加密算法虽然依然非常厉害，但是存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密：

# 加上自己的key
obj = hashlib.md5(bytes('abcdefg',encoding='utf-8'))
obj.update(bytes('123',encoding='utf-8'))
result = obj.hexdigest()
print(result)

python内置还有一个hmac模块，它内部对我们创建key和内容进行进一步的处理后再加密：

import hmac

obj = hmac.new(bytes('abcdefg', encoding="utf-8"))
obj.update(bytes('123', encoding="utf-8"))
result = obj.hexdigest()
print(result)

shutil模块

高级的文件、文件夹、压缩包处理模块

shutil.copyfileobj(fsrc,fdst[,length])

将文件内容拷贝到另一个文件中

import shutil

shutil.copyfileobj(open('old.xml','r'),open('new.xml','w'))

shutil.copyfile(src,dst)

拷贝文件

shutil.copyfile('f1.log','f2.log')

shutil.copymode(src,dst)

仅拷贝权限。内容、组、用户均不变

shutil.copymode('f1.log','f2.log')

shutil.copystat(src,dst)

仅拷贝状态的信息，包括：mode bits,atime,mtime,flags

shutil.copystat('f1.log','f2.log')

shutil.copy(src,dst)

拷贝文件和权限

import shutil

shutil.copy('f1.log','f2.log')

shutil.copy2(src,dst)

拷贝文件和状态信息

import shutil

shutil.copy2('f1.log','f2.log')

shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件夹

import shutil

shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))

import shutil

shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))

shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件

import shutil

shutil.rmtree('folder1')

shutil.move(src, dst)
递归的去移动文件，它类似mv命令，其实就是重命名。

import shutil

shutil.move('folder1', 'folder3')

shutil.make_archive(base_name, format,...)

创建压缩包并返回文件路径，例如：zip、tar

创建压缩包并返回文件路径，例如：zip、tar

• base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
• 如：www                        =>保存至当前路径
• 如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
• format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
• root_dir： 要压缩的文件夹路径（默认当前目录）
• owner： 用户，默认当前用户
• group： 组，默认当前组
• logger： 用于记录日志，通常是logging.Logger对象

#将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录
import shutil
ret = shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')

#将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录
import shutil
ret = shutil.make_archive("/Users/wupeiqi/wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：

ZipFile解压缩：

import zipfile

# 压缩
z = zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log')
z.write('data.data')
z.close()

# 解压
z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall()
z.close()

TarFile解压缩：

import tarfile

# 压缩
tar = tarfile.open('your.tar','w')
tar.add('/Users/wupeiqi/PycharmProjects/bbs2.log', arcname='bbs2.log')
tar.add('/Users/wupeiqi/PycharmProjects/cmdb.log', arcname='cmdb.log')
tar.close()

# 解压
tar = tarfile.open('your.tar','r')
tar.extractall()  # 可设置解压地址
tar.close()

random模块

Python中的random模块用于生成随机数。下面介绍一下random模块中最常用的几个函数。

random.random

random.random()用于生成一个0到1的随机浮点数：0 <= n < 1.0

import random

obj = random.random()
print(obj)

# 输出
0.6381345244952162

random.uniform

random.uniform的函数原型为：random.uniform(a,b)，用于生成一个指定范围内的随机浮点数，两个参数一个是上限，另一个是下限。

如果a < b，则生成的随机数 a <= n <= b，如果a > b,则生成的随机数 a >= n >= b:

import random

obj = random.uniform(10,20)
obj1 = random.uniform(20,10)
print(obj)
print(obj1)

# 输出
18.291334903013258
12.121621916906559

random.randint

random.randint()的函数原型为：random.randint(a,b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数a <= n <= b:

import random

obj = random.randint(10,20)
print(obj)

# obj = random.randint(20,20)  结果永远是20
# obj = random.randint(20,10)  语句错误，下限必须大于上限

random.randrange

random.randrange的函数原型为：random.randrange([start],[stop],step),从指定范围内，按指定基数递增的集合中获取一个随机数。如：

import random

obj = random.randrange(1,100,2)
print(obj)

# 输出
73

这里的step：2代表的是步长，结果相当于从[1,3,5,7...99]序列中获取一个随机数。结果上与random.choice(range(10,100,2))等效

random.choice

random.choice从序列中获取一个随机元素。其原型为：random.choice(sequence).参数sequenc表示一个有序类型。

这里要说明一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。list，tuple，字符串都属于sequence。

import random

print(random.choice("学习python"))
print(random.choice(["life","is","short","i","use","python"]))
print(random.choice(("use","python","hahaha")))

# 输出
p
short
hahaha

random.shuffle

random.shuffle的函数原型为：random.shuffle(x[,random])，用于将一个列表中的元素打乱。

import random

li = [11,22,33,44,55,66]
random.shuffle(li)
print(li)

# 输出
[44, 55, 11, 22, 33, 66]

random.sample

random.sample的函数原型为：random.sample(sequence,k)，从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列：

import random

li = [11,22,33,44,55,66]
obj = random.sample(li,3)
print(obj)
print(li)

# 输出
[55, 22, 33]
[11, 22, 33, 44, 55, 66]