day06模块

原博文地址：http://www.cnblogs.com/linhaifeng/articles/6384466.html#_label2

时间模块time

import time

print(time.time())#1970年到现在的秒数，1970unix元年

print(time.localtime().tm_year)#2017

print(time.localtime())#time.struct_time(tm_year=2017, tm_mon=6, tm_mday=9, tm_hour=14, tm_min=40, tm_sec=4, tm_wday=4, tm_yday=160, tm_isdst=0)

#结构化的时间

print(time.strftime("%Y-%m-%d %H-%M-%S"))#2017-06-09 14-41-22

print(time.strftime("%Y-%m-%d %X"))#2017-06-09 14:41:22

print(time.mktime(time.localtime()))#1496990564.0  时间戳

#格式化字符串转成结构化时间

print(time.strftime("%Y %X",time.localtime()))#2017 14:48:12

print(time.strptime("2017-06-04 11:11:11","%Y-%m-%d %X"))#time.struct_time(tm_year=2017, tm_mon=6, tm_mday=4, tm_hour=11, tm_min=11, tm_sec=11, tm_wday=6, tm_yday=155, tm_isdst=-1)

print(time.ctime(223342113))#Sat Jan 29 07:28:33 1977   秒转为结构化时间

random模块

import random

print(random.random())#【0,1】，不能取到0和1，只能是之间的小数

print(random.randint(1,3))#[1,3]大于1且小于3的整数 ，包括1,3

print(random.randrange(1,3))#1和3之间的整数，不包括3，包括1【1.3）

a=[1,2,3,4,5,6]

print(random.choice(a))#列表中任意一个

print(random.sample(a,3))#随机选择几个元素，这里是三个，结果是一个列表

print(random.uniform(1,3))#生成1-3之间的小数

random.shuffle(a)#打乱a的顺序

print(a)

随机生成验证码

import random

def v_code():

    code = ''

    for i in range(5):

        num=random.randint(0,9)

        alf=chr(random.randint(65,90))

        add=random.choice([num,alf])

        code += str(add)

    return code

print(v_code())

os模块

常规操作

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下为" ",Linux下为" "

os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:

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

os.path.getsize(path) 返回path的大小

在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。

>>> os.path.normcase('c:/windows\system32\')  

'c:\windows\system32\'  

  

规范化路径，如..和/

>>> os.path.normpath('c://windows\System32\../Temp/')  

'c:\windows\Temp'  

>>> a='/Users/jieli/test1/\a1/\\aa.py/../..'

>>> print(os.path.normpath(a))

/Users/jieli/test1

os路径处理

#方式一：推荐使用

import os

#具体应用

import os,sys

possible_topdir = os.path.normpath(os.path.join(

    os.path.abspath(__file__),

    os.pardir, #上一级

    os.pardir,

    os.pardir

))

sys.path.insert(0,possible_topdir)

#方式二：不推荐使用

os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

sys模块

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

2 sys.exit(n)        退出程序，正常退出时exit(0)

3 sys.version        获取Python解释程序的版本信息

4 sys.maxint         最大的Int值

5 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

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

shutil模块

高级的 文件、文件夹、压缩包 处理模块

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

将文件内容拷贝到另一个文件中

1 import shutil 

3 shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))

shutil.copyfile(src, dst)

拷贝文件

1 shutil.copyfile('f1.log', 'f2.log') #目标文件无需存在

shutil.copymode(src, dst)

仅拷贝权限。内容、组、用户均不变

1 shutil.copymode('f1.log', 'f2.log') #目标文件必须存在

shutil.copystat(src, dst)

仅拷贝状态的信息，包括：mode bits, atime, mtime, flags

1 shutil.copystat('f1.log', 'f2.log') #目标文件必须存在

拷贝文件和权限

shutil.copy(src, dst)

1 import shutil

3 shutil.copy('f1.log', 'f2.log')

拷贝文件和状态信息

shutil.copy2(src, dst)

1 import shutil

3 shutil.copy2('f1.log', 'f2.log')

shutil.ignore_patterns(*patterns)

递归的去拷贝文件夹

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

1 import shutil

2 

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

拷贝软连接

import shutil

shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))

'''

通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件

'''

递归的去删除文件

shutil.rmtree(path[, ignore_errors[, onerror]])

1 import shutil

2 

3 shutil.rmtree('folder1')

递归的去移动文件，它类似mv命令，其实就是重命名。

shutil.move(src, dst)

1 import shutil

3 shutil.move('folder1', 'folder3')

压缩文件

shutil.make_archive(base_name, format,...)

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

• base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
  如 data_bak                       =>保存至当前路径
  如：/tmp/data_bak =>保存至/tmp/
• 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')

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：

zipfile压缩解压缩

import zipfile

# 压缩

z = zipfile.ZipFile('laxi.zip', 'w')

z.write('a.log')

z.write('data.data')

z.close()

# 解压

z = zipfile.ZipFile('laxi.zip', 'r')

z.extractall(path='.')

z.close()

tarfile压缩解压缩

import tarfile

# 压缩

>>> t=tarfile.open('/tmp/egon.tar','w')

>>> t.add('/test1/a.py',arcname='a.bak')

>>> t.add('/test1/b.py',arcname='b.bak')

>>> t.close()

# 解压

>>> t=tarfile.open('/tmp/egon.tar','r')

>>> t.extractall('/egon')

>>> t.close()

六 json&pickle模块

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

1 import json

2 x="[null,true,false,1]"

3 print(eval(x)) #报错，无法解析null类型，而json就可以

4 print(json.loads(x))

什么是序列化？

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。

为什么要序列化？

1：持久保存状态

需知一个软件/程序的执行就在处理一系列状态的变化，在编程语言中，'状态'会以各种各样有结构的数据类型(也可简单的理解为变量)的形式被保存在内存中。

内存是无法永久保存数据的，当程序运行了一段时间，我们断电或者重启程序，内存中关于这个程序的之前一段时间的数据（有结构）都被清空了。

在断电或重启程序之前将程序当前内存中所有的数据都保存下来（保存到文件中），以便于下次程序执行能够从文件中载入之前的数据，然后继续执行，这就是序列化。

具体的来说，你玩使命召唤闯到了第13关，你保存游戏状态，关机走人，下次再玩，还能从上次的位置开始继续闯关。或如，虚拟机状态的挂起等。

2：跨平台数据交互

序列化之后，不仅可以把序列化后的内容写入磁盘，还可以通过网络传输到别的机器上，如果收发的双方约定好实用一种序列化的格式，那么便打破了平台/语言差异化带来的限制，实现了跨平台数据交互。

反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

如何序列化之json和pickle：

json

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

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

复制代码

 1 import json

 2 

 3 dic={'name':'alvin','age':23,'sex':'male'}

 4 print(type(dic))#<class 'dict'>

 5 

 6 j=json.dumps(dic)

 7 print(type(j))#<class 'str'>

 8 

 9 

10 f=open('序列化对象','w')

11 f.write(j)  #-------------------等价于json.dump(dic,f)

12 f.close()

13 #-----------------------------反序列化<br>

14 import json

15 f=open('序列化对象')

16 data=json.loads(f.read())#  等价于data=json.load(f)

复制代码

 注意点

pickle

复制代码

 1 import pickle

 2 

 3 dic={'name':'alvin','age':23,'sex':'male'}

 4 

 5 print(type(dic))#<class 'dict'>

 6 

 7 j=pickle.dumps(dic)

 8 print(type(j))#<class 'bytes'>

 9 

10 

11 f=open('序列化对象_pickle','wb')#注意是w是写入str,wb是写入bytes,j是'bytes'

12 f.write(j)  #-------------------等价于pickle.dump(dic,f)

13 

14 f.close()

15 #-------------------------反序列化

16 import pickle

17 f=open('序列化对象_pickle','rb')

18 

19 data=pickle.loads(f.read())#  等价于data=pickle.load(f)

20 

21 

22 print(data['age'])  

复制代码

    Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

七 shelve模块

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

复制代码

import shelve

f=shelve.open(r'sheve.txt')

# f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}

# f['stu2_info']={'name':'gangdan','age':53}

# f['school_info']={'website':'http://www.pypy.org','city':'beijing'}

print(f['stu1_info']['hobby'])

f.close()

八 xml模块

xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。

xml的格式如下，就是通过<>节点来区别数据结构的:

<?xml version="1.0"?>

<data>

    <country name="Liechtenstein">

        <rank updated="yes">2</rank>

        <year>2008</year>

        <gdppc>141100</gdppc>

        <neighbor name="Austria" direction="E"/>

        <neighbor name="Switzerland" direction="W"/>

    </country>

    <country name="Singapore">

        <rank updated="yes">5</rank>

        <year>2011</year>

        <gdppc>59900</gdppc>

        <neighbor name="Malaysia" direction="N"/>

    </country>

    <country name="Panama">

        <rank updated="yes">69</rank>

        <year>2011</year>

        <gdppc>13600</gdppc>

        <neighbor name="Costa Rica" direction="W"/>

        <neighbor name="Colombia" direction="E"/>

    </country>

</data>

xml协议在各个语言里的都 是支持的，在python中可以用以下模块操作xml：

 

# print(root.iter('year')) #全文搜索

# print(root.find('country')) #在root的子节点找，只找一个

# print(root.findall('country')) #在root的子节点找，找所有

import xml.etree.ElementTree as ET

 

tree = ET.parse("xmltest.xml")

root = tree.getroot()

print(root.tag)

 

#遍历xml文档

for child in root:

    print('========>',child.tag,child.attrib,child.attrib['name'])

    for i in child:

        print(i.tag,i.attrib,i.text)

 

#只遍历year 节点

for node in root.iter('year'):

    print(node.tag,node.text)

#---------------------------------------

 

import xml.etree.ElementTree as ET

 

tree = ET.parse("xmltest.xml")

root = tree.getroot()

 

#修改

for node in root.iter('year'):

    new_year=int(node.text)+1

    node.text=str(new_year)

    node.set('updated','yes')

    node.set('version','1.0')

tree.write('test.xml')

 

 

#删除node

for country in root.findall('country'):

   rank = int(country.find('rank').text)

   if rank > 50:

     root.remove(country)

 

tree.write('output.xml')

自己创建 xml文档

import xml.etree.ElementTree as ET

new_xml = ET.Element("namelist")

name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})

age = ET.SubElement(name,"age",attrib={"checked":"no"})

sex = ET.SubElement(name,"sex")

sex.text = '33'

name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})

age = ET.SubElement(name2,"age")

age.text = '19'

et = ET.ElementTree(new_xml) #生成文档对象

et.write("test.xml", encoding="utf-8",xml_declaration=True)

ET.dump(new_xml) #打印生成的格式

九 configparser模块

配置文件模块

# 注释1

; 注释2

[section1]

k1 = v1

k2:v2

user=egon

age=18

is_admin=true

salary=31

[section2]

k1 = v1

读取

import configparser

config=configparser.ConfigParser()

config.read('a.cfg')

#查看所有的标题

res=config.sections() #['section1', 'section2']

print(res)

#查看标题section1下所有key=value的key

options=config.options('section1')

print(options) #['k1', 'k2', 'user', 'age', 'is_admin', 'salary']

#查看标题section1下所有key=value的(key,value)格式

item_list=config.items('section1')

print(item_list) #[('k1', 'v1'), ('k2', 'v2'), ('user', 'egon'), ('age', '18'), ('is_admin', 'true'), ('salary', '31')]

#查看标题section1下user的值=>字符串格式

val=config.get('section1','user')

print(val) #egon

#查看标题section1下age的值=>整数格式

val1=config.getint('section1','age')

print(val1) #18

#查看标题section1下is_admin的值=>布尔值格式

val2=config.getboolean('section1','is_admin')

print(val2) #True

#查看标题section1下salary的值=>浮点型格式

val3=config.getfloat('section1','salary')

print(val3) #31.0

改写

import configparser

config=configparser.ConfigParser()

config.read('a.cfg')

#删除整个标题section2

config.remove_section('section2')

#删除标题section1下的某个k1和k2

config.remove_option('section1','k1')

config.remove_option('section1','k2')

#判断是否存在某个标题

print(config.has_section('section1'))

#判断标题section1下是否有user

print(config.has_option('section1',''))

#添加一个标题

config.add_section('egon')

#在标题egon下添加name=egon,age=18的配置

config.set('egon','name','egon')

config.set('egon','age',18) #报错,必须是字符串

#最后将修改的内容写入文件,完成最终的修改

config.write(open('a.cfg','w'))

十 hashlib模块

hash：一种算法 ,3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

三个特点：

1.内容相同则hash运算结果相同，内容稍微改变则hash值则变

2.不可逆推

3.相同算法：无论校验多长的数据，得到的哈希值长度固定。

十一 suprocess模块

见老师博客

十二 logging模块

一:如果不指定filename,则默认打印到终端

二:指定日志级别:

    指定方式:

        1:level=10

        2:level=logging.ERROR

 

    日志级别种类:

        CRITICAL = 50

        FATAL = CRITICAL

        ERROR = 40

        WARNING = 30

        WARN = WARNING

        INFO = 20

        DEBUG = 10

        NOTSET = 0

 

三:指定日志级别为ERROR,则只有ERROR及其以上级别的日志会被打印

logging.basicConfig(filename='access.log',

                    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',

                    datefmt='%Y-%m-%d %H:%M:%S %p',

                    level=10)

logging.debug('debug')

logging.info('info')

logging.warning('warning')

logging.error('error')

logging.critical('critical')

logging.log(10,'log') #如果level=40,则只有logging.critical和loggin.error的日志会被打印

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

filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。

filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。

format：指定handler使用的日志显示格式。

datefmt：指定日期时间格式。

level：设置rootlogger（后边会讲解具体概念）的日志级别

stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略

re模块

#在线调试工具:tool.oschina.net/regex/#

#re.findall:找到符合条件的所有结果

# res=re.findall('<ashref=.*?<bstitle="(.*?)".*?b>',content)

# for i in res:

#     print(i)

re.sub:字符串替换

import re

content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings'

 

# content=re.sub('d+','',content)

# print(content)

#用1取得第一个括号的内容

#用法:将123与456换位置

# import re

# content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings'

#

# # content=re.sub('(Extra.*?)(d+)(s)(d+)(.*?strings)',r'14325',content)

# content=re.sub('(d+)(s)(d+)',r'321',content)

# print(content)

# import re

# content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings'

#

# res=re.search('Extra.*?(d+).*strings',content)

# print(res.group(1))

# import requests,re

# respone=requests.get('https://book.douban.com/').text

# print(respone)

# print('======'*1000)

# print('======'*1000)

# print('======'*1000)

# print('======'*1000)

# res=re.findall('<li.*?cover.*?href="(.*?)".*?title="(.*?)">.*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span.*?</li>',respone,re.S)

# # res=re.findall('<li.*?cover.*?href="(.*?)".*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span>.*?</li>',respone,re.S)

#

#

# for i in res:

#     print('%s    %s    %s   %s' %(i[0].strip(),i[1].strip(),i[2].strip(),i[3].strip()))