pydu 文档

介绍

pydu （python data structures and utils —— python 数据结构和工具）是一个面向Python 2和3的库。它收集自开源项目，也由贡献者创建。

它支持Python 2.7 到 3.6。

内容

Archive 存档

提供归档相关工具，如解压。

pydu.archive.extract(path, to_path='', ext='')

解压tar或zip文件，可指定 to_path 解压到特定目录。它支持很多文件格式，包括 .tar、.tar.bz2、.tar.gz、.tgz、.tz2、.zip。如果给定的 path 不包含文件格式，则可指定 ext 参数来说明文件格式。

>>> from pydu.archive import extract
>>> extract('foobar.tgz', '/tmp')
>>> extract('foobar', '/tmp', ext='.tgz')
>>> extract('foobar', '/tmp')
Traceback (most recent call last):
 ...    AttributeError: pydu.archive.UnrecognizedArchiveFormat: Path not a recognized archive format: foobar

Cmd 命令

提供运行命令和获取命令行等工具。

class pydu.cmd.TimeoutExpired(cmd, timeout, output=None, stderr=None)

该异常在等待子进程超时时抛出。

属性：

cmd, output, stdout, stderr, timeout

pydu.cmd.run(cmd, shell=False, env=None, timeout=None, timeinterval=1)

Run 命令基于 subprocess.Popen ，并返回 (returncode, stdout) 的这样元组。

注意，``stderr` 被重定向到了 stdout。shell` 同 Popen 中的参数一样。

如果在 timeout 秒后进程没有退出，将会抛出 TimeoutExpired 异常。timeinterval 在Python 2中给定 timeout时生效。它表示进程状态检查时间间隔。

如果超时了，子进程不会被杀掉。为了合理清除表现良好的应用，应该要杀掉子进程，并且结束通信。

>>> from pydu.cmd import run
>>> run('echo hello')
(0, b'hello\r\n')  # Python 3

pydu.cmd.run_with_en_env(cmd, shell=False, env=None, timeout=None, timeinterval=1)

在英文字符集环境下运行命令，从而得到英文输出。参数同 run。

pydu.cmd.terminate(pid)

根据给定 pid 终止进程。

在Windows上，使用 kernel32.TerminateProcess 来终止。在其他平台上，使用携带 signal.SIGTERM 信号的 os.kill 来终止。

pydu.cmd.cmdline_argv()

获取当前Python进程的命令行参数。在Windows上使用Python 2时， cmdline_argv 的实现是基于 shell32.GetCommandLineArgvW 获取列表元素为Unicode字符串形式的sys.argv。

而在其他平台或者是使用Python 3时， cmdline_argv 和 sys.argv 相同。

>>> from pydu.cmd import cmdline_argv
>>> cmdline_argv()
['/Applications/PyCharm.app/Contents/helpers/pydev/pydevconsole.py', '61253', '61254']

Compat 兼容性

提供Python 2和3兼容的数据结构、库和函数。

pydu.compat.PY2

判断当前Python解释器是Python 2还是3。

pydu.compat.urlib(base, url, allow_fragments=True)

在PY2中是 urlparse.urljoin，在PY3中是 urllib.parse.urljoin。

pydu.compat.urlparse(base, url, allow_fragments=True)

在PY2中是 urlparse.urljoin，在PY3中是 urllib.parse.urljoin。

pydu.compat.urljoin(base, url, allow_fragments=True)

在PY2中是 urlparse.urljoin，在PY3中是 urllib.parse.urljoin。

pydu.compat.iterkeys(d)

返回字典键的iter对象。

pydu.compat.itervalues(d)

返回字典值的iter对象。

pydu.compat.iteritems(d)

返回字典键值对的iter对象。

pydu.compat.text_type

text类型在PY2中是 unicode，在PY3中是 str。

pydu.compat.string_types

string类型在PY2中是 (str, unicode)，在PY3中是 (str,)。

pydu.compat.strbytes_types

strbytes（string bytes）类型在PY2中是 (str, unicode, bytes)，在PY3中是 (str, bytes)。

pydu.compat.numeric_types

在PY2中是 (int, long)，在PY3中是 (int,)。

pydu.compat.imap(function, sequence, *sequence_1)

在PY2中是 itertools.imap，在PY3中是 map。

pydu.compat.reduce(function, sequence, initial=None)

在PY2中是内建 reduce，在PY3中是 functools.reduce。

pydu.compat.cmp(x, y)

Same to cmp on PY2, but implement on PY3.

pydu.compat.has_next_attr(x)

检查是否是可迭代的。

pydu.compat.is_iterable(x)

检查是否是可迭代的。

>>> from pydu.compat import is_iterable
>>> is_iterable([])
True
>>> is_iterable(1)
False

Console 控制台

提供处理控制台的工具。

pydu.console.console_size(fallback=(80, 25))

对于Windows系统，返回可用窗口区域的(width, height)。如果没有控制台，则返回fallback。对于POSIX系统，返回控制终端的(width, height)。如果遇到IOError，比如没有控制台，返回fallback。对于其他系统，返回fallback。Fallback默认为(80, 25)，这是大多数终端模拟器的默认大小。

>>> from pydu.console import console_size
>>> console_size()
(80, 25)

Convert 转换

提供将一类数据转换为另一类的工具。

pydu.convert.boolean(obj)

将对象转换为布尔值。

如果对象是字符串，将会以不区分大小写的形式转换：

• 将 yes、 y、 on、 true、 t、 1 转换为True
• 将 no、 n、 off、 false、 f、 0 转换为False
• 如果传入其他值，抛出TypeError

如果对象不是字符串，将会使用 bool(obj) 转换。

>>> from pydu.string import boolean
>>> boolean('yes')
True
>>> boolean('no')
False

pydu.convert.bin2oct(x)

把二进制字符串转换为八进制字符串。比如：'1001' -> '11'

>>> from pydu.convert import bin2oct
>>> bin2oct('1001')
'11'

pydu.convert.bin2dec(x)

把二进制字符串转换为十进制数字。比如：'11' -> 3

>>> from pydu.convert import bin2dec
>>> bin2dec('11')
3

pydu.convert.bin2hex(x)

把二进制字符串转换为十六进制字符串。比如：'11010' -> '1a'

>>> from pydu.convert import bin2hex
>>> bin2hex('11010')
'1a'

pydu.convert.oct2bin(x)

把八进制字符串转换为二进制字符串。比如：'11' -> '1001'

>>> from pydu.convert import oct2bin
>>> oct2bin('11')
'1001'

pydu.convert.oct2dec(x)

把八进制字符串转换为十进制数字。比如：'11' -> 9

>>> from pydu.convert import oct2dec
>>> oct2dec('11')
9

pydu.convert.oct2hex(x)

把八进制字符串转换为十六进制字符串。比如：'32' -> '1a'

>>> from pydu.convert import oct2hex
>>> oct2hex('32')
'1a'

pydu.convert.dec2bin(x)

把十进制数字转换为二进制字符串。比如：3 -> '11'

>>> from pydu.convert import dec2bin
>>> dec2bin(3)
'11'

pydu.convert.dec2oct(x)

把十进制数字转换为八进制字符串。比如：9 -> '11'

>>> from pydu.convert import dec2oct
>>> dec2oct(9)
'11'

pydu.convert.dec2hex(x)

把十进制数字转换为十六进制字符串。比如：26 -> '1a'

>>> from pydu.convert import dec2hex
>>> dec2hex(26)
'1a'

pydu.convert.hex2bin(x)

把十六进制字符串转换为二进制字符串。比如：'1a' -> '11010'

>>> from pydu.convert import hex2bin
>>> hex2bin('1a')
'11010'

pydu.convert.hex2oct(x)

把十六进制字符串转换为八进制字符串。比如：'1a' -> '32'

>>> from pydu.convert import hex2oct
>>> hex2oct('1a')
'32'

pydu.convert.hex2dec(x)

把十六进制字符串转换为十进制数字。比如：'1a' -> 26

>>> from pydu.convert import hex2dec
>>> hex2dec('1a')
26

Dict 字典

额外的强大的字典和相关函数。

class pydu.dict.AttrDict(seq=None, **kwargs)

AttrDict 对象类似于字典，除了能使用 obj['foo']，还能使用 obj.foo。

>>> from pydu.dict import AttrDict
>>> o = AttrDict(a=1)
o.a
1
>>> o['a']
1
>>> o.a = 2
>>> o['a']
2
>>> del o.a
>>> o.a
Traceback (most recent call last):
 ...    AttributeError: 'a'

class pydu.dict.CaseInsensitiveDict(data=None, **kwargs)

大小写不敏感类 字典 对象。实现了 collections.MutableMapping 的所有方法和操作，也实现了字典的 copy，此外还提供 lower_items。所有的键都应是字符串。内部结构会记住最后一次被设置的键的大小写，iter(instance)、keys()、items()、iterkeys() 和 iteritems() 将会包含大小写敏感的键。

>>> from pydu.dict import CaseInsensitiveDict
>>> cid = CaseInsensitiveDict()
>>> cid['Accept'] = 'application/json'
>>> cid['aCCEPT'] == 'application/json'
True
>>> list(cid) == ['Accept']
True

class pydu.dict.LookupDict(name=None)

字典查找对象

>>> from pydu.dict import LookupDict
>>> d = LookupDict()
>>> d['key']
None
>>> d['key'] = 1
>>> d['key']
1

class pydu.dict.OrderedDefaultDict(default_factory=None, *args, **kwds)

记住插入顺序且能根据默认工厂提供默认值的字典。

当key不存在（仅限通过 __getitem__ 中）时，无参数调用默认工厂来产生新值。OrderedDefaultDict 和 collections.defaultdict 在比较时是等同的。所有剩余参数和传入 defaultdict 构造器中的相同，包括关键字参数。

>>> from pydu.dict import OrderedDefaultDict
>>> d = OrderedDefaultDict(int)
>>> d['b']
0
>>> d['a']
0
>>> d.keys()
odict_keys(['b', 'a'])

pydu.dict.attrify(obj)

将对象属性化为 AttriDict 或 包含 AttriDict 的列表（如果对象为列表）。如果对象或对象中的元素不是列表或字典，将会返回其本身。

>>> from pydu.dict import attrify
>>> attrd = attrify({
    'a': [1, 2, {'b': 'b'}],
    'c': 'c',
})
>>> attrd
<AttrDict {'a': [1, 2, <AttrDict {'b': 'b'}>], 'c': 'c'}>
>>> attrd.a
1
>>> attrd.a[2].b
b
>>> attrd.c
c

Environ 环境

提供处理环境相关内容的工具。

pydu.environ.environ(**kwargs)

更新一个或多个环境变量的上下文管理器。

保存先前的环境变量（如果有），并在退出上下文管理器时还原。

如果给定 variable_name=None，表示从环境变量中临时移除该变量。

>>> from pydu.environ import environ
>>> with environ(a='a'):
...     print(os.environ['a'])
...
a

pydu.environ.path(append=None, prepend=None, replace=None)

更新PATH环境变量的上下文管理器。可将给定的字符串或字符串列表，插入在PATH的开头和末尾，也可替换PATH。

>>> import os
>>> from pydu.environ import path
>>> with path(append='/foo'):
...     print(os.environ['PATH'])
...
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/foo

Exception 异常

提供处理异常的工具。

pydu.exception.ignore(*exceptions)

忽略给定异常的上下文管理器

>>> from pydu.exception import ignore
>>> with ignore(ValueError, AttributeError):
...     int('abc')
...     int.no_exists_func()
...
>>>

Functional 函数式

提供函数式编程的工具。

pydu.functional.compose(*funcs)

组成所有函数。前一个函数必须接受一个参数，该参数为后一个函数的输出值。最后一个函数可以接受任意位置参数和关键字参数。

compose(f1, f2, f3)(*x) 和 f1(f2(f3(*x))) 一样。

>>> from pydu.functional import compose
>>> def f1(a):
...     return a+1
...
>>> def f2(a, b=2):
...     return a+b
...
>>> compose(f1, f2)(1, b=3)
5

Inspect 检查

提供函数参数检查的工具。

pydu.inspect.getargspec(func)

获得函数参数的名称和默认值。

返回由四个字符串组成的元组：(args, vargs, varkw, defaults)。 args 是参数名称的列表（可能包含嵌套列表）。 varargs 和 varkw 是 * 和 ** 参数的名称，或者为 None。 defaults 是最后n个参数的默认值组成的元组。

>>> from pydu.inspect import getargspec
>>> def f(name, address='home', age=25, *args, **kwargs):
...     pass
...
>>> getargspect(f)
ArgSpec(args=['name', 'address', 'age'], varargs='args', keywords='kwargs', defaults=('home', 25))

pydu.inspect.get_func_args(func)

返回参数名称的列表。诸如 *args 和 *kwargs 的参数不被包含。

>>> from pydu.inspect import get_func_args
>>> def f(name, address='home', age=25, *args, **kwargs):
...     pass
...
>>> get_func_args(f)
['name', 'address', 'age']

pydu.inspect.get_func_full_args(func)

返回(参数名称, 默认值)元组的列表。如果参数没有默认值，则在元组中丢弃。诸如 *args 和 *kwargs 的参数也被包含在内。

>>> from pydu.inspect import get_func_full_args
>>> def f(name, address='home', age=25, *args, **kwargs):
...     pass
...
>>> get_func_full_args(f)
[('name',), ('address', 'home'), ('age', 25), ('*args',), ('**kwargs',)]

pydu.inspect.func_accepts_kwargs(func)

检查函数是否接受关键字参数。

>>> from pydu.inspect import func_accepts_kwargs
>>> def f(**kwargs):
...     pass
...
>>> func_accepts_kwargs(f)
True

pydu.inspect.func_accepts_var_args(func)

检查函数是否接受位置参数。

>>> from pydu.inspect import func_accepts_var_args
>>> def f(*vargs):
...     pass
...
>>> func_accepts_var_args(f)
True

pydu.inspect.func_supports_parameter(func)

检查函数是否接受给定参数。

>>> from pydu.inspect import func_supports_parameter
>>> def f(name):
...     pass
...
>>> func_supports_parameter(f, 'name')
True
>>> func_supports_parameter(f, 'unkown')
Fasle

pydu.inspect.func_has_no_args(func)

检查函数是否接受任意参数。

>>> from pydu.inspect import func_has_no_args
>>> def f():
...     pass
...
>>> func_has_no_args(f)
True

Iter 迭代

提供处理迭代对象的工具。

pydu.iter.first(iterable)

获取可迭代对象的第一个项。

>>> from pydu.iter import first
>>> first([1, 2])
1

pydu.iter.last(iterable)

获取可迭代对象的最后一个项。注意，由于逐步迭代到最后一项，这可能会较慢。

>>> from pydu.iter import last
>>> last([1, 2])
2

pydu.iter.all(iterable, predicate)

如果给定可迭代对象的所有元素套用判定函数都是True，则返回True。

>>> from pydu.iter import all
>>> all([0, 1, 2], lambda x: x+1)
True

pydu.iter.any(iterable)

如果给定可迭代对象的任一元素套用判定函数是True，则返回True。

>>> from pydu.iter import any
>>> any([-1, -1, 0], lambda x: x+1)
True

pydu.iter.join(iterable, separator='')

将可迭代对象中的每一项连接为字符串。

>>> from pydu.iter import join
>>> join([1, '2', 3], separator=',')
'1,2,3'

List 列表

提供处理列表的工具。

pydu.list.uniq(seq, key=None)

从列表中删除重复的元素，同时保留其余的顺序。

可选参数 key 的值应该是一个函数，它接受一个参数并返回一个 key 来测试唯一性。

>>> from pydu.list import uniq
>>> uniq([1, 4, 0, 2, 0, 3])
[1, 4, 0, 2, 3]

pydu.list.tolist(obj)

将给定的 obj 转换为列表。

如果 obj 不是列表，返回 [obj]，否则返回 obj 本身。

>>> from pydu.list import tolist
>>> tolist('foo')
['foo']

pydu.list.flatten(seq)

生成给定 seq 中的每个元素。如果元素是可迭代的并且不是字符串，就递归yield元素中的每个子元素。

>>> from pydu.list import flatten
>>> flatten([1, [2, [3, 4]]])
[1, 2, 3, 4]

Miscellanea 综合

提供诸如 timeout、 trace 等综合性工具。

pydu.misc.timeout(seconds)

This func decorates any func which may be hang for a while. The param seconds can be either integer or float. In test.py, you may write like below:

import time
from pydu.misc import unix_timeout
@timeout(1)
def f():
    time.sleep(1.01)
f()

然后运行 test.py，将会看到 TimeoutError。

pydu.misc.trace(obj)

跟踪运行中程序的每条语句和行号，就像 bash -x 。在 test.py 中，你可以这么写：

from pydu.misc import trace
@trace
def f():
    print(1)
    a = 1 + 5
    b = [a]
    print(2)
f()

然后运行 test.py，将会看到如下控制台输出：

test.py(4):     print(1)
1
test.py(5):     a = 1 + 5
test.py(6):     b = [a]
test.py(7):     print(2)
2

pydu.misc.memoize(obj)

简单的缓存装饰器，可供支持可哈希的位置参数的函数使用。它还提供 cache_clear() 方法来清除缓存。

>>> @memoize
... def foo()
...     return 1
    ...
>>> foo()
1
>>> foo.cache_clear()
>>>

pydu.misc.memoize_when_activated(obj)

缓存装饰器，默认禁用。它能根据需求启用和禁用。为效率起见，它只能用于没有参数的类方法。

>>> class Foo:
...     @memoize
...     def foo()
...         print(1)
...
>>> f = Foo()
>>> # deactivated (default)
>>> foo()
1
>>> foo()
1
>>>
>>> # activated
>>> foo.cache_activate()
>>> foo()
1
>>> foo()
>>> foo()
>>>

pydu.misc.super_len(obj)

获取具有 __len__ ， len ， fileno ， tell 等属性的对的长度，比如： list ， tuple ， dict， file 等等。

>>> from pydu.misc import super_len
>>> super_len([1, 2])
2
>>> super_len(open('test', 'w'))
0

Network 网络

提供处理网络的工具。

pydu.network.dotted_netmask(mask)

将mask从 /xx 转化为 xxx.xxx.xxx.xxx 形式。 mask 可以是 int 或者 str。

>>> from pydu.network import dotted_netmask
>>> dotted_netmask('24')
'255.255.255.0'
>>> dotted_netmask(24)
'255.255.255.0'

pydu.network.private_ipv4s

ipv4地址列表。每个项是（ipv4地址，掩码）这样的元组。

pydu.network.is_ipv4(ip)

判断给定的 ip 是否为 IPV4。

>>> from pydu.network import is_ipv4
>>> is_ipv4('8.8.8.8')
True
>>> is_ipv4('localhost.localdomain')
False

pydu.network.is_ipv6(ip)

判断给定的 ip 是否为 IPV6。

>>> from pydu.network import is_ipv6
>>> is_ipv6('fe80::9e5b:b149:e187:1a18')
True
>>> is_ipv6('localhost.localdomain')
False

pydu.network.get_free_port()

获取可以绑定的空闲端口

>>> from pydu.network import get_free_port
>>> get_free_port()
57118

pydu.network.ip2int(ip_str)

将IP转换为整数。支持IPV4和IPV6。如果转换失败，将会抛出 ValueError。

>>> from pydu.network import ip2int
>>> ip2int('10.1.1.1')
167837953

pydu.network.int2ip(ip_int)

将整数转换为IP。支持IPV4和IPV6。如果转换失败，将会抛出 ValueError。

>>> from pydu.network import int2ip
>>> int2ip(167837953)
'10.1.1.1'

Path 路径

提供处理路径的工具。

pydu.path.cd(path)

进入到给定目录的上下文管理器。

>>> from pydu.path import cd
>>> with cd('test'):
...     pass

pydu.path.is_super_path(path1, path2)

判断 path1 是否是 path2 的父路径（或父父路径等）。注意如果 path1 和 path2 一样，它也被视作是 path2 的父路径。

比如，"/"、"opt"或者"/opt/test"是"/opt/test"的超级父路径，而"/opt/t"则不是。

>>> from pydu.path import is_super_path
>>> is_super_path('/aa/bb/cc', '/aa/bb/cc')
True
>>> is_super_path('/aa/bb', '/aa/bb/cc')
True
>>> is_super_path('/aa/b', '/aa/bb/cc')
False

Platform 平台

表示特定平台的常量。

pydu.platform.WINDOWS

判断当前操作系统是否为 WINDOWS 。

pydu.platform.LINUX

判断当前操作系统是否为 LINUX 。

pydu.platform.POSIX

判断当前操作系统是否为 POSIX 。

pydu.platform.DARWIN

判断当前操作系统是否为 DARWIN 。

pydu.platform.SUNOS

判断当前操作系统是否为 SUNOS 。

pydu.platform.SMARTOS

判断当前操作系统是否为 SMARTOS 。

pydu.platform.FREEBSD

判断当前操作系统是否为 FREEBSD 。

pydu.platform.NETBSD

判断当前操作系统是否为 NETBSD 。

pydu.platform.OPENBSD

判断当前操作系统是否为 OPENBSD 。

pydu.platform.AIX

判断当前操作系统是否为 AIX 。

Process 进程

提供处理进程的工具。

注解

pydu.process 的实现基于 psutil。需要先 pip install psutil。

pydu.process.get_processes_by_path(path)

获取占用给定路径或者其子路径的进程。

>>> from pydu.process import get_processes_by_path
>>> get_processes_by_path('/usr/bin/python')
[{'cmdline': '/usr/bin/python2.7', 'pid': 23383, 'name': 'python'}]

Request 请求

提供处理请求的工具。

class pydu.request.Filename

提供各类获取文件名的方法

static from_url(url)

检测文件名为 unicode 或 None。

static from_headers(headers)

从响应头的Content-Disposition（如果有）中获取文件名。 headers 可以使字典、列表或者字符串。

static from_any(dst=None, headers=None, url=None)

从目录，响应头部或者路径获取文件名称

pydu.request.download(url, dst=None)

将URL下载到当前目录的临时文件中，然后重命名为从URL或者HTTP头中自动检测出的文件名。url 是要下载的URL地址。 dst 是文件名或目录的目标路径，默认为 None，表示下载到当前目录。

pydu.request.check_connect(ip, port, retry=1, timeout=0.5)

在给定的 timeout 时间内尝试连接给定的 ip 和 port 。

>>> from pydu.request import check_connect
>>> check_connect('http://www.baidu.com', 80)
'192.168.3.8'
>>>

Set 集合

额外的强大的集合。

class pydu.set.OrderedSet(iterable=None)

保持插入元素有序的集合。

>>> from pydu.set import OrderedSet
>>> s = OrderedSet([1, 3, 1, 2])
>>> list(s)
[1, 3, 2]
>>> s.discard(3)
>>> list(s)
[1, 2]

String 字符串

提供处理字符串的工具。

pydu.string.safeunicode(obj, encoding='utf-8')

将任何对象转换为 unicode 字符串。

>>> from pydu.string import safeunicode
>>> safeunicode('hello')
u'hello'
>>> safeunicode(2)
u'2'
>>> safeunicode('\xe4\xb8\xad\xe6\x96\x87')
u'中文'

pydu.string.safeencode(obj, encoding='utf-8')

将任何对象转换为编码后字符串（默认为 utf-8）。

>>> from pydu.string import safeencode
>>> safeencode('hello')
'hello'
>>> safeencode(2)
'2'
>>> safeencode(u'中文')
'\xe4\xb8\xad\xe6\x96\x87'

pydu.string.lstrips(text, remove)

移除字符串 text 左侧的 remove。

>>> from pydu.string import lstrips
>>> lstrips('foobar', 'foo')
'bar'
>>> lstrips('FOOBARBAZ', ['FOO', 'BAR'])
'BAZ'
>>> lstrips('FOOBARBAZ', ['BAR', 'FOO'])
'BARBAZ'

pydu.string.rstrips(text, remove)

移除字符串 text 右侧的 remove。

>>> from pydu.string import rstrips
>>> rstrips('foobar', 'bar')
'foo'

pydu.string.strips(text, remove)

移除字符串 text 两边的 remove。

>>> from pydu.string import strips
>>> strips('foobarfoo', 'foo')
'bar'

pydu.string.common_prefix(l)

返回字符串的共有前缀。

>>> from pydu.string import common_prefix
>>> common_prefix(['abcd', 'abc1'])
'abc'

pydu.string.common_suffix(l)

返回字符串的共有后缀

>>> from pydu.string import common_suffix
>>> common_suffix(['dabc', '1abc'])
'abc'

pydu.string.sort(s, reversed=False)

对给定的字符串进行排序，默认是升序，如果 reverse 的值为 True，将以降序排序。

>>> from pydu.string import sort
>>> sort('dabc')
'abcd'

System 系统

提供处理系统（如追踪文件、创建目录、链接等）的工具。

class pydu.system.FileTracker

跟踪当前打开的文件，调用 FileTracker.track() 开始跟踪。当打开许多文件时，FileTracker 能够跟踪它们，你可以通过调用 FileTracker.get_openfiles() 来定位得到这些文件对象。

static track()

开始跟踪打开文件。

static untrack()

停止跟踪打开文件。

static get_openfiles()

获取当前已打开的文件。

>>> from pydu.system import FileTracker
>>> FileTracker.track()
>>> f = open('test', 'w')
>>> FileTracker.get_openfiles()
{<_io.TextIOWrapper name='test' mode='w' encoding='UTF-8'>}
>>> f.close()
>>> FileTracker.get_openfiles()
set()
>>> FileTracker.untrack()
>>> f = open('test', 'w')
>>> FileTracker.get_openfiles()
set()

pydu.system.makedirs(path, mode=0o755, ignore_errors=False, exist_ok=False)

makedirs 基于 os.makedirs ，它会创建目标文件夹，以及中间文件夹（当中间文件夹不存在的时候）。 mode 默认值为 0o75 ， 当被创建的文件夹已经存在的时候， 如果 eist_ok 的值为 False ， makedirs 将会抛出异常。 如果 ignore_errors 的值为 True ， 所有的异常将会被忽略。

>>> from pydu.system import makedirs
>>> makedirs('test1/test2')
>>> makedirs('test1',exist_ok=True)
>>> makedirs('test1')
Traceback (most recent call last):
 ...    OSError: Create dir: test1 error.

pydu.system.remove(path, mode=0o755, ignore_errors=False, onerror)

删除文件或者文件夹。

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, it attempts to set path as writeable and then proceed with deletion if path is read-only, or raise an exception if path is not read-only.

>>> from pydu.system import makedirs
>>> from pydu.system import remove
>>> from pydu.system import touch
>>> makedirs('test')
>>> remove('test')
>>> touch('test.txt')
>>> remove('test.txt')
>>> remove('test.txt', ignore_errors=True)
>>> remove('test.txt')
Traceback (most recent call last):
 ...    OSError: Remove path: test error. Reason: [Errno 2] No such file or directory: 'test.txt'

pydu.system.removes(paths, mode=0o755, ignore_errors=False, onerror)

删除多个文件或者（和）文件夹，其他的参数见 remove。

>>> from pydu.system import makedirs
>>> from pydu.system import remove
>>> from pydu.system import open_file
>>> makedirs('test1')
>>> makedirs('test2')
>>> open_file('test.txt')
>>> removes(['test.txt','test1','test2'])

pydu.system.open_file(path, mode='wb+', buffer_size=-1, ignore_errors=False):

默认以 wb+ 的方式打开文件，如果需要被创建的文件的上级目录不存在，该目录将会被创建。如果 ignore_errors 为 True ，异常将会被忽略。

>>> from pydu.system import open_file
>>> open_file('test.txt')
>>> ls
    test.txt
>>> open_file('test1.txt',mode='r')
Traceback (most recent call last):
 ...    OSError: Open file: test1.txt error

pydu.system.copy(src, dst, ignore_errors=False, follow_symlinks=True):

复制源文件（文件夹）到目标文件（文件夹）。当复制的文件夹包含软连接时，如果 symlink 的值为 True ，那么在目标文件夹中会创建相应的软连接；否者将会复制软连接所指向的文件。当复制的文件为软连接的时候，如果 symlink 的值为 False ，那么将会创建与软连接指向相同的软连接；否者，将会复制软连接所指向的文件。

>>> from pydu.system import copy,symlink
>>> from pydu.system import makedirs,open_fle
>>> open_fle('test/test.txt')
>>> symlink('test/test.txt','test/test.link')
>>> copy('test/test.link','test/test_copy1.link')
>>> copy('test/test.link','test/test_copy2.link',follow_symlink=False)

pydu.system.touch(path):

生成一个新的文件

>>> from pydu.system import touch
>>> touch('test.txt')

pydu.system.symlink(src, dst, overwrite=False, ignore_errors=False)

symlink 只支持 Unix-link 系统，它将会创建指向源文件的软连接。如果 overwrite 的值为 True ，那么已存在的软连接将会被覆盖。

>>> from pydu.system import symlink
>>> symlink('test.txt','test.link')

注解

symlink 只支持 类Unix 系统。

pydu.system.link(src, dst, overwrite=False, ignore_errors=False):

link 只支持 Unix-link 系统，它将会创建指向源文件的硬连接。如果 overwrite 的值为 True ，那么已存在的硬连接将会被覆盖。

>>> from pydu.system import link
>>> link('test.txt','test.link')

注解

link 只支持 类Unix 系统。

pydu.system.which(cmd, mode=os.F_OK | os.X_OK, path=None):

给定命令名称、模式、和环境变量PATH，返回在PATH下符合给定模式的命令的路径，如果找不到就返回None。

mode 默认是 os.F_OK | os.X_OK。 path 默认是 os.environ.get("PATH")的结果，也可被被自定义的搜索路径重载。

在Python 3中，which 就是 shutil.which。

>>> from pydu.system import which
>>> which('echo')
/bin/echo

pydu.cmd.chmod(path, mode, recursive=False)

将权限改成给定模式。如果 recursive 是True，将会递归。

>>> from pydu.system import chmod
>>> chmod('/opt/sometest', 0o744)
>>> oct(os.stat('/opt/sometest').st_mode)[-3:]
'744'

注解

尽管Windows支持 chmod，但你只能使用它设置文件的只读标志（通过 tat.S_IWRITE 和 stat.S_IREAD）常量 或者相关整数值。其他所有位会被忽略。

pydu.cmd.chcp(code)

设置活动代码页号的上下文管理器。它也能够被当做函数使用。

>>> from pydu.cmd import chcp
>>> chcp(437)
<active code page number: 437>
>>> with chcp(437):
...     pass
>>>

注解

chcp 只能用于 Windows 系统。

Unit 单位

提供处理单位的工具。

class pydu.unit.Bytes(bytes)

提供处理字节的各类方法。

convert(self, unit=None, multiple=1024)

将字节转化为给定 unit。如果 unit 是 None，将字节转换为合适的单位。转换 multiple 的默认值是 1024。

>>> Bytes(1024).convert()
(1, 'KB')