我的Python升级打怪之路【五】：Python模块

模块，是一些代码实现了某个功能的集合

模块的分类：

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

导入模块

1 import module
2 
3 from module.xx.xx import xx
4 
5 from module.xx.xx import xx as rename
6 
7 from module.xx.xx import *

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

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

1 import sys
2 
3 print(sys.path)

如果路径不在其中，我们可以人为添加一下

1 import sys
2 
3 sys.path.append(路径)

模块

一、sys模块

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

 1 sys.argv            #命令行参数List，第一个元素是程序本身的路径
 2 
 3 sys.exit(n)        #退出程序，并打印n，正常退出exit(0)
 4 
 5 sys.version        #获取Python解释器的版本信息
 6 
 7 sys.maxint        #最大的int值
 8 
 9 sys.path            #返回模块搜索路径
10 
11 sys.platform        #返回操作系统的平台名称
12 
13 sys.stdin            #输入相关
14 
15 sys.stdout            #输出相关
16 
17 sys.stderror            #错误相关

 1 import sys
 2 import time
 3 
 4 
 5 def view_bar(num, total):
 6     rate = float(num) / float(total)
 7     rate_num = int(rate * 100)
 8     r = '\r%d%%' % (rate_num, )
 9     sys.stdout.write(r)
10     sys.stdout.flush()
11 
12 
13 if __name__ == '__main__':
14     for i in range(0, 100):
15         time.sleep(0.1)
16         view_bar(i, 100)

sys实现进度条

二、os模块

用于提供系统级别的操作

 1 os.getcwd()            #获取当前工作目录，即Python脚本工作的目录路径
 2 os.chdir(路径)         #改变当前脚本的工作目录
 3 os.curdir                #返回当前目录  （'.'）
 4 os.makedirs('1/2')  #可生成多层递归目录
 5 os.removedirs('path')    #若目录为空，则删除，并递归到上一级目录，依次类推
 6 os.mkdir()            #生成单级目录
 7 os.rmdir()            #删除单级目录
 8 os.listdir()            #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
 9 os.remove()         #删除一个文件
10 os.rename()         #重命名文件/目录
11 os.stat()              #获取文件/目录的信息
12 os.sep                 #操作系统特定的路径分割符
13 os.linesep            #当前平台的终止符
14 os.pathsep           #当前平台的路径分隔符
15 os.name              #字符串只是当前的平台
16 os.system()         #运行命令
17 os.environ            #获取系统环境变量
18 os.path.abspath(path)       #返回path规范化的绝对路径
19 os.path.split(path)         #将path分割成目录和文件名二元组返回
20 os.path.dirname(path)       #返回path的目录。其实就是os.path.split(path)的第一个元素
21 os.path.basename(path)      #返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
22 os.path.exists(path)        #如果path存在，返回True；如果path不存在，返回False
23 os.path.isabs(path)         #如果path是绝对路径，返回True
24 os.path.isfile(path)        #如果path是一个存在的文件，返回True。否则返回False
25 os.path.isdir(path)         #如果path是一个存在的目录，则返回True。否则返回False
26 os.path.join(path1[, path2[, ...]])  #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
27 os.path.getatime(path)      #返回path所指向的文件或者目录的最后存取时间
28 os.path.getmtime(path)      #返回path所指向的文件或者目录的最后修改时间

三、haslib模块

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

 1 import hashlib
 2  
 3 # ######## md5 ########
 4 hash = hashlib.md5()
 5 # help(hash.update)
 6 hash.update(bytes('admin', encoding='utf-8'))
 7 print(hash.hexdigest())
 8 print(hash.digest())
 9  
10  
11 ######## sha1 ########
12  
13 hash = hashlib.sha1()
14 hash.update(bytes('admin', encoding='utf-8'))
15 print(hash.hexdigest())
16  
17 # ######## sha256 ########
18  
19 hash = hashlib.sha256()
20 hash.update(bytes('admin', encoding='utf-8'))
21 print(hash.hexdigest())
22  
23  
24 # ######## sha384 ########
25  
26 hash = hashlib.sha384()
27 hash.update(bytes('admin', encoding='utf-8'))
28 print(hash.hexdigest())
29  
30 # ######## sha512 ########
31  
32 hash = hashlib.sha512()
33 hash.update(bytes('admin', encoding='utf-8'))
34 print(hash.hexdigest())

对加密算法中添加自定义key加密

1 import hashlib
2  
3 # ######## md5 ########
4  
5 hash = hashlib.md5(bytes('898oaFs09f',encoding="utf-8"))
6 hash.update(bytes('admin',encoding="utf-8"))
7 print(hash.hexdigest())

结合自定义key和hmac模块进行加密

1 import hmac
2  
3 h = hmac.new(bytes('898oaFs09f',encoding="utf-8"))
4 h.update(bytes('admin',encoding="utf-8"))
5 print(h.hexdigest())

四、random模块

使用：

1 import random
2  
3 print(random.random())
4 print(random.randint(1, 2))
5 print(random.randrange(1, 10))

 1 import random
 2 checkcode = ''
 3 for i in range(4):
 4     current = random.randrange(0,4)
 5     if current != i:
 6         temp = chr(random.randint(65,90))
 7     else:
 8         temp = random.randint(0,9)
 9     checkcode += str(temp)
10 print checkcode

random实现随机验证码

五、re正则模块

字符：

　　.          匹配除换行符以外的任意字符

　　\w        匹配字母或数字或下划线或汉字

　　\s　　  匹配任意空白符

　　\d         匹配数字

　　\b　　  匹配单词的开始或结束

　　^　　　匹配字符串的开始

　　$　　　匹配字符串的结束

次数：

　　*　　　重复0次或更多次

　　+　　　重复一次或更多次

　　?　　　重复0次或1次

　　{n}　　 重复n次

　　{n,}　　重复n次或更多次

　　{n,m}    重复n到m次　　

match：从起始位置开始匹配，匹配成功返回一个对象，未成功返回None

match(pattern,string,flags=0)
# pattern  :正则模型
# string    ：要匹配的字符串
# falgs    ：匹配的模式

 1 # 无分组
 2 r = re.match("h\w+", origin)
 3 print(r.group())     # 获取匹配到的所有结果
 4 print(r.groups())    # 获取模型中匹配到的分组结果
 5 print(r.groupdict()) # 获取模型中匹配到的分组结果
 6 
 7 # 有分组
 8 
 9 # 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
10 
11 r = re.match("h(\w+).*(?P<name>\d)$", origin)
12 print(r.group())     # 获取匹配到的所有结果
13 print(r.groups())    # 获取模型中匹配到的分组结果
14 print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组

例子

search：浏览整个字符串去匹配第一个，未匹配成功返回None

search(pattern,string,flags=0)

 1         # 无分组
 2 
 3         r = re.search("a\w+", origin)
 4         print(r.group())     # 获取匹配到的所有结果
 5         print(r.groups())    # 获取模型中匹配到的分组结果
 6         print(r.groupdict()) # 获取模型中匹配到的分组结果
 7 
 8         # 有分组
 9 
10         r = re.search("a(\w+).*(?P<name>\d)$", origin)
11         print(r.group())     # 获取匹配到的所有结果
12         print(r.groups())    # 获取模型中匹配到的分组结果
13         print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组

例子

findall：获取非重复的匹配列表；如果有分组，则组以元组的形式返回

findall(pattern, string, flags=0)

1         # 无分组
2         r = re.findall("a\w+",origin)
3         print(r)
4 
5         # 有分组
6         origin = "hello alex bcd abcd lge acd 19"
7         r = re.findall("a((\w*)c)(d)", origin)
8         print(r)

例子

sub：替换匹配成功的指定位置的字符串

sub(pattern, repl, string, count=0, flags=0)
# pattern： 正则模型
# repl   ： 要替换的字符串或可执行对象
# string ： 要匹配的字符串
# count  ： 指定匹配个数
# flags  ： 匹配模式

1         # 与分组无关
2 
3         origin = "hello alex bcd alex lge alex acd 19"
4         r = re.sub("a\w+", "999", origin, 2)
5         print(r)

例子

split：根据正则分割字符串

split(pattern, string, maxsplit=0, flags=0)
# pattern： 正则模型
# string ： 要匹配的字符串
# maxsplit：指定分割个数
# flags  ： 匹配模式

 1         # 无分组
 2         origin = "hello alex bcd alex lge alex acd 19"
 3         r = re.split("alex", origin, 1)
 4         print(r)
 5 
 6         # 有分组
 7         
 8         origin = "hello alex bcd alex lge alex acd 19"
 9         r1 = re.split("(alex)", origin, 1)
10         print(r1)
11         r2 = re.split("(al(ex))", origin, 1)
12         print(r2)

例子

1 IP：
2 ^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$
3 手机号：
4 ^1[3|4|5|8][0-9]\d{8}$
5 邮箱：
6 [a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

re实现匹配IP，手机号，邮箱

六、序列化

Python中序列化的模块：

• json　　用于【字符串】和【Python基本数据类型】之间的转换
• pickle     用于【Python特有的类型】和【Python基本数据类型】之间的转换

Json模块提供了四个功能：dumps、dump、loads、load

pickle模块提供了四个功能：dumps、dump、loads、load

七、requests

1.requests模块的安装

pip  install  requests

2.使用模块

GET请求

import requests

#无参数
ret = requests.get('https://www.baidu.com')
print(ret.url)
print(ret.text)


#有参数
payload = {'k':'v'}
ret = requests.get('https://www.baidu.com',params = payload)
print(ret.url)
print(ret.text)

POST请求

import requests

#基本
payload = {'k':'v'}
ret = requests.post('https://www.baidu.com',data=payload)
print(ret.text)

#带请求头和数据
import json
url = "https://www.baidu.com"
payload = {'k':'v'}
headers = {'content-type': 'application/json'}

ret =requests.post(url,data=json.dumps(payload),headers=headers)

print(ret.text)


print(ret.cookies)

requests.get(url, params=None, **kwargs)
requests.post(url, data=None, json=None, **kwargs)
requests.put(url, data=None, **kwargs)
requests.head(url, **kwargs)
requests.delete(url, **kwargs)
requests.patch(url, data=None, **kwargs)
requests.options(url, **kwargs)
 
# 以上方法均是在此方法的基础上构建
requests.request(method, url, **kwargs)

其他的一些请求

八、logging日志模块

用于便捷记录日志且线程安全的模块

1.单文件日志

 1 import logging
 2   
 3   
 4 logging.basicConfig(filename='log.log',
 5                     format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
 6                     datefmt='%Y-%m-%d %H:%M:%S %p',
 7                     level=10)
 8   
 9 logging.debug('debug')
10 logging.info('info')
11 logging.warning('warning')
12 logging.error('error')
13 logging.critical('critical')
14 logging.log(10,'log')

日志的等级：

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0

补充：只有大于定义的日志等级时才会被记录

2.多文件日志

 1 # 定义文件
 2 file_1_1 = logging.FileHandler('l1_1.log', 'a', encoding='utf-8')
 3 fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s")
 4 file_1_1.setFormatter(fmt)
 5 
 6 file_1_2 = logging.FileHandler('l1_2.log', 'a', encoding='utf-8')
 7 fmt = logging.Formatter()
 8 file_1_2.setFormatter(fmt)
 9 
10 # 定义日志
11 logger1 = logging.Logger('s1', level=logging.ERROR)
12 logger1.addHandler(file_1_1)
13 logger1.addHandler(file_1_2)
14 
15 
16 # 写日志
17 logger1.critical('1111')

1 # 定义文件
2 file_2_1 = logging.FileHandler('l2_1.log', 'a')
3 fmt = logging.Formatter()
4 file_2_1.setFormatter(fmt)
5 
6 # 定义日志
7 logger2 = logging.Logger('s2', level=logging.INFO)
8 logger2.addHandler(file_2_1)

九、subprocess模块-系统命令

call：执行命令，返回状态码,成功为0，失败为1

1 ret = subprocess.call(['ls','-l'],shell=False)
2 
3 ret = subprocess.call("ls -l",shell=True)

check_call：执行命令，成功返回0，失败抛出异常

1 subprocess.check_call(['ls','-l'],shell=False)
2 
3 subprocess.check_call("ls -l",shell=True)

check_output：用法和check_call相同

subprocess.Popen()  用于执行复杂的命令

import subprocess

ret1 = subprocess.Popen(["mkdir",'1'])

ret2 = subprocess.Popen("mkdir 2",shell=True)

subprocess.Popen()参数：

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

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

• 输入即可得到输出
• 输入进行某环境，以来再输入

 输入进行某环境，以来再输入的例子

 1 import subprocess
 2 
 3 obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
 4 obj.stdin.write("print(1)\n")
 5 obj.stdin.write("print(2)")
 6 obj.stdin.close()
 7 
 8 cmd_out = obj.stdout.read()
 9 obj.stdout.close()
10 cmd_error = obj.stderr.read()
11 obj.stderr.close()
12 
13 print(cmd_out)
14 print(cmd_error)

十、shutil模块

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

shutil.copyfileobj(fsrc,fdst,length)   将文件内容拷贝到另一个文件中

import shutil

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

shutil.copyfile(src,dst)    拷贝文件

shutil.copyfile('1','2')

shutil.copymode(src,dst)   仅拷贝权限。内容、组、用户都不变

shutil.copymode('1','2')

shutil.copystat(src,dst)     仅拷贝状态的信息

shutil.copystat('1','2')

shutil.copy(src,dst)   拷贝文件和权限

shutil.copy('1','2')

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

import shutil
 
shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
#ignore表示排除某些

shutil.rmtree()      递归的去删除文件

shutil.rmtree(文件)

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

创建压缩包并返回文件路径

• base_name：压缩包的文件名，也可以是路径
• format：压缩包的种类，“zip”，“tar”，“bztar”，“gztar”
• root_dir：要压缩的文件夹路径
• owner：用户，默认当前用户
• group：组，默认当前组
• logger：用于记录日志，通常是logging.Logger对象

shutil.make_archive('被压缩的文件夹路径','gztar',root_dir="放置路径")

补充：shutil对压缩包的处理是调用了ZipFile和TarFiel两个模块来进行的。

zipfile模块

import zipfile

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


#解压
z = zipfile.ZipFile('1.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()

十一、paramiko

paramiko是一个用于做远程控制的模块，该模块可以实现对远程服务器进行命令或文件操作

1.下载安装

pip  install  pycrypto

pip  install  paramiko

2.模块使用

1 import paramiko
2 
3 ssh = paramiko.SSHClient()
4 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
5 ssh.connect('192.168.1.108', 22, 'alex', '123')
6 stdin, stdout, stderr = ssh.exec_command('df')
7 print stdout.read()
8 ssh.close()

执行命令 - 基于用户名和密码

 1 import paramiko
 2 
 3 private_key_path = '/home/auto/.ssh/id_rsa'
 4 key = paramiko.RSAKey.from_private_key_file(private_key_path)
 5 
 6 ssh = paramiko.SSHClient()
 7 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
 8 ssh.connect('主机名 ', 端口, '用户名', key)
 9 
10 stdin, stdout, stderr = ssh.exec_command('df')
11 print stdout.read()
12 ssh.close()

执行命令 - 基于密钥

 1 import os,sys
 2 import paramiko
 3 
 4 t = paramiko.Transport(('182.92.219.86',22))
 5 t.connect(username='wupeiqi',password='123')
 6 sftp = paramiko.SFTPClient.from_transport(t)
 7 sftp.put('/tmp/test.py','/tmp/test.py') 
 8 t.close()
 9 
10 
11 import os,sys
12 import paramiko
13 
14 t = paramiko.Transport(('182.92.219.86',22))
15 t.connect(username='wupeiqi',password='123')
16 sftp = paramiko.SFTPClient.from_transport(t)
17 sftp.get('/tmp/test.py','/tmp/test2.py')
18 t.close()

文件上传下载 - 用户名密码

 1 import paramiko
 2 
 3 pravie_key_path = '/home/auto/.ssh/id_rsa'
 4 key = paramiko.RSAKey.from_private_key_file(pravie_key_path)
 5 
 6 t = paramiko.Transport(('182.92.219.86',22))
 7 t.connect(username='wupeiqi',pkey=key)
 8 
 9 sftp = paramiko.SFTPClient.from_transport(t)
10 sftp.put('/tmp/test3.py','/tmp/test3.py') 
11 
12 t.close()
13 
14 import paramiko
15 
16 pravie_key_path = '/home/auto/.ssh/id_rsa'
17 key = paramiko.RSAKey.from_private_key_file(pravie_key_path)
18 
19 t = paramiko.Transport(('182.92.219.86',22))
20 t.connect(username='wupeiqi',pkey=key)
21 
22 sftp = paramiko.SFTPClient.from_transport(t)
23 sftp.get('/tmp/test3.py','/tmp/test4.py') 
24 
25 t.close()

文件上传下载 - 密钥

十二、time时间模块

时间的相关操作，时间有三种表现方式：

• 时间戳　　       time.time()     时间从1970年1月1日之后
• 格式化的字符串      time.strftime("%Y-%m-%d")
• 结构化时间        time.localtime()

 1 time.time()     #时间戳
 2 time.mktime(time.localtime())
 3    
 4 time.gmtime()    #可加时间戳参数
 5 time.localtime() #可加时间戳参数
 6 time.strptime('2018-11-11', '%Y-%m-%d')   #格式化时间
 7    
 8 time.strftime('%Y-%m-%d') #默认当前时间
 9 time.strftime('%Y-%m-%d',time.localtime()) #默认当前时间
10 time.asctime()
11 time.asctime(time.localtime())
12 time.ctime(time.time())
13    
14 import datetime
15 '''
16 datetime.date：表示日期的类。常用的属性有year, month, day
17 datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond
18 datetime.datetime：表示日期时间
19 datetime.timedelta：表示时间间隔，即两个时间点之间的长度
20 timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
21 strftime("%Y-%m-%d")
22 '''
23 import datetime
24 datetime.datetime.now()
25 datetime.datetime.now() - datetime.timedelta(days=5)