python常用库

1，time

时间的表示形式：

• 格式化的字符串：'2018-2-4 14:08:01'
• 时间戳：1970年1月1日至今经历的秒数
• 元组（struct_time）：time.struct_time(tm_year=2018, tm_mon=2, tm_mday=4, tm_hour=10, tm_min=34, tm_sec=56, tm_wday=6, tm_yday=35, tm_isdst=0

 

time模块方法：

• time()：获取本地时间戳
• gmtime(secondes)：UTC时间戳 —> 元组，缺省为当前时间
• localtime(seconds)：本地时间戳 —> 元组，缺省为当前时间
• mktime(tupple)：元组 —> 时间戳
• strftime(format[,tupple])：元组 —> 字符串，例如time.strftime("%Y-%m-%d %H-%M-%S") ，不输入tupple是本地时间
• strptime(string, format)：字符串 —> 元组，例如time.strptime(%H-%M-%S", "%Y-%m-%d")，不输入tupple是本地时间
• asctime([tupple])：元组 —> 字符串，是sat aug 20 15:01:42 2016这种格式
• ctime(seconds)：时间戳 —> 字符串，是sat aug 20 15:01:42 2016这种格式
• sleep()：略

 

举例，改时间戳，计算2个时间点相差了多少个小时：

def timeformat(item):  # 改时间戳
    local_timeArray = time.strptime(item, "%Y-%m-%d %H:%M:%S")
    local_timeStamp = int(time.mktime(local_timeArray))
    return round(float(local_timeStamp)/3600, 2)   # 对时间戳换算到小时并保留2位
 
>>> t1 = timeformat('2019-3-27 18:20:01')
>>> t1
431578.33
>>> t2 = timeformat('2019-3-29 6:10:20')
>>> t2
431614.17
>>> t2 - t1   
35.839999999967404    # t2减去t1，相差35.84个小时

 

datatime：time的高级封装，包括date类，time类，datetime类

datetime.datetime.now() +  datetime.timedetla(3) # 当前时间+3天
datetime.datetime.now() +  datetime.timedetla(hours=3)  # 当前时间+3个小时

 

2，random

• random.random() # 0到1之间的随机浮点数
• random.uniform(1, 10)  # 1到10之间的随机浮点数，相比较random增加了区间功能
• random.randint(1, 8)  # 1到8之间的随机整数，范围是[1,8]，包括1和8
• random.randrange(1,8) # 1到8之间的随机整数，范围是[1,7]，包括1，但不包括8，和range一样，顾头不顾尾
• random.choice('hello')  # 从传入的序列中随机取值，可以传字符串、列表元组等
• random.sample('hello', 2)  # 从传入的序列中随机取2个值
• random.shuffle(list)  # 把传入的list的序列打乱

举例，生成伪随机验证码：

import random 
checkcode = ''   # 4位数字
for i in range(4):
    current = random.randint(1,9)
    checkcode += str(current)
print(checkcode)
 
checkcode = ''   # 4位数字或大写字母
for i in range(4):
    current = random.randint(0,3)
    if current == i:
        tmp = chr(random.randint(65, 90))
    else:
        tmp = random.randint(0, 9)
    checkcode += str(tmp)
print(checkcode)

　　

3，os

• os.getcwd()     # 获取当前工作目录
• os.listdir(path)    # 列出指定目录下的所有文件和f子目录，包括隐藏文件。listdir不会遍历子目录，但os.walk会遍历子目录。

>>> os.listdir(os.getcwd())  # 获取执行脚本所在文件下的全部内容

• os.walk(path)  # 遍历目录，返回generator，三元组：当前路径，当前路径下的文件夹列表，当前路径下的文件列表
• os.chdir("dirname")   # 改变当前脚本工作目录；相当于shell下cd，注意切换目录时需要转移，方法一用'/'，方法二前面加'r'
• os.curdir  # 返回当前目录: ('.')
• os.pardir  # 获取当前目录的父目录字符串名：('..')
• os.mkdir('dirname')    # 生成单级目录；相当于shell中mkdir dirname
• os.makedirs('dirname1/dirname2')    # 可生成多层递归目录，例如:os.mkdirs(r'd:\a\b\c\d')
• os.rmdir('dirname')    # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname，清理单个空文件夹
• os.removedirs('dirname1')    # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推，清理递归空文件夹
• os.remove()  # 删除一个文件
• os.rename("oldname","newname")  # 重命名文件/目录
• os.stat('path/filename')  # 获取文件/目录信息，atime存储时间，mtime修改时间，大小等等
• os.sep    # 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
• os.linesep    # 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
• os.pathsep    # 输出用于分割文件路径的字符串
• os.name    # 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
• os.system("bash command")  # 运行linux的shell命令，windows的cmd命令
• os.environ  # 获取系统环境变量，返回的是所有环境变量，sys.path返回的是python相关的环境变量
• os.get_terminal_size()  # 获取终端大小

 

os.path

• os.path.dirname(pah)：返回path的目录名
• os.path.basename(path)：返回path的文件名
• os.path.split(path)：返回路径 + 文件/文件名
• os.path.splitext(path)：返回路径 + 后缀
• os.path.exists(path)：是否存在
• os.path.isfile(path)：是否文件
• os.path.isdir(path)：是否目录
• os.path.islink(path)：是否link
• os.path.isabs(path)：是否绝对路径
• os.path.realpath(path)：link对应的真实路径
• os.path.listdir(path)：获取path下的目录 + 文件列表
• os.path.abspath(path) ：返回path规范化的绝对路径
• os.path.join(path1[, path2[, ...]])：将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
• os.path.size(path)：获取大小
• os.path.getmtime(path)：最后修改时间
• os.path.getatime(path)：最后存取时间

 

4，sys

• sys.argv   # 是传给脚本的参数，是一个list，python abc.py 1 2 3，sys.argv就是[abc.py, 1, 2, 3]
• sys.exit(n)  # 退出程序，正常退出时exit(0)
• sys.version    # 获取Python解释程序的版本信息
• sys.maxint    # 最大的Int值
• sys.path   # 返回模块的绝对路径，初始化时使用PYTHONPATH环境变量的值
• sys.platform   # 返回操作系统平台名称
• sys.stdout.write() 和 sys.stdout.flush()   # print('abc') 等效于 sys.stdout.write('abc\n')

终止程序并显示错误：

raise SystemExit('it falied') 

 

5，shutil

copy文件，压缩文件、拷贝目录、删除目录等，shutil压缩功能是通过调用zipfile和tarfile这2个模块实现的

• shutil.copyfileobj(src, dst)  # 需要自己open
• shutil.copyfile(src, dst)  # 无需自己open，只拷贝文件
• shutil.copy(src, dst)  # 同时拷贝文件和权限
• shutil.copy2(src, dst)  # 拷贝文件保留元数据
• shutil.copytree(src, dst)  # 拷贝目录，如果想保留符号链接，可以设置Symlinks=True
• shutil.move(src, dst)  # 移动文件
• shutil.copymode 
• shutil.copystat  # 拷贝状态信息
• shutil.make_archive()  # 压缩
• shutil.unpack_archive()  # 解压缩

 

6，json，pickle，shelve，PyYAML，ConfigParser，xml.etree.ElementTree

处理json，序列化，反序列化，配置文件

常见配置文件：

适合人类编写：ini > toml > yaml > json > xml > plist

可以存储的数据复杂度：xml > yaml > toml ~ json ~ plist > ini

json：所有语言之间交互，但只能传字典

pickle：python内部交互，可以传所有内容

shelve：pickle更上一层封装

PyYAML：处理yaml配置文件

ConfigParser：处理ini配置文件

xml.etree.ElementTree：处理xml文件

 

序列化举例，字典到文件的读写：

方法一：str + eval

f.write(str(dict))  # 转成str存，即序列化
eval(str(dict))     # 用eval读，即反序列化

方法二：json

# dumps序列化：
f.write(json.dumps(info)）
json.dump(info, f) 
# loads反序列化：       
json.loads(f.read())   
json.load(f)

方法三：pickle，参照json

json不支持函数序列化，pickle支持函数的序列化

json可以跨语言，pickle只能python内部

注意：json和pickle，python3只能dump和load一次

 

7，paramiko

SSH登录

 

9，itertools

9.1，过滤

def screen(val):
    return True if val > 0 else False
ls = [3, 1, -5, 2, 3, -9, 10]

filter(fun, it)： 将it中的元素i逐个传给fun，如果fun(i)为真值，name产出对应的i。

>>> list(filter(screen, ls))  
[3, 1, 2, 3, 10]

itertools.filterfalse(fun, it)：与filter功能相反

>>> list(itertools.filterfalse(screen, ls))
[-5, -9]

itertools.compress(it,  it_ref)：并行迭代it和it_ref，如果it_ref中的值为真值，产出it中对应的值，返回的是iterable

>>> list(itertools.compress('abcd', [1, 0, 1, 0]))
['a', 'c']

itertools.dropwhile(fun, it)：跳过开头几个匹配为True的，后面不再匹配

list(itertools.dropwhile(screen, ls))    
[-5, 2, 3, -9, 10]    # 后面再碰到返回True的2不再跳过了

itertools.takewhile(fun, it)：产出相当于dropwhile丢掉的几个值，takewhile + dropwhile = it

>>> list(itertools.takewhile(screen, ls))
[3, 1]

itertools.islice(it, start, stop, step)：切片，it可以是任何iterable，start可选默认=0，step可选默认=1，注意：迭代器由于没有getitem没法使用普通切片函数，islice会消耗掉迭代器中的数据。如果stop=None，表示无限大，结合start值可以用来跳过前几个元素。

def count(n):
    while True:
        yield n
        n += 1
c = count(1)
>>> list(itertools.islice(c, 10, 20, 2))  
[11, 13, 15, 17, 19]
>>> list(itertools.islice(c, 10, 15))     
[11, 12, 13, 14, 15]
>>> list(itertools.islice(c, 5))          
[1, 2, 3, 4, 5]

 

9.2，映射

enumerate(it, start=0) ：索引 + value

>>> list(enumerate('abcde', 1))
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')]

map(fun, it1[it2, it3, ... itN])：将it中的元素传给fun，产出元素

>>> list(map(lambda x, y: x + y, [1, 2, 3], [1, 1, 1]))
[2, 3, 4]　　

itertools.accumulate(it, [fun])：产出列表，不断将it传给后面的函数，产出结果，如果没有函数，产出累加

>>> list(itertools.accumulate([1, 3, 2, 4]))
[1, 4, 6, 10]
>>> list(itertools.accumulate([1, 3, 2, 4], operator.mul))
[1, 3, 6, 24]

itertools.startmap(fun, it)：获取it中的元素，传给fun执行

>>> list(itertools.starmap(operator.mul, enumerate('abcde', 1)))
['a', 'bb', 'ccc', 'dddd', 'eeeee']

　　

9.3，容器合并

zip(it1, it2, ..., itN)：从多个可迭代对象中获取元素

>>> list(zip('abc', range(4)))
[('a', 0), ('b', 1), ('c', 2)]

itertools.zip_longst(it1, ...itN, fillvalue=None)：zip的longst版

>>> list(itertools.zip_longest('abc', range(4), fillvalue='#'))
[('a', 0), ('b', 1), ('c', 2), ('#', 3)]

itertools.product(it1, ...itN, repeat=1)：计算笛卡尔积，矩阵展开，可以多个省略for循环语句

>>> list(itertools.product('abc', range(2), repeat=1))
[('a', 0), ('a', 1), ('b', 0), ('b', 1), ('c', 0), ('c', 1)]

itertools.chain(it1, it2,..., itN)：依次迭代多个容器，可以是不同类型的容器，省空间不会产生新序列。heapq.merge()也可以迭代多个不同容器，但元素需要相同类型。

>>> list(itertools.chain('abc', range(2), ('c', 'd'))
['a', 'b', 'c', 0, 1, 'c', 'd']

itertools.chain.from_iterable(it) : 和chain差不多， 从嵌套的容器中获取元素，只是将不同容器放在一个iterable中

>>> list(itertools.chain.from_iterable(['abc', range(2), ('c', 'd')]))
['a', 'b', 'c', 0, 1, 'c', 'd']

　　

9.4，输入—>输出n

itertools.combinations(it, n)：前n元素的组合，不重复

>>> list(itertools.combinations('abc', 2))  
[('a', 'b'), ('a', 'c'), ('b', 'c')]

itertools.combinations_with_replacement(it, n)：前n元素的组合，可重复

>>> list(itertools.combinations_with_replacement('abc', 2))
[('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'b'), ('b', 'c'), ('c', 'c')]

itertools.permutations(it, n=None)：前n元素的排列

>>> list(itertools.permutations('abc', 2))
[('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'c'), ('c', 'a'), ('c', 'b')]

itertools.count(start=0, step=1)：无限产出值，默认从0开始，步长为1

itertools.repeat(item, [n])：产出n次item，不提供参数n则无限产出

itertools.cycle(it)：从it中无限循环产出值

 

9.5，重排

reversed(seq)：反向遍历

itertools.groupby(it, key=None)：分组产出iterable，key是分组标准，使用前必须先根据分组标准排序

# 根据首字母分组：
l = ['apple', 'dark', 'china', 'apache', 'cry', 'department','cycle']
l.sort(key=lambda i: i[0])   # 必须先排序
for first_letter, group in itertools.groupby(l, key=lambda i: i[0]):
    print(first_letter, list(group))
# 输出为：
a ['apple', 'apache']
c ['china', 'cry', 'cycle']
d ['dark', 'department']

# 根据单词字母数量分组：
l = ['apple', 'dark', 'china', 'apache', 'crazy', 'depart', 'cycle']
l.sort(key=len)   # 必须先排序
for first_letter, group in itertools.groupby(l, key=len):
    print(first_letter, list(group))
# 输出为：
4 ['dark']
5 ['apple', 'china', 'crazy', 'cycle']
6 ['apache', 'depart'

# 字典列表中，根据根据x的value的首字母进行分组：
rows = [{'x': 'apple', 'y': 'a'},    
        {'x': 'dark', 'y': 'b'},
        {'x': 'china', 'y': 'a'},
        {'x': 'apache', 'y': 'a'},
        {'x': 'cry', 'y': 'c'},
        {'x': 'department', 'y': 'a'},
        {'x': 'cycle', 'y': 'b'}]
rows.sort(key=itemgetter('x'))
for i, t in groupby(rows, key=lambda i: itemgetter('x')(i)[0]):
    print(i)
    for j in t:
        print(j)
# 输出为：
a
{'x': 'apache', 'y': 'a'}
{'x': 'apple', 'y': 'a'}
c
{'x': 'china', 'y': 'a'}
{'x': 'cry', 'y': 'c'}
{'x': 'cycle', 'y': 'b'}
d
{'x': 'dark', 'y': 'b'}
{'x': 'department', 'y': 'a'}

 

itertools.tee(it, n=2)：产出n个相同的it

>>> t = itertools.tee(iter(range(5)), 2)
>>> list(t[0])
[0, 1, 2, 3, 4]
>>> list(t[1])
[0, 1, 2, 3, 4]

 

10，collections

collections的所有方法：['deque', 'defaultdict', 'namedtuple', 'UserDict', 'UserList', 'UserString', 'Counter', 'OrderedDict', 'ChainMap']，详见collections/__init__.py

collections.abc：抽象基类，详见抽象基类笔记

collections.deque(maxlen=n)：只保留有限的n个数据

collections.defaultdict：一键多值字典

d = defaultdict(list)
d['a'].append(1)

collections.OrderedDict：有序字典，类似pd.Series

collections.Counter：统计序列元素出现次数，并且Counter类对运算符进行了重载，支持统计结果加减，pandas

s1 = list('imabigbiggirl')
s2 = list('inabigbigworld')
c1 = Counter(s1)
c2 = Counter(s2)
print(c1) # Counter({'i': 4, 'g': 3, 'b': 2, 'm': 1, 'a': 1, 'r': 1, 'l': 1})
print(c1.most_common(3)) # [('i', 4), ('g', 3), ('b', 2)]
print(c1 + c2) # Counter({'i': 7, 'g': 5, 'b': 4, 'a': 2, 'r': 2, 'l': 2, 'm': 1, 'n': 1, 'w': 1, 'o': 1, 'd': 1})
pd.Series(s1).value_counts()[:3] # pandas.Series也可以完成统计前3的功能，但是2个Seires没法完成相加统计，NaN的加上int还是NaN

collections.namedtuple()：具名元组

Stock = namedtuple('Stock', 'name shares price')
s = Stock('IBM', 1000, 70)
print(s)  # Stock(name='IBM', shares=1000, price=70)

collections.chinamap(m1, m2, ... mn)：将多个映射合并为一个，有重复key时只取第一个，有修改映射时只作用第一个

 

11，heapq

heapq.nlargest(it, n)：在it中找出最大的n个数

heapq.nsmallest(it, n)：在it中找出最小的n个数

heapq.merge(it1, it2, ..., itn)：对不同类型的容器进行排序后依次迭代，注意与itertools.chain()的区别

>>> list(heapq.merge([1, 3, 5], (2, 4, 6)))
[1, 2, 3, 4, 5, 6]

 

12，operator

itemgetter：获取字典的value，对字典列表排序，也可以用lambada，或者将字典列表交个dataframe排序，但itemgetter效果高

ds = [{'a': 6, 'b': 2}, {'a': 3, 'b': 5}, {'a': 2, 'b': 7}, {'a': 4, 'b': 3}]
# itemgetter用法示例：itemgetter返回的是一个函数，需要作用到参数上
key = itemgetter('a')
for each_dict in ds:
　　print(key(each_dict), end=' ')  # 6 3 2 4 
# 方法一：itemgetter
ds.sort(key=itemgetter('a'))    # 根据a的value排序
ds.sort(key=itemgetter('b'))    # 根据b的value排序
# 方法二：lambda
ds.sort(key=lambda k: k['a'])
# 方法三：pandas
df = pd.DataFrame(ds)           # 方法三：pandas，dataframe可以接收字典列表 
df = df.sort_values('a')        # 根据'a'列排序，sort_values不会就地修改

attrgetter：获取对象的属性

class User:
    def __init__(self, user_id):
        self.user_id = user_id
    def __repr__(self):
        return 'User({})'.format(self.user_id)
users = [User(3), User(10), User(7)]
# attrgetter用法示例：attrgetter返回的是一个函数，需要作用到类的实例上
key = attrgetter('user_id')
for u in users:
    print(key(u), end=' ')  # 3 10 7 
# 方法一：attrgetter
users.sort(key=attrgetter('user_id'))
# 方法二：lambda
users.sort(key=lambda u: u.user_id)

methodcaller：实现getattr的功能

operator.methodcaller('distance', 0, 0)(p)  # 相当于p.distance(0, 0)

 

13，fnmatch

fnmatch.fnmatch(filename, pattern)：测试文件名是否符合pattern

>>>fnmatch.fnmatch('test.py', '*.py')
True

fnmatch.fnmatchcase(filename, pattern)：测试文件名是否符合pattern，严格区分大小写

fnmatch.filter(filenames, pattern)：对文件名列表应用pattern过滤，返回的是列表，可以用下面语句替代：

[file for file in filenames if re.match(pattern, file)]

fnmatch.translate(pattern)：fnmatch将这种全局模式转换成一个正则式？

 

14，glob

glob('dir/pattern') ：获取文件

glob.glob('*.py')   # 获取当前目录下的.py文件
glob.glob('fw*.py')  # 获取当前目录下含有fw的.py文件
glob.glob('somedir/*.py')   # 获取somedir目录下的.py文件

　　

15，functools

functools.partial(fun, args): 冻结参数（好像只能冻结最后一个）

def run(a, b):
    print(a, b)
 
p = functools.partial(run, b='b')

functools.partial + iter：实现对固定大小内容进行迭代，f.read()可以通过partial绑定一个固定大小的参数

with open('file.data', 'rb') as f:
    records = iter(partial(f.read, 32), b'')   # 固定大小间隔为32，哨符值为‘’
    for i in records:
        ......

 

16，io

io.StringIO()：类似文本文件的对象，主要有read/write/getvalue方法

io.BytesIO()：类似二进制文件的对象，主要有read/write/getvalue方法

 

17，mmap

看起来就像bytearray，对文件进行内存映射不会将整个文件读到内存中，而是保留一段虚拟内存，按需映射到内存中

def memory_map(filename, access=mmap.ACCESS_WRITE):
    size = os.path.getsize(filename)
    fd = os.open(filename, os.O_RDWR)
    return mmap.mmap(fd, size, access=access)
 
with open('data', 'wb') as f:
    f.seek(999999)
    f.write(b'\x00')
 
m = memory_map('data')
print(len(m))      # 1000000
print(m[0: 11])   # b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
m[0: 11] = b'hello world'
print(m[0: 11])   # b'hello world'

 

18，getpass

• getpass.getuser()  # 获取当前shell环境的用户名
• getpass.getpass()  # 输入密码时不显示

 

19，subprocess

• subprocess.check_out()  # 执行外部命令并获取输出
• subprocess.Popen()  # 需要与子进程交互时

 

20，logging

• logging.getLogger()  # 日志对象
• logging.bascConfig()  # 设置配置信息，只能被调用一次，想修改需要通过日志对象
• logging.config.fileConfig()  # 从配置文件中进行配置