【python自动化第五篇：python入门进阶】

今天内容：

1. 模块的定义
2. 导入方法
3. import的本质
4. 导入优化
5. 模块分类
6. 模块介绍

一、模块定义：

　　　　用来在逻辑上组织python代码（变量，函数，逻辑，类）；本质就是为了实现一个功能（就是以.py结尾的python文件）

　　　　比如说：文件名为test.py的文件，他的模块名就是test

例如：在同一个文件夹下创建main.py（导入模块的程序）,test.py(模块文件)

#main.py文件内容如下：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:wanghui
import test
printtest.name)                              #导入test模块下的变量
print(test.say_hello())                    #导入test模块下的函数say_hello()##要注意调用函数要加括号

#test.py文件内容如下：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:wanghui
name = "wanghui"
def say_hello():
    print('hello %s'%name)

　　

二、导入方法：

　　import module_name         (单个导入)

　　import module1,module2,module3.....           （多个导入用英文逗号隔开）

　　from module_name import *                         (导入所有的module_name下的所有代码拿到当前的程序下先执行一遍，建议不要这样使用)

　　from module_name import logger as logger_module_name               (导入module_name模块下的logger函数，并重命名为logger_module_name使用的时候用logger_module_name函数)

三、import的本质

　　import导入：相当于是将模块的内容解释之后赋值给需要导入该模块的程序，调用的时候需要以module.func(模块对应的方法)来调用这个模块的方法

　　from module import func这样的导入：相当于是打开module这个文件并找到遁影的func方法执行一遍，直接用func名来调用即可。

示例如下：

#main.py文件内容如下：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:wanghui
import test
print（test.name)                              #导入test模块下的变量
print(test.say_hello())                       #导入test模块下的函数say_hello()##要注意调用函数要加括号，还有要将模块名写上，否则出错
#from导入
from module1 import name,logger               #from导入test模块下的name，logger方法，调用时只需调用这个name和logger方法即可
print(name)
logger()

#test.py文件内容如下：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:wanghui
name = "wanghui"
def say_hello():
    print('hello %s'%name)
def logger():
    print("in the test!!!")

　　包的定义：本质就是一个目录（必须带有一个__init.py__的文件），

　　　　用法：从逻辑上组织模块的

　　包的导入：导入包的目的就是为了解释包下的init.py文件

　　路径搜索的意义：就是为了能在import的时候找到正确的模块路径（也就是跨目录的模块搜索功能），方便找到模块予以执行；否则将在自己所在的文件目录下查找模块，找的到的话 就能够使用模块，找不到的话就报错。

　　路径搜索用到的模块：sys,os

import sys,os
print(os.path.abspath(__file__))   #获取当前文件的路径绝对路径（结果D:\project\s14\day5\review\main.py）
#n那么这会儿要是往上走一级目录的话就是要os.path.dirname(),线来获取此文件所在的目录
print(os.path.dirname(os.path.abspath(__file__)))   #这会儿就到文件所在的目录了（结果D:\project\s14\day5\review）
#因为你的module1.py模块在day5下呢，所以现在还是找不到的，那我们就再上一层吧，还是用os.path.dirname()结合上一个os.path.dirname(os.path.abspath(__file__))就可以实现往上一级目录定位了。
print(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) #这样子就可以找到day5这个目录了
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))   #将这个路径加载到当前程序的环境变量中，以便调用模块的时候能够找的到模块（当然也可以使用insert来添加到指定位置）
import module1
print(module1.name)

　这样的话就可以实现跨目录的调用了，一定要记得加载到环境变量中，不然还是找不到呢。

　完整的导入技巧如下：

#import 跨路径导入模块
import sys,os
BASE_DIR=os.path.dirname(os.path.abspath(__file__))  #定义当前文件完整路径
MODULE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  #可已通过os.path.dirname()往上一级目录，
sys.path.append(MODULE_DIR)   #将当前模块路径写入当前调用程序的环境变量
import module_name                    #现在就可以导入跨路径的模块了       绝对路径
from day5 import package_name

四、导入优化

　　像是有些模块的重复使用对的情况下，import的导入方法要弱于from module import func；毕竟重复使用的时候也只是使用模块对应的方法。要单纯使用import的时候多个函数的模块调用会导致运行效率不高。故引入from modue import func 来直接定义好要调用的func，从而提高多多个函数的模块调用的效率！

五、模块的分类：

1. 标准库（内置模块）
2. 第三方库（开源模块）
3. 自定义模块

六、标准库

　　1.时间模块

　　　　时间格式：时间戳，格式化的时间，元组话表示

　　        time：

#Author:wanghui
import time
t = time.time()          #时间戳格式显示，单位是秒
x = t          #遮掩算出来的就是从1970.1.1-00:00:00到现在经历的年
print(x)

q = time.localtime()     #时间元组格式的时间
print(q)                 #time.struct_time(tm_year=2016, tm_mon=8, tm_mday=22, tm_hour=2, tm_min=57, tm_sec=59, tm_wday=0, tm_yday=235, tm_isdst=0)

w = time.timezone        #格里尼治时间和本地时间的差（按秒计算）
print(w/3600)            #打印时区差

e = time.altzone         #夏令时（DST）和UTC时间差    time.daylight 是否使用夏令时
print(e/3600)            #打印小时差

#time.sleep(10)          #休息10秒

r = time.gmtime()        #需要传入秒数，然后就转换成时间元组（time.timezone）,
print(r)                 #不加时间戳参数则表示打印的是格林尼治时间元组

y = time.localtime()     #转换成当地时间元组形式
print(y)                 #加参数则能够随着本地的时间格式转换
d = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())        #将元组结构时间转换成格式化时间
print(d)

f = time.strptime('2016-08-23 00:30:32',"%Y-%m-%d %H:%M:%S")   #格式化时间转换成元组结构时间
print(f)

g = time.asctime()                              #将时间转换成Tue Aug 23 00:35:52 2016格式
print(g)

k = time.ctime()                                #将时间戳格式转换成Tue Aug 23 00:35:52 2016格式
print(k)

　　操作图如下：

　　timedate模块：

import datetime
print(datetime.date)
print(datetime.time)
print(datetime.datetime.now())                #获取当前时间
print(datetime.datetime.now()+datetime.timedelta(3))    #获取到的三天后的时间
print(datetime.datetime.now()+datetime.timedelta(-3))   #获取三天前的时间
print(datetime.datetime.now()+datetime.timedelta(hours=3))   #获取三小时以后的时间
print(datetime.datetime.now()+datetime.timedelta(hours=-3))  #获取三小时钱的时间
print(datetime.datetime.now()+datetime.timedelta(minutes=3)) #获取三分钟以后的时间
print(datetime.datetime.now()+datetime.timedelta(minutes=-3)) #获取三分钟之前的时间

#时间替换
c_time = datetime.datetime.now()                       #获取当前时间
print(c_time.replace(minute=4,hour=2))                 #replace当前时间

　　2.random

　　random基础操作：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:wanghui
import random

print(random.random())      #打印生成的0到1之间的随机额浮点数
print(random.uniform(1,9))  #打印1到9之间的随机浮点数
print(random.randint(1,9))  #打印1到9之间的随机整数
print(random.randrange(1,9)) #打印1到9之间除了9之外的随机整数（顾头不顾尾，类似于range(9)）
# #random.choie()         其中可以传入任意的数据类型并随机选其一
print(random.choice("abcdefghijklmn"))     #随机选择一个字符串
print(random.choice((1,2,3,[4,5,6],7,8)))      #随机选择元组中的一个参数（序列都能这么玩）
#print(random.choice({'name':"wanghui",'age':"24",'job':"IT"}))           #金测试字典中的元素不能被随机打印（因为时间支队，不能被拆散）

print(random.sample("hello",2))       #sample()对于定义的字符春后面的数字代表能够随机取出的个数（以列表的方式打印）

#洗牌效果：实现对其中的列表或者元组元素顺序的打乱
li_old = [1,2,3,4,5,6]
li_new = random.shuffle(li_old)     #洗牌操作
print(li_old)               #将li_old列表的元素乱序排列

　　random实战生成六位验证码：

#方法一：
import random
check_code = []                           #定义空列表，用于传递验证码用
for i in range(6):                       #定义验证码位数
    r = random.randint(0,5)               #定义生成验证码的次数
    if i == 2 or r == 4:                 #第二位或者第四次生成数字。将其加入空列表
        num = random.randint(0,9)
        check_code.append(str(num))
    else:                                #其他情况
        word = random.randint(65,90)     #定义字母并见此追加到列表中
        word_str = chr(word)
        check_code.append(str(word_str))
final_code = "".join(check_code)        #将最后生成的列表中的字符串去掉标点符号来join到一起
print(final_code)

#方法二：
import random
checkcode = ''
for m in range(6):                     #定义验证码位数
    current = random.randint(0,9)       #让数字活动起来
    if m ==2 or current ==4:           #位数和次数    (完全随机的话current == m)
        tmp = random.randint(0,9)       #如果次数随机等于m，则将其任意值赋给tmp
    else:
        tmp = chr(random.randint(65,90))   #其余的为字母
    checkcode+=str(tmp)                    #拼接字符串
print(checkcode)                           #打印验证码

　　3.os模块：

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于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')  获取文件/目录信息
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所指向的文件或者目录的最后修改时间

　　3.sys模块：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#sys模块

import sys
print(sys.agv[1])   #窜入第一个参数
sys.exit(7)         #按照状态码为7退出
sys.maxint          #最大的int值
print(sys.platform) #打印操作系统平台
sys.stdout.write('please')   #系统输出，用于打印进度条

　　4.phutil：高级的 文件、文件夹、压缩包 处理模块

#shutil模块：进行文件的copy，还能打包
import shutil
f_old = open('test1.txt',encoding='utf-8')           #源文件
f_new = open('test2.txt','w',encoding='utf-8')       #复制后的文件
shutil.copyfileobj(f_old,f_new)                      #复制操作
shutil.copyfile("test2.txt","test3.txt")            #不需要读取文件，直接复制
shutil.copymode("test1.txt","test4.txt")            #仅拷贝权限。内容、组、用户均不变
shutil.copystat("test4.txt","test5.txt")            #拷贝状态的信息，包括：mode bits, atime, mtime, flags
shutil.copy("test5.txt","test6.txt")                #拷贝文件和权限
shutil.copytree("a","a_test")                       #递归拷贝目录以及其内容
shutil.rmtree("a_test")                             #删除递归目录

shutil.make_archive('test','zip','D:\pytest')     #对D:\pytest下的文件进行压缩
import zipfile
#使用zip压缩
m = zipfile.ZipFile('D:\pytest\day5.zip','w')      #以写的方式打开文件
m.write("test.zip")                        #传入文件
print("-----")
m.write("test1.txt")                      #再来一发
m.close()                                   #文件关闭
#解压
m = zipfile.ZipFile('D:\pytest\day4.zip','r')       #读的方式打开文件
m.extractall()                               #解压文件
m.close()                                    #解压完成关闭文件

import tarfile
#使用tar压缩
tar = tarfile.open("test.tar",'w')
tar.add('D:\pytest\day3.zip',arcname="day3.zip")
tar.add('D:\pytest\day4.zip',arcname="day4.zip")
tar.close()
#使用tar解压
tar = tarfile.open('test.tar','r')
tar.extractall()  # 可设置解压地址
tar.close()

　　5.stelve模块：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:wanghui
#由于不能多次dump或者load多次，效率低下
import shelve,datetime
#简单的将key,value数据持久化的一个模块，可以持久化任何pickle支持的python数据格式
d = shelve.open("test.txt")
info = {'name':'wanghui','age':25}
job = ['IT','WORKER','DESIGNER']
d["job"] = job
d["info"] = info
d['date'] = datetime.datetime.now()
d.close()

print(d.get('job'))    #获取job列表
print(d.get('info'))   #获取字典
print(d.get('date')   #获取时间

　　6.xml模块

需要处理的test.xml文件：

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

调用xml模块的方法处理xml文件：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import xml.etree.ElementTree as ET
tree = ET.parse('test.xml')        #定义要处理的文件
first = tree.getroot()                #获取根节点参数
print(first.tag)                      #.tag就是将内存数据转化成可以读取的形式

#遍历xml文档
for second in first:                  #读取第二级节点
    print(second.tag,second.attrib)
    for third in second:              #读取第三级节点
        print(third.tag,third.attrib)
        for forth in third:
            print(forth.tag,forth.attrib)
#只遍历其中的year节点
for node in first.iter("year"):
    print(node.tag,node.text)

#修改xml文件
for node in first.iter('year'):
    new = int(node.text) + 1          #year + 1
    node.text = str(new)              #转换成str
    node.set("updated",'yes')       #添加新的属性
tree.write("test.xml")

#删除节点
for country in first.findall('country'):
    rank = int(country.find('rank').text)
    if rank > 50:
        first.remove(country)
tree.write('out.xml')

#创建xml文件
import xml.etree.ElementTree as ET
new_xml = ET.Element("namelist")            #声明namelist
personinfo = ET.SubElement(new_xml,'personinfo',attrib={'enrolled':'yes'})
name = ET.SubElement(personinfo,"age",atrrib={'checked','no'})
name.text = 'wanghui'
age = ET.SubElement(personinfo,"age",atrrib={'checked','no'})
sex = ET.SubElement(name,'sex')
age.text = '25'
personinfo2 = ET.SubElement(new_xml,'personinfo',attrib={'enrolled':'no'})
name = ET.SubElement(personinfo2,"age",atrrib={'checked','no'})
name.text = "alex"
age = ET.SubElement(personinfo2,"age")
age.text = '12'

ex = ET.ElementTree(new_xml)                   #生成文档对象
ex.write('test1.xml',encoding='utf-8',xml_declaration=True)
ET.dump(new_xml)       #打印生成的格式

　　7.configparser模块：用于处理配置文件

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#configparser:处理配置文件
import configparser
conf = configparser.ConfigParser()      #生成configparser对象
conf["DEFAULT"] = {'ServerAliveInterval':'45',   #生成第一个实例
                   'Compression':'yes',
                   "CompressionLevel":9
}
conf['bitbucher.org'] = {}                         #第二个实例
conf['bitbucher.org'] ['User'] = 'hg'

conf["topsecret.server.com"] = {}               #第三个实例
topsecret = conf["topsecret.server.com"]
topsecret['Host Port'] = "52333"
topsecret['ForwardXll'] = 'no'

with open('example.ini','w',encoding='utf-8') as configfile:
    conf.write(configfile)                                    #写入配置文件

　　其他操作：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# import configparser
# conf = configparser.ConfigParser()        #读取文件前戏
# conf.read('example.ini')
# print(conf.sections())
# print(conf.defaults())   #打印所有
# print(conf['bitbucher.org']['User'])   #读取bitbucher.org的user信息
# for key in conf['bitbucher.org']:      #利用循环读取
#     print(key)

#增删改查语法
import configparser
conf = configparser.ConfigParser()
conf.read('example.ini')
#读取一把
print(conf.sections())
print(conf['bitbucher.org']['User'])               #读取配置文件
#增删操作
ret = conf.remove_section('bitbucher.org')          #删除
conf.write(open('exaple.ini','w'))                  #写入文件

　　8.hashlib模块：提供加密算法

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import hashlib
m = hashlib.md5()        #创建md5加密对象
m.update(b'hello')      #对象中插入数值
print(m.hexdigest())      #以十六进制打印md5值
m.update(b"it's me!!")
print(m.hexdigest())
m.update(b'as long as you love me!')
print(m.hexdigest())
#拼接
m2 = hashlib.md5()
m2.update(b"helloit's me!!")  #更新之后的和拼接的md5一样
print(m2.hexdigest())

s1 = hashlib.sha512()
s1.update(b"helloit's me!!")  #复杂算法
print(s1.hexdigest())
#带中文的加密
f1 = hashlib.md5()
f1.update("你妹呀！！".encode(encoding='utf-8'))
print(f1.hexdigest())
#更吊的版本
import hmac
k1 = hmac.new(b'wanghui',b'message')      #仅支持ascii码，不支持中文
print(k1.hexdigest())
print(k1.digest())
#带中文的加密
k2 = hmac.new("你大爷的！！".encode(encoding='utf-8'),"呵呵哒！".encode(encoding='utf-8'))
print(k2.hexdigest())

　　9.re模块：匹配字符串（模糊匹配）