跟我一起学python（四），python的模块

最新推荐文章于 2021-06-26 10:04:05 发布

Walker-Wang

最新推荐文章于 2021-06-26 10:04:05 发布

阅读量1.8k

点赞数 1

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/u010608352/article/details/52787048

版权

Python 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

模块，用一砣代码实现了某个功能的代码集合。

类似于函数式编程和面向过程编程，函数式编程则完成一个功能，其他代码用来调用即可，提供了代码的重用性和代码间的耦合。而对于一个复杂的功能来，可能需要多个函数才能完成（函数又可以在不同的.py文件中），n个 .py 文件组成的代码集合就称为模块。

如：os 是系统相关的模块；file是文件操作相关的模块

模块分为三种：

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

自定义模块

1、定义模块：

情景一：
这里写图片描述

情景二：
这里写图片描述

情景三：
这里写图片描述

2、导入模块：

Python之所以应用越来越广泛，在一定程度上也依赖于其为程序员提供了大量的模块以供使用，如果想要使用模块，则需要导入。导入模块有一下几种方法：

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

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

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

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


print sys.path

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

import sys
import os
project_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(project_path)

模块介绍

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

sys.argv    可以接收外部传入的参数,传入参数变为列表的形式

sys.path    查看模块默认地址

sys.path.append("E:\\")可以添加模块的搜寻地址

    sys.path.append("D:\python")    #在D盘下找到python找模块

sys.exit(n)        退出程序，正常退出时exit(0)

sys.version        获取Python解释程序的版本信息

sys.maxint         最大的Int值

sys.platform       返回操作系统平台名称

sys.stdin          输入相关

sys.stdout         输出相关
    sys.stdout.flush()  输出清空
    sys.stdout.write(变量或文本) 不会换行直接写

sys.stderror       错误相关

sys举例–进度条：

import sys
import time

def view_bar(num, total):
    rate = num / total
    rate_num = int(rate * 100)
    r = '\r%d%%' % (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)

sys举例–进度条带进度的：

import sys
import 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)

os模块：
用于提供系统级别的操作

os.path.abspath()   #获取绝对路径 #路径的作用主要用于程序跨机器和平台
    os.path.abspath(__file__)

os.path.dirname()   #获取文件的上级目录
    os.path.dirname(os.path.abspath(__file__))  #找到上一级目录    
    sys.path.append()os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
        #找到/bin下内容的主目录，主要用于在其他机器也能正常运行 必加！！！
        sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

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所指向的文件或者目录的最后修改时间

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

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再来做加密。

import hashlib

# ######## md5 ########

hash = hashlib.md5(bytes('898oaFs09f',encoding="utf-8"))
hash.update(bytes('admin',encoding="utf-8"))
print(hash.hexdigest())

re模块：
正则表达式处理模块

flags: 便宜标志位，用于修改正则的表达式的匹配方式，如：是否区分大小写，多行匹配等等

re.findall() 将结果分别保存列表中的元素中

refindall("规则","要搜索的内容")

re.match()  只匹配字符串的启示位置，并将结果返回成对象的形式通过调用对象的方法获得具体的值
    re.match("规则","要搜索的内容",flags=0)

start() 返回匹配开始的位置

end()   返回匹配结束的位置

span()  返回一个元祖包含匹配(开始,结束)的位置

group() 返回re整个匹配的字符串，可以一次输入多个组号，对应组号匹配的字符串

re.search() 匹配字符串内任意字符，并将第一个匹配结果返回成对象，通过调用对象的方法获得值，对象的方法同match

re.search("规则","要搜索的内容",flags=0)

re.finditer()   同findall一样，但finditer返回的是对象

re.sub()        匹配替换
    re.sub("模式","替换的新字符串","要被搜索的字符串",max)   max为数字，意思是替换的最大次数   
re.split()  对字符串做分割

re.split("\d+","one1two2three3four4")   #返回：['one', 'two', 'three', 'four', '']

# 无分组
origin = "hello alex bcd alex lge alex acd 19"
r = re.split("alex", origin, 1)
print(r)

# 有分组
origin = "hello alex bcd alex lge alex acd 19"
r1 = re.split("(alex)", origin, 1)
print(r1)
r2 = re.split("(al(ex))", origin, 1)
print(r2)

re.compile() 将模式封装成对象，然后调用对象可以批量匹配字符串
    text = "sad123oo123dff"
    regex=re.compile(r'\w*oo\w*)    #先把模式封装成regex的对象，r的意思是让python解释器不转译，将原生字符直接传送给函数
    print regex.findall(text)       #查找text里oo字符

正则分组：
去已经提取到的数据中再提取数据

match和search分组：
r = re.match("h(\w+).*(?P<name>\d)$", origin)
print(r.group())     # 获取匹配到的所有结果
print(r.groups())    # 获取模型中匹配到的分组结果
print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组
多层括号会从外层逐层取值

正则表达式基础用法:
元字符

.   单个任意字符
^   锁定起始位置
$  锁定结束位置
*   匹配其前面的字符任意次

a*b  的含义是b前面可以有任意一个a
    .*任意长度的任意字符


+   必须最少有一个字符
    a+b ab之间至少有一个字符


{}  规定ab之间可以有多少个字符可以匹配

a.{1，5}b        指的是ab之间可以匹配1-5个字符

a.{1，}b     任意多次

a.{，5}b     从0次开始
    如果不加. 就会重复a

[]  字符范围，元字符在中括号里不起任何作用，除了-(范围),^(非),\（转义）

a[bc]d  可以匹配acd、abd

[a-z]   可以匹配a-z

[a-z]+  可以匹配个a-z

[^f]    可以比配不是f的任意一个字符，相当于否定

|       或者
    C|cat  匹配是C或者Cat
    (C|c)at 匹配是Cat或者cat   

()      分组
        a（ab）*c 可以匹配a和c之间出现任意一次ab

\   第一个功能是转译，跟后面字幕实现特殊功能
\d  匹配任何十进制数(后面是相当于)        [0-9]
\D  匹配任意非数字字符：              [^0-9]
\s  匹配任何空白字符                    [\t\n\r\f\v]
\S  匹配任何非空白字符                   [^\t\n\r\f\v]
\w  匹配任何字母数字字符              [a-zA-Z0-9_]
\W  匹配任何非字母数字字符             [a-zA-Z0-9_]
\b  匹配一个单词（连续字幕、数字、下划线组成的字符串）边界，以空格、非字幕数字都可以匹配


#IP：
    ^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$

#手机号：
    ^1[3|4|5|8][0-9]\d{8}$

#邮箱：
    [a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

configparser模块：
用于处理特定格式的文件，其本质上是利用open来操作文件。

只支持以下两种注释方法：
# 注释1
; 注释2

[section1] # 节点
k1 = v1    # 值
k2:v2       # 值

[section2] # 节点
k1 = v1    # 值

1、获取所有节点

import configparser
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
ret = config.sections()
print(ret)

2、获取指定节点下所有的键值对

import configparser
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
ret = config.items('section1')
print(ret)

3、获取指定节点下所有的键

import configparser
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
ret = config.options('section1')
print(ret)

4、获取指定节点下指定key的值

import configparser
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8') 
v = config.get('section1', 'k1')
# v = config.getint('section1', 'k1')       #可以将数值转换成int
# v = config.getfloat('section1', 'k1')
# v = config.getboolean('section1', 'k1')
print(v)

5、检查、删除、添加节点

import configparser
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
# 检查
has_sec = config.has_section('section1')
print(has_sec)      #返回Ture和False
# 添加节点
config.add_section("SEC_1")
config.write(open('xxxooo', 'w'))
# 删除节点
config.remove_section("SEC_1")
config.write(open('xxxooo', 'w'))

6、检查、删除、设置指定组内的键值对

import configparser
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
# 检查
has_opt = config.has_option('section1', 'k1')
print(has_opt)
# 删除
config.remove_option('section1', 'k1')
config.write(open('xxxooo', 'w'))
# 设置
config.set('section1', 'k10', "123")
config.write(open('xxxooo', 'w'))

XML模块：

引用模块：
from xml.etree import ElementTree as ET

1 解析XML：

#利用ElementTree.XML将字符串解析成xml对象
from xml.etree import ElementTree as ET

# 打开文件，读取XML内容
str_xml = open('xo.xml', 'r').read()

# 将字符串解析成xml特殊对象，root代指xml文件的根节点
root = ET.XML(str_xml)

#利用ElementTree.parse将文件直接解析成xml对象:
from xml.etree import ElementTree as ET

# 直接解析xml文件
tree = ET.parse("xo.xml")

# 获取xml文件的根节点
root = tree.getroot()

2、操作XML ：
XML格式类型是节点嵌套节点，对于每一个节点均有以下功能，以便对当前节点进行操作

Example form:
<tag attrib>text</tag>

salf    相当于Element的节点(node)名称
tag     标签
attrib  属性
text    文本
salf.tag,salf.attrib,salf.text

def makeelement(self, tag, attrib): 
#创建一个新节点

def copy(self):                     
#同列表复制

def append(self, subelement):       
#为当前节点追加一个子节点

def extend(self, elements):         
#为当前节点扩展 n 个子节点

def insert(self, index, subelement):
#在当前节点的子节点中插入某个节点，即：为当前节点创建子节点，然后插入指定位置

def remove(self, subelement):
#在当前节点在子节点中删除某个节点

def getchildren(self):
#获取所有的子节点（废弃）

def find(self, path, namespaces=None):
#获取第一个寻找到的子节点

def findtext(self, path, default=None, namespaces=None):
#获取第一个寻找到的子节点的内容

def findall(self, path, namespaces=None):
#获取所有的子节点

def iterfind(self, path, namespaces=None):
#获取所有指定的节点，并创建一个迭代器（可以被for循环）

def clear(self):
#清空节点

def get(self, key, default=None):
#获取当前节点的属性值

def set(self, key, value):
#为当前节点设置属性值

def keys(self):
#获取当前节点的所有属性的 key

def items(self):
#获取当前节点的所有属性值，每个属性都是一个键值对

def iter(self, tag=None):
#在当前节点的子孙中根据节点名称寻找所有指定的节点，并返回一个迭代器（可以被for循环）。

def itertext(self):
#在当前节点的子孙中根据节点名称寻找所有指定的节点的内容，并返回一个迭代器（可以被for循环）。

由于每个节点都具有以上的方法，并且在上一步骤中解析时均得到了root（xml文件的根节点），so 可以利用以上方法进行操作xml文件

a. 遍历XML文档的所有内容

############ 解析方式一 ############
# 打开文件，读取XML内容
str_xml = open('xo.xml', 'r').read()

# 将字符串解析成xml特殊对象，root代指xml文件的根节点
root = ET.XML(str_xml)

############ 解析方式二 ############
# 直接解析xml文件
tree = ET.parse("xo.xml")

# 获取xml文件的根节点
root = tree.getroot()

### 操作
# 顶层标签
print(root.tag)

# 遍历XML文档的第二层
for child in root:
    # 第二层节点的标签名称和标签属性
    print(child.tag, child.attrib)
    # 遍历XML文档的第三层
    for i in child:
        # 第二层节点的标签名称和内容
        print(i.tag,i.text)

b、遍历XML中指定的节点

rom xml.etree import ElementTree as ET
############ 解析方式一 ############
"""
# 打开文件，读取XML内容
str_xml = open('xo.xml', 'r').read()

# 将字符串解析成xml特殊对象，root代指xml文件的根节点
root = ET.XML(str_xml)
"""
############ 解析方式二 ############

# 直接解析xml文件
tree = ET.parse("xo.xml")

# 获取xml文件的根节点
root = tree.getroot()

### 操作

# 顶层标签
print(root.tag)

# 遍历XML中所有的year节点
for node in root.iter('year'):

# 节点的标签名称和内容
print(node.tag, node.text)

c、修改节点内容
由于修改的节点时，均是在内存中进行，其不会影响文件中的内容。所以，如果想要修改，则需要重新将内存中的内容写到文件。

#解析字符串方式，修改，保存
from xml.etree import ElementTree as ET
############ 解析方式一 ############     

# 打开文件，读取XML内容
str_xml = open('xo.xml', 'r').read()

# 将字符串解析成xml特殊对象，root代指xml文件的根节点
root = ET.XML(str_xml)

############ 操作 ############

# 顶层标签
print(root.tag)

# 循环所有的year节点
for node in root.iter('year'):
# 将year节点中的内容自增一
new_year = int(node.text) + 1
node.text = str(new_year)

# 设置属性
node.set('name', 'alex')
node.set('age', '18')
# 删除属性
del node.attrib['name']
############ 保存文件 ############
tree = ET.ElementTree(root)
tree.write("newnew.xml", encoding='utf-8')


#解析文件方式，修改，保存
from xml.etree import ElementTree as ET
############ 解析方式二 ############ 

# 直接解析xml文件
tree = ET.parse("xo.xml")

# 获取xml文件的根节点
root = tree.getroot()

############ 操作 ############

# 顶层标签
print(root.tag)

# 循环所有的year节点
for node in root.iter('year'):
    # 将year节点中的内容自增一
    new_year = int(node.text) + 1
    node.text = str(new_year)

    # 设置属性
    node.set('name', 'alex')
    node.set('age', '18')
    # 删除属性
    del node.attrib['name']


############ 保存文件 ############
tree.write("newnew.xml", encoding='utf-8')

d、删除节点

#解析字符串方式打开，删除，保存
from xml.etree import ElementTree as ET
############ 解析字符串方式打开 ############
# 打开文件，读取XML内容
str_xml = open('xo.xml', 'r').read()

# 将字符串解析成xml特殊对象，root代指xml文件的根节点
root = ET.XML(str_xml)
############ 操作 ############
# 顶层标签
print(root.tag)

# 遍历data下的所有country节点
for country in root.findall('country'):
    # 获取每一个country节点下rank节点的内容
    rank = int(country.find('rank').text)

    if rank > 50:
        # 删除指定country节点
        root.remove(country)
############ 保存文件 ############
tree = ET.ElementTree(root)
tree.write("newnew.xml", encoding='utf-8')

#解析文件方式打开，删除，保存
from xml.etree import ElementTree as ET
############ 解析文件方式 ############

# 直接解析xml文件
tree = ET.parse("xo.xml")

# 获取xml文件的根节点
root = tree.getroot()

############ 操作 ############

# 顶层标签
print(root.tag)

# 遍历data下的所有country节点
for country in root.findall('country'):
    # 获取每一个country节点下rank节点的内容
    rank = int(country.find('rank').text)

    if rank > 50:
        # 删除指定country节点
        root.remove(country)

############ 保存文件 ############
tree.write("newnew.xml", encoding='utf-8')

3、创建XML文档：

#第一种 基础
from xml.etree import ElementTree as ET
# 创建根节点
root = ET.Element("famliy")
# 创建节点大儿子
son1 = ET.Element('son', {'name': '儿1'})
# 创建小儿子
son2 = ET.Element('son', {"name": '儿2'})
# 在大儿子中创建两个孙子
grandson1 = ET.Element('grandson', {'name': '儿11'})
grandson2 = ET.Element('grandson', {'name': '儿12'})
son1.append(grandson1)
son1.append(grandson2)
# 把儿子添加到根节点中
root.append(son1)
root.append(son1)
tree = ET.ElementTree(root)
tree.write('oooo.xml',encoding='utf-8', short_empty_elements=False)

#第二种 使用makeelement
from xml.etree import ElementTree as ET
# 创建根节点

root = ET.Element("famliy")
# 创建大儿子

# son1 = ET.Element('son', {'name': '儿1'})
son1 = root.makeelement('son', {'name': '儿1'})
# 创建小儿子

# son2 = ET.Element('son', {"name": '儿2'})
son2 = root.makeelement('son', {"name": '儿2'})
# 在大儿子中创建两个孙子

# grandson1 = ET.Element('grandson', {'name': '儿11'})
grandson1 = son1.makeelement('grandson', {'name': '儿11'})
# grandson2 = ET.Element('grandson', {'name': '儿12'})
grandson2 = son1.makeelement('grandson', {'name': '儿12'})
son1.append(grandson1)
son1.append(grandson2)
# 把儿子添加到根节点中

root.append(son1)
root.append(son1)
tree = ET.ElementTree(root)
tree.write('oooo.xml',encoding='utf-8', short_empty_elements=False)


#第三种 使用SubElement
from xml.etree import ElementTree as ET
# 创建根节点

root = ET.Element("famliy")
# 创建节点大儿子

son1 = ET.SubElement(root, "son", attrib={'name': '儿1'})
# 创建小儿子

son2 = ET.SubElement(root, "son", attrib={"name": "儿2"})
# 在大儿子中创建一个孙子

grandson1 = ET.SubElement(son1, "age", attrib={'name': '儿11'})
grandson1.text = '孙子'
et = ET.ElementTree(root)  #生成文档对象
et.write("test.xml", encoding="utf-8", xml_declaration=True, short_empty_elements=False)

4、创建XML带有缩进：
由于原生保存的XML时默认无缩进，如果想要设置缩进的话，需要修改保存方式

rom xml.etree import ElementTree as ET
from xml.dom import minidom
def prettify(elem):
    #将节点转换成字符串，并添加缩进。
    rough_string = ET.tostring(elem, 'utf-8')
    reparsed = minidom.parseString(rough_string)
    return reparsed.toprettyxml(indent="\t")
# 创建根节点
root = ET.Element("famliy")

# 创建大儿子
# son1 = ET.Element('son', {'name': '儿1'})
son1 = root.makeelement('son', {'name': '儿1'})

# 创建小儿子
# son2 = ET.Element('son', {"name": '儿2'})
son2 = root.makeelement('son', {"name": '儿2'})

# 在大儿子中创建两个孙子
# grandson1 = ET.Element('grandson', {'name': '儿11'})
grandson1 = son1.makeelement('grandson', {'name': '儿11'})
# grandson2 = ET.Element('grandson', {'name': '儿12'})
grandson2 = son1.makeelement('grandson', {'name': '儿12'})

son1.append(grandson1)
son1.append(grandson2)

# 把儿子添加到根节点中
root.append(son1)
root.append(son1)

raw_str = prettify(root)

f = open("xxxoo.xml",'w',encoding='utf-8')
f.write(raw_str)
f.close()

5、其他技巧
tree.write 增加参数，xml_declaration=True 即可输出带有头部标识的xml

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

shutil.copyfileobj(fsrc, fdst[, length])        #将文件内容拷贝到另一个文件中
    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.copy2('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.rmtree(path[, ignore_errors[, onerror]])         #递归的去删除文件
    shutil.rmtree('folder1')

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

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

        zip压缩
            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()


        tar压缩
            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()

系统命令：subprocess模块

call        #执行命令，返回状态码
    ret = subprocess.call(["ls", "-l"], shell=False)
    ret = subprocess.call("ls -l", shell=True)

check_call  #执行命令，如果执行状态码是 0 ，则返回0，否则抛异常
    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()      #相当于第二段代码的  cmd_out = obj.stdout.read()及往下四行
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)