Python的常用模块

time模块

time()模块中的重要函数

time()模块时间格式转换

time()模块时间转换

时间戳 1970年1月1日之后的秒，即：time.time()
格式化的字符串 2014-11-11 11:11，即：time.strftime(’%Y-%m-%d’)
结构化时间元组包含了：年、日、星期等… time.struct_time 即：time.localtime()

time模块时间转换

import time
print(time.time())                              # 时间戳：1511166937.2178104
print(time.strftime('%Y-%m-%d'))                 # 格式化的字符串: 2017-11-20
print(time.localtime())                         # 结构化时间(元组): (tm_year=2017, tm_mon=11...)
print(time.gmtime())                            # 将时间转换成utc格式的元组格式： (tm_year=2017, tm_mon=11...)#1. 将结构化时间转换成时间戳： 1511167004.0
print(time.mktime(time.localtime()))#2. 将格字符串时间转换成结构化时间 元组： (tm_year=2017, tm_mon=11...)
print(time.strptime('2014-11-11', '%Y-%m-%d'))#3. 结构化时间(元组) 转换成  字符串时间  ：2017-11-20
print(time.strftime('%Y-%m-%d', time.localtime()))  # 默认当前时间#4. 将结构化时间(元组) 转换成英文字符串时间 : Mon Nov 20 16:51:28 2017
print(time.asctime(time.localtime()))#5. 将时间戳转成 英文字符串时间 : Mon Nov 20 16:51:28 2017
print(time.ctime(time.time()))

datetime获取时间

import datetime
#1、datetime.datetime获取当前时间
print(datetime.datetime.now())
#2、获取三天后的时间
print(datetime.datetime.now()+datetime.timedelta(+3))
#3、获取三天前的时间
print(datetime.datetime.now()+datetime.timedelta(-3))
#4、获取三个小时后的时间
print(datetime.datetime.now()+datetime.timedelta(hours=3))
#5、获取三分钟以前的时间
print(datetime.datetime.now()+datetime.timedelta(minutes = -3))import datetime
print(datetime.datetime.now())                                   #2017-08-18 11:25:52.618873
print(datetime.datetime.now().date())                            #2017-08-18
print(datetime.datetime.now().strftime("%Y-%m-%d %H-%M-%S"))    #2017-08-18 11-25-52

random()模块

random()模块常用函数

random常用函数举例

import random
#⒈ 随机整数：
print(random.randint(0,99))             # 随机选取0-99之间的整数
print(random.randrange(0, 101, 2))      # 随机选取0-101之间的偶数#⒉ 随机浮点数：
print(random.random())                   # 0.972654134347
print(random.uniform(1, 10))             # 4.14709813772#⒊ 随机字符：
print(random.choice('abcdefg'))         # c
print(random.sample('abcdefghij',3))    # ['j', 'f', 'c']

使用random实现四位验证码

使用for循环实现

import random
checkcode = ''
for i in range(4):current = random.randrange(0,4)if current == i:tmp = chr(random.randint(65,90))    #65,90表示所有大写字母else:tmp = random.randint(0,9)checkcode += str(tmp)
print(checkcode)

使用random.sample实现

import random
import string
str_source = string.ascii_letters + string.digits
str_list = random.sample(str_source,7)#['i', 'Q', 'U', 'u', 'A', '0', '9']
print(str_list)
str_final = ''.join(str_list)#iQUuA09
print(str_final)            # 运行结果： jkFU2Ed

os模块

os模块常用方法

import os
#1 当前工作目录，即当前python脚本工作的目录路径
print(os.getcwd())    # C:\Users\admin\PycharmProjects\s14\Day5\test4#2 当前脚本工作目录；相当于shell下cd
os.chdir("C:\\Users\\admin\\PycharmProjects\\s14")
os.chdir(r"C:\Users\admin\PycharmProjects\s14")
print(os.getcwd())    # C:\Users\admin\PycharmProjects\s14#3 返回当前目录: ('.')
print(os.curdir)        # ('.')#4 获取当前目录的父目录字符串名：('..')
print(os.pardir)        # ('..')#5 可生成多层递归目录
os.makedirs(r'C:\aaa\bbb')         # 可以发现在C盘创建了文件夹/aaa/bbb#6 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.removedirs(r'C:\aaa\bbb')    # 删除所有空目录#7 生成单级目录；相当于shell中mkdir dirname
os.mkdir(r'C:\bbb')        # 仅能创建单个目录#8 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.rmdir(r'C:\aaa')        # 仅删除指定的一个空目录#9 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
print(os.listdir(r"C:\Users\admin\PycharmProjects\s14"))#10 删除一个文件
os.remove(r'C:\bbb\test.txt')        # 指定删除test.txt文件#11 重命名文件/目录
os.rename(r'C:\bbb\test.txt',r'C:\bbb\test00.bak')#12 获取文件/目录信息
print(os.stat(r'C:\bbb\test.txt'))#13 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
print(os.sep)                # \#14 输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"
print(os.linesep)#15 输出用于分割文件路径的字符串
print(os.pathsep)                # ;  （分号）#16 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
print(os.name)                # nt#17 运行shell命令，直接显示
os.system("bash command")#18 获取系统环境变量
print(os.environ)                # environ({'OS': 'Windows_NT', 'PUBLIC': ………….#19 返回path规范化的绝对路径
print(os.path.abspath(r'C:/bbb/test.txt'))    # C:\bbb\test.txt#20 将path分割成目录和文件名二元组返回
print(os.path.split(r'C:/bbb/ccc'))    # ('C:/bbb', 'ccc')#21 返回path的目录。其实就是os.path.split(path)的第一个元素
print(os.path.dirname(r'C:/bbb/ccc'))    # C:/bbb#22 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
print(os.path.basename(r'C:/bbb/ccc/ddd'))    # ddd#23 如果path存在，返回True；如果path不存在，返回False
print(os.path.exists(r'C:/bbb/ccc/'))    # True#24 如果path是绝对路径，返回True        # True
print(os.path.isabs(r"C:\Users\admin\PycharmProjects\s14\Day5\test4"))#25 如果path是一个存在的文件，返回True。否则返回False
print(os.path.isfile(r'C:/bbb/ccc/test2.txt'))        # True#26 如果path是一个存在的目录，则返回True。否则返回False
print(os.path.isdir(r'C:/bbb/ccc'))            # True#28 返回path所指向的文件或者目录的最后存取时间
print(os.path.getatime(r'C:/bbb/ccc/test2.txt'))        # 1483509254.9647143#29 返回path所指向的文件或者目录的最后修改时间
print(os.path.getmtime(r'C:/bbb/ccc/test2.txt'))        # 1483510068.746478#30 无论linux还是windows，拼接出文件路径
put_filename = '%s%s%s'%(self.home,os. path.sep, filename)
#C:\Users\admin\PycharmProjects\s14\day10select版FTP\home

os命令创建文件夹并写入文件file.txt文件

import osos.makedirs('C:/aaa/bbb/ccc/ddd',exist_ok=True)         # exist_ok=True：如果存在当前文件夹不报错
path = os.path.join('C:/aaa/bbb/ccc','ddd',)
f_path = os.path.join(path,'file.txt')with open(f_path,'w',encoding='utf8') as f:f.write('are you ok!!')

os.popen获取脚本执行结果

data.py

data = {'name':'aaa'}
import json
print json.dumps(data)

get_data.py

#! /usr/bin/env python
# -*- coding: utf-8 -*-
import os,jsonret = os.popen('python data.py')
data = ret.read().strip()
ret.close()
data = json.loads(data)
print data  # {'name':'aaa'}

sys模块

sys.argv　　　　　　　　　　返回执行脚本传入的参数sys.exit(n)        　　　　           退出程序，正常退出时exit(0)sys.version        　　                 获取Python解释程序的版本信息sys.maxint         　　                 最大的Int值sys.path          　　                    返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值sys.platform       　　                  返回操作系统平台名称sys.stdout.write('please:')val = sys.stdin.readline()[:-1]

使用sys.argv返回执行脚本传入的参数

import sys
# C:\Users\tom\PycharmProjects\s14Review\day01>  python test01.py 1 2 3
print(sys.argv)         # 打印所有参数                 ['test01.py', '1', '2', '3']
print(sys.argv[1:])     # 获取索引 1 往后的所有参数     ['1', '2', '3']

Json模块

json序列化

序列化 (json.dumps) ：是将内存中的对象存储到硬盘，变成字符串
反序列化(json.loads) ：将刚刚保存在硬盘中的内存对象从新加载到内存中
json.dumps( data,ensure_ascii=False, indent=4)

json序列化

#json序列化代码
import json
info = {'name':"tom","age" :"100"
}
f = open("test.txt",'w')
# print(json.dumps(info))
f.write(json.dumps(info))
f.close()

json反序列化

#json反序列化代码
import json
f = open("test.txt","r")
data = json.loads(f.read())
f.close()
print(data["age"])

解决Json不可序列化datetime类型

import json,datetimeclass JsonCustomEncoder(json.JSONEncoder):def default(self, field):if isinstance(field, datetime.datetime):return field.strftime('%Y-%m-%d %H:%M:%S')elif isinstance(field, datetime.date):return field.strftime('%Y-%m-%d')else:return json.JSONEncoder.default(self, field)t = datetime.datetime.now()print(type(t),t)
f = open('ttt','w')                              #指定将内容写入到ttt文件中
f.write(json.dumps(t,cls=JsonCustomEncoder))      #使用时候只要在json.dumps增加个cls参数即可

hashlib 模块

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

常见的五种加密方式

import hashlib#1 ######## md5 ########
# 目的：实现对b"HelloIt's me" 这句话进行md5加密
m = hashlib.md5()            # 1）生成一个md5加密对象
m.update(b"Hello")          # 2）使用m对 b"Hello" 加密
m.update(b"It's me")        # 3) 使用m对 b"It's me"加密
print(m.hexdigest())         # 4) 最终加密结果就是对b"HelloIt's me"加密的md5值：5ddeb47b2f925ad0bf249c52e342728a#2 ######## sha1 ########
hash = hashlib.sha1()
hash.update(b'admin')
print(hash.hexdigest())#3 ######## sha256 ########
hash = hashlib.sha256()
hash.update(b'admin')
print(hash.hexdigest())#4 ######## sha384 ########
hash = hashlib.sha384()
hash.update(b'admin')
print(hash.hexdigest())#5 ######## sha512 ########
hash = hashlib.sha512()
hash.update(b'admin')
print(hash.hexdigest())

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

hmac添加自定义key加密

######### hmac ########
import hmac
h = hmac.new(b"123456","真实要传的内容".encode(encoding="utf-8"))
print(h.digest())
print(h.hexdigest())
# 注：hmac是一种双重加密方法，前面是加密的内容，后面才是真实要传的数据信息

subprocess模块

subprocess原理以及常用的封装函数

运行python的时候，我们都是在创建并运行一个进程。像Linux进程那样，一个进程可以fork一个子进程，并让这个子进程exec另外一个程序
在Python中，我们通过标准库中的subprocess包来fork一个子进程，并运行一个外部的程序。
subprocess包中定义有数个创建子进程的函数，这些函数分别以不同的方式创建子进程，所以我们可以根据需要来从中选取一个使用
另外subprocess还提供了一些管理标准流(standard stream)和管道(pipe)的工具，从而在进程间使用文本通信。

subprocess常用函数

#1、返回执行状态：0 执行成功
retcode = subprocess.call(['ping', 'www.baidu.com', '-c5'])#2、返回执行状态：0 执行成功，否则抛异常
subprocess.check_call(["ls", "-l"])#3、执行结果为元组：第1个元素是执行状态，第2个是命令结果
>>> ret = subprocess.getstatusoutput('pwd')
>>> ret
(0, '/test01')#4、返回结果为 字符串 类型
>>> ret = subprocess.getoutput('ls -a')
>>> ret
'.\n..\ntest.py'#5、返回结果为'bytes'类型
>>> res=subprocess.check_output(['ls','-l'])
>>> res.decode('utf8')
'总用量 4\n-rwxrwxrwx. 1 root root 334 11月 21 09:02 test.py\n'

将dos格式文件转换成unix格式

subprocess.check_output(['chmod', '+x', filepath])
subprocess.check_output(['dos2unix', filepath])

subprocess.Popen()

实际上，上面的几个函数都是基于Popen()的封装(wrapper)，这些封装的目的在于让我们容易使用子进程
当我们想要更个性化我们的需求的时候，就要转向Popen类，该类生成的对象用来代表子进程
与上面的封装不同，Popen对象创建后，主程序不会自动等待子进程完成。我们必须调用对象的wait()方法，父进程才会等待 (也就是阻塞block)
从运行结果中看到，父进程在开启子进程之后并没有等待child的完成，而是直接运行print

paramiko模块

在windows中安装paramiko

   pip3 install paramiko

linux中scp命令的使用

ssh root@10.1.0.51　#ssh远程登录
scp -rp aa.txt root@10.1.0.50:/tmp/ #将本地aa.txt文件复制到10.1.0.50的/tmp文件夹中

Paramiko模块作用

如果需要使用SSH从一个平台连接到另外一个平台，进行一系列的操作时
比如：批量执行命令，批量上传文件等操作，paramiko是最佳工具之一
paramiko是用python语言写的一个模块,遵循SSH2协议,支持以加密和认证的方式，进行远程服务器的连接
由于使用的是python这样的能够跨平台运行的语言，所以所有python支持的平台，如Linux, Solaris, BSD,MacOS X, Windows等，paramiko都可以支持
如果需要使用SSH从一个平台连接到另外一个平台，进行一系列的操作时，paramiko是最佳工具之一
现在如果需要从windows服务器上下载Linux服务器文件：
（1）使用paramiko可以很好的解决以上问题，它仅需要在本地上安装相应的软件（python以及PyCrypto）
（2）对远程服务器没有配置要求，对于连接多台服务器，进行复杂的连接操作特别有帮助

re模块

re模块常用的表达式符号

1 '.'         默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行2 '^'         匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)3 '$'         匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以4 '*'         匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  结果为['abb', 'ab', 'a']5 '+'         匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']6 '?'         匹配前一个字符1次或0次7 '{m}'       匹配前一个字符m次8 '{n,m}'     匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']9 '|'         匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
10 '(...)'     分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c
11
12 '\A'       只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的
13 '\Z'       匹配字符结尾，同$
14 '\d'       匹配数字0-9
15 '\D'       匹配非数字
16 '\w'       匹配[A-Za-z0-9]
17 '\W'       匹配非[A-Za-z0-9]
18 's'        匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'
19 \b           匹配一个单词边界，也就是指单词和空格间的位置，如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”
20 \B           匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”

re模块常用函数

re.compile(pattern[, flags])

1）把一个正则表达式pattern编译成正则对象，以便可以用正则对象的match和search方法
2）用了re.compile以后，正则对象会得到保留，这样在需要多次运用这个正则对象的时候，效率会有较大的提升

re.complie的使用

import re
mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$')
ret = re.match(mobile_re,'18538762511')
print(ret)            # <_sre.SRE_Match object; span=(0, 11), match='18538652511'>

search(pattern, string[, flags]) 和 match(pattern, string[, flags])

1）match ：只从字符串的开始与正则表达式匹配，匹配成功返回matchobject，否则返回none
2）search ：将字符串的所有字串尝试与正则表达式匹配，如果所有的字串都没有匹配成功，返回none，否则返回matchobject

search 和match的比较

import re
a =re.match('www.bai', 'www.baidu.com')
b = re.match('bai', 'www.baidu.com')
print(a.group())       # www.bai
print(b)               # None# 无论有多少个匹配的只会匹配一个
c = re.search('bai', 'www.baidubaidu.com')
print(c)               # <_sre.SRE_Match object; span=(4, 7), match='bai'>
print(c.group())       # bai

split(pattern, string[, maxsplit=0])

作用：将字符串以指定分割方式，格式化成列表　　
　
split使用

import re
text = 'aa 1bb###2cc3ddd'
print(re.split('\W+', text))        # ['aa', '1bb', '2cc3ddd']
print(re.split('\W', text))          # ['aa', '1bb', '', '', '2cc3ddd']
print(re.split('\d', text))           # ['aa ', 'bb###', 'cc', 'ddd']
print(re.split('#', text))            # ['aa 1bb', '', '', '2cc3ddd']
print(re.split('#+', text))          # ['aa 1bb', '2cc3ddd']

findall(pattern, string)

作用：正则表达式 re.findall 方法能够以列表的形式返回能匹配的子串

findall使用

import re
p = re.compile(r'\d+')
print(p.findall('one1two2three3four4'))             # ['1', '2', '3', '4']
print(re.findall('o','one1two2three3four4'))        # ['o', 'o', 'o']
print(re.findall('\w+', 'he.llo, wo#rld!'))         # ['he', 'llo', 'wo', 'rld']

sub(pat, repl, string[, count=0])

1）替换，将string里匹配pattern的部分，用repl替换掉，最多替换count次然后返回替换后的字符串

2）如果string里没有可以匹配pattern的串，将被原封不动地返回

3）repl可以是一个字符串，也可以是一个函数

4）如果repl是个字符串，则其中的反斜杆会被处理过，比如 \n 会被转成换行符，反斜杆加数字会被替换成相应的组，比如 \6 表示pattern匹配到的第6个组的内容

sub使用

import re
test="Hi, nice to meet you where are you from?"
print(re.sub(r'\s','-',test))          # Hi,-nice-to-meet-you-where-are-you-from?
print(re.sub(r'\s','-',test,5))        # Hi,-nice-to-meet-you-where are you from?
print(re.sub('o','**',test))           # Hi, nice t** meet y**u where are y**u fr**m?

escape(string)

1） re.escape(pattern) 可以对字符串中所有可能被解释为正则运算符的字符进行转义的应用函数。

2）如果字符串很长且包含很多特殊技字符，而你又不想输入一大堆反斜杠，或者字符串来自于用户(比如通过raw_input函数获取输入的内容)，
且要用作正则表达式的一部分的时候，可以用这个函数

escape使用

import re
print(re.escape('www.python.org'))

re模块中的匹配对象和组 group()

1）group方法返回模式中与给定组匹配的字符串，如果没有给定匹配组号，默认为组0

2）m.group() == m.group(0) == 所有匹配的字符

group()匹配之返回匹配索引

import re
m = re.match('www\.(.*)\..*','www.baidu.com')
print(m.group(1))           # baidu
print(m.start(1))             # 4
print(m.end(1))             # 9
print(m.span(1))            # (4, 9)

详细链接参考这个