内置模块

一 collections模块 ：数据类型模块

　namedtuple:可命名元组

p=collections.namedtuple('p',['x','y'])
a=p(1,2)
print(a.x+a.y)

　deque：双端队列 1 append：后添加；2 appendleft：前添加；3 pop：从后向前取值；4 　　popleft：从前到后取值

q=collections.deque([1,2,3,4])
q.append(5)  #后面添加
q.appendleft(7)  #第一个位置添加
q.pop()     #最后一个位置读取
q.popleft()    #第一个把位置开始读取
print(q)

　ordereddict：创建有序的字典

# d=collections.OrderedDict([('a',1),('b',2),('d',3)])
# for i in d.items():print(i)

　defaultdict：默认字典的value值

# values = [11, 22, 33,44,55,66,77,88,99,90]
# dic=collections.defaultdict(list)
# for l in values:
#     if l>66:
#         dic['k1'].append(l)
#     else:
#         dic['k2'].append(l)
# print(dic)

　counter计算字符出现的次数

print(collections.Counter('asasfewruvs'))

二 time模块：时间模块

　time.time()：当前时间戳   （计算机识别的时间）   从1970年1月1日00：00：00开始计算

# print(time.time(

　time.strftime()：时间字符串  结构化时间转成字符串时间   #（人类识别的时间）

# print(time.strftime('%Y-%m-%d'))

　time.localtime()：结构化时间（计算国内时间）   时间戳装成结构化时间（计算国内时间）

# print(time.localtime())

　time.gmtime()：结构化时间（计算国际时间）   时间戳转换成结构化时间（计算国际时间）

# print(time.gmtime())

　time.mktime()：结构化时间转成时间戳   （机器识别的时间）

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

　time.strptime()：字符串时间转成结构化时间　（计算时间）

# time_1=time.strftime('%Y-%m-%d')
# print(time.strptime(time_1,"%Y-%m-%d"))

　

    time.asctime()：结构化时间转成字符串时间（转换后有固定的格式）

# print(time.asctime())

　time.ctime()：时间戳转成字符串时间（转换后有固定的格式）

# print(time.ctime())

          

    计算时间差：

# import time
# end=time.time()
# start=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
# end_start=end-start
# cha_time=time.localtime(end_start)
# print('已经过去了%s年%s月%s天%s小时%s分种%s秒'%(cha_time.tm_year-1970,cha_time.tm_mon-1,cha_time.tm_mday-1,cha_time.tm_hour-0,cha_time.tm_min-1,cha_time.tm_sec-0))

时间日期格式化符合

　%y：两位数的年份

　%Y：四位数的年份

　%m：月份

　%d：天

　%H：24进制的小时

　%I：12进制的小时

　%M：分钟

　%S：秒

　%a：本地简化星期名称

　%A：本地完整星期名称

　%b：本地简化的月份名称

　%B：本地完整的月份名称

　%c：本地相应的日期和时间的表示

　%j：年内的一天

　%p：本地AM或者PM的等价符

　%U：一年中的星期数，星期天为星期的开始

　%w：星期（0-6）,星期天为开始

　%W：一年中的星期数，星期一为开始

　%x：本地相应的时间表示

　%X：当前时期的名称

　%%：%本身

‘三 random模块：随机模块

　random：0到1之间的小数

print(random.random())

　uniform：自定义小数范围

print(random.uniform(1,4))

　randint：自定义随机整数的范围（取头取尾）

print(random.randint(1,10))

　randrange：自定义随机整数的范围（取头不取尾）还可以定义步长取

print(random.randrange(1,20,2))

　choice：随机返回一个值

print(random.choice([1,2,3,44,(2,4,6)]))

　sample：随机返回多个值，自定义返回值的个数

print(random.sample([1,2,3,44,(2,4,6)],3))

　shuffle：打乱顺序

l=[1,2,3,4,5,6,7,8,9]
random.shuffle(l)
print(l)

随机验证码

# import random
# def yan(n):
#     ll=''
#     for num in range(n):
#         i=random.randint(0,9)
#         j=chr(random.randint(65,90))
#         z=chr(random.randint(97,122))
#         l=random.choice([str(i),j,z])
#         ll+=l
#     print(ll)
# yan(6)

四 os模块

  os.getcwd：获取当前的工作目录

　os.chdir：改变当前脚本的工作目录

　os.curdir：返回当前目录

　os.pardir：获取当前目录的父目录字符串名

　os.makedirs：可生成多层递归目录

　os.removedirs：递归删除上一级的空目录

　os.mkdir：生成单层目录

　os.rmdir：删除单级空的目录

　os.listdir：列出指定目录下的所有的文件和子目录

　os.remove：删除一个文件

　os.rename：修改文件名/目录名

　os.stat：获取文件/目录信息

　os.sep：输出操作系统特定的路劲分割符

　os.linesep：输出当前平台的行终止符

　os.pathsep：输出用于分割文件路径的字符串

　os.name：输出字符串指示的当前平台

　os.system：运行shell命令直接显示

　os.popen：运行shell命令，获取执行结果

　os.environ：获取系统的环境变量

　os.path.abspath：返回path规范化的绝对路径

　os.path.exists：如果path存在，返回True；相反返回False

　os.path.isabs：如果path是绝对路径返回True

　os.path.isfile：如果是是一个存在的文件返回True

　os.path.isdir：如果是一个存在的目录返回True

　os.path.join：路径拼接

　os.path.getatime：返回所指向文件或者目录最后的访问时间

　os.path.getmtime：返回所指文件或者目录的最后修改时间

　os.path.getsize：返回文件或者目录的大

 五 sys模块

    sys 模块提供了许多函数和变量来处理 Python 运行时环境的不同部分

　sys.argv：命令行参数list，第一个元素是程序的路径本身

　sys.exit：退出程序

　sys.version：获取python解释器的版本信息

　sys.path：返回模块的 搜索路径

　sys.platform：返回操作系统平台名称

小练习
count=1
while count<10:
    print('ok')
    if count==8:
        #break        #终止了if判断的后面条件，但是while循环还会继续进行
        sys.exit()  #程序在这后面的都结束。直接全部终止
    count+=1
print('ending')

小练习

ret=sys.arge    #["模块.py","fang","666"]
print(ret)   #["sys模块.py",'-u','fang','-p','666']
            #  只有放在-u后面的是用户名，放在-p后面的是用户名密码。
username=ret[1]
password=ret[2]
print(sys.argv)   #显示当前服务器的绝对路径，
print('huijia')
username=input('username:')   #io是一个阻塞状态
password=input('password:')
if username =='fang'and password=='666':
    print('huijia')

sys.path   #显示一堆路径，以列表的形式显示出来
print(sys.path)  #['E:\文本编辑器\pycharm\方杰\目录\模块', 'E:\文本编辑器\pycharm', 'E:\python3.5\python36.zip',
 'E:\python3.5\DLLs', 'E:\python3.5\lib', 'E:\python3.5', 'E:\python3.5\lib\site-packages']
#寻找模块，从当前的路径下开始寻找，如果当前路径下没有，就会挨个的按照列表
# 的顺序寻找下去，如果找到了，就不再寻找。
import re
import hashlib
print(re.findall(r"hello","hello"))

Base_dir=r'E:文本编辑器pycharm方杰阿豪'
sys.path.append(Base_dir)
import lesson1
lesson1.foo()
不管是人家添加还是自己添加的模块，只要有路径，就会寻找到。

   查找模块的优先级：内置模块（python解释器）---------------》第三方模块，自定义模块（sys.path）

六 序列化模块

     之前我们学习过用eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。

　什么叫做序列化：将原本的数据类型转换成字符串的过程就叫做序列化；相反将字符串转为非字符串的数据类型就叫做反序列化.在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

　序列化的好处：1以某种存储形式使自定义对象持久化；2 将对象从一个地方传送到另一个地方；3 使程序更具有维护性

　序列化的几个模块：json模块：用于各种开发语言之间的，只能在基本的数据类型上使用.但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

　　　　　　　　　　pickle模块：只能用于python开发中，不过可以对特殊的数据类型进行操作

　　　　　　　　　　shelve模块：只有open一个方法，直接就可以对文件句柄操作。读取的内容是以存入的类型读取的。

json和pickle的四种功能：dump和dumps：序列化，转成字符串，dump用于文件操作；dumps用于网络传输。

　　　　　　　　　　　　load和loads：反序列化，转换成非字符串（内容中假如要用引号，必须用双引号）。load用于文件操作，loads用于网络传输。

json：

import json
# a={'fan':123,'jie':321}
# with open('a','w',encoding='utf-8')as f:
#     json.dump(a,f)  #序列化写入文件
#
# with open('a')as f:
#     print(json.load(f))  #反序列化读取


# print(type(json.dumps({'fan':123,'jie':321})))  #序列化
# print(type(json.loads('{"fan":123,"jie":321}')))   #反序列化

JSON表示的对象就是标准的JavaScript语言的对象一个子集，JSON和Python内置的数据类型对应如下：

 pickle：

# import pickle
# a={'fan':123,'jie':321}
# with open('a1','wb')as f:
#     pickle.dump(a,f)  #序列化写入文件
# 
# with open('a1','rb')as f:
#     print(pickle.load(f))  #反序列化读取
# 
# 
# print(type(pickle.dumps({'fan':123,'jie':321})))  #序列化
# print(type(pickle.loads(pickle.dumps('{"fan":123,"jie":321}'))))   #反序列化

优点：能支持python中的所有数据类型，所有数据类型之间都可以进行转换的。

 缺点：pickle仅仅用于python数据类型转换，不能在其他语言之间进行使用。

shelve:

# import shelve
# with shelve.open('a2')as f:
#     f['k1']={"fan":123,"jie":321}            直接对文件句柄操作，就可以存入数据
#     f['k2'] = {"fang": 1234, "jie": 3210}          直接对文件句柄操作，就可以存入数据
#     f1=f['k2']              #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错
#     print(f1)
#     print(f['k1'])        #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错

 七 

logging 模块

日志模块，为我们记录一些信息

  1 简单的配置方法

1 logging.debug('debug message')
2 logging.info('info message')
3 logging.warning('warning message')
4 logging.error('error message')
5 logging.critical('critical meddage')

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

 2 灵活配置日志级别，日志格式，输出位置:

 

3 配置参数：

 

4 logger对象配置

 

 

logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。另外，可以通过：logger.setLevel(logging.Debug)设置级别。

八 

内置模块 hashlib

 1 算发介绍

import hashlib

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

      什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。

      摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。

      摘要算法之所以能指出数据是否被篡改过，就是因为摘要函数是一个单向函数，计算f(data)很容易，但通过digest反推data却非常困难。而且，对原始数据做一个bit的修改，都会导致

  计算出的摘要完全不同。

     我们以常见的摘要算法MD5为例，计算出一个字符串的MD5值：