zoukankan      html  css  js  c++  java
  • 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

    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

    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()))

  • 相关阅读:
    Spark&Hive结合起来
    spark&dataframe
    JAVA-数组或集合
    九种经典排序算法详解(冒泡排序,插入排序,选择排序,快速排序,归并排序,堆排序,计数排序,桶排序,基数排序)
    B+树介绍
    @transactional注解在什么情况下会失效,为什么。
    一个ArrayList在循环过程中删除,会不会出问题,为什么?
    Java:传值还是传引用?
    Java序列化的方式。
    实现动态代理的两种方式
  • 原文地址:https://www.cnblogs.com/doudouzheng/p/6973857.html
Copyright © 2011-2022 走看看