精华内容
下载资源
问答
  • python常用模块有哪些?
    千次阅读
    2021-01-29 23:28:31

    本文和大家分享的主要是python中常用几大模块相关内容,一起来看看吧,希望对大家学习python有所帮助。

    一、时间模块(time)

    在学习模块之前我们所接触的时间模块

    import time

    time.sleep(1)#(线程)推迟指定的时间运行。单位为秒。time.time()#获取当前时间戳

    简单使用

    表示时间的三种方式

    在Python中,通常有这三种方式来表示时间:时间戳、元组(struct_time)、格式化的时间字符串:

    1、时间戳(timestamp):时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量

    2、格式化的时间字符串(Format String):2017-8-8

    %y 两位数的年份表示(00-99)%Y四位数的年份表示(000-9999)%m月份(01-12)%d月内中的一天(0-31)%H 24小时制小时数(0-23)%I 12小时制小时数(01-12)%M分钟数(00=59)%S秒(00-59)%a本地简化星期名称%A本地完整星期名称%b本地简化的月份名称%B本地完整的月份名称%c本地相应的日期表示和时间表示%j年内的一天(001-366)%p本地A.M.或P.M.的等价符%U一年中的星期数(00-53)星期天为星期的开始%w星期(0-6),星期天为星期的开始%W一年中的星期数(00-53)星期一为星期的开始%x本地相应的日期表示%X本地相应的时间表示%Z当前时区的名称%% %号本身

    python中时间日期格式化符号

    3、元组(struct_time):struct_time元组共有9个元素共九个元素:time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=16, tm_min=37, tm_sec=23, tm_wday=1, tm_yday=220, tm_isdst=0)

    tm_year(年)比如2011

    tm_mon(月)1 - 12

    tm_mday(日)1 - 31

    tm_hour(时)0 - 23

    tm_min(分)0 - 59

    tm_sec(秒)0 - 61

    tm_wday(weekday)0 - 6(0表示周日)

    tm_yday(一年中的第几天)1 - 366

    tm_isdst(是否是夏令时)默认为-1

    python中时间日期结构化属性

    python中表示时间的几种格式

    import time

    #数字,时间戳print(time.time())  #在存时间 并且给计算机用的时候

    #格式化的时间字符串print(time.strftime("%y/%m/%d %H:%M:%S"))   #展示 : 打印时间的时候 需要记录的时候

    #结构化的时间元组print(time.localtime())  #用于计算机对时间进行计算

    表示时间的格式

    小结:时间戳是计算机能够识别的时间;时间字符串是人能够看懂的时间;元组则是用来操作时间的

    几种格式之间的转换

    import time

    #时间戳-->结构化print(time.gmtime(1500000000))print(time.localtime(1500000000))print(time.localtime(3000000000))print(time.time())

    #结构化-->时间戳

    t = time.localtime()print(t)print(time.mktime(t))

    #结构化-->格式化

    t = time.localtime()s = time.strftime("%B",t)s = time.strftime("%a %b %d %H:%M:%S %Y",t)print(s)

    #格式化-->结构化print(time.strptime(s,"%Y-%m-%d %H"))

    时间格式转化

    注意:格式化和时间戳不能直接转换

    生成固定格式的时间表示格式

    print(time.asctime(time.localtime()))

    print(time.ctime(time.time()))# Tue Aug  8 16:54:09 2017

    #如果不传参返回当前时间

    View Code

    二、romdom模块

    import random

    #随机小数

    random.random()      # 大于0且小于1之间的小数

    random.uniform(1,3) #大于1小于3的小数

    #随机整数

    random.randint(1,5)  # 大于等于1且小于等于5之间的整数

    random.randrange(1,10,2) # 大于等于1且小于10之间的奇数

    #随机选择一个返回

    random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]#随机选择多个返回,返回的个数为函数的第二个参数

    random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合

    #打乱列表顺序

    item=[1,3,5,7,9]

    random.shuffle(item) # 打乱次序

    三、sys模块

    sys模块是与python解释器交互的一个接口

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

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

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

    sys.maxsize         最大的Int值

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

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

    import sysprint(sys.argv)

    # name = sys.argv[1]

    # password = sys.argv[2]

    # if name == 'egon' and password == 'somebody':

    #     print('继续执行程序')

    # else:

    #     exit()

    # sys.exit()print(sys.version)print(sys.maxsize)print(sys.path)

    # sys.path.clear()  #清除下载的模块

    import requestsprint(sys.platform)

    四、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下为"\t\n",Linux下为"\n"

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

    os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

    os.system("bash command")  运行shell命令,直接显示

    os.popen("bash command)  运行shell命令,获取执行结果

    os.environ  获取系统环境变量

    os.path

    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的大小

    注意:os.stat ('path/filename' )    获取文件/目录信息的结构说明

    stat 结构:

    st_mode: inode 保护模式st_ino: inode节点号。st_dev: inode驻留的设备。st_nlink: inode的链接数。st_uid:所有者的用户ID。st_gid:所有者的组ID。st_size:普通文件以字节为单位的大小;包含等待某些特殊文件的数据。st_atime:上次访问的时间。st_mtime:最后一次修改的时间。st_ctime:由操作系统报告的"ctime"。在某些系统上(如Unix)是最新的元数据更改的时间,在其它系统上(如Windows)是创建时间(详细信息参见平台的文档)。

    stat 结构

    五、序列化模块

    什么叫序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化

    提到转换我们就会想到一个内置函数eval(),这么强大的函数我们为什么不建议大家用呢?eval()可以 将字符串str当成有效的表达式来求值并返回计算结果。这么强大的功能使它有一个致命的缺点: 安全性。 如果我们从文件中读出的不是一个数据结构,而是一句具有破坏性的语句,那么后果实在不堪设设想。而使用eval就要担这个风险。

    序列化的目的

    1、以某种存储形式使自定义对象持久化 ;

    2、将对象从一个地方传递到另一个地方。

    3、使程序更具维护性。

    1、json模块

    Json模块提供了四个功能:dumps、dump、loads、load:

    d = {'1':{'k':[1,2,3,4]}}

    s = str(d)print(s,type(s))print(eval(s),type(eval(s)))  #不安全

    import json#序列化将d转换为字符串#json转换完的字符串类型的字典中的字符串是由""表示的

    ret_s = json.dumps(d)print(ret_s,type(ret_s))

    #反序列化将字符串格式的字典转换成一个字典

    ret_d = json.loads(ret_s)print(ret_d,type(ret_d))

    f = open('json_file','w')

    dic = {'k1':'v1','k2':'v2','k3':'v3'}#可以直接接收句柄操作

    json.dump(dic,f)# f.write(json.dumps(dic))

    f.close()

    f = open('json_file')#可以直接接收句柄操作

    dic2 = json.load(f)print(dic2,type(dic2))

    f.close()

    方法简介

    2、pickle模块

    和json区别:你序列化的内容如果是列表或者字典,使用json模块。 但如果序列化其他的数据类型,而未来你还会用python对这个数据进行反序列化的话,那么就可以使用pickle。如果是使用json序列化的其他语言可以使用,pickle不可以。

    pickle模块提供了四个功能:dumps、dump、loads、load:

    import pickle

    tu = {1,2,3,4}

    pik_b = pickle.dumps(tu)

    print(pik_b)  #二进制内容

    print(pickle.loads(pik_b))  #集合

    #其它两个方法的区别和json一样也是可以直接操作句柄

    方法简介

    3、shelve模块

    shelve只提供给我们一个open方法,是用key来访问的,使用起来和字典类似。

    import shelve

    f = shelve.open('shelve_file')

    f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作,就可以存入数据

    f.close()

    f1 = shelve.open('shelve_file')

    f1['key']['str'] = 'Sample'#取出数据的时候也只需要直接用key获取即可,但是如果key不存在会报错

    print(f1['key'])

    f1 = shelve.open('shelve_file',writeback=True)#如果想将修改后的结果同步到文件需要修改参数

    f1['key']['str'] = 'Sample'

    print(f1['key'])

    方法使用

    使用writeback以后,会增加额外的内存消耗

    来源:博客园

    更多相关内容
  • python常用模块

    2018-01-08 20:12:41
    这个模块提供了一个轻便的方法使用要依赖操作系统的功能。 如何你只是想读或写文件,请使用open() ,如果你想操作文件路径,请使用os.path模块,如果你想在命令行中,读入所有文件的所有行,请使用 fileinput模块。...
  • Python常用模块介绍

    2020-12-25 17:24:58
    python除了关键字(keywords)和内置的类型和...* pickle: pickle模块被用来序列化python的对象到bytes流,从而适合存储到文件,网络传输,或数据库存储。(pickle的过程也被称serializing,marshalling或者flattening
  • python常用模块打包.zip

    2020-11-19 00:03:10
    1.beautifulsoup4-4.5.1.tar 2.beautifulsoup4-4.5.1.tar 3.chardet-3.0.4-py2.py3-none-any 4.cssselect-1.1.0-py2.py3-none-any 5.idna-2.8-py2.py3-none-any 6.lxml-4.5.2-cp36-cp36m-win_amd64 ...
  • 这篇文章主要介绍了Python常用模块sys,os,time,random功能与用法,结合实例形式分析了Python模块sys,os,time,random功能、原理、相关模块函数、使用技巧与操作注意事项,需要的朋友可以参考下 本文实例讲述了Python...
  • Python常用模块大全

    千次阅读 多人点赞 2021-12-22 20:33:01
    Python常用模块大全(总结) 时间模块time() 与 datetime() time()模块中的重要函数 time()模块时间格式转换 time()模块时间转换 时间戳 1970年1月1日之后的秒, 即:time.time() 格式化的字符串 2014-11-11 ...

    文章目录


    Python常用模块大全(总结)

    一、时间模块time() 与 datetime()

    time()模块中的重要函数

    在这里插入图片描述

    time()模块时间格式转换

    在这里插入图片描述

    time()模块时间转换

    1. 时间戳 1970年1月1日之后的秒, 即:time.time()

    2. 格式化的字符串 2014-11-11 11:11, 即:time.strftime(’%Y-%m-%d’)

    3. 结构化时间 元组包含了:年、日、星期等… time.struct_time 即:time.localtime()

      import time
      print(time.time())                              # 时间戳:1511166937.2178104
      print(time.strftime('%Y-%m-%d'))                # 格式化的字符串: 2017-11-20
      print(time.localtime())                         # 结构化时间(元组): 
      (tm_year=2017, tm_mon=11...)
      print(time.gmtime())                            # 将时间转换成utc格式的元组格式: 
      (tm_year=2017, tm_mon=11...)
      
      #1. 将结构化时间转换成时间戳: 1511167004.0
      print(time.mktime(time.localtime()))
      

      #2. 将格字符串时间转换成结构化时间 元组: (tm_year=2017, tm_mon=11...)
      print(time.strptime('2014-11-11', '%Y-%m-%d'))
      

      #3. 结构化时间(元组) 转换成  字符串时间  :2017-11-20
      print(time.strftime('%Y-%m-%d', time.localtime()))  # 默认当前时间
      

      #4. 将结构化时间(元组) 转换成英文字符串时间 : Mon Nov 20 16:51:28 2017
      print(time.asctime(time.localtime()))
      

      #5. 将时间戳转成 英文字符串时间 : Mon Nov 20 16:51:28 2017
      print(time.ctime(time.time()))
      

    ctime和asctime区别

    1)ctime传入的是以秒计时的时间戳转换成格式化时间
    2)asctime传入的是时间元组转换成格式化时间

    import time
    t1 = time.time()
    print(t1)               #1483495728.4734166
    print(time.ctime(t1))   #Wed Jan  4 10:08:48 2017
    t2 = time.localtime()
    print(t2)               #time.struct_time(tm_year=2017, tm_mon=1, tm_mday=4,     
    tm_hour=10, print(time.asctime(t2)) #Wed Jan  4 10:08:48 2017
    

    datetime获取时间

    import datetime
    #1、datetime.datetime获取当前时间
    print(datetime.datetime.now())
    #2、获取三天后的时间
    print(datetime.datetime.now()+datetime.timedelta(+3))
    #3、获取三天前的时间
    print(datetime.datetime.now()+datetime.timedelta(-3))
    #4、获取三个小时后的时间
    print(datetime.datetime.now()+datetime.timedelta(hours=3))
    #5、获取三分钟以前的时间
    print(datetime.datetime.now()+datetime.timedelta(minutes = -3))
    
    import datetime
    print(datetime.datetime.now())                                   #2017-08-18 
    11:25:52.618873
    print(datetime.datetime.now().date())                            #2017-08-18
    print(datetime.datetime.now().strftime("%Y-%m-%d %H-%M-%S"))        
    #2017-08-18 11-25-52
    

    datetime时间转换

    #1、datetime对象与str转化
    # datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    '2018-03-09 10:08:50'
    
    # datetime.datetime.strptime('2016-02-22',"%Y-%m-%d")
    datetime.datetime(2016, 2, 22, 0, 0)
    

    #2、datetime对象转时间元组
    # datetime.datetime.now().timetuple()
    time.struct_time(tm_year=2018, tm_mon=3, tm_mday=9,
    

    #3、时间戳转换成datetime对象
    # datetime.datetime.fromtimestamp(1520561646.8906238)
    datetime.datetime(2018, 3, 9, 10, 14, 6, 890624)
    

    本地时间与utc时间相互转换

    # 本地时间与utc时间相互转换
    import time
    import datetime
    
    def utc2local(utc_st):
        ''' 作用:将UTC时间装换成本地时间
        :param utc_st: 传入的是utc时间(datatime对象)
        :return:  返回的是本地时间 datetime 对象
        '''
        now_stamp = time.time()
        local_time = datetime.datetime.fromtimestamp(now_stamp)
        utc_time = datetime.datetime.utcfromtimestamp(now_stamp)
        offset = local_time - utc_time
        local_st = utc_st + offset
        return local_st
    
    def local2utc(local_st):
        ''' 作用:将本地时间转换成UTC时间
        :param local_st: 传入的是本地时间(datatime对象)
        :return: 返回的是utc时间 datetime 对象
        '''
        time_struct = time.mktime(local_st.timetuple())
        utc_st = datetime.datetime.utcfromtimestamp(time_struct)
        return utc_st
    
    utc_time = datetime.datetime.utcfromtimestamp(time.time())
    # utc_time = datetime.datetime(2018, 5, 6, 5, 57, 9, 511870)        # 比北京时间
    晚了8个小时
    local_time = datetime.datetime.now()
    # local_time = datetime.datetime(2018, 5, 6, 13, 59, 27, 120771)    # 北京本地时间
    
    utc_to_local = utc2local(utc_time)
    local_to_utc = local2utc(local_time)
    print utc_to_local       # 2018-05-06 14:02:30.650270     已经转换成了北京本地时间
    print local_to_utc       # 2018-05-06 06:02:30            转换成北京当地时间
    

    django的timezone时间与本地时间转换

    # django的timezone时间与本地时间转换
    from django.utils import timezone
    from datetime import datetime
    
    utc_time = timezone.now()
    local_time = datetime.now()
    
    #1、utc时间装换成本地时间
    utc_to_local = timezone.localtime(timezone.now())
    

    #2、本地时间装utc时间
    local_to_utc = timezone.make_aware(datetime.now(),  
    timezone.get_current_timezone())
    

    Python计算两个日期之间天数

    import datetime
    d1 = datetime.datetime(2018,10,31)   # 第一个日期
    d2 = datetime.datetime(2019,2,2)     # 第二个日期
    interval = d2 - d1                   # 两日期差距
    print(interval.days)                 # 具体的天数
    

    二、random()模块

    random()模块常用函数

    在这里插入图片描述

    random常用函数举例

    import random
    #⒈ 随机整数:
    print(random.randint(0,99))             # 随机选取0-99之间的整数
    print(random.randrange(0, 101, 2))      # 随机选取0-101之间的偶数
    

    #⒉ 随机浮点数:
    print(random.random())                   # 0.972654134347
    print(random.uniform(1, 10))             # 4.14709813772
    

    #⒊ 随机字符:
    print(random.choice('abcdefg'))         # c
    print(random.sample('abcdefghij',3))    # ['j', 'f', 'c']
    

    使用random实现四位验证码

    1.使用for循环实现
    #使用for循环实现
    import random
    checkcode = ''
    for i in range(4):
    current = random.randrange(0,4)
    if current == i:
        tmp = chr(random.randint(65,90))    #65,90表示所有大写字母
    else:
        tmp = random.randint(0,9)
    checkcode += str(tmp)
    print(checkcode)                            #运行结果: 851K
    
    2.使用random.sample实现
    import random
    import string
    str_source = string.ascii_letters + string.digits
    str_list = random.sample(str_source,7)
    
    #['i', 'Q', 'U', 'u', 'A', '0', '9']
    print(str_list)
    str_final = ''.join(str_list)
    
    #iQUuA09
    print(str_final)            # 运行结果: jkFU2Ed
    

    三、os模块

    os模块常用方法

    import os
    #1 当前工作目录,即当前python脚本工作的目录路径
    print(os.getcwd())    # C:\Users\admin\PycharmProjects\s14\Day5\test4
    

    #2 当前脚本工作目录;相当于shell下cd
    os.chdir("C:\\Users\\admin\\PycharmProjects\\s14")
    os.chdir(r"C:\Users\admin\PycharmProjects\s14")
    print(os.getcwd())    # C:\Users\admin\PycharmProjects\s14
    

    #3 返回当前目录: ('.')
    print(os.curdir)        # ('.')
    

    #4 获取当前目录的父目录字符串名:('..')
    print(os.pardir)        # ('..')
    

    #5 可生成多层递归目录
    os.makedirs(r'C:\aaa\bbb')         # 可以发现在C盘创建了文件夹/aaa/bbb
    

    #6 若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
    os.removedirs(r'C:\aaa\bbb')    # 删除所有空目录
    

    #7 生成单级目录;相当于shell中mkdir dirname
    os.mkdir(r'C:\bbb')        # 仅能创建单个目录
    

    #8 删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir
    dirname
    os.rmdir(r'C:\aaa')        # 仅删除指定的一个空目录
    

    #9 列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
    print(os.listdir(r"C:\Users\admin\PycharmProjects\s14"))
    

    #10 删除一个文件
    os.remove(r'C:\bbb\test.txt')        # 指定删除test.txt文件
    

    #11 重命名文件/目录
    os.rename(r'C:\bbb\test.txt',r'C:\bbb\test00.bak')
    

    #12 获取文件/目录信息
    print(os.stat(r'C:\bbb\test.txt'))
    

    #13 输出操作系统特定的路径分隔符,win下为"\\",Linux下为"/"
    print(os.sep)                # \
    

    #14 输出当前平台使用的行终止符,win下为"\r\n",Linux下为"\n"
    print(os.linesep)
    

    #15 输出用于分割文件路径的字符串
    print(os.pathsep)                # ;  (分号)
    

    #16 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
    print(os.name)                # nt
    

    #17 运行shell命令,直接显示
    os.system("bash command")
    

    #18 获取系统环境变量
    print(os.environ)                # environ({'OS': 'Windows_NT', 'PUBLIC': ………….
    

    #19 返回path规范化的绝对路径
    print(os.path.abspath(r'C:/bbb/test.txt'))    # C:\bbb\test.txt
    

    #20 将path分割成目录和文件名二元组返回
    print(os.path.split(r'C:/bbb/ccc'))    # ('C:/bbb', 'ccc')
    

    #21 返回path的目录。其实就是os.path.split(path)的第一个元素
    print(os.path.dirname(r'C:/bbb/ccc'))    # C:/bbb
    

    #22 返回path最后的文件名。如何path以/或\结尾,那么就会返回空值。即
    os.path.split(path)的第二个元素
    print(os.path.basename(r'C:/bbb/ccc/ddd'))    # ddd
    

    #23 如果path存在,返回True;如果path不存在,返回False
    print(os.path.exists(r'C:/bbb/ccc/'))    # True
    

    #24 如果path是绝对路径,返回True        # True
    print(os.path.isabs(r"C:\Users\admin\PycharmProjects\s14\Day5\test4"))
    

    #25 如果path是一个存在的文件,返回True。否则返回False
    print(os.path.isfile(r'C:/bbb/ccc/test2.txt'))        # True
    

    #26 如果path是一个存在的目录,则返回True。否则返回False
    print(os.path.isdir(r'C:/bbb/ccc'))            # True
    

    #28 返回path所指向的文件或者目录的最后存取时间
    print(os.path.getatime(r'C:/bbb/ccc/test2.txt'))        # 1483509254.9647143
    

    #29 返回path所指向的文件或者目录的最后修改时间
    print(os.path.getmtime(r'C:/bbb/ccc/test2.txt'))        # 1483510068.746478
    

    #30 无论linux还是windows,拼接出文件路径
    put_filename = '%s%s%s'%(self.home,os. path.sep, filename)
    #C:\Users\admin\PycharmProjects\s14\day10select版FTP\home
    

    os命令创建文件夹: C:/aaa/bbb/ccc/ddd并写入文件file1.txt

    import os
    
    os.makedirs('C:/aaa/bbb/ccc/ddd',exist_ok=True)         # exist_ok=True:如果存
    在当前文件夹不报错
    path = os.path.join('C:/aaa/bbb/ccc','ddd',)
    f_path = os.path.join(path,'file.txt')
    
    with open(f_path,'w',encoding='utf8') as f:
    f.write('are you ok!!')
    

    将其他目录的绝对路径动态的添加到pyhton的环境变量中

    import os,sys
    print(os.path.dirname( os.path.dirname( os.path.abspath(__file__) ) ))
    BASE_DIR = os.path.dirname( os.path.dirname( os.path.abspath(__file__) ) )
    sys.path.append(BASE_DIR)
    
    # 代码解释:
    # 要想导入其他目录中的函数,其实就是将其他目录的绝对路径动态的添加到
    pyhton的环境变量中,这样python解释器就能够在运行时找到导入的模块而不报
    错:
    # 然后调用sys模块sys.path.append(BASE_DIR)就可以将这条路径添加到python
    环境变量中
    

    os.popen获取脚本执行结果

    1.data.py
    data = {'name':'aaa'}
    import json
    print json.dumps(data)
    
    2.get_data.py
    #! /usr/bin/env python
    # -*- coding: utf-8 -*-
    import os,json
    
    ret = os.popen('python data.py')
    data = ret.read().strip()
    ret.close()
    data = json.loads(data)
    print data  # {'name':'aaa'}
    

    四、sys模块

    1、 sys基本方法

    sys.argv     返回执行脚本传入的参数
    
    sys.exit(n)      退出程序,正常退出时exit(0)
    
    sys.version    获取Python解释程序的版本信息
    
    sys.maxint    最大的Int值
    
    sys.path    返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
    
    sys.platform    返回操作系统平台名称
    
    sys.stdout.write(‘please:’)
    
    val = sys.stdin.readline()[:-1]
    

    2、使用sys返回运行脚本参数

    import sys
    # C:\Users\tom\PycharmProjects\s14Review\day01>  python test01.py 1 2 3
    print(sys.argv)         # 打印所有参数                 ['test01.py', '1', '2', '3']
    print(sys.argv[1:])     # 获取索引 1 往后的所有参数     ['1', '2', '3']
    

    tarfile用于将文件夹归档成 .tar的文件

    tarfile使用

    import tarfile
    # 将文件夹Day1和Day2归档成your.rar并且在归档文件夹中Day1和Day2分别变成
    bbs2.zip和ccdb.zip的压缩文件
    tar = tarfile.open('your.tar','w')
    tar.add(r'C:\Users\admin\PycharmProjects\s14\Day1', arcname='bbs2.zip')
    tar.add(r'C:\Users\admin\PycharmProjects\s14\Day2', arcname='cmdb.zip')
    tar.close()
    

    # 将刚刚的归档文件your.tar进行解压解压的内容是bbs2.zip和cmdb.zip压缩文件
    而不是变成原有的文件夹
    tar = tarfile.open('your.tar','r')
    tar.extractall()  # 可设置解压地址
    tar.close()
    

    shutil 创建压缩包,复制,移动文件

    : shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的  作用: shutil 创建压缩包并返回文件路径(如:zip、tar),并且可以复制文件,移动文件

    shutil使用

    import shutil
    #1 copyfileobj()  将文件test11.txt中的内容复制到test22.txt文件中
    f1 = open("test11.txt",encoding="utf-8")
    f2 = open("test22.txt",'w',encoding="utf-8")
    shutil.copyfileobj(f1,f2)
    

    #2  copyfile()  直接指定文件名就可进行复制
    shutil.copyfile("test11.txt",'test33.txt')
    

    #3  shutil.copymode(src, dst) 仅拷贝权限。内容、组、用户均不变
    

    #4  shutil.copystat(src, dst)  拷贝状态的信息,包括:mode bits, atime, mtime, 
    flags
    shutil.copystat('test11.txt','test44.txt')
    

    #5  递归的去拷贝目录中的所有目录和文件,这里的test_dir是一个文件夹,包含多
    级文件夹和文件
    shutil.copytree("test_dir","new_test_dir")
    

    #6  递归的去删除目录中的所有目录和文件,这里的test_dir是一个文件夹,包含多
    级文件夹和文件
    shutil.rmtree("test_dir")
    

    #7 shutil.move(src, dst)  递归的去移动文件
    shutil.move('os_test.py',r'C:\\')
    

    #8  shutil.make_archive(base_name, format,...) 创建压缩包并返回文件路径,例
    如:zip、tar
    ' ' '
    
    1. base_name: 压缩包的文件名,也可以是压缩包的路径。只是文件名时,则保存至当前目录,否则保存至指定路径,
      如:www =>保存至当前路径
      如:/Users/wupeiqi/www =>保存至/Users/wupeiqi/
    2. format: 压缩包种类,“zip”, “tar”, “bztar”,“gztar”
    3. root_dir: 要压缩的文件夹路径(默认当前目录)
    4. owner: 用户,默认当前用户
    5. group: 组,默认当前组
    6. logger: 用于记录日志,通常是logging.Logger对象

    ’ ’ ’

    #将C:\Users\admin\PycharmProjects\s14\Day4 的文件夹压缩成 testaa.zip
    shutil.make_archive("testaa","zip",r"C:\Users\admin\PycharmProjects    
    \s14\Day4")
    

    zipfile将文件或文件夹进行压缩

    zipfile使用

    import zipfile
    #将文件main.py和test11.py压缩成day5.zip的压缩文件
    z = zipfile.ZipFile('day5.zip', 'w')
    z.write('main.py')
    z.write("test11.txt")
    z.close()
    

    #将刚刚压缩的day5.zip文件进行解压成原文件
    z = zipfile.ZipFile('day5.zip', 'r')
    z.extractall()
    z.close()
    

    五、shelve 模块

    作用:shelve模块是一个简单的k,v将内存数据通过文件持久化的模块,可以持久化任何pickle可支持的python数据格式

    shelve持久化

    import shelve
    import datetime
    #1 首先使用shelve将.py中定义的字典列表等读取到指定文件shelve_test中,其
    实我们可不必关心在文件中是怎样存储的
    d = shelve.open('shelve_test')   #打开一个文件
    info = {"age":22,"job":"it"}
    name = ["alex","rain","test"]
    d["name"] = name                  #持久化列表
    d["info"] = info
    d["date"] = datetime.datetime.now()
    d.close()
    

    #2 在这里我们可以将刚刚读取到 shelve_test文件中的内容从新获取出来
    d = shelve.open('shelve_test')   # 打开一个文件
    print(d.get("name"))             # ['alex', 'rain', 'test']
    print(d.get("info"))             # {'job': 'it', 'age': 22}
    print(d.get("date"))             # 2017-11-20 17:54:21.223410
    

    json和pickle序列化

    1、json序列化

    1. 序列化 (json.dumps) :是将内存中的对象存储到硬盘,变成字符串

    2. 反序列化(json.loads) : 将刚刚保存在硬盘中的内存对象从新加载到内存中

      json.dumps( data,ensure_ascii=False, indent=4)
      

    json序列化

    #json序列化代码
    import json
    info = {
        'name':"tom",
        "age" :"100"
    }
    f = open("test.txt",'w')
    # print(json.dumps(info))
    f.write(json.dumps(info))
    f.close()
    

    json反序列化

    #json反序列化代码
    import json
    f = open("test.txt","r")
    data = json.loads(f.read())
    f.close()
    print(data["age"])
    

    2、pickle序列化

    1. python的pickle模块实现了python的所有数据序列和反序列化。基本上功能使用和JSON模块没有太大区别,方法也同样是dumps/dump和loads/load

    2. 与JSON不同的是pickle不是用于多种语言间的数据传输,它仅作为python对象的持久化或者python程序间进行互相传输对象的方法,因此它支持了python所有的数据类型。

    pickle序列化

    #pickle序列化代码
    import pickle
    info = {
        'name':"tom",
        "age" :"100"
    }
    f = open("test.txt",'wb')
    f.write(pickle.dumps(info))
    f.close()
    

    pickle反序列化

    #pickle反序列化代码
    import pickle
    f = open("test.txt","rb")
    data = pickle.loads(f.read())
    f.close()
    print(data["age"])
    

    3、解决JSON不可以序列化datetime类型

    解决json无法序列化时间格式
    import json,datetime
    
    class JsonCustomEncoder(json.JSONEncoder):
        def default(self, field):
            if isinstance(field, datetime.datetime):
                return field.strftime('%Y-%m-%d %H:%M:%S')
            elif isinstance(field, datetime.date):
                return field.strftime('%Y-%m-%d')
            else:
                return json.JSONEncoder.default(self, field)
    
    t = datetime.datetime.now()
    
    print(type(t),t)
    f = open('ttt','w')                              #指定将内容写入到ttt文件中
    f.write(json.dumps(t,cls=JsonCustomEncoder))      #使用时候只要在json.dumps
    增加个cls参数即可
    

    4、JSON和pickle模块的区别

    1. JSON只能处理基本数据类型。pickle能处理所有Python的数据类型。

    2. JSON用于各种语言之间的字符转换。pickle用于Python程序对象的持久化或者Python程序间对象网络传输,但不同版本的Python序列化可能还有差异

    hashlib 模块

    1、用于加密相关的操作,代替了md5模块和sha模块,主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ,MD5 算法

    五种简单加密方式

        import hashlib
    
        #1 ######## md5 ########
    # 目的:实现对b"HelloIt's me" 这句话进行md5加密
    m = hashlib.md5()            # 1)生成一个md5加密对象
    m.update(b"Hello")          # 2)使用m对 b"Hello" 加密
    m.update(b"It's me")        # 3) 使用m对 b"It's me"加密
    print(m.hexdigest())         # 4) 最终加密结果就是对b"HelloIt's me"加密的md5
    值:5ddeb47b2f925ad0bf249c52e342728a
    

    #2 ######## sha1 ########
    hash = hashlib.sha1()
    hash.update(b'admin')
    print(hash.hexdigest())
    

    #3 ######## sha256 ########
    hash = hashlib.sha256()
    hash.update(b'admin')
    print(hash.hexdigest())
    

    #4 ######## sha384 ########
    hash = hashlib.sha384()
    hash.update(b'admin')
    print(hash.hexdigest())
    

    #5 ######## sha512 ########
    hash = hashlib.sha512()
    hash.update(b'admin')
    print(hash.hexdigest())
    

    2、以上加密算法虽然依然非常厉害,但时候存在缺陷,即:通过撞库可以反解。所以,有必要对加密算法中添加自定义key再来做加密。

    hmac添加自定义key加密

    ######### hmac ########
    import hmac
    h = hmac.new(b"123456","真实要传的内容".encode(encoding="utf-8"))
    print(h.digest())
    print(h.hexdigest())
    # 注:hmac是一种双重加密方法,前面是加密的内容,后面才是真实要传的数据
    信息
    

    六、subprocess 模块

    1、subprocess原理以及常用的封装函数

    1. 运行python的时候,我们都是在创建并运行一个进程。像Linux进程那样,一个进程可以fork一个子进程,并让这个子进程exec另外一个程序
    2. 在Python中,我们通过标准库中的subprocess包来fork一个子进程,并运行一个外部的程序。
    3. subprocess包中定义有数个创建子进程的函数,这些函数分别以不同的方式创建子进程,所以我们可以根据需要来从中选取一个使用
    4. 另外subprocess还提供了一些管理标准流(standard stream)和管道(pipe)的工具,从而在进程间使用文本通信。

    subprocess常用函数

    #1、返回执行状态:0 执行成功

    retcode = subprocess.call(['ping', 'www.baidu.com', '-c5'])
    

    #2、返回执行状态:0 执行成功,否则抛异常

    subprocess.check_call(["ls", "-l"])
    

    #3、执行结果为元组:第1个元素是执行状态,第2个是命令结果

    >>> ret = subprocess.getstatusoutput('pwd')
    >>> ret
    (0, '/test01')
    

    #4、返回结果为 字符串 类型

    >>> ret = subprocess.getoutput('ls -a')
    >>> ret
    '.\n..\ntest.py'
    

    #5、返回结果为’bytes’类型

    >>> res=subprocess.check_output(['ls','-l'])
    >>> res.decode('utf8')
    '总用量 4\n-rwxrwxrwx. 1 root root 334 11月 21 09:02 test.py\n'
    

    将dos格式文件转换成unix格式

    subprocess.check_output(['chmod', '+x', filepath])
    subprocess.check_output(['dos2unix', filepath])
    

    2、subprocess.Popen()

    1. 实际上,上面的几个函数都是基于Popen()的封装(wrapper),这些封装的目的在于让我们容易使用子进程

    2. 当我们想要更个性化我们的需求的时候,就要转向Popen类,该类生成的对象用来代表子进程

    3. 与上面的封装不同,Popen对象创建后,主程序不会自动等待子进程完成。我们必须调用对象的wait()方法,父进程才会等待 (也就是阻塞block)

    4. 从运行结果中看到,父进程在开启子进程之后并没有等待child的完成,而是直接运行print。

    chil

    #1、先打印'parent process'不等待child的完成
    import subprocess
    child = subprocess.Popen(['ping','-c','4','www.baidu.com'])
    print('parent process')
    

    #2、后打印'parent process'等待child的完成
    import subprocess
    child = subprocess.Popen('ping -c4 www.baidu.com',shell=True)
    child.wait()
    print('parent process')
    

    child.poll() # 检查子进程状态
                    child.kill() # 终止子进程
                    child.send_signal() # 向子进程发送信号
                    child.terminate() # 终止子进程
    

    3、subprocess.PIPE 将多个子进程的输入和输出连接在一起

    1. subprocess.PIPE实际上为文本流提供一个缓存区。child1的stdout将文本输出到缓存区,随后child2的stdin从该PIPE中将文本读取走

    2. child2的输出文本也被存放在PIPE中,直到communicate()方法从PIPE中读取出PIPE中的文本。

    3. 注意:communicate()是Popen对象的一个方法,该方法会阻塞父进程,直到子进程完成

    分步执行cat /etc/passwd | grep root命

    import subprocess
    #下面执行命令等价于: cat /etc/passwd | grep root
    child1 = subprocess.Popen(["cat","/etc/passwd"], stdout=subprocess.PIPE)
    child2 = subprocess.Popen(["grep","root"],stdin=child1.stdout, 
    stdout=subprocess.PIPE)
    out = child2.communicate()               #返回执行结果是元组
    print(out)
    #执行结果: (b'root:x:0:0:root:/root:/bin/bash\noperator:x:11:0:operator:/root:
    /sbin/nologin\n', None)
    

    获取ping命令执行结果

    import subprocess
    
    list_tmp = []
    def main():
        p = subprocess.Popen(['ping', 'www.baidu.com', '-c5'], stdin =     subprocess.PIPE, stdout = subprocess.PIPE)
        while subprocess.Popen.poll(p) == None:
            r = p.stdout.readline().strip().decode('utf-8')
            if r:
                # print(r)
                v = p.stdout.read().strip().decode('utf-8')
                list_tmp.append(v)
    main()
    print(list_tmp[0])
    

    七、re模块

    常用正则表达式符号

    ⒈通配符( . )

    作用:点(.)可以匹配除换行符以外的任意一个字符串

    例如:‘.ython’ 可以匹配‘aython’ ‘bython’ 等等,但只能匹配一个字符串

    ⒉转义字符( \ )

    作用:可以将其他有特殊意义的字符串以原本意思表示

    例如:‘python.org’ 因为字符串中有一个特殊意义的字符串(.)所以如果想将其按照普通意义就必须使用这样表示: ‘python.org’ 这样就只会匹配‘python.org’ 了

    注:如果想对反斜线(\)自身转义可以使用双反斜线(\)这样就表示 ’\’

    ⒊字符集

    作用:使用中括号来括住字符串来创建字符集,字符集可匹配他包括的任意字串

    ①‘[pj]ython’ 只能够匹配‘python’ ‘jython’

    ② ‘[a-z]’ 能够(按字母顺序)匹配a-z任意一个字符

    ③‘[a-zA-Z0-9]’ 能匹配任意一个大小写字母和数字

    ④‘[^abc]’ 可以匹配任意除a,b和c 之外的字符串

    ⒋管道符

    作用:一次性匹配多个字符串

    例如:’python|perl’ 可以匹配字符串‘python’ 和 ‘perl’

    ⒌可选项和重复子模式(在子模式后面加上问号?)

    作用:在子模式后面加上问号,他就变成可选项,出现或者不出现在匹配字符串中都是合法的

    例如:r’(aa)?(bb)?ccddee’ 只能匹配下面几种情况

    ‘aabbccddee’

    ‘aaccddee’

    ‘bbccddee’

    ‘ccddee’

    ⒍字符串的开始和结尾

    ① ‘w+’ 匹配以w开通的字符串

    ② ‘^http’ 匹配以’http’ 开头的字符串

    ③‘ $com’ 匹配以‘com’结尾的字符串

    7.最常用的匹配方法

    \d 匹配任何十进制数;它相当于类 [0-9]。

    \D 匹配任何非数字字符;它相当于类 [^0-9]。

    \s 匹配任何空白字符;它相当于类 [ fv]。

    \S 匹配任何非空白字符;它相当于类 [^ fv]。

    \w 匹配任何字母数字字符;它相当于类 [a-zA-Z0-9_]。

    \W 匹配任何非字母数字字符;它相当于类 [^a-zA-Z0-9_]。

    \w* 匹配所有字母字符

    \w+ 至少匹配一个字符

    re模块更详细表达式符号

    1. ‘.’ 默认匹配除\n之外的任意一个字符,若指定flag DOTALL,则匹配任意字符,包括换行
    2. ‘^’ 匹配字符开头,若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
    3. ' ′ 匹 配 字 符 结 尾 , 或 e . s e a r c h ( " f o o ' 匹配字符结尾,或e.search("foo e.search("foo",“bfoo\nsdfsf”,flags=re.MULTILINE).group()也可以
    4. '’ 匹配号前的字符0次或多次,re.findall(“ab*”,“cabb3abcbbac”) 结果为[‘abb’, ‘ab’, ‘a’]
    5. ‘+’ 匹配前一个字符1次或多次,re.findall(“ab+”,“ab+cd+abb+bba”) 结果[‘ab’, ‘abb’]
    6. ‘?’ 匹配前一个字符1次或0次
    7. ‘{m}’ 匹配前一个字符m次
    8. ‘{n,m}’ 匹配前一个字符n到m次,re.findall(“ab{1,3}”,“abb abc abbcbbb”) 结果’abb’, ‘ab’, ‘abb’]
    9. ‘|’ 匹配|左或|右的字符,re.search(“abc|ABC”,“ABCBabcCD”).group() 结果’ABC’
    10. ‘(…)’ 分组匹配,re.search("(abc){2}a(123|456)c", “abcabca456c”).group() 结果 abcabca456c
    11. ‘\A’ 只从字符开头匹配,re.search("\Aabc",“alexabc”) 是匹配不到的
    12. ‘\Z’ 匹配字符结尾,同$
    13. ‘\d’ 匹配数字0-9
    14. ‘\D’ 匹配非数字
    15. ‘\w’ 匹配[A-Za-z0-9]
    16. ‘\W’ 匹配非[A-Za-z0-9]
    17. ‘s’ 匹配空白字符、\t、\n、\r , re.search("\s+",“ab\tc1\n3”).group() 结果 ‘\t’
    18. \b 匹配一个单词边界,也就是指单词和空格间的位置,如,“er\b”可以匹配“never”中的“er”,但不能匹配“verb”中的“er”
    19. \B 匹配非单词边界。“er\B”能匹配“verb”中的“er”,但不能匹配“never”中的“er”

    re模块常用函数*

    在这里插入图片描述

    ⒈ re.compile(pattern[, flags])

    1)把一个正则表达式pattern编译成正则对象,以便可以用正则对象的match和search方法

    2)用了re.compile以后,正则对象会得到保留,这样在需要多次运用这个正则对象的时候,效率会有较大的提升

    re.compile使用

    import re
    mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])
    [0-9]{8}$')
    ret = re.match(mobile_re,'18538762511')
    print(ret)            # <_sre.SRE_Match object; span=(0, 11), 
    match='18538652511'>
    

    ⒉ search(pattern, string[, flags]) 和 match(pattern, string[, flags])

    1)match :只从字符串的开始与正则表达式匹配,匹配成功返回matchobject,否则返回none;

    2)search :将字符串的所有字串尝试与正则表达式匹配,如果所有的字串都没有匹配成功,返回none,否则返回matchobject;

    match与search使用比较

    import re
    a =re.match('www.bai', 'www.baidu.com')
    b = re.match('bai', 'www.baidu.com')
    print(a.group())                                # www.bai
    print(b)                                        # None
    
    # 无论有多少个匹配的只会匹配一个
    c = re.search('bai', 'www.baidubaidu.com')
    print(c)                                        # <_sre.SRE_Match object; span=(4, 7), 
    match='bai'>
    print(c.group())                                # bai
    

    ⒊ split(pattern, string[, maxsplit=0])

    作用:将字符串以指定分割方式,格式化成列表

    import re
    text = 'aa 1bb###2cc3ddd'
    print(re.split('\W+', text))         # ['aa', '1bb', '2cc3ddd']
    print(re.split('\W', text))          # ['aa', '1bb', '', '', '2cc3ddd']
    print(re.split('\d', text))          # ['aa ', 'bb###', 'cc', 'ddd']
    print(re.split('#', text))           # ['aa 1bb', '', '', '2cc3ddd']
    print(re.split('#+', text))          # ['aa 1bb', '2cc3ddd']
    

    ⒋ findall(pattern, string)

    作用:正则表达式 re.findall 方法能够以列表的形式返回能匹配的子串

    import re
    p = re.compile(r'\d+')
    print(p.findall('one1two2three3four4'))             # ['1', '2', '3', '4']
    print(re.findall('o','one1two2three3four4'))        # ['o', 'o', 'o']
    print(re.findall('\w+', 'he.llo, wo#rld!'))         # ['he', 'llo', 'wo', 'rld']
    

    ⒌ sub(pat, repl, string[, count=0])

    1)替换,将string里匹配pattern的部分,用repl替换掉,最多替换count次然后返回替换后的字符串

    2)如果string里没有可以匹配pattern的串,将被原封不动地返回

    3)repl可以是一个字符串,也可以是一个函数

    4) 如果repl是个字符串,则其中的反斜杆会被处理过,比如 \n 会被转成换行符,反斜杆加数字会被替换成相应的组,比如 \6 表示pattern匹配到的第6个组的内容

    import re
    test="Hi, nice to meet you where are you from?"
    print(re.sub(r'\s','-',test))          # Hi,-nice-to-meet-you-where-are-you-from?
    print(re.sub(r'\s','-',test,5))        # Hi,-nice-to-meet-you-where are you from?
    print(re.sub('o','**',test))           # Hi, nice t** meet y**u where are y**u fr**m?
    

    ⒍ escape(string)

    1) re.escape(pattern) 可以对字符串中所有可能被解释为正则运算符的字符进行转义的应用函数。

    2) 如果字符串很长且包含很多特殊技字符,而你又不想输入一大堆反斜杠,或者字符串来自于用户(比如通过raw_input函数获取输入的内容),

    且要用作正则表达式的一部分的时候,可以用这个函数

    import re
    print(re.escape('www.python.org'))
    

    re模块中的匹配对象和组 group()

    1)group方法返回模式中与给定组匹配的字符串,如果没有给定匹配组号,默认为组0

    2)m.group() == m.group(0) == 所有匹配的字符

    group(0)与group(1)区别比较

    import re
    a = "123abc321efg456"
    print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0))    # 123abc321
    print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).groups())    # ('123', 'abc', '321')
    print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1))    # 123
    print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2))    # abc
    print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3))    # 321
    

    import re
    m = re.match('(..).*(..)(..)','123456789')
    print(m.group(0))              # 123456789
    print(m.group(1))              # 12
    print(m.group(2))              # 67
    print(m.group(3))              # 89
    

    group()匹配之返回匹配索引

    import re
    m = re.match('www\.(.*)\..*','www.baidu.com')
    print(m.group(1))           # baidu
    print(m.start(1))           # 4
    print(m.end(1))             # 9
    print(m.span(1))            # (4, 9)
    

    group()匹配ip,状态以元组返回

    import re
    test = 'dsfdf 22 g2323  GigabitEthernet0/3        10.1.8.1        YES NVRAM up 
    eee'
    # print(re.match('(\w.*\d)\s+(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\s+YES\s+NVRAM
    \s+(\w+)\s+(\w+)\s*', test).groups())
    
    ret = re.search(  r'(\w*\/\d+).*\s(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}).*(\s+up\s+)',test
     ).groups()
    print(ret)          # 运行结果: ('GigabitEthernet0/3', '10.1.8.1', ' up ')
    
    #1. (\w*\d+\/\d+)      匹配结果为:GigabitEthernet0/3
    #1.1   \w*: 匹配所有字母数字     
    #1.2   /\d+:匹配所有斜杠开头后根数字 (比如:/3 )
    
    #2. (\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})  匹配结果为:10.1.8.1
    
    #3. \s+up\s+   匹配结果为: up 这个单词,前后都为空格
    

    re模块其他知识点

    re匹配忽略大小写,匹配换行

    import re
    #匹配时忽略大小写
    print(re.search("[a-z]+","abcdA").group())                      #abcd
    print(re.search("[a-z]+","abcdA",flags=re.I).group())           #abcdA
    #连同换行符一起匹配:
    #'.'默认匹配除\n之外的任意一个字符,若指定flag DOTALL,则匹配任意字符,包
    括换行
    print(re.search(r".+","\naaa\nbbb\nccc").group())               #aaa
    print(re.search(r".+","\naaa\nbbb\nccc",flags=re.S))            
            #<_sre.SRE_Match object; span=(0, 12), match='\naaa\nbbb\nccc'>
    print(re.search(r".+","\naaa\nbbb\nccc",flags=re.S).group())
                                                 aaa
                                                 bbb
                                                 ccc
    

    计算器用到的几个知识点

    1. init_l=[i for i in re.split(’(-\d+.\d)’,expression) if i]
      a. 按照类似负数的字符串分割成列表
      b. -\d+.\d是为了可以匹配浮点数(比如:3.14)
      c. (if i)是为了去除列表中的空元素
      d. 分割结果:[’-1’, ‘-2’, ‘*((’, ‘-60’, ‘+30+(’,
    2. re.search(’[+-*/(]$’,expression_l[-1])
      a. 匹配expression_l列表最后一个元素是 +,-,*,/,( 这五个符号就是负数
    3. new_l=[i for i in re.split(’([+-*/()])’,exp) if i]
      a. 将字符串按照+,-,*,/,(,)切分成列表(不是正真的负数就切分)
    4. print(re.split(’([+-])’,’-1+2-3*(22+3)’)) #按照加号或者减号分割成列表
      运行结果: [’’, ‘-’, ‘1’, ‘+’, ‘2’, ‘-’, '3
      (2*2’, ‘+’, ‘3)’]
    展开全文
  • python常用模块详解

    2018-05-04 15:32:23
    学习python时经常要用到一些模块,这个文件里有python常用模块详解
  • Python常用模块

    2017-01-23 23:45:55
    Python常用模块整理
  • python常用模块什么是模块? 常见的场景:一个模块就是一个包含了python定义和声明的文件,文件名就是模块名字加上.py的后缀。 但其实import加载的模块分为四个通用类别:1 使用python编写的代码(.py文件) 2已被...

    flbm1hkjk6.jpg广告关闭

    2017年12月,云+社区对外发布,从最开始的技术博客到现在拥有多个社区产品。未来,我们一起乘风破浪,创造无限可能。

    z4wubu82qr.png

    python常用模块什么是模块? 常见的场景:一个模块就是一个包含了python定义和声明的文件,文件名就是模块名字加上.py的后缀。 但其实import加载的模块分为四个通用类别:1 使用python编写的代码(.py文件) 2已被编译为共享库或dll的c或c++扩展 3 包好一组模块的包 4使用c编写并链接到python解释器的内置模块为何要...

    一、time与datetime模块1、在python中,通常有这几种方式来表示时间:时间戳(timestamp):通常来说,时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量格式化的时间字符串(format string)结构化的时间(struct_time:struct_time元组共有9个元素共九个元素:(年,月,日,时,分,秒,一年中第几周...

    第一个元素是程序本身路径 sys.exit(n) 退出程序,正常退出时exit(0),错误退出sys.exit(1) sys.version 获取python解释程序的版本信息 sys.path返回模块的搜索路径,初始化时使用pythonpath环境变量的值 sys.platform 返回操作系统平台名称...

    python常用模块集锦常用模块主要分为以下几类(缺失的后续再补充):时间转换时间计算序列化和反序列化:json,pickle编解码:unicode,base64加解密:md5,sha1,hmac_sha1,aes常见装饰器:计算执行时间装饰器缓存装饰器错误重试装饰器延迟装饰器尾递归优化装饰器ini配置文件读取代码整合如下:#! usrbinenv python...

    1、configparser模块:说明: 读取配置文件 http:wangwei007.blog.51cto.com6801911049112、sqlalchemy说明:数据库操作模块http:blog.sina.com.cnsblog_4ddef8f80101g6cl.html 3、pystatgrab说明:系统信息获取模块4、platform说明:获取系统信息5、logging说明:输出日志模块...

    sr991uamsj.png

    beijing} print(f)f.close()logging模块 很多程序都有记录日志的需求,并且日志中包含的信息即有正常的程序访问日志,还可能有错误、警告等信息输出,python的logging模块提供了标准的日志接口,你可以通过它存储各种格式的日志,logging的日志可以分为 debug、info、warning、error、critical5个级别1. 模块初始...

    python允许“导入”其他模块以实现代码重用,从而也实现了将独立的代码文件组织成更大的程序系统。 python中,模块也是对象。 在一个模块的顶层定义的所有变量都在被导入时成为了被导入模块的属性。 二、模块的使用1、python程序架构一个python程序通常包括一个顶层程序文件和若干个模块文件。 顶层文件包含了程序的...

    blog = blog.51cto.comweb =www.51cto.com更多configparser模块用法猛击这里四、re正则表达式是一种小型的、高度专业化的编程语言,在python中,他通过re模块实现。 正则表达式模式被编译成一系列的字节码,然后由c编写的匹配引擎执行。 字符: . 匹配除换行符以外的任意字符 w 匹配字母或数字或下划线或汉字 s...

    time模块: 在python中,通常有以下几种方式来表示时间: 1、时间戳,如time.time 2、格式化的时间字符串,如17012017 10:17:00 3、元组(struct_time),如gmtime、localtime等等 time.time():把从1970年开始到现在的所有时间转换成秒数,即时间戳 time.gmtime():将时间戳(秒数)转换成utc时区的元组形式 time...

    hashilib模块我们的登录密码在数据库中不能存明文,当别人拿到数据库,看到账号密码是很恐怖的事情。 所以我们就需要hashilib模块来加密。 前几年csdn的...pythonprint(config.get(path, path1))#判断一个组是否在其中print(path in config) # true# 其他取值方式print(config) #d:python# 也可以循环一个组for ...

    os模块这个模块包含普遍的操作系统功能 os.name:获取当前系统平台,windows下返回nt,linux下返回posix。 os.linesep:获取当前平台使用的行终止符。 windows下返回rn,linux使用n。 os.getcwd(): 获取当前工作目录,即当前python脚本工作的目录路径。 os.listdir(path):返回指定目录下的所有文件和目录名。 os...

    python标准库之urllib模块 涉及到网络这块,必不可少的模式就是urllib.request了,顾名思义这个模块主要负责打开url和http协议之类的urllib最简单的应用就是urllib.request.urlopen(url, data=none, *, cafile=none, capath=none, cadefault=false,context=none)url 需要打开的网址data post提交的数据timeout...

    三、其他1.time.sleep()例如:time.sleep(2)表示线程休眠2秒,单位为秒; 2.datetime模块一种常用的格式为:datetime.datetime.now()表示输出当前时间,如下图所示: ?...

    但大多数模块没有提供这样的安装方式,有些同学没能成功安装而导致无法在程序中引入模块。 在这里,介绍一下python模块几种常见的安装方法。 1. 直接copy下载的模块文件中已经有了模块的文件,有些模块只有一个文件,比如较早版本的beautifulsoup,有些是一个文件夹,比如新版本beautifulsoup就是一个叫做bs4的文件夹...

    常用模块calendartimedatetimetimeitosshutilzipmathstring上述所有模块使用理论上都应该先导入,string是特例calendar,time,datetime的区别参考中文意思关于log模块请参考:log模块calendar跟日历相关的模块# 使用需要先导入import calendar# calendar:获取一年的日历字符串# 参数# w = 每个日期之间的间隔字符数...

    python中的os模块可以用来编写于平台无关的一些文件系统操作。 主要的方法如下:一些标记属性1. os.linesep 文件中分割行的字符串2. os.sep文件路径名的分隔符3. os.curdir当前工作目录的字符串名称4. os.pardir父目录字符串名称常用方法1. os.remove()删除文件2. os.rename()冲命名文件3. os.walk()生成目录树下的...

    返回一个打开的模式为(w+b)的文件对象 . 这文件对象没有文件夹入口,没有文件描述符,将会自动删除。 58os.tmpnam() python3 中已删除。 为创建一个临时...返回实际写入的字符串长度64os.path 模块获取文件的属性信息。 65os.path.abspath(path)获取绝对路径66os.path.basename(p)获取目录的最后一层目录...

    9lwkvolsk2.gif

    如果你用python开发服务器应用,特别是网络游戏这样的应用,pyprocessing怎么可以不去关注一下!=====python模块安装1. 单文件模块直接把文件拷贝到$...原文地址:http:xinsync.xju.edu.cnindex.phparchives4401=========我常用的几个第三方 python 库收藏作者:赖勇浩(http:blog.csdn.netlanphaday)xpy...

    print(dt)2015-04-19 12:20:003、datetime转时间戳>>> from datetime import datetime>>> dt =datetime(2015, 4, 19, 12, 20) # 用指定日期时间创建datetime>>> dt.timestamp() #把datetime转换为timestamp1429417200.0注:python的timestamp是一个浮点数。 如果有小数位,小数位表示毫秒数。 4、时间戳转datetime>>>...

    常用模块(二)四、os模块os模块是与操作系统交互的一个接口,用于对操作系统进行调用os.getcwd() # 提供当前工作目录os.chdir() #改变当前工作目录os.curdir() # 返回当前目录(.)os.pardir() #获取当前目录的父目录字符串名(..)os.makedirs() #生成多层递归目录(aprilweek1day3)os.removedirs() #从最里层往外...

    展开全文
  • 主要介绍了Python常用模块之requests模块用法,结合实例形式分析了Python使用requests模块发送GET、POST请求及响应相关操作技巧,需要的朋友可以参考下
  • Python常用模块大全(总结)

    万次阅读 多人点赞 2018-08-22 11:41:23
    os模块: os.remove() 删除文件 os.unlink() 删除文件 os.rename() 重命名文件 os.listdir() 列出指定目录下所有文件 os.chdir() 改变当前工作目录 os.getcwd() 获取当前文件路径 os.mkdir() 新建目录 os.rmdir...

    os模块:

    os.remove() 删除文件 
    os.unlink() 删除文件 
    os.rename() 重命名文件 
    os.listdir() 列出指定目录下所有文件 
    os.chdir() 改变当前工作目录
    os.getcwd() 获取当前文件路径
    os.mkdir() 新建目录
    os.rmdir() 删除空目录(删除非空目录, 使用shutil.rmtree())
    os.makedirs() 创建多级目录
    os.removedirs() 删除多级目录
    os.stat(file) 获取文件属性
    os.chmod(file) 修改文件权限
    os.utime(file) 修改文件时间戳
    os.name(file) 获取操作系统标识
    os.system() 执行操作系统命令
    os.execvp() 启动一个新进程
    os.fork() 获取父进程ID,在子进程返回中返回0
    os.execvp() 执行外部程序脚本(Uinx)
    os.spawn() 执行外部程序脚本(Windows)
    os.access(path, mode) 判断文件权限(详细参考cnblogs)
    os.wait() 暂时未知
    os.path模块:
    os.path.split(filename) 将文件路径和文件名分割(会将最后一个目录作为文件名而分离)
    os.path.splitext(filename) 将文件路径和文件扩展名分割成一个元组
    os.path.dirname(filename) 返回文件路径的目录部分
    os.path.basename(filename) 返回文件路径的文件名部分
    os.path.join(dirname,basename) 将文件路径和文件名凑成完整文件路径
    os.path.abspath(name) 获得绝对路径
    os.path.splitunc(path) 把路径分割为挂载点和文件名
    os.path.normpath(path) 规范path字符串形式
    os.path.exists() 判断文件或目录是否存在
    os.path.isabs() 如果path是绝对路径,返回True
    os.path.realpath(path) #返回path的真实路径
    os.path.relpath(path[, start]) #从start开始计算相对路径 
    os.path.normcase(path) #转换path的大小写和斜杠
    os.path.isdir() 判断name是不是一个目录,name不是目录就返回false
    os.path.isfile() 判断name是不是一个文件,不存在返回false
    os.path.islink() 判断文件是否连接文件,返回boolean
    os.path.ismount() 指定路径是否存在且为一个挂载点,返回boolean
    os.path.samefile() 是否相同路径的文件,返回boolean
    os.path.getatime() 返回最近访问时间 浮点型
    os.path.getmtime() 返回上一次修改时间 浮点型
    os.path.getctime() 返回文件创建时间 浮点型
    os.path.getsize() 返回文件大小 字节单位
    os.path.commonprefix(list) #返回list(多个路径)中,所有path共有的最长的路径
    os.path.lexists #路径存在则返回True,路径损坏也返回True
    os.path.expanduser(path) #把path中包含的”~”和”~user”转换成用户目录
    os.path.expandvars(path) #根据环境变量的值替换path中包含的”$name”和”${name}”
    os.path.sameopenfile(fp1, fp2) #判断fp1和fp2是否指向同一文件
    os.path.samestat(stat1, stat2) #判断stat tuple stat1和stat2是否指向同一个文件
    os.path.splitdrive(path) #一般用在windows下,返回驱动器名和路径组成的元组
    os.path.walk(path, visit, arg) #遍历path,给每个path执行一个函数详细见手册
    os.path.supports_unicode_filenames() 设置是否支持unicode路径名

    stat模块:

    描述os.stat()返回的文件属性列表中各值的意义
    fileStats = os.stat(path) 获取到的文件属性列表
    fileStats[stat.ST_MODE] 获取文件的模式
    fileStats[stat.ST_SIZE] 文件大小
    fileStats[stat.ST_MTIME] 文件最后修改时间
    fileStats[stat.ST_ATIME] 文件最后访问时间
    fileStats[stat.ST_CTIME] 文件创建时间
    stat.S_ISDIR(fileStats[stat.ST_MODE]) 是否目录
    stat.S_ISREG(fileStats[stat.ST_MODE]) 是否一般文件
    stat.S_ISLNK(fileStats[stat.ST_MODE]) 是否连接文件
    stat.S_ISSOCK(fileStats[stat.ST_MODE]) 是否COCK文件
    stat.S_ISFIFO(fileStats[stat.ST_MODE]) 是否命名管道
    stat.S_ISBLK(fileStats[stat.ST_MODE]) 是否块设备
    stat.S_ISCHR(fileStats[stat.ST_MODE]) 是否字符设置

    sys模块:

    sys.argv 命令行参数List,第一个元素是程序本身路径 
    sys.path 返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值 
    sys.modules.keys() 返回所有已经导入的模块列表
    sys.modules 返回系统导入的模块字段,key是模块名,value是模块 
    sys.exc_info() 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息
    sys.exit(n) 退出程序,正常退出时exit(0)
    sys.hexversion 获取Python解释程序的版本值,16进制格式如:0x020403F0
    sys.version 获取Python解释程序的版本信息
    sys.platform 返回操作系统平台名称
    sys.stdout 标准输出
    sys.stdout.write(‘aaa‘) 标准输出内容
    sys.stdout.writelines() 无换行输出
    sys.stdin 标准输入
    sys.stdin.read() 输入一行
    sys.stderr 错误输出
    sys.exc_clear() 用来清除当前线程所出现的当前的或最近的错误信息 
    sys.exec_prefix 返回平台独立的python文件安装的位置 
    sys.byteorder 本地字节规则的指示器,big-endian平台的值是‘big‘,little-endian平台的值是‘little‘ 
    sys.copyright 记录python版权相关的东西 
    sys.api_version 解释器的C的API版本 
    sys.version_info ‘final‘表示最终,也有‘candidate‘表示候选,表示版本级别,是否有后继的发行 
    sys.getdefaultencoding() 返回当前你所用的默认的字符编码格式 
    sys.getfilesystemencoding() 返回将Unicode文件名转换成系统文件名的编码的名字 
    sys.builtin_module_names Python解释器导入的内建模块列表 
    sys.executable Python解释程序路径 
    sys.getwindowsversion() 获取Windows的版本 
    sys.stdin.readline() 从标准输入读一行,sys.stdout.write(“a”) 屏幕输出a
    sys.setdefaultencoding(name) 用来设置当前默认的字符编码(详细使用参考文档) 
    sys.displayhook(value) 如果value非空,这个函数会把他输出到sys.stdout(详细使用参考文档)

    datetime,date,time模块:

    datetime.date.today() 本地日期对象,(用str函数可得到它的字面表示(2014-03-24))
    datetime.date.isoformat(obj) 当前[年-月-日]字符串表示(2014-03-24)
    datetime.date.fromtimestamp() 返回一个日期对象,参数是时间戳,返回 [年-月-日]
    datetime.date.weekday(obj) 返回一个日期对象的星期数,周一是0
    datetime.date.isoweekday(obj) 返回一个日期对象的星期数,周一是1
    datetime.date.isocalendar(obj) 把日期对象返回一个带有年月日的元组
    datetime对象:
    datetime.datetime.today() 返回一个包含本地时间(含微秒数)的datetime对象 2014-03-24 23:31:50.419000
    datetime.datetime.now([tz]) 返回指定时区的datetime对象 2014-03-24 23:31:50.419000
    datetime.datetime.utcnow() 返回一个零时区的datetime对象
    datetime.fromtimestamp(timestamp[,tz]) 按时间戳返回一个datetime对象,可指定时区,可用于strftime转换为日期表示 
    datetime.utcfromtimestamp(timestamp) 按时间戳返回一个UTC-datetime对象
    datetime.datetime.strptime(‘2014-03-16 12:21:21‘,”%Y-%m-%d %H:%M:%S”) 将字符串转为datetime对象
    datetime.datetime.strftime(datetime.datetime.now(), ‘%Y%m%d %H%M%S‘) 将datetime对象转换为str表示形式
    datetime.date.today().timetuple() 转换为时间戳datetime元组对象,可用于转换时间戳
    datetime.datetime.now().timetuple()
    time.mktime(timetupleobj) 将datetime元组对象转为时间戳
    time.time() 当前时间戳
    time.localtime
    time.gmtime

    hashlib,md5模块:

    hashlib.md5(‘md5_str‘).hexdigest() 对指定字符串md5加密
    md5.md5(‘md5_str‘).hexdigest() 对指定字符串md5加密

    random模块:

    random.random() 产生0-1的随机浮点数
    random.uniform(a, b) 产生指定范围内的随机浮点数
    random.randint(a, b) 产生指定范围内的随机整数
    random.randrange([start], stop[, step]) 从一个指定步长的集合中产生随机数
    random.choice(sequence) 从序列中产生一个随机数
    random.shuffle(x[, random]) 将一个列表中的元素打乱
    random.sample(sequence, k) 从序列中随机获取指定长度的片断

    types模块:

    保存了所有数据类型名称。
    if type(‘1111‘) == types.StringType:
    MySQLdb模块:
    MySQLdb.get_client_info() 获取API版本
    MySQLdb.Binary(‘string‘) 转为二进制数据形式
    MySQLdb.escape_string(‘str‘) 针对mysql的字符转义函数
    MySQLdb.DateFromTicks(1395842548) 把时间戳转为datetime.date对象实例
    MySQLdb.TimestampFromTicks(1395842548) 把时间戳转为datetime.datetime对象实例
    MySQLdb.string_literal(‘str‘) 字符转义
    MySQLdb.cursor()游标对象上的方法:《python核心编程》P624

    atexit模块:

    atexit.register(fun,args,args2..) 注册函数func,在解析器退出前调用该函数

    string模块

    str.capitalize() 把字符串的第一个字符大写
    str.center(width) 返回一个原字符串居中,并使用空格填充到width长度的新字符串
    str.ljust(width) 返回一个原字符串左对齐,用空格填充到指定长度的新字符串
    str.rjust(width) 返回一个原字符串右对齐,用空格填充到指定长度的新字符串
    str.zfill(width) 返回字符串右对齐,前面用0填充到指定长度的新字符串
    str.count(str,[beg,len]) 返回子字符串在原字符串出现次数,beg,len是范围
    str.decode(encodeing[,replace]) 解码string,出错引发ValueError异常
    str.encode(encodeing[,replace]) 解码string
    str.endswith(substr[,beg,end]) 字符串是否以substr结束,beg,end是范围
    str.startswith(substr[,beg,end]) 字符串是否以substr开头,beg,end是范围
    str.expandtabs(tabsize = 8) 把字符串的tab转为空格,默认为8个
    str.find(str,[stat,end]) 查找子字符串在字符串第一次出现的位置,否则返回-1
    str.index(str,[beg,end]) 查找子字符串在指定字符中的位置,不存在报异常
    str.isalnum() 检查字符串是否以字母和数字组成,是返回true否则False
    str.isalpha() 检查字符串是否以纯字母组成,是返回true,否则false
    str.isdecimal() 检查字符串是否以纯十进制数字组成,返回布尔值
    str.isdigit() 检查字符串是否以纯数字组成,返回布尔值
    str.islower() 检查字符串是否全是小写,返回布尔值
    str.isupper() 检查字符串是否全是大写,返回布尔值
    str.isnumeric() 检查字符串是否只包含数字字符,返回布尔值
    str.isspace() 如果str中只包含空格,则返回true,否则FALSE
    str.title() 返回标题化的字符串(所有单词首字母大写,其余小写)
    str.istitle() 如果字符串是标题化的(参见title())则返回true,否则false
    str.join(seq) 以str作为连接符,将一个序列中的元素连接成字符串
    str.split(str=‘‘,num) 以str作为分隔符,将一个字符串分隔成一个序列,num是被分隔的字符串
    str.splitlines(num) 以行分隔,返回各行内容作为元素的列表
    str.lower() 将大写转为小写
    str.upper() 转换字符串的小写为大写
    str.swapcase() 翻换字符串的大小写
    str.lstrip() 去掉字符左边的空格和回车换行符
    str.rstrip() 去掉字符右边的空格和回车换行符
    str.strip() 去掉字符两边的空格和回车换行符
    str.partition(substr) 从substr出现的第一个位置起,将str分割成一个3元组。
    str.replace(str1,str2,num) 查找str1替换成str2,num是替换次数
    str.rfind(str[,beg,end]) 从右边开始查询子字符串
    str.rindex(str,[beg,end]) 从右边开始查找子字符串位置 
    str.rpartition(str) 类似partition函数,不过从右边开始查找
    str.translate(str,del=‘‘) 按str给出的表转换string的字符,del是要过虑的字符

    urllib模块:

    urllib.quote(string[,safe]) 对字符串进行编码。参数safe指定了不需要编码的字符
    urllib.unquote(string) 对字符串进行解码
    urllib.quote_plus(string[,safe]) 与urllib.quote类似,但这个方法用‘+‘来替换‘ ‘,而quote用‘%20‘来代替‘ ‘
    urllib.unquote_plus(string ) 对字符串进行解码
    urllib.urlencode(query[,doseq]) 将dict或者包含两个元素的元组列表转换成url参数。
    例如 字典{‘name‘:‘wklken‘,‘pwd‘:‘123‘}将被转换为”name=wklken&pwd=123″
    urllib.pathname2url(path) 将本地路径转换成url路径
    urllib.url2pathname(path) 将url路径转换成本地路径
    urllib.urlretrieve(url[,filename[,reporthook[,data]]]) 下载远程数据到本地
    filename:指定保存到本地的路径(若未指定该,urllib生成一个临时文件保存数据)
    reporthook:回调函数,当连接上服务器、以及相应的数据块传输完毕的时候会触发该回调
    data:指post到服务器的数据
    rulrs = urllib.urlopen(url[,data[,proxies]]) 抓取网页信息,[data]post数据到Url,proxies设置的代理
    urlrs.readline() 跟文件对象使用一样
    urlrs.readlines() 跟文件对象使用一样
    urlrs.fileno() 跟文件对象使用一样
    urlrs.close() 跟文件对象使用一样
    urlrs.info() 返回一个httplib.HTTPMessage对象,表示远程服务器返回的头信息
    urlrs.getcode() 获取请求返回状态HTTP状态码
    urlrs.geturl() 返回请求的URL

    re模块:

    一.常用正则表达式符号和语法:
    '.' 匹配所有字符串,除\n以外
    ‘-’ 表示范围[0-9]
    '*' 匹配前面的子表达式零次或多次。要匹配 * 字符,请使用 \*。
    '+' 匹配前面的子表达式一次或多次。要匹配 + 字符,请使用 \+
    '^' 匹配字符串开头
    ‘$’ 匹配字符串结尾 re
    '\' 转义字符, 使后一个字符改变原来的意思,如果字符串中有字符*需要匹配,可以\*或者字符集[*] re.findall(r'3\*','3*ds')结['3*']
    '*' 匹配前面的字符0次或多次 re.findall("ab*","cabc3abcbbac")结果:['ab', 'ab', 'a']
    ‘?’ 匹配前一个字符串0次或1次 re.findall('ab?','abcabcabcadf')结果['ab', 'ab', 'ab', 'a']
    '{m}' 匹配前一个字符m次 re.findall('cb{1}','bchbchcbfbcbb')结果['cb', 'cb']
    '{n,m}' 匹配前一个字符n到m次 re.findall('cb{2,3}','bchbchcbfbcbb')结果['cbb']
    '\d' 匹配数字,等于[0-9] re.findall('\d','电话:10086')结果['1', '0', '0', '8', '6']
    '\D' 匹配非数字,等于[^0-9] re.findall('\D','电话:10086')结果['电', '话', ':']
    '\w' 匹配字母和数字,等于[A-Za-z0-9] re.findall('\w','alex123,./;;;')结果['a', 'l', 'e', 'x', '1', '2', '3']
    '\W' 匹配非英文字母和数字,等于[^A-Za-z0-9] re.findall('\W','alex123,./;;;')结果[',', '.', '/', ';', ';', ';']
    '\s' 匹配空白字符 re.findall('\s','3*ds \t\n')结果[' ', '\t', '\n']
    '\S' 匹配非空白字符 re.findall('\s','3*ds \t\n')结果['3', '*', 'd', 's']
    '\A' 匹配字符串开头
    '\Z' 匹配字符串结尾
    '\b' 匹配单词的词首和词尾,单词被定义为一个字母数字序列,因此词尾是用空白符或非字母数字符来表示的
    '\B' 与\b相反,只在当前位置不在单词边界时匹配
    '(?P<name>...)' 分组,除了原有编号外在指定一个额外的别名 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{8})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '19930614'}
    [] 是定义匹配的字符范围。比如 [a-zA-Z0-9] 表示相应位置的字符要匹配英文字符和数字。[\s*]表示空格或者*号。
    
    
    
    二.常用的re函数:
    方法/属性 作用
    re.match(pattern, string, flags=0) 从字符串的起始位置匹配,如果起始位置匹配不成功的话,match()就返回none
    re.search(pattern, string, flags=0) 扫描整个字符串并返回第一个成功的匹配
    re.findall(pattern, string, flags=0) 找到RE匹配的所有字符串,并把他们作为一个列表返回
    re.finditer(pattern, string, flags=0) 找到RE匹配的所有字符串,并把他们作为一个迭代器返回
    re.sub(pattern, repl, string, count=0, flags=0) 替换匹配到的字符串

    math模块

    ceil:取大于等于x的最小的整数值,如果x是一个整数,则返回x
    copysign:把y的正负号加到x前面,可以使用0
    cos:求x的余弦,x必须是弧度
    degrees:把x从弧度转换成角度
    e:表示一个常量
    exp:返回math.e,也就是2.71828的x次方
    expm1:返回math.e的x(其值为2.71828)次方的值减1
    fabs:返回x的绝对值
    factorial:取x的阶乘的值
    floor:取小于等于x的最大的整数值,如果x是一个整数,则返回自身
    fmod:得到x/y的余数,其值是一个浮点数
    frexp:返回一个元组(m,e),其计算方式为:x分别除0.5和1,得到一个值的范围
    fsum:对迭代器里的每个元素进行求和操作
    gcd:返回x和y的最大公约数
    hypot:如果x是不是无穷大的数字,则返回True,否则返回False
    isfinite:如果x是正无穷大或负无穷大,则返回True,否则返回False
    isinf:如果x是正无穷大或负无穷大,则返回True,否则返回False
    isnan:如果x不是数字True,否则返回False
    ldexp:返回x*(2**i)的值
    log:返回x的自然对数,默认以e为基数,base参数给定时,将x的对数返回给定的base,计算式为:log(x)/log(base)
    log10:返回x的以10为底的对数
    log1p:返回x+1的自然对数(基数为e)的值
    log2:返回x的基2对数
    modf:返回由x的小数部分和整数部分组成的元组
    pi:数字常量,圆周率
    pow:返回x的y次方,即x**y
    radians:把角度x转换成弧度
    sin:求x(x为弧度)的正弦值
    sqrt:求x的平方根
    tan:返回x(x为弧度)的正切值
    trunc:返回x的整数部分

    说明:这些方法都是在各博客总结而来,并非自己所写,这是方便以后自己使用!!!

    展开全文
  • 今天小编就为大家分享一篇关于举例讲解Python常用模块,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 主要介绍了Python 常用模块 re 使用方法,本文给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了Python常用模块函数代码汇总解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 能够实现获取系统运行的进程和系统利用率(内存,CPU,磁盘,...4、difflib:difflib作为Python的标准模块,无需安装,作用是对比文本之间的差异。 5、filecmp:系统自带,可以实现文件,目录,遍历子目录的差异,对比
  • os.path 模块主要用于获取文件的属性。这篇文章主要介绍了Python常用模块os.path——文件及路径操作,需要的朋友可以参考下
  • python常用模块总结

    2019-04-23 21:42:19
    python常见模块整理,整理为PPT格式,文档带有超链接,查询方便。
  • python常用模块.pdf

    2021-09-30 22:25:21
    python常用模块.pdf
  • 课程目标掌握Python常用模块 适用人群零基础小白入门 课程简介 20天掌握Python开发④Python常用模块
  • Python常常用用模模块块用用法法分分析析 这篇文章主要介绍了Python常用模块用法分析,主要包括内置函数文件操作正则匹配等等,需要的朋友 以参考 下 本文较为详细的讲述了Python中常用的模块分享给大家便于大家查阅...
  • Python常用模块.pdf

    2021-10-19 20:31:55
    Python常用模块.pdf
  • logging模块是Python的内置模块,主要用于输出运行日志,可以灵活配置输出日志的各项信息。这篇文章主要介绍了Python常用模块logging——日志输出的实例代码,需要的朋友可以参考下
  • Python常用模块.doc

    2021-10-11 17:53:48
    Python常用模块.doc
  • python常用模块.docx

    2021-09-30 16:29:29
    python常用模块.docx
  • Python中的psutil模块,主要用于对系统的资源信息进行发现

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 216,630
精华内容 86,652
关键字:

python常用模块

友情链接: SED_One_Line_Script.zip