常用模块

一. collections模块

　　1.namedtuple(用来表示坐标）

from collections import namedtuple

point=namedtuple('point',['x','y'])
p=point(1,2)
print(p.x)
print(p.y)




circle=namedtuple('circle',['x','y','r'])
c=circle(1,2,3)
print(c)

 

 

　　2.deque(deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：)

from collections import deque

a=deque(['a','b','c'])
a.append('1')
a.appendleft('3')
print(a)



#deque(['3', 'a', 'b', 'c', '1'])

from collections import deque
q=deque(['a','b','c'])
print(q.pop())
print(q)
print(q.popleft())
print(q)




#c
#deque(['a', 'b'])
#a
#deque(['b'])

　　3.OrderedDict(可以保持key的顺序）

from collections import OrderedDict
d = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(d)




#OrderedDict([('a', 1), ('b', 2), ('c', 3)])

　　4.defalutdict

　　有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = {}

for value in  values:
    if value>66:
        if 'k1' in my_dict:
            my_dict['k1'].append(value)
        else:
            my_dict['k1'] = [value]
    else:
        if 'k2' in my_dict:
            my_dict['k2'].append(value)
        else:
            my_dict['k2'] = [value]
print(my_dict)

from collections import defaultdict

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = defaultdict(list)

for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

二.  时间模块

import time
# print(time.time())   #时间戳
# print(time.strftime("%Y-%m-%d %H:%M:%S"))  #对应的当时时间字符串
# print(time.localtime())  #对应的当地的结构化时间
# print(time.gmtime())   #当时的伦敦当地时间


#将结构化时间转化为时间戳
# time_tuple = time.localtime(1500000000)
# ret = time.mktime(time_tuple)
# print(ret)


# #将结构化时间转化为字符串时间
print(time.strftime("%Y-%m-%d",time.localtime(1500000000)))

#字符串时间转化为结构化时间
ret=time.strptime("2017-03-16","%Y-%m-%d")
print(ret)

　　计算时间差

#将时间转化为时间戳
true_time=time.mktime(time.localtime(1600000000))
now_time=time.mktime(time.localtime())
#两者进行相减
dif_time=true_time-now_time
#将结果转化为伦敦时间
struct_time=time.gmtime(dif_time)
#再与1970年一月一日相减结果就是所求时间
print('还剩%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
                                       struct_time.tm_mday-1,struct_time.tm_hour,
                                       struct_time.tm_min,struct_time.tm_sec))

三. random模块

import random

print(random.random())
#0.5397941284620414随机匹配0-1之间的数

print(random.randint(1,5))
#3随机匹配1-5之间的整数包括1和5

print(random.randrange(1,10,2))
#3随机匹配1-10之间的数，且步长为2

print(random.choice([1,2,'23',[1,2,3]]))
#[1, 2, 3]随机选择一个

print(random.sample([1,2,3,'34',[1,4,6]],2))
#[2, [1, 4, 6]]随机选择两个

　　2.随机生成4位验证码

#a-z的ASCII码位97~122，A~Z的为65~90
import random

def code():
    code=''
    for i in range(4):
        num=random.randint(0,9)
        zimu=chr(random.randint(65,90))
        add=random.choice([num,zimu])
        code=''.join([code,str(add)])
    return code
print(code())

　　四. 序列化模块

            将数据类型转化为字符串就是序列化

　　1.json（用于字符串 和 python数据类型间进行转换）

　　　　四个语法（dumps,dump,loads,load)

　　　　dumps和dump将数据类型序列化成字符串类型，而loads和load是反序列化

import json
dic={'k1':'v1','k2':'v2'}
str_dic=json.dumps(dic)
print(type(str_dic),str_dic)  #<class 'str'> {"k1": "v1", "k2": "v2"}

dit=json.loads(str_dic)
print(type(dit),dit)          #<class 'str'> {"k1": "v1", "k2": "v2"}

　　　　dump和load应用再文件中

import json
f = open('xiaowu','w')
dic={'k1':'v1','k2':'v2'}
json.dump(dic,f)
f.close()

f=open('xiaowu')
a = json.load(f)
f.close()
print(a)

　　2.pickle（用于python特有的类型 和 python的数据类型间进行转换）

         pickle.dumps将数据类型序列化bytes类型

import pickle

list=[1,2,3,4,5]
str_l=pickle.dumps(list)
print(type(str_l),str_l)     #<class 'bytes'> b'x80x03]qx00(Kx01Kx02Kx03Kx04Kx05e.'

b=pickle.loads(str_l)
print(b)                     #[1, 2, 3, 4, 5]

import pickle

f=open('xiaowu','wb')
a={1,2,3,4}
pickle.dump(a,f)
f.close()

f=open('xiaowu','rb')
a=pickle.load(f)
f.close()
print(a)

这里我们要说明一下，json是一种所有的语言都可以识别的数据结构。
如果我们将一个字典或者序列化成了一个json存在文件里，那么java代码或者js代码也可以拿来用。
但是如果我们用pickle进行序列化，其他语言就不能读懂这是什么了～
所以，如果你序列化的内容是列表或者字典，我们非常推荐你使用json模块
但如果出于某种原因你不得不序列化其他的数据类型，而未来你还会用python对这个数据进行反序列化的话，那么就可以使用pickle

 　　重要的内置模块hashlib

　　　　Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等

　　　　什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。摘要算法就是通过　　　　摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。摘要算法之所以能指出数据是否被篡改过，就是因为摘要函数是一个单向函数，计算f(data)很容易，但通过digest反推data却非常困难。而且，对原始数据做一个bit的修改，都会导致计算出的摘要完全不同。我们以常见的摘要算法MD5为例，计算出一个字符串的MD5值：

import hashlib
md5 = hashlib.md5()
md5.update(b'Do you love me ? Yes,I do')
print(md5.hexdigest())

#49491115a4a3ce8574c8f1cd516c5030


#当一个字符串太长时，我们可以拆开调用update

import hashlib
md5 = hashlib.md5()
md5.update(b'Do you love me ? ')
md5.update(b'Yes,I do')
print(md5.hexdigest())

#49491115a4a3ce8574c8f1cd516c5030

MD5是最常见的摘要算法，速度很快，生成结果是固定的128 bit字节，通常用一个32位的16进制字符串表示。另一种常见的摘要算法是SHA1，调用SHA1和调用MD5完全类似：

import hashlib
sha1 = hashlib.sha1()
sha1.update(b'Do you love me ? ')
sha1.update(b'Yes,I do')
print(sha1.hexdigest())

#f0509b33f8d5847dde6708bbad19072a2f5f0090

SHA1的结果是160 bit字节，通常用一个40位的16进制字符串表示。比SHA1更安全的算法是SHA256和SHA512，不过越安全的算法越慢，而且摘要长度更长。

当我们的字符串太简单时，人家可以通过算法给我们计算出来，此时我们可以通过加盐算法让其复杂化

import hashlib
md5 = hashlib.md5('salt'.encode('utf-8'))
md5.update(b'Do you love me ? ')
md5.update(b'Yes,I do')
print(md5.hexdigest())


#0cc083aa89c4e8182ffaaa8fb0d7ba24

　　　　logging模块（日志，用来记录用户行为或者代码的执行过程）

　　　　两种配置方式：basicconfig和log对象配置方式，通常使用log对象方式

　　函数式简单配置

import logging
logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message') 

默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG），默认的日志格式为日志级别：Logger名称：用户输出消息

import logging
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                    datefmt='%a, %d %b %Y %H:%M:%S',
                    filename='/tmp/test.log',
                    filemode='w')

logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')

　　配置参数

logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有：

filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。

format参数中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息

　　logger对象配置

import logging

logger = logging.getLogger()
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('test.log',encoding='utf-8') 

# 再创建一个handler，用于输出到控制台 
ch = logging.StreamHandler() 
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setLevel(logging.DEBUG)

fh.setFormatter(formatter) 
ch.setFormatter(formatter) 
logger.addHandler(fh) #logger对象可以添加多个fh和ch对象 
logger.addHandler(ch) 

logger.debug('logger debug message') 
logger.info('logger info message') 
logger.warning('logger warning message') 
logger.error('logger error message') 
logger.critical('logger critical message')