Python模块（一）

模块：

一个.py文件被称为是一个模块，模块就是已经写好的代码。每个模块有不同的功能，应用那个模块的时候直接import调用就行了，模块可以大大提高编程效率。模块有Python内置的模块和第三方的模块，还有就是自己编写的模块。

模块分为三种：

• 自定义模块
• 内置标准模块（又称标准库）
• 开源模块

安装软件管理工具pip3及安装requests

通过软件管理工具可以安装第三发模块
1.安装pip3（网上找）
2.pip3添加到环境变量
3.pip3 install requests

源码安装
先下载 https://github.com/kennethreitz/requests/tarball/master
解压
进入目录
执行python setup.py install

调用模块的方法：

import lib.account
from module.xx.xx import xx as rename
from module.xx.xx import xx
from module.xx.xx import xx

导入模块是依赖于sys.path内的路径来寻找模块的，如果模块的路径没有在sys.path里面的话就需要手动添加。

import os
print(__file__)     #查看当前文件路径
os.path.dirname     #查看当前问及那的上一层
os.path.join    #拼接
sys.path    #执行环境路径

import os
import sys
a1 = os.path.dirname(__file__)
print(a1)
a2 = "bin"
c1 = os.path.join(a1, a2)
print(c1)
sys.path.append(c1)
print(sys.path)

可以简写为：

sys.path.append(os.path.dirname(__file__) + "bin")

sys模块

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

sys模块的方法：

sys.argb    #捕捉命令传入的参数
sys.path    #返回搜索模块的路径，相当于linux中的环境变量，使用模块的时候会在这里面的几个路径中找，如果模块没有在这几个路径里面则导入不了。
sys.version    #显示python的版本号
sys.exit("goodby!")    #退出Pyhton，括号里是退出时显示的内容可以更改。
sys.platform    #返回当前系统参数：windows系统为：‘win32‘
sys.stdout    #输出相关
sys.stdin    #输入相关
sys.stderror    #错误相关

实例：制作进度条

import time
import sys
for i in range(101):
   sys.stdout.write("\r%s%% |%s" % (int(i/100*100), int(i/100*100)*‘#‘ ))
   sys.stdout.flush()
   time.sleep(0.2)

os模块

提供类似与系统操作的动作

os模块方法

os.getcwd()    #获取当前工作文件的父目录
os.chdir("dirname")    #改变当前脚本工作目录，相当于shell的cd
os.curdir    #返回当前目录(cd .)
os.pardir    #返回当前目录符目录（cd ..）
os.makedirs("dir1/dir2")    #创建递归目录（mkdir -p）
os.removedirs("dirname")    #删除目录 rm -r
os.mkdir("dirname")    #生成单级目录
os.rmdir("dirname")    #删除单级目录
os.listdir("dirname")    #列出指定目录下的所有文件（ls -a）
os.remove()    #删除一个文件
os.rename("oldname", "newname")    #改名(mv)
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.absplit(path)    #返回path规范化的绝对路径
os.path.splist(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 ;如果不存在返回 False
os.path.isabs(path)    #如果path是绝对路径，返回True
os.path.isfile(path)    #入股path是一个存在的文件，返回True,否则返回 False
os.path.isdir(path)    #如果path是一个存在的目录，返回True，否则返回False
os.path.oin(path1[, path2[, ...]])    #将多个路径拼接，第一个绝对路径之前的参数被忽略
os.path.getatime(path)    #返回path所指向的文件或者目录的最后存取实际那
os.path.getmtime(path)    #返回path所执行的文件或目录的最后修改时间

hashlib模块

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

加密示例：

import hashlib
hash = hashlib.md5()
#help(hash.update)
hash.update(bytes(‘admin‘, encoding=("utf-8")))
print(type(hash.hexdigest()))    #格式是固定的，以字符串的形式显示加密后的字符串
print(type(hash.digest()))    #格式固定，以字节的形式显示加密后的dfazij

加盐：
加密后的密码可以通过撞库来破解，为了使密码更安全可以自定义key来进行加密，这个过程就叫做加盐。

import hashlib
hash = hashlib.md5(bytes(‘aassdd1‘, encoding=‘utf-8‘))    #这的引号字符就是自定义的key值
hash.update(bytes(‘admin‘, encoding=("utf-8")))
print(type(hash.hexdigest()))
print(type(hash.digest()))

Python内置还有一个hmac模块，他对内部的key再进一步加密，然后再给密码加密。
操作如下：

import hmac
h = hmac.new(bytes(‘aaddss1‘, encoding=‘utf-8‘))
h.update(bytes(‘admin‘, encoding="utf-8"))
print(h.hexdigest())
print(h.digest())

加密引用实例：
注册，登录用户验证信息。

import hashlib
def md5(arg):
    h = hashlib.md5(bytes(‘ddssaa‘, encoding="utf-8"))
    h.update(bytes(arg, encoding=‘utf-8‘))
return h.hexdigest()

def register(user, pwd):
with open("da", "a", encoding="utf-8") as f:
        temp = user + "|" + md5(pwd)
        f.write(temp)

def login(user,pwd):
with open(‘da‘, ‘r‘, encoding=‘utf-8‘) as f:
for line in f:
            user1,pwd1 = line.strip().split(‘|‘)
if user1 == user and pwd1 ==md5(pwd):
return True

i = input("登录1，注册2")
if i == "1":
    user = input("用户名：")
    pwd = input("密码")
    r = login(user, pwd)
if r == True:
print("登录成功")
else:
print("登录失败")
elif i == "2":
    user = input("用户名：")
    pwd = input("密码：")
    register(user,pwd)

random模块

随机生成数字，可以规定数字的范围。

import random
temp = ""
for i in range(6):
    num = random.randrange(0, 4)    #生成0-4的随机数
if num == 3 or num == 1:    #如果随机数是1或3，那么就在验证码中生成一个 0-9的随机数
rad2 = random.randrange(0, 10)
        temp += str(rad2)
else:   #否则，验证码中生成一个随机字母
rad1 = random.randrange(65, 91)
        c1 = chr(rad1)
        temp = temp + c1
print(temp)

li = [11,22,33,44]

dic = dict(enumerate(li, 10))
print(dic)

json，pickle模块：序列化

数据在传输过程中只能传送字符串格式，通过json的两个函数可以把数据转换，跨语言]

json.loads() #将字符串转换成基本数据类型，数据集合

import json
d = ‘{"key1": 212,"k2": "21"}‘    #里面一定要是双引号#
l = "[1,33,44,2]"
result = json.loads(l)
dic = json.loads(d)
print(dic, type(dic),"\n", result, type(result))

重点：装换的时候如果包含符号里面的内容一定要用双引号括住元素

json.dumps() #将字符类型，集合转换成字符串

d = {‘key1‘: 212,‘k2‘: ‘21‘}
l = [1,33,44,2]
result = json.dumps(l)
dic = json.dumps(d)
print(dic, type(dic),"\n", result, type(result))
{"key1": 212, "k2": "21"} <class ‘str‘> 
 [1, 33, 44, 2] <class ‘str‘>

注意：dumps()元组会变成列表，因为别的语言里没有元组。

json.dump() #把集合转换成字符串并写在一个文件里

d = {‘key1‘: 212,‘k2‘: ‘21‘}
l = [1,33,44,2]
l = json.dump(l, open(‘db‘, ‘w‘))
print(l, type(l))

time 模块

time.sleep()    #参数为秒数，等待时间。
time.sleep(4)    #使用方法：等待4秒

time.time()    #返回当前系统时间戳；时间戳：时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数
print(time.time())       #使用方法：只解决打印
1463500391.1482878

time.ctime()    #输出当前系统时间，格式：星期 月份  几号 小时:分钟:秒 年
print(time.ctime())
Tue May 17 23:54:40 2016

time.ctime(time.time())    #把时间戳转换为字符格式
print(time.ctime(time.time()-86400))    #减去一天的秒数，得出昨天的同一时间
Mon May 16 23:59:16 2016

time.gmtime(time.time())    #输出当前时间结构，把时间细分出来显示
time.struct_time(tm_year=2016, tm_mon=5, tm_mday=17, tm_hour=16, tm_min=4, tm_sec=45, tm_wday=1, tm_yday=138, tm_isdst=0)
time_a = time.gmtime(time.time() )
print(time_a)
print("%s-%s-%s %s:%s" % (time_a.tm_year, time_a.tm_mon, time_a.tm_mday, time_a.tm_hour, time_a.tm_min))    #这里引用到格式化
2016-5-17 16:20    #这里的时间是按照格林威治时间来显示的，也可以更换成东八区，北京时间

格式化：

print("%s-%s_%s" % (time_obj.tm_year,......))

• %d #表示整形
• %s #接受所有类型
• %f #浮点，接受小数

time.localtime(time.time()-86400    #以时间格式输出本地时间
print(time.localtime(time.time()-86400))

time.struct_time(tm_year=2016, tm_mon=5, tm_mday=17, tm_hour=0, tm_min=33, tm_sec=3, tm_wday=1, tm_yday=138, tm_isdst=0)

print(time.mktime(time.localtime()))    #time.localtime功能相反，把本地时间输出为时间戳格式
1463502905.0

print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()) )    #将struct_time（时间格式）转成指定的字符串格式

2016-05-17 16:39:04 #年月日都用不同的%符号表示

• %Y 代表年
• %m 代表月
• %d 代表日
• %H 代表时
• %M 代表分
• %S 代表秒

print(time.strptime("2016-05-18", "%Y-%m-%d") )    #参数要告诉系统，上传时间的格式。与上一条相反，将字符串格式转成struct_time格式
time.struct_time(tm_year=2016, tm_mon=5, tm_mday=18, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=139, tm_isdst=-1)    #因为没有指定小时分钟所以输出为

0

datetime 模块

print(datetime.date.today())    #输出格式 2016-05-18
print(datetime.date.fromtimestamp(time.time()-86400))    #将时间戳转成日期格式
print(datetime.datetime.now())    #输出2016-05-18 00:51:36.531784 格式
a = (datetime.datetime.now())
print(a.timetuple())    #返回struct_time格式
print(a.replace(2014,9,12)) #输出2014-09-12 19:06:24.074900,返回当前时间,但指定的值将被替换
str_to_date = datetime.datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M") #将字符串转换成日期格式
new_date = datetime.datetime.now() + datetime.timedelta(days=10) #比现在加10天
new_date = datetime.datetime.now() + datetime.timedelta(days=-10) #比现在减10天
new_date = datetime.datetime.now() + datetime.timedelta(hours=-10) #比现在减10小时
new_date = datetime.datetime.now() + datetime.timedelta(seconds=120) #比现在+120s

urllib模块，访问网页

import urllib
f = request.urlopen(‘http://www.baidu.com‘)
result = f.read().decode(‘utf -8‘)
print(result)

requests 模块：模拟浏览器的动作

import requests
response = requests.get("http://www.weather.com.cn/adat/sk/101010500.html") #获取这个URL的内容
response.encoding = "utf-8"     #用utf-8解码
result = response.text      #这一步必须要做，将网页的内容定义到变量里面
print(response.text)    #显示

用requests得到网页上的字符串格式，可以用json.loads转换成字典类型

XML模块：

XML是实现不同语言或程序之间进行数据交换的协议
http请求返回数据格式：html；str；xml

XML的几个方法

ET.XML    #以xml的格式分析
ET.parse    #打开xml文件
.text    #把变量的对象用文件的格式定义
.attrib    #按照属性的名字， .del 删除指定名字的属性
.set    #添加属性
.iter    #进行迭代
.getroot    #获取根节点
.tag   
.etree    #标签的属性，可以指定某个属性
.find    #查找
.get    #获取
del    #删除

调用xml模块

from xml.etree import ElementTree as ET #调用xml模块里面的El...功能，别名为ET

对XML格式进行分析：查看QQ是否在线

import requests
r = requests.get(‘http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode=11984774‘)
result = r.text
from xml.etree import ElementTree as ET
node = ET.XML(result)

if node.text == "Y":
    print("在线")
else:
    print("离线")

对XML数据格式进行分析，查看列车时刻表

import requests     #调用requests模块
from xml.etree import ElementTree as ET     #调用xml模块里面的El...功能，别名为ET

#访问WEB接口得到xml格式的数据，把数据定义给变量r
r = requests.get(‘http://www.webxml.com.cn/WebServices/TrainTimeWebService.asmx/getDetailInfoByTrainCode?TrainCode=K234&UserID=‘)
result = r.text     #把r变量的对象用文本的格式定义给result变量
root = ET.XML(result)       #用ET函数的XML格式分析，分析后赋值给root变成一个对象
for node in root.iter(‘TrainDetailInfo‘):   #用得带的方式循环其中的TrainDetailInfo标签的内容
    pi  print(node.find(‘TrainStation‘).text, node.find(‘StartTime‘).text)  #输出每次循环的.find查找到的标签

对文件的XML格式数据进行加工

from xml.etree import ElementTree as ET
root = ET.XML(open("first.xml", "r", encoding="utf-8").read())  #用到了，re的操作

for node in root:   #循环root中的每个对象
print(node.tag, node.attrib, node.find("rank").text, node.find("year").text)

直接打开xml文件，对节点进行读取或删除

from xml.etree import ElementTree as ET

tree = ET.parse("first.xml")    #.parse打开xml文件
root = tree.getroot()    #获取这个文件的第一个根节点
for node in root.iter("year"):    #以迭代的方式循环所有节点的year
new_year = int(node.text) + 1    #对内容修改，加1
node.text = str(new_year)    #讲内容转换成字符类型
node.set(‘name‘, ‘alex‘)    #.set增加一个属性
node.set(‘age‘, ‘19‘)    #.set再增加一个属性
del node.attrib[‘name‘]     #.attrib按照属性的名字,.del删除指定名字的属性

对节点进行删除

解析字符串方式打开，删除，保存
from xml.etree import ElementTree as ET
str_xml = open(‘first.xml‘, ‘r‘).read()    #打开文件，读取XML内容
root = ET.XML(str_xml)    #将字符串解析成xml特殊对象，root代指xml的根节点
for country in root.findall(‘country‘):    #遍历data下所有country节点
    rank = int(country.find("rank").text)    #获取每一个country节点下rank节点的内容
    if rank > 50:   
        root.remove(country)    #删除指定country节点
tree = ET.ElementTree(root)
tree.write("new.xml", encoding="utf-8")

解析文件方式打开，删除，保存

from xml.etree import ElementTree as ET

tree = ET.parse("first.xml")    #直接解析xml文件
root = tree.getroot()    #获取xml文件的根节点

for country in root.findall("country"):    #遍历data下的所有country节点
    rank = int(country.find("rank").text)    #获取每一个country节点下rank节点的内容
    if rank > 50:
    root.remove(country)    #删除指定country节点
tree.write("new.xml", encouding="utf-8")

命名空间：

from xml.etree import ElementTree as ET

ET.register_namespace(‘com‘,"http://www.company.com") #some name# build a tree structure
root = ET.Element("{http://www.company.com}STUFF")
body = ET.SubElement(root, "{http://www.company.com}MORE_STUFF", attrib={"{http://www.company.com}hhh": "123"})
body.text = "STUFF EVERYWHERE!"# wrap it in an ElementTree instance, and save as XML
tree = ET.ElementTree(root)

tree.write("page.xml",
           xml_declaration=True,
           encoding=‘utf-8‘,
           method="xml")

configparser模块

对特殊的文件处理

特殊的文件格式：

[xiaoming]
age = 13
gender = "man"
gander = 112

[liming]
age = 18
gender = "gay"

import configparser
con = configparser.ConfigParser()

con对象的read功能，读取文件吧内容提取到con对象里

con.read("ini", encoding="utf-8")

con对象的sections方法，内存中寻找所有的节点

result = con.sections()
print(result)

options查看节点下面的键

ret = con.options("xiaoming")
print(ret)

.get 获取指定节点下指定的key值

v = con.get("xiaoming", "age")
print(v)

检查文件下有没有节点

has_sec = con.has_section("xiaoming")
print(has_sec)

添加节点

con.add_section("zhenni")

删除节点

con.remove_section("zhenni")

写入

con.write(open(‘ini‘, ‘w‘))

检查键的值

has_opt = con.has_option("xiaoming", "age")

删除键的值

con.remove_option(‘xiaoming‘, ‘gander‘)

设置键的值

con.set(‘xiaoming‘, ‘gander‘, ‘112‘)

写入

con.write(open(‘ini‘,‘w‘))

shutil模块：高级模块，对文件文件夹，压缩包处理

import shutil

.copyfileobj(open(旧文件, “r”)，open(新文件, ‘w’))
把一个文件的内容复制到另一个文件里

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)
拷贝文件和权限

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

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

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

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

    shuil.move("name1", "name2")

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

import zipfile
z = zipfile.ZipFile(‘laxi.zip‘, ‘w‘)
z.write("first.xml")
z.write("ini")
z.close()

z = zipfile.ZipFile("laxi.zip", ‘r‘)
#z.namelist()
print(dir(z))
import tarfile

logging模块

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

单文件日志

import logging


logging.basicConfig(filename=‘log.log‘,
                    format=‘%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s‘,
                    datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
                    level=10)

logging.debug(‘debug‘)
logging.info(‘info‘)
logging.warning(‘warning‘)
logging.error(‘error‘)
logging.critical(‘critical‘)
logging.log(10,‘log‘)

日志等级
只有当前写等级大于日志等级时，日志文件才被记录

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

多文件日志
对于上述记录日志的功能，只能将日志记录在单文件中，如果想要设置多个日志文件，logging.basicConfig将无法完成，需要自定义文件和日志操作对象。

定义文件

file_1_1 = logging.FileHandler(‘l1_1.log‘, ‘a‘)
fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s")
file_1_1.setFormatter(fmt)

file_1_2 = logging.FileHandler(‘l1_2.log‘, ‘a‘)
fmt = logging.Formatter()
file_1_2.setFormatter(fmt)

定义日志

logger1 = logging.Logger(‘s1‘, level=logging.ERROR)
logger1.addHandler(file_1_1)
logger1.addHandler(file_1_2)

写日志

logger1.critical(‘1111‘)

定义文件

file_2_1 = logging.FileHandler(‘l2_1.log‘, ‘a‘)
fmt = logging.Formatter()
file_2_1.setFormatter(fmt)

定义日志

logger2 = logging.Logger(‘s2‘, level=logging.INFO)
logger2.addHandler(file_2_1)