Python学习 - 常用模块(一)

目录

一. 常用模块 - time

二. 常用模块 - datetime

三. 常用模块 - random

四. 常用模块 - os

五. 常用模块 - sys

六. 常用模块 - shutil

七. 常用模块 - json & pickle & shelve

八. 常用模块 - xml

九. 常用模块 - configparser

 

一. 常用模块 - time

time.altzone # 函数返回格林威治西部的夏令时地区的偏移秒数. 如果该地区在格林威治东部会返回负值(如西欧, 包括英国). 对夏令时启用地区才能使用.

# Python 3.x
import time
print("time.altzone %d " % time.altzone)
# 以上实例输出结果为: 
time.altzone -32400

time.asctime([t])) # 函数接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"(2008年12月11日 周二18时07分14秒)的24个字符的字符串. 格式固定, 无法更改

• t -- 9个元素的元组或者通过函数 gmtime() 或 localtime() 返回的时间值.

# Python 3.x
import time
t = time.localtime()
print("time.asctime(t): %s " % time.asctime(t))
# 以上实例输出结果为: 
time.asctime(t): Tue Feb 17 09:42:58 2009

time.clock() # 函数以浮点数计算的秒数返回当前的CPU时间.
用来衡量不同程序的耗时, 比time.time()更有用.
这个需要注意, 在不同的系统上含义不同. 在UNIX系统上, 它返回的是"进程时间", 它是用秒表示的浮点数(时间戳). 而在WINDOWS中, 第一次调用, 返回的是进程运行的实际时间. 而第二次之后的调用是自第一次调用以后到现在的运行时间. (实际上是以WIN32上QueryPerformanceCounter()为基础, 它比毫秒表示更为精确)

# Python 3.x
import time

def procedure():
time.sleep(2.5)

# measure process time
t0 = time.clock()
procedure()
print(time.clock() - t0, "seconds process time")

# measure wall time
t0 = time.time()
procedure()
print(time.time() - t0, "seconds wall time")
# 以上实例输出结果为: 
0.0 seconds process time
2.50023603439 seconds wall time

time.ctime([ sec ])  # 函数把一个时间戳(按秒计算的浮点数)转化为time.asctime()的形式. 如果参数未给或者为None的时候, 将会默认time.time()为参数. 它的作用相当于 asctime(localtime(secs)).

• sec -- 要转换为字符串时间的秒数.

# Python 3.x
import time

print("time.ctime() : %s" % time.ctime())
# 以上实例输出结果为: 
time.ctime() : Tue Feb 17 10:00:18 2013

time.daylight #

time.get_clock_info()  #

time.gmtime([ sec ])  # 将一个时间戳转换为UTC时区(0时区)的struct_time, 可选的参数sec表示从1970-1-1以来的秒数. 其默认值为time.time(), 函数返回time.struct_time类型的对象. (struct_time是在time模块中定义的表示时间的对象).

• sec -- 转换为time.struct_time类型的对象的秒数.

# Python 3.x
import time

print("time.gmtime() : %s" % time.gmtime())
# 以上实例输出结果为: 
time.gmtime() : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=2, tm_min=55, tm_sec=45, tm_wday=3, tm_yday=98, tm_isdst=0)

time.localtime([ sec ])  # 类似gmtime(), 作用是格式化时间戳为本地的时间. 如果sec参数未输入, 则以当前时间为转换标准. DST (Daylight Savings Time) flag (-1, 0 or 1) 是否是夏令时.

• sec -- 转换为time.struct_time类型的对象的秒数.

# Python 3.x
import time

print("time.localtime() : %s" % time.localtime())
# 以上实例输出结果为: 
time.localtime() : time.struct_time(tm_year=2016, tm_mon=11, tm_mday=27, tm_hour=10, tm_min=26, tm_sec=5, tm_wday=6, tm_yday=332, tm_isdst=0)

time.mktime(t)  # 执行与gmtime(), localtime()相反的操作, 它接收struct_time对象作为参数, 返回用秒数来表示时间的浮点数.
如果输入的值不是一个合法的时间, 将触发 OverflowError 或 ValueError.

• t -- 结构化的时间或者完整的9位元组元素.

# Python 3.x
import time

t = (2009, 2, 17, 17, 3, 38, 1, 48, 0)
secs = time.mktime(t)
print("time.mktime(t) : %f" % secs)
print("asctime(localtime(secs)): %s" % time.asctime(time.localtime(secs)))
# 以上实例输出结果为: 
time.mktime(t) : 1234915418.000000
asctime(localtime(secs)): Tue Feb 17 17:03:38 2009

time.monotonic() #

time.perf_counter() #

time.process_time() #

time.sleep(t)  # 推迟调用线程的运行, 可通过参数secs指秒数, 表示进程挂起的时间.

• t -- 推迟执行的秒数.

# Python 3.x
import time

print("Start : %s" % time.ctime())
time.sleep( 5 )
print("End : %s" % time.ctime())
# 以上实例输出结果为: 
Start : Tue Feb 17 10:19:18 2013
End : Tue Feb 17 10:19:23 2013

time.strftime(format[, t]) # 接收以时间元组, 并返回以可读字符串表示的当地时间, 格式由参数format决定.

• format -- 格式字符串.
• t -- 可选的参数t是一个struct_time对象.

# Python 3.x
import time

t = (2009, 2, 17, 17, 3, 38, 1, 48, 0)
t = time.mktime(t)
print(time.strftime("%b %d %Y %H:%M:%S", time.gmtime(t)))
# 以上实例输出结果为: 
Feb 17 2009 09:03:38

time.strptime(string[, format])   # 根据指定的格式把一个时间字符串解析为时间元组.

• string -- 时间字符串.
• format -- 格式化字符串.

# Python 3.x
import time

struct_time = time.strptime("30 Nov 00", "%d %b %y")
print("returned tuple: %s " % struct_time)
# 以上实例输出结果为: 
returned tuple: (2000, 11, 30, 0, 0, 0, 3, 335, -1)

time.struct_time() #

time.time()  # 当前时间的时间戳(1970纪元后经过的浮点秒数).

# Python 3.x
import time

print("time.time(): %f " % time.time())
print(time.localtime( time.time() ))
print(time.asctime( time.localtime(time.time())))
# 以上实例输出结果为: 
time.time(): 1234892919.655932
(2009, 2, 17, 10, 48, 39, 1, 48, 0)
Tue Feb 17 10:48:39 2009

time.timezone #

time.tzname #

 

时间字符串与时间戳相关转换的关系图: 

 

 

二. 常用模块 - datetime

import datetime, time
print(datetime.datetime.now()) # 打印当前日期与时间
print(datetime.date.fromtimestamp(time.time())) # 时间戳转字符串, 2017-02-22 无法改变格式
print(datetime.datetime.now() + datetime.timedelta(3)) # 时间的加减 正数加 负数减 days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0
# 执行结果
2017-02-22 14:38:08.984240
2017-02-22
2017-02-25 14:38:08.984240

# 时间替换
c_time = datetime.datetime.now()
print(c_time)
print(c_time.replace(minute=3, hour=2))
# 执行结果
2017-02-22 14:37:06.500666
2017-02-22 02:03:06.500666

 

三. 常用模块 - random

random.randrange(start, stop[, step])  # 随机一个数字, 范围为[start:stop], step为步长值

# Python 3.x 
print(randdom.randrange(1, 10, 2))
print(randdom.randrange(1, 10, 2))
print(randdom.randrange(1, 10, 2))
# 
3
1
3

 

random.randint(a, b)  # 返回一个证书N 范围[a, b+1]

# Python 3.x 
import random
print(random.randint(1, 10))
print(random.randint(1, 10))
print(random.randint(1, 10))
# 
9
5
9

 

random.choice(seq)  # 接受一个序列, 随机返回其中一个元素, 如果序列为空抛出IndexError

# Python 3.x 
import random
seq = range(10)
print(random.choice(seq))
print(random.choice(seq))
seq = []
print(random.choice(seq))
#
2
8
Traceback (most recent call last):
File "times.py", line 7, in <module>
print(random.choice(seq))
File "C:\Python36\lib\random.py", line 257, in choice
raise IndexError('Cannot choose from an empty sequence')
IndexError: Cannot choose from an empty sequence

 

random.random()  # 返回0<=n<1之间的随机数

# Python 3.x 
import random
print(random.random())
print(random.random())
print(random.random())
#
0.12529181534548717
0.17046733942054138
0.44022267123668235

 

random.shuffle(x[, random]) # 洗牌序列, 将一个序列的顺序打乱

# Python 3.x 
import random
li = list(range(10))
random.shuffle(li)
print(li)
random.shuffle(li)
print(li)
random.shuffle(li)
print(li)
# 
[9, 6, 3, 7, 1, 8, 4, 2, 0, 5]
[6, 2, 0, 1, 5, 7, 8, 4, 9, 3]
[9, 4, 0, 8, 1, 7, 5, 3, 2, 6]

 

random.sample(seq, n)  # 从序列中随机取n个值

# Python 3.x 
import random
li = list(range(10))

print(random.sample(li, 2))
print(random.sample(li, 2))
print(random.sample(li, 2))
# 
[2, 1]
[7, 2]
[1, 7]

使用random模块实现随机验证码:

```python
# 随机验证码实现方法
import random
# 第一版
def authcode(n):
    checkcode = ""
    for i in range(4):
        current = random.randrange(0, 4)
        if current != i:
            temp = chr(random.randint(65, 90))
        else:
            temp = random.randint(0, 9)
        checkcode += str(temp)
    return checkcode
print(authcode(4))

# 第二版
import string
source = string.digits + string.ascii_uppercase + string.ascii_lowercase
print("".join(random.sample(source, 4)))

 

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

 

五. 常用模块 - sys

sys.argv           命令行参数List，第一个元素是程序本身路径
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]  获取标准输入, 等同于val = input("")

 

六. 常用模块 - shutil

shutil模块提供了大量的文件的高级操作. 特别针对文件拷贝和删除, 主要功能为目录和文件操作以及压缩操作. 对单个文件的操作也可参见os模块.

shutil 相关模块: os, zipfile, tarfile

shutil.copyfileobj(fsrc, fdst[,length])

def copyfileobj(fsrc, fdst, length=16*1024):
    """copy data from file-like object fsrc to file-like object fdst"""
    while 1:
        buf = fsrc.read(length)
        if not buf:
            break
        fdst.write(buf)

拷贝文件

• fsrc 原文件对象
• fdst 目标文件对象
• length 每次拷贝多少byte

shutil.copyfile(src, dst)

def copyfile(src, dst, *, follow_symlinks=True):
    """Copy data from src to dst.

    If follow_symlinks is not set and src is a symbolic link, a new
    symlink will be created instead of copying the file it points to.

    """
    if _samefile(src, dst):
        raise SameFileError("{!r} and {!r} are the same file".format(src, dst))

    for fn in [src, dst]:
        try:
            st = os.stat(fn)
        except OSError:
            # File most likely does not exist
            pass
        else:
            # XXX What about other special files? (sockets, devices...)
            if stat.S_ISFIFO(st.st_mode):
                raise SpecialFileError("`%s` is a named pipe" % fn)

    if not follow_symlinks and os.path.islink(src):
        os.symlink(os.readlink(src), dst)
    else:
        with open(src, 'rb') as fsrc:
            with open(dst, 'wb') as fdst:
                copyfileobj(fsrc, fdst)
    return dst

拷贝文件

• src 原文件路径
• dst 目标文件路径

shutil.copymode(src, dst)

def copymode(src, dst, *, follow_symlinks=True):
    """Copy mode bits from src to dst.

    If follow_symlinks is not set, symlinks aren't followed if and only
    if both `src` and `dst` are symlinks.  If `lchmod` isn't available
    (e.g. Linux) this method does nothing.

    """
    if not follow_symlinks and os.path.islink(src) and os.path.islink(dst):
        if hasattr(os, 'lchmod'):
            stat_func, chmod_func = os.lstat, os.lchmod
        else:
            return
    elif hasattr(os, 'chmod'):
        stat_func, chmod_func = os.stat, os.chmod
    else:
        return

    st = stat_func(src)
    chmod_func(dst, stat.S_IMODE(st.st_mode))

仅拷贝文件的权限, 目标文件与原文件必须存在

• src 原文件路径
• dst 目标文件路径

shutil.copystat(src, dst)

def copystat(src, dst, *, follow_symlinks=True):
    """Copy all stat info (mode bits, atime, mtime, flags) from src to dst.

    If the optional flag `follow_symlinks` is not set, symlinks aren't followed if and
    only if both `src` and `dst` are symlinks.

    """
    def _nop(*args, ns=None, follow_symlinks=None):
        pass

    # follow symlinks (aka don't not follow symlinks)
    follow = follow_symlinks or not (os.path.islink(src) and os.path.islink(dst))
    if follow:
        # use the real function if it exists
        def lookup(name):
            return getattr(os, name, _nop)
    else:
        # use the real function only if it exists
        # *and* it supports follow_symlinks
        def lookup(name):
            fn = getattr(os, name, _nop)
            if fn in os.supports_follow_symlinks:
                return fn
            return _nop

    st = lookup("stat")(src, follow_symlinks=follow)
    mode = stat.S_IMODE(st.st_mode)
    lookup("utime")(dst, ns=(st.st_atime_ns, st.st_mtime_ns),
        follow_symlinks=follow)
    try:
        lookup("chmod")(dst, mode, follow_symlinks=follow)
    except NotImplementedError:
        # if we got a NotImplementedError, it's because
        #   * follow_symlinks=False,
        #   * lchown() is unavailable, and
        #   * either
        #       * fchownat() is unavailable or
        #       * fchownat() doesn't implement AT_SYMLINK_NOFOLLOW.
        #         (it returned ENOSUP.)
        # therefore we're out of options--we simply cannot chown the
        # symlink.  give up, suppress the error.
        # (which is what shutil always did in this circumstance.)
        pass
    if hasattr(st, 'st_flags'):
        try:
            lookup("chflags")(dst, st.st_flags, follow_symlinks=follow)
        except OSError as why:
            for err in 'EOPNOTSUPP', 'ENOTSUP':
                if hasattr(errno, err) and why.errno == getattr(errno, err):
                    break
            else:
                raise
    _copyxattr(src, dst, follow_symlinks=follow)

仅拷贝 权限位(mode bits), 最后访问时间(atime), 最后修改时间(mtime), flags. 目标文件与原文件必须存在

• src 原文件路径
• dst 目标文件路径

 

shutil.copy(src, dst) # 对copyfile与copymode的封装

def copy(src, dst, *, follow_symlinks=True):
    """Copy data and mode bits ("cp src dst"). Return the file's destination.

    The destination may be a directory.

    If follow_symlinks is false, symlinks won't be followed. This
    resembles GNU's "cp -P src dst".

    If source and destination are the same file, a SameFileError will be
    raised.

    """
    if os.path.isdir(dst):
        dst = os.path.join(dst, os.path.basename(src))
    copyfile(src, dst, follow_symlinks=follow_symlinks)
    copymode(src, dst, follow_symlinks=follow_symlinks)
    return dst

先拷贝文件, 在拷贝权限

• src 原文件路径
• dst 目标文件路径

shutil.copy2(src, dst) # 对copyfile与copymode与copystat的封装

def copy2(src, dst, *, follow_symlinks=True):
    """Copy data and all stat info ("cp -p src dst"). Return the file's
    destination."

    The destination may be a directory.

    If follow_symlinks is false, symlinks won't be followed. This
    resembles GNU's "cp -P src dst".

    """
    if os.path.isdir(dst):
        dst = os.path.join(dst, os.path.basename(src))
    copyfile(src, dst, follow_symlinks=follow_symlinks)
    copystat(src, dst, follow_symlinks=follow_symlinks)
    return dst

内容, 权限, 状态都拷贝

• src 原文件路径
• dst 目标文件路径

 

shutil.ignore_patterns(*patterns)

为copytree的辅助函数, 创建过滤规则

 

shutil.copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2, ignore_dangling_symlinks=False)

def copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2,
             ignore_dangling_symlinks=False):
    """Recursively copy a directory tree.

    The destination directory must not already exist.
    If exception(s) occur, an Error is raised with a list of reasons.

    If the optional symlinks flag is true, symbolic links in the
    source tree result in symbolic links in the destination tree; if
    it is false, the contents of the files pointed to by symbolic
    links are copied. If the file pointed by the symlink doesn't
    exist, an exception will be added in the list of errors raised in
    an Error exception at the end of the copy process.

    You can set the optional ignore_dangling_symlinks flag to true if you
    want to silence this exception. Notice that this has no effect on
    platforms that don't support os.symlink.

    The optional ignore argument is a callable. If given, it
    is called with the `src` parameter, which is the directory
    being visited by copytree(), and `names` which is the list of
    `src` contents, as returned by os.listdir():

        callable(src, names) -> ignored_names

    Since copytree() is called recursively, the callable will be
    called once for each directory that is copied. It returns a
    list of names relative to the `src` directory that should
    not be copied.

    The optional copy_function argument is a callable that will be used
    to copy each file. It will be called with the source path and the
    destination path as arguments. By default, copy2() is used, but any
    function that supports the same signature (like copy()) can be used.

    """
    names = os.listdir(src)
    if ignore is not None:
        ignored_names = ignore(src, names)
    else:
        ignored_names = set()

    os.makedirs(dst)
    errors = []
    for name in names:
        if name in ignored_names:
            continue
        srcname = os.path.join(src, name)
        dstname = os.path.join(dst, name)
        try:
            if os.path.islink(srcname):
                linkto = os.readlink(srcname)
                if symlinks:
                    # We can't just leave it to `copy_function` because legacy
                    # code with a custom `copy_function` may rely on copytree
                    # doing the right thing.
                    os.symlink(linkto, dstname)
                    copystat(srcname, dstname, follow_symlinks=not symlinks)
                else:
                    # ignore dangling symlink if the flag is on
                    if not os.path.exists(linkto) and ignore_dangling_symlinks:
                        continue
                    # otherwise let the copy occurs. copy2 will raise an error
                    if os.path.isdir(srcname):
                        copytree(srcname, dstname, symlinks, ignore,
                                 copy_function)
                    else:
                        copy_function(srcname, dstname)
            elif os.path.isdir(srcname):
                copytree(srcname, dstname, symlinks, ignore, copy_function)
            else:
                # Will raise a SpecialFileError for unsupported file types
                copy_function(srcname, dstname)
        # catch the Error from the recursive copytree so that we can
        # continue with other files
        except Error as err:
            errors.extend(err.args[0])
        except OSError as why:
            errors.append((srcname, dstname, str(why)))
    try:
        copystat(src, dst)
    except OSError as why:
        # Copying file access times may fail on Windows
        if getattr(why, 'winerror', None) is None:
            errors.append((src, dst, str(why)))
    if errors:
        raise Error(errors)
    return dst

# version vulnerable to race conditions

递归的去拷贝文件夹

• src 原文件路径
• dst 目标文件路径
• symlinks # 待更新
• ignore 过滤条件
• copy_function 使用的copy函数
• ignore_dangling_symlinks 忽略连接文件

实例1:

import shutil
shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
#目标目录不能存在, 注意对folder2目录父级目录要有可写权限, ignore的意思是排除

实例2:

[root@slyoyo python_test]# tree copytree_test/
copytree_test/
└── test
    ├── test1
    ├── test2
    └── hahaha

[root@slyoyo test]# ls -l
total 0
-rw-r--r--. 1 python python 0 May 14 19:36 hahaha
-rw-r--r--. 1 python python 0 May 14 19:36 test1
-rw-r--r--. 1 root   root   0 May 14 19:36 test2

>>> shutil.copytree('copytree_test','copytree_copy')
'copytree_copy'

[root@slyoyo python_test]# ls -l
total 12
drwxr-xr-x. 3 root   root   4096 May 14 19:36 copytree_copy
drwxr-xr-x. 3 root   root   4096 May 14 19:36 copytree_test
-rw-r--r--. 1 python python   79 May 14 05:17 test1
-rw-r--r--. 1 root   root      0 May 14 19:10 test2
[root@slyoyo python_test]# tree copytree_copy/
copytree_copy/
└── test
    ├── hahaha
    ├── test1
    └── test2

 

rmtree(path, ignore_errors=False, onerror=None)

def rmtree(path, ignore_errors=False, onerror=None):
    """Recursively delete a directory tree.

    If ignore_errors is set, errors are ignored; otherwise, if onerror
    is set, it is called to handle the error with arguments (func,
    path, exc_info) where func is platform and implementation dependent;
    path is the argument to that function that caused it to fail; and
    exc_info is a tuple returned by sys.exc_info().  If ignore_errors
    is false and onerror is None, an exception is raised.

    """
    if ignore_errors:
        def onerror(*args):
            pass
    elif onerror is None:
        def onerror(*args):
            raise
    if _use_fd_functions:
        # While the unsafe rmtree works fine on bytes, the fd based does not.
        if isinstance(path, bytes):
            path = os.fsdecode(path)
        # Note: To guard against symlink races, we use the standard
        # lstat()/open()/fstat() trick.
        try:
            orig_st = os.lstat(path)
        except Exception:
            onerror(os.lstat, path, sys.exc_info())
            return
        try:
            fd = os.open(path, os.O_RDONLY)
        except Exception:
            onerror(os.lstat, path, sys.exc_info())
            return
        try:
            if os.path.samestat(orig_st, os.fstat(fd)):
                _rmtree_safe_fd(fd, path, onerror)
                try:
                    os.rmdir(path)
                except OSError:
                    onerror(os.rmdir, path, sys.exc_info())
            else:
                try:
                    # symlinks to directories are forbidden, see bug #1669
                    raise OSError("Cannot call rmtree on a symbolic link")
                except OSError:
                    onerror(os.path.islink, path, sys.exc_info())
        finally:
            os.close(fd)
    else:
        return _rmtree_unsafe(path, onerror)

# Allow introspection of whether or not the hardening against symlink
# attacks is supported on the current platform
rmtree.avoids_symlink_attacks = _use_fd_functions

递归的去删除文件

• path 目标路径
• ignore_errors 如果为True , 错误将被忽略
• onerror 处理错误的函数, 需支持(func, path, exc_info)参数

 

shutil.move(src,dst)

def move(src, dst):
    """Recursively move a file or directory to another location. This is
    similar to the Unix "mv" command. Return the file or directory's
    destination.

    If the destination is a directory or a symlink to a directory, the source
    is moved inside the directory. The destination path must not already
    exist.

    If the destination already exists but is not a directory, it may be
    overwritten depending on os.rename() semantics.

    If the destination is on our current filesystem, then rename() is used.
    Otherwise, src is copied to the destination and then removed. Symlinks are
    recreated under the new name if os.rename() fails because of cross
    filesystem renames.

    A lot more could be done here...  A look at a mv.c shows a lot of
    the issues this implementation glosses over.

    """
    real_dst = dst
    if os.path.isdir(dst):
        if _samefile(src, dst):
            # We might be on a case insensitive filesystem,
            # perform the rename anyway.
            os.rename(src, dst)
            return

        real_dst = os.path.join(dst, _basename(src))
        if os.path.exists(real_dst):
            raise Error("Destination path '%s' already exists" % real_dst)
    try:
        os.rename(src, real_dst)
    except OSError:
        if os.path.islink(src):
            linkto = os.readlink(src)
            os.symlink(linkto, real_dst)
            os.unlink(src)
        elif os.path.isdir(src):
            if _destinsrc(src, dst):
                raise Error("Cannot move a directory '%s' into itself '%s'." % (src, dst))
            copytree(src, real_dst, symlinks=True)
            rmtree(src)
        else:
            copy2(src, real_dst)
            os.unlink(src)
    return real_dst

递归的移动文件

 

shutil.make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,dry_run=0, owner=None, group=None, logger=None)

def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
                 dry_run=0, owner=None, group=None, logger=None):
    """Create an archive file (eg. zip or tar).

    'base_name' is the name of the file to create, minus any format-specific
    extension; 'format' is the archive format: one of "zip", "tar", "bztar"
    or "gztar".

    'root_dir' is a directory that will be the root directory of the
    archive; ie. we typically chdir into 'root_dir' before creating the
    archive.  'base_dir' is the directory where we start archiving from;
    ie. 'base_dir' will be the common prefix of all files and
    directories in the archive.  'root_dir' and 'base_dir' both default
    to the current directory.  Returns the name of the archive file.

    'owner' and 'group' are used when creating a tar archive. By default,
    uses the current owner and group.
    """
    save_cwd = os.getcwd()
    if root_dir is not None:
        if logger is not None:
            logger.debug("changing into '%s'", root_dir)
        base_name = os.path.abspath(base_name)
        if not dry_run:
            os.chdir(root_dir)

    if base_dir is None:
        base_dir = os.curdir

    kwargs = {'dry_run': dry_run, 'logger': logger}

    try:
        format_info = _ARCHIVE_FORMATS[format]
    except KeyError:
        raise ValueError("unknown archive format '%s'" % format)

    func = format_info[0]
    for arg, val in format_info[1]:
        kwargs[arg] = val

    if format != 'zip':
        kwargs['owner'] = owner
        kwargs['group'] = group

    try:
        filename = func(base_name, base_dir, **kwargs)
    finally:
        if root_dir is not None:
            if logger is not None:
                logger.debug("changing back to '%s'", save_cwd)
            os.chdir(save_cwd)

    return filename

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

• base_name： 压缩包的文件名, 也可以是压缩包的路径. 只是文件名时, 则保存至当前目录, 否则保存至指定路径,
• format： 压缩包种类, “zip”, “tar”, “bztar”, “gztar”
• root_dir： 要压缩的文件夹路径（默认当前目录）
• owner： 用户, 默认当前用户
• group： 组, 默认当前组
• logger： 用于记录日志, 通常是logging.Logger对象

实例:

# 将 /data 下的文件打包放置当前程序目录
import shutil
ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')

# 将 /data下的文件打包放置 /tmp/目录
import shutil
ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data')

七. 常用模块 - json & pickle & shelve

pickle，用于python特有的类型 和 python的数据类型间进行转换

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

# Python 3.x 
import pickle

data = {"1":1, "2":2, "3":3}
pickle_str = pickle.dumps(data)  # dumps 将python对象转成pickle格式的bytes类型
print(pickle_str)
# b'\x80\x03}q\x00(X\x01\x00\x00\x001q\x01K\x01X\x01\x00\x00\x002q\x02K\x02X\x01\x00\x00\x003q\x03K\x03u.'
python_ojb = pickle.loads(pickle_str)  # loads 将pickle格式的bytes类型转成python对象
print(python_ojb, type(python_ojb))
# {'1': 1, '2': 2, '3': 3} <class 'dict'>

with open("test.pkl", "wb") as f:  # dump 将python对象转成pickle格式的bytes类型并写入文件
    pickle.dump(data, f)

with open("test.pkl", "rb") as f:  # load 将文件读取出来的内容转成python对象
    python_ojb = pickle.load(f)
    print(python_ojb, type(python_ojb))
# {'1': 1, '2': 2, '3': 3} <class 'dict'>

 

json，用于字符串 和 python数据类型间进行转换

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

# Python 3.x 
import json

data = {1:1, 2:2, 3:3}
json_str = json.dumps(data)  # dumps 将python对象转成json格式的字符串
print(json_str)
# {"1": 1, "2": 2, "3": 3}
python_ojb = json.loads(json_str)  # loads 将json格式的字符串转成python对象
print(python_ojb, type(python_ojb))
# {'1': 1, '2': 2, '3': 3} <class 'dict'>

with open("test.pkl", "w") as f:  # dump 将python对象转成json格式的字符串并写入文件
    json.dump(data, f)

with open("test.pkl", "r") as f:  # load 将文件读取出来的json格式的字符串内容转成python对象
    python_ojb = json.load(f)
    print(python_ojb, type(python_ojb))
# {'1': 1, '2': 2, '3': 3} <class 'dict'>

仔细看的朋友会发现一个问题, 我的元数据key的类型是int, 但经过json转换后key的类型变成了str. 这是为啥啊.

这就与python对象和json对象之间转换的对应关系又关了. 请看下图:

 

shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型

import shelve
 
f = shelve.open(r'shelve.txt')
 
f['stu1_info']={'name':'alex','age':'18'}
f['stu2_info']={'name':'alvin','age':'20'}
f['school_info']={'website':'oldboyedu.com','city':'beijing'}

f.close()
 
print(f.get('stu_info')['age'])

注意, 通过shelve或pickle序列化 类 和 函数 的时候 只是序列化他的名称, 
如果需要在其他模块调用, 要么自己写一个同名的 函数 或 类, 要么导入之前的模块

八. 常用模块 - xml

import xml.etree.ElementTree as xml  # 导入模块 设置别名 xml

tree = xml.parse("test.xml")  # 解析xml文档
root = tree.getroot()  # 获取根对象
print(root.tag)  # 打印根标签

# 遍历整个xml文档, 根据具体xml文档有所变化
for child in root:
    print(child.tag, child.attrib)  # 打印第二层标签, 属性

    for i in child:
        print(i.tag, i.text, i.attrib)  # 打印第三层标签, 值, 属性

# 只遍历指定xml节点
for node in root.iter("year"):  # 全文搜索year标签的内容
    print(node.tag, node.text, node.attrib)

# 修改xml内容
for node in root.iter("year"):
    new_year = int(node.text) + 1
    node.text = str(new_year)  # 修改值
    node.set("updated", "yes")  # 加属性
tree.write("test2.xml")  # 将内存中新的xml数据写入文件

# 删除xml内容
for country in root.findall("country"):  # 找到当前层所有的country标签
    print(country)
    rank = int(country.find("rank").text)
    if rank > 50: root.remove(country)  # 删除标签
tree.write("test3.xml", encoding="utf-8")

# 创建xml文档
new_xml = xml.Element("namelist")  # 生成一个根节点
name = xml.SubElement(new_xml, "name",
                      attrib={"testenrolled": "asdfb"})  # 生成一个子节点, 第一个参数为子节点的父节点, 第二个参数是子节点的名称, 第三个参数是子节点的属性
age = xml.SubElement(name, "age", attrib={"checked": "no"})
sex = xml.SubElement(name, "sex")
sex.text = '33'  # 设置 sex 子节点的值
name2 = xml.SubElement(new_xml, "name", attrib={"enrolled": "no"})
age = xml.SubElement(name2, "age")
age.text = '19'  # 设置 age 子节点的值

et = xml.ElementTree(new_xml)  # 生成文档对象
et.write("namelist.xml", encoding="utf-8", xml_declaration=True)  # 将生成的xml对象写入文件, xml_declaration 为True会自动添加xml版本的头信息
xml.dump(new_xml)  # 打印生成的格式

 

九. 常用模块 - configparser

用configparser生成配置文件
import configparser  # Python 2.7上 是Configparser
config = configparser.ConfigParser()  # 获取配置对象
config["DEFAULT"] = {'abc':45,'cdf': 'yes','coasdf': '0'}  # 为default添加配置属性
config["bitbucket.org"] = {}  # 创建bitbucket.org配置块, 暂无配置属性
config["bitbucket.org"]["asdf"] = "aweasdf"  # 为bitbucket.org配置块添加一条配置属性

config["server.com"] = {}  # 创建server.com配置块, 暂无配置属性
server = config["server.com"]  # 获取server.com配置块字典
server["Host"] = "123"  # 通过字典形式添加属性
server["Port"] = "80"
with open("example.conf", 'w') as f:
    config.write(f)  # 将配置写入文件

# 用configparser 解析配置文件
conf = configparser.ConfigParser()  # 获取配置对象
conf.read("example.conf")  # 打开配置文件
print(conf.sections())  # 看配置文件有几个配置块, DEFAULT不显示
default = conf["DEFAULT"]  # 获取default配置块字典
print(list(default.keys()), type(default))
# 增删改 就是字典的操作, 这里不再细说, 做了修改最后保存到文件中.