• 【Python第四篇】python模块

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

    而对于一个复杂的功能来，可能需要多个函数才能完成（函数又可以在不同的.py文件中），n个 .py 文件组成的代码集合就称为模块。

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

    模块分为三种：

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

    自定义模块

    导入模块

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

    1
    2
    3
    4
    import s1
    from lib import common
    from lib import common as lib_commin 
    from lib import *

    导入模块时是根据sys.path为基准来进行的。

    如果sys.path路径列表没有你想要的路径：

    sys.path.insert(0,path)  # 添加python环境变量,插入到sys.path的0位置

    还可以通过 sys.path.append('路径') 添加：

    import  sys
sys.path.append('E:\')
print(sys.path)

    第三方开源模块

    一、下载安装

    下载安装有两种方式：

    方式一：
    yum 
pip
apt    -get


    方式二：
    下载源码
解压源码
进入目录
编译源码    python setup.py build
安装源码    python setup.py install

    注：在使用源码安装时，需要使用到gcc编译和python开发环境，所以，需要先执行：

    1
    2
    3
    4
    yum install gcc
    yum install python-devel
    或
    apt-get python-dev

    安装成功后，模块会自动安装到 sys.path 中的某个目录中，如：

    1
    /usr/lib/python2.7/site-packages/

    举例：以模块 paramiko 为例：

    paramiko是一个用于做远程控制的模块，使用该模块可以对远程服务器进行命令或文件操作，值得一说的是，fabric和ansible内部的远程管理就是使用的paramiko来现实。

    下载安装

    1
    pip3 install paramiko

    或

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    # pycrypto，由于 paramiko 模块内部依赖pycrypto，所以先下载安装pycrypto
     
    # 下载安装 pycrypto
    wget http://files.cnblogs.com/files/wupeiqi/pycrypto-2.6.1.tar.gz
    tar -xvf pycrypto-2.6.1.tar.gz
    cd pycrypto-2.6.1
    python setup.py build
    python setup.py install
     
    # 进入python环境，导入Crypto检查是否安装成功
     
    # 下载安装 paramiko
    wget http://files.cnblogs.com/files/wupeiqi/paramiko-1.10.1.tar.gz
    tar -xvf paramiko-1.10.1.tar.gz
    cd paramiko-1.10.1
    python setup.py build
    python setup.py install
     
    # 进入python环境，导入paramiko检查是否安装成功

    二、导入模块

    同自定义模块中导入的方式

    内置模块

    内置模块是Python自带的功能，在使用内置模块相应的功能时，需要【先导入】再【使用】

    一、sys

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

    sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
sys.stdin          输入相关
sys.stdout         输出相关
sys.stderror       错误相关
    import sys
import time

def view_bar(num, total):
    rate = num / total
    rate_num = int(rate * 100)
    r = '
%s>%d%%' % ("="*num,rate_num, )
    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.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下为"	
",Linux下为"
"
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 算法

    ######### md5加密 ########
import hashlib

obj = hashlib.md5()
obj.update(bytes('123',encoding='utf-8'))
result = obj.hexdigest()
print(result)

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

    import hashlib

obj = hashlib.md5(bytes('fdfsfsadf',encoding='utf-8'))
obj.update(bytes('123',encoding='utf-8'))
result = obj.hexdigest()
print(result)

    四、random

    import random
#随机浮点数：
print (random.random())
# 随机整数：
print( random.randint(1,50))
# 随机选取0到100之间的整数：
print (random.randrange(0, 101))
#随机选取0到100间的偶数：
print (random.randrange(0, 101, 2))
#随机字符：
print (random.choice('abcdefghijklmnopqrstuvwxyz!@#$%^&*()'))
#随机选取字符串：
print(random.choice(['剪刀', '石头', '布']))
    import random
num = ''
for i in range(6):
    current = random.randrange(0,6)
    if current != i:
        temp = chr(random.randint(65,90))
    else:
        temp = random.randint(0,9)
        num += str(temp)
print(num)
    随机验证码

    五、re正则表达式

    python中re模块提供了正则表达式相关操作

    字符：

    　　. 匹配除换行符以外的任意字符
    　　w 匹配字母或数字或下划线或汉字
    　　s 匹配任意的空白符
    　　d 匹配数字
    　　 匹配单词的开始或结束
    　　^ 匹配字符串的开始
    　　$ 匹配字符串的结束

    次数：

    　　* 重复零次或更多次
    　　+ 重复一次或更多次
    　　? 重复零次或一次
    　　{n} 重复n次
    　　{n,} 重复n次或更多次
    　　{n,m} 重复n到m次

    match

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

    match(pattern, string, flags=0)
     # pattern： 正则模型
     # string ： 要匹配的字符串
     # falgs  ： 匹配模式
    import re
# 无分组
origin = "has dsfshasfdadsasdf3"
r = re.match("hw+", origin)
print(r.group())  # 获取匹配到的所有结果
print(r.groups())  # 获取模型中匹配到的分组结果
print(r.groupdict())  # 获取模型中匹配到的分组结果

# 有分组,提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
origin = "has dsfsfhasdadsasdf3"
r = re.match("h(w+).*(?P<name>d)$", origin)
print(r.group())  # 获取匹配到的所有结果
print(r.groups())  # 获取模型中匹配到的分组结果
print(r.groupdict())  # 获取模型中匹配到的分组中所有执行了key的组
    match使用

    search

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

    # search(pattern, string, flags=0)
    import re
# 无分组
origin = "ffhas dsfshasfdadsasdf3"
r = re.search("hw+", origin)
print(r.group())  # 获取匹配到的所有结果
print(r.groups())  # 获取模型中匹配到的分组结果
print(r.groupdict())  # 获取模型中匹配到的分组结果

# 有分组,提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
origin = "ffhas dsfsfhasdadsasdf3"
r = re.search("h(w+).*(?P<name>d)$", origin)
print(r.group())  # 获取匹配到的所有结果
print(r.groups())  # 获取模型中匹配到的分组结果
print(r.groupdict())  # 获取模型中匹配到的分组中所有执行了key的组
    search使用

    findall

    # findall，获取非重复的匹配列表；如果有一个组则以列表形式返回，且每一个匹配均是字符串；如果模型中有多个组，则以列表形式返回，且每一个匹配均是元祖；

    # 空的匹配也会包含在结果中
    #findall(pattern, string, flags=0)
    origin = "hello chris bcd abcd lge acd 19"
# 无分组
r = re.findall("aw+", origin)
print(r)

# 有分组
r = re.findall("a((w*)c)(d)", origin)
print(r)
    findall

    sub

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

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

origin = "hello chris bcd alex lge alex acd 19"
r = re.sub("aw+", "999", origin, 2)
print(r)
    sub替换

    split

    # split，根据正则匹配分割字符串

     
    split(pattern, string, maxsplit=0, flags=0)
    # pattern： 正则模型
    # string ： 要匹配的字符串
    # maxsplit：指定分割个数
    # flags  ： 匹配模式
    # 无分组
origin = "hello chris bcd chris lge chris acd 19"
r = re.split("chris", origin, 1)
print(r)

# 有分组

origin = "hello chris bcd chris lge chris acd 19"
r1 = re.split("(chris)", origin, 1)
print(r1)
r2 = re.split("(chr(is))", origin, 1)
print(r2)
    split
    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_-]+)+
    常用正则表达式

    六、序列化

    Python中用于序列化的两个模块

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

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

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

    json和pickle区别：

    #json更适合跨语言，基本数据类型

    #pickle仅适用于python，python所有类型的序列化

    import  json

dic = {'k1':'v1'}
print(dic,type(dic))
#将python基本数据类型转化成字符串形式
result = json.dumps(dic)
print(result,type(result))

s1 = '{"k1":123}'
#将python字符串转化成基本数据类型
dic = json.loads(s1)
print(dic,type(dic))

import requests
response = requests.get('http://wthrcdn.etouch.cn/weather_mini?city=长沙')
response.encoding = 'utf-8'
dic = json.loads(response.text)
print(dic,type(dic))

r = json.dumps([11,22,33])
print(r,type(r))

li = '["chris","eric"]'
ret = json.loads(li) #反序列化时一定要使用双引号""
print(ret,type(ret))

li = [11,22,33]
json.dump(li,open('db','w'))
li = json.load(open('db','r'))
print(li,type(li))
    json
    import  pickle
li = [11,22,33]
r = pickle.dumps(li)
print(r)

result = pickle.loads(r)
print(result)

li = [11,22,33]
pickle.dump(li,open('db','wb'))
    pickle

    七、configparser

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

    [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')
# 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)
 
# 添加节点
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

    xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。

    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协议在各个语言里的都 是支持的，在python中可以用以下模块操作xml 　　

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    import xml.etree.ElementTree as ET
     
    tree = ET.parse("xmltest.xml")
    root = tree.getroot()
    print(root.tag)
     
    #遍历xml文档
    for child in root:
        print(child.tag, child.attrib)
        for i in child:
            print(i.tag,i.text)
     
    #只遍历year 节点
    for node in root.iter('year'):
        print(node.tag,node.text)

    修改和删除xml文档内容

    import xml.etree.ElementTree as ET
     
    tree = ET.parse("xmltest.xml")
    root = tree.getroot()
     
    #修改
    for node in root.iter('year'):
        new_year = int(node.text) + 1
        node.text = str(new_year)
        node.set("updated","yes")
     
    tree.write("xmltest.xml")
     
     
    #删除node
    for country in root.findall('country'):
       rank = int(country.find('rank').text)
       if rank > 50:
         root.remove(country)
     
    tree.write('output.xml')

    自己创建xml文档

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    import xml.etree.ElementTree as ET
     
     
    new_xml = ET.Element("namelist")
    name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
    age = ET.SubElement(name,"age",attrib={"checked":"no"})
    sex = ET.SubElement(name,"sex")
    sex.text = '33'
    name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
    age = ET.SubElement(name2,"age")
    age.text = '19'
     
    et = ET.ElementTree(new_xml) #生成文档对象
    et.write("test.xml", encoding="utf-8",xml_declaration=True)
     
    ET.dump(new_xml) #打印生成的格式

    九、requests

    Requests 是使用 Apache2 Licensed 许可证的 基于Python开发的HTTP 库，其在Python内置模块的基础上进行了高度的封装，从而使得Pythoner进行网络请求时，变得美好了许多，使用Requests可以轻而易举的完成浏览器可有的任何操作。

    1、安装模块

    1
    pip3 install requests

    2、使用模块

    # 1、无参数实例
import requests
ret = requests.get('https://github.com/timeline.json')
print(ret.url)
print(ret.text)
 
# 2、有参数实例
import requests
payload = {'key1': 'value1', 'key2': 'value2'}
ret = requests.get("http://httpbin.org/get", params=payload)
print(ret.url)
print(ret.text)
    get请求
    # 1、基本POST实例
 
import requests
 
payload = {'key1': 'value1', 'key2': 'value2'}
ret = requests.post("http://httpbin.org/post", data=payload)
 
print(ret.text)
 
 
# 2、发送请求头和数据实例
 
import requests
import json
 
url = 'https://api.github.com/some/endpoint'
payload = {'some': 'data'}
headers = {'content-type': 'application/json'}
 
ret = requests.post(url, data=json.dumps(payload), headers=headers)
 
print(ret.text)
print(ret.cookies)
    POST请求

    3、Http请求和XML实例

    实例：检测QQ账号是否在线

    import requests
from xml.etree import ElementTree as ET

# 使用第三方模块requests发送HTTP请求，或者XML格式内容
r = requests.get('http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode=33456666')
result = r.text

# 解析XML格式内容
node = ET.XML(result)

# 获取内容
if node.text == "Y":
    print("在线")
else:
    print("离线")
    View Code

    注：更多接口猛击这里

    十、logging

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

    日志等级：

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

    1、输出到文件

    import logging

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

logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')
    将日志输出到文件方式1
    # 定义文件
file = logging.FileHandler('1.log', 'a')
fmt = logging.Formatter()
file.setFormatter(fmt)

# 定义日志
logger2 = logging.Logger('s2', level=logging.INFO)
logger2.addHandler(file)

# 写日志
logger2.debug('debug')
logger2.critical('critical')
    将日志输出到文件方式2

    logging.basicConfig函数各参数:
    filename: 指定日志文件名
    filemode: 和file函数意义相同，指定日志文件的打开模式，'w'或'a'
    format: 指定输出的格式和内容，format可以输出很多有用信息，如上例所示:
     %(levelno)s: 打印日志级别的数值
     %(levelname)s: 打印日志级别名称
     %(pathname)s: 打印当前执行程序的路径，其实就是sys.argv[0]
     %(filename)s: 打印当前执行程序名
     %(funcName)s: 打印日志的当前函数
     %(lineno)d: 打印日志的当前行号
     %(asctime)s: 打印日志的时间
     %(thread)d: 打印线程ID
     %(threadName)s: 打印线程名称
     %(process)d: 打印进程ID
     %(message)s: 打印日志信息
    datefmt: 指定时间格式，同time.strftime()
    level: 设置日志级别，默认为logging.WARNING
    stream: 指定将日志的输出流，可以指定输出到sys.stderr,sys.stdout或者文件，默认输出到sys.stderr，当stream和filename同时指定时，stream被忽略

    2、输出到屏幕

    import logging

logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')
    将日志打印到屏幕

    默认情况下，logging将日志打印到屏幕，日志级别为WARNING；
    日志级别大小关系为：CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET，当然也可以自己定义日志级别。

    3、同时输出到屏幕和文件

    # 输出到屏幕
console = logging.StreamHandler()
console.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(name)-12s: %(lineno)d %(levelname)-8s %(message)s')
console.setFormatter(formatter)

# 定义文件
file = logging.FileHandler('fyf.log', 'a', encoding='utf-8')
fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s")
file.setFormatter(fmt)

# 定义日志
logger1 = logging.Logger('s1', level=logging.DEBUG)  #全局日志级别
logger1.addHandler(file)
logger1.addHandler(console)

# 写日志
logger1.debug('debug')
logger1.critical('critical')
    同时输出到屏幕和文件

    十一、Subprocess模块 

    常用subprocess方法示例

    #执行命令，返回命令执行状态 ， 0 or 非0
>>> retcode = subprocess.call(["ls", "-l"])

#执行命令，如果命令结果为0，就正常返回，否则抛异常
>>> subprocess.check_call(["ls", "-l"])
0

#接收字符串格式命令，返回元组形式，第1个元素是执行状态，第2个是命令结果 
>>> subprocess.getstatusoutput('ls /bin/ls')
(0, '/bin/ls')

#接收字符串格式命令，并返回结果
>>> subprocess.getoutput('ls /bin/ls')
'/bin/ls'

#执行命令，并返回结果，注意是返回结果，不是打印，下例结果返回给res
>>> res=subprocess.check_output(['ls','-l'])
>>> res
b'total 0
drwxr-xr-x 12 alex staff 408 Nov 2 11:05 OldBoyCRM
'

#上面那些方法，底层都是封装的subprocess.Popen
poll()
Check if child process has terminated. Returns returncode

wait()
Wait for child process to terminate. Returns returncode attribute.


terminate() 杀掉所启动进程
communicate() 等待任务结束

stdin 标准输入

stdout 标准输出

stderr 标准错误

pid
The process ID of the child process.

#例子
>>> p = subprocess.Popen("df -h|grep disk",stdin=subprocess.PIPE,stdout=subprocess.PIPE,shell=True)
>>> p.stdout.read()
b'/dev/disk1 465Gi 64Gi 400Gi 14% 16901472 104938142 14% /
'

    十二、shutil

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

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

    1
    2
    3
    import shutil
     
    shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))

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

    1
    shutil.copyfile('f1.log', 'f2.log')

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

    1
    shutil.copymode('f1.log', 'f2.log')

    shutil.copystat(src, dst)
    仅拷贝状态的信息，包括：mode bits, atime, mtime, flags

    1
    shutil.copystat('f1.log', 'f2.log')

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

    1
    2
    3
    import shutil
     
    shutil.copy('f1.log', 'f2.log')

    shutil.copy2(src, dst)
    拷贝文件和状态信息

    1
    2
    3
    import shutil
     
    shutil.copy2('f1.log', 'f2.log')

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

    1
    2
    3
    import shutil
     
    shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
    		 
    import shutil

shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))

    shutil.rmtree(path[, ignore_errors[, onerror]])
    递归的去删除文件

    1
    2
    3
    import shutil
     
    shutil.rmtree('folder1')

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

    1
    2
    3
    import shutil
     
    shutil.move('folder1', 'folder3')

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

    创建压缩包并返回文件路径，例如：zip、tar

    创建压缩包并返回文件路径，例如：zip、tar

    • base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
      如：www                        =>保存至当前路径
      如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
    • format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
    • root_dir： 要压缩的文件夹路径（默认当前目录）
    • owner： 用户，默认当前用户
    • group： 组，默认当前组
    • logger： 用于记录日志，通常是logging.Logger对象
    1
    2
    3
    4
    5
    6
    7
    8
    #将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录
    import shutil
    ret = shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')
      
      
    #将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录
    import shutil
    ret = shutil.make_archive("/Users/wupeiqi/wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')

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

    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()
    zipfile解压缩
    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()
    tarfile解压缩

    十三、paramiko

     paramiko是一个用于做远程控制的模块，使用该模块可以对远程服务器进行命令或文件操作，值得一说的是，fabric和ansible内部的远程管理就是使用的paramiko来现实。

    十四、time

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

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

print(time.time())
print(time.mktime(time.localtime()))

print(time.gmtime())  # 可加时间戳参数
print(time.localtime())  # 可加时间戳参数
print(time.strptime('2014-11-11', '%Y-%m-%d'))

print(time.strftime('%Y-%m-%d %H:%M:%S'))  # 默认当前时间
print(time.strftime('%Y-%m-%d', time.localtime()))  # 默认当前时间
print(time.asctime())
print(time.asctime(time.localtime()))
print(time.ctime(time.time()))


import datetime
'''
datetime.date：表示日期的类。常用的属性有year, month, day
datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond
datetime.datetime：表示日期时间
datetime.timedelta：表示时间间隔，即两个时间点之间的长度
timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
strftime("%Y-%m-%d")
'''

print(datetime.datetime.now())
print(datetime.datetime.now() - datetime.timedelta(days=5))
    %y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
    时间日期格式化符号

    十五、shelve 模块

    shelve模块是一个简单的k,v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    import shelve
     
    d = shelve.open('shelve_test') #打开一个文件
     
    class Test(object):
        def __init__(self,n):
            self.n = n
     
     
    t = Test(123) 
    t2 = Test(123334)
     
    name = ["alex","rain","test"]
    d["test"] = name #持久化列表
    d["t1"] = t      #持久化类
    d["t2"] = t2
     
    d.close()
  • 相关阅读:
    day13 python学习 迭代器，生成器
    day12 python学习 装饰器
    day10 python学习 函数的嵌套命名空间作用域 三元运算 位置参数 默认参数 动态参数
    day11 python学习 函数的建立，返回值，参数
    day7 python学习
    2易错概念和点
    day8 python学习 集合 深浅拷贝
    1.易错概念和点
    python_基础算法
    css基础示例代码
  • 原文地址：https://www.cnblogs.com/fuyefeng/p/7087512.html
Copyright © 2020-2023  润新知