zoukankan      html  css  js  c++  java
  • 十五、常用模块collections,时间模块,random,os,sys,subproce,序列化模块

    一、collections模块

    1.namedtuple                                  
    # 1.namedtuple: namedtuple.(“名称”,“[属性list]”)
    # Circle = namedtuple("circle","x y z")
    #tuple表示不变的集合,例如,一个点的二位坐标就可以表示成,
    #如果要用坐标和半径表示一个圆,也可以用namedtuple表示
    from collections import namedtuple
    Point = namedtuple("坐标",“x y z”)
    p =Point(1,2,3)
    print(p.x)  # 1
    print(p.y)  # 2
    print(p.z)   # 3
    
    
    ##花色和数字
    Card = namedtuple("card",["suits","number"])
    c1 =Card("黑桃",“10”)
    print(c1.suits)  # 黑桃
    print(c1.number) # 10
    print(c1) # card(suits=“黑桃”,nemberi=10)

     2.deque                                    
    #  2.deque:使用list存储数据时,按索引访问元素很快,但是插入和删除元素就很慢了,因为list是线性存储,数据量大的时候,插入和删除效率低
    #  depue是为了高效实现插入和删除操作的双向列表,适合用于队列和栈
    # from collections import deque
    #
    # list1 = deque([1, 2])
    # list1.append(3)  # 从后面放数据 [1,2,3]
    # list1.appendleft(4)  # 从前面放数据[4,1,2,3]
    # list1.insert(5, 3)  # 插入索引3 [4,1,2,5,3]
    #
    # res = list1.pop()  # 从后面取数据
    # print(res)  # 3
    # res1 = list1.popleft()  # 从前面取数据
    # print(res1)  # 4
    # 队列:现进先出(FIFO first in first out)
    # import queue
    # q = queue.Queue()  # 生成队列对象
    # q.put('first')  # 往队列中添加值
    # q.put('second')
    # q.put('third')
    #
    # print(q.get())  # 朝队列要值
    # print(q.get())
    # print(q.get())
    # print(q.get())  # 如果队列中的值取完了 程序会在原地等待 直到从队列中拿到值才停止
    
    # deque双端队列
    # from collections import deque
    # q = deque(['a','b','c'])
    # """
    # append
    # appendleft
    #
    # pop
    # popleft
    # """
    # q.append(1)
    # q.appendleft(2)
    #
    # """
    # 队列不应该支持任意位置插值
    # 只能在首尾插值(不能插队)
    # """
    # q.insert(0,'哈哈哈')  # 特殊点:双端队列可以根据索引在任意位置插值
    # print(q.pop())
    # print(q.popleft())
    # print(q.popleft())
     3.OrderedDict                                      
    # 3.OrderedDict 使用dict时,key是无序的,在对dict做迭代时,我们无法确定key的顺序
    # 如果要保持key的顺序,可以用OrderedDict:
    # from collections import OrderedDict
    #
    # dict1 = dict([("a", 1), ("b", 2), ("c", 3)])
    # print(dict1)  # {'a': 1, 'b': 2, 'c': 3}  dict的key是无序的
    # od = OrderedDict([("a", 1), ("b", 2), ("c", 3)])  # OrderedDict dict的key是y有序的
    # print(od)  # OrderedDict([('a', 1), ('b', 2), ('c', 3)]) 可以都过取key拿出来
    # print(od["a"])  # 1  可以都过取key拿出来value

    4.Counter                                          

    # 需求计算变量s中每个字符的个数并用字典形式表示
    from collections import Counter
    s = 'abcdeabcdabcaba'
    res = Counter(s)
    print(res)
    #Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

    5.defaultdict                                               

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

    即: {'k1': 大于66 'k2': 小于66}
    from collections import defaultdict
    
    values = [11, 22, 33,44,55,66,77,88,99,90]
    
    my_dict = defaultdict(list)
    
    for value in  values:
        if value>66:
            my_dict['k1'].append(value)
        else:
            my_dict['k2'].append(value)

    二、时间模块

    和时间有关系的我们就要用到时间模块。在使用模块之前,应该首先导入这个模块。

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

    表示时间的三种方式

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

    (1)时间戳(timestamp) :通常来说,时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”,返回的是float类型。

    (2)格式化的时间字符串(Format String): ‘1999-12-06’

    %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模块,来认识一下python中表示时间的几种格式:

    复制代码
    #导入时间模块
    >>>import time
    
    #时间戳
    >>>time.time()
    1500875844.800804
    
    #时间字符串
    >>>time.strftime("%Y-%m-%d %X")
    '2017-07-24 13:54:37'
    >>>time.strftime("%Y-%m-%d %H-%M-%S")
    '2017-07-24 13-55-04'
    
    #时间元组:localtime将一个时间戳转换为当前时区的struct_time
    time.localtime()
    time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
              tm_hour=13, tm_min=59, tm_sec=37, 
                     tm_wday=0, tm_yday=205, tm_isdst=0)
    复制代码

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

    几种格式之间的转换

    复制代码
    #时间戳-->结构化时间
    #time.gmtime(时间戳)    #UTC时间,与英国伦敦当地时间一致
    #time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法:与UTC时间相差8小时,UTC时间+8小时 = 北京时间 
    >>>time.gmtime(1500000000)
    time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
    >>>time.localtime(1500000000)
    time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
    
    #结构化时间-->时间戳 
    #time.mktime(结构化时间)
    >>>time_tuple = time.localtime(1500000000)
    >>>time.mktime(time_tuple)
    1500000000.0
    复制代码
    复制代码
    #结构化时间-->字符串时间
    #time.strftime("格式定义","结构化时间")  结构化时间参数若不传,则显示当前时间
    >>>time.strftime("%Y-%m-%d %X")
    '2017-07-24 14:55:36'
    >>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
    '2017-07-14'
    
    #字符串时间-->结构化时间
    #time.strptime(时间字符串,字符串对应格式)
    >>>time.strptime("2017-03-16","%Y-%m-%d")
    time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
    >>>time.strptime("07/24/2017","%m/%d/%Y")
    time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)
    复制代码

    复制代码
    #结构化时间 --> %a %b %d %H:%M:%S %Y串
    #time.asctime(结构化时间) 如果不传参数,直接返回当前时间的格式化串
    >>>time.asctime(time.localtime(1500000000))
    'Fri Jul 14 10:40:00 2017'
    >>>time.asctime()
    'Mon Jul 24 15:18:33 2017'
    
    #时间戳 --> %a %b %d %H:%M:%S %Y串
    #time.ctime(时间戳)  如果不传参数,直接返回当前时间的格式化串
    >>>time.ctime()
    'Mon Jul 24 15:19:07 2017'
    >>>time.ctime(1500000000)
    'Fri Jul 14 10:40:00 2017' 
    复制代码
     计算时间差

    random模块

    复制代码
    >>> import random
    #随机小数
    >>> random.random()      # 大于0且小于1之间的小数
    0.7664338663654585
    >>> random.uniform(1,3) #大于1小于3的小数
    1.6270147180533838
    #恒富:发红包 #随机整数 >>> 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个组合 [[4, 5], '23'] #打乱列表顺序 >>> item=[1,3,5,7,9] >>> random.shuffle(item) # 打乱次序 >>> item [5, 1, 3, 7, 9] >>> random.shuffle(item) >>> item [5, 9, 7, 1, 3]

    练习:生成随机验证码

    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="".join([code,str(add)])
    
        return code
    
    print(v_code()

    os模块

     os模块是与操作系统交互的一个接口

    复制代码
    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.system("bash command")  运行shell命令,直接显示
    os.popen("bash command).read()  运行shell命令,获取执行结果
    os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
    os.chdir("dirname")  改变当前脚本工作目录;相当于shell下cd
    
    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')  获取文件/目录信息 的结构说明

    sys模块

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

    sys.argv           命令行参数List,第一个元素是程序本身路径
    sys.exit(n)        退出程序,正常退出时exit(0),错误退出sys.exit(1)
    sys.version        获取Python解释程序的版本信息
    sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
    sys.platform       返回操作系统平台名称
    import sys
    # sys.path.append()  # 将某个路径添加到系统的环境变量中
    # print(sys.platform)
    # print(sys.version)  # python解释器的版本
    
    print(sys.argv)  # 命令行启动文件 可以做身份的验证
    if len(sys.argv) <= 1:
        print('请输入用户名和密码')
    else:
        username = sys.argv[1]
        password = sys.argv[2]
        if username == 'jason' and password == '123':
            print('欢迎使用')
            # 当前这个py文件逻辑代码
        else:
            print('用户不存在 无法执行当前文件')
    # 序列化:将原本的字典,列表等内容转换成一个字符串的过程就叫序列化

    # 序列化的目的
    # 1.已某种存储形式使自定义对象持久化
    # 2.将对象从一个地方传递到另外一个地方
    # 3.使程序更具有维护性

    # str -------》反序列化----------》》数据过程
    # 数据结构 --------》》序列化----------》str

    "fsdfsdfsdfsdfsdfsdfsdfsdf[]"
    # 序列化-------转向一个字符串数据类型
    # 序列 》》》》字符串

    # 1.数据存储(写文件,数据库)
    # 网络上传输,
    # 比如有一个字典dict,你要将它先转化成字符串,然后再变成字节进行传输

    # 从数据类型转化成----字符串的过程就叫序列化
    # 从字符串转化成--------数据类型就叫做反序列化
    # json
    # 通用的序列化格式,好处就是通用(比如java,c)
    # 只有很少的一部分数据类型能够通过json转化成字符串
    
    # pickle
    # 所有的python中的数据类型都可以装化成字符串形式
    # pickle序列化的内容只有python能解释,python专用,且反序列化(字符串转化存储数据类型)依赖python代码
    
    # shelve
    # 序列化句柄(f=open("text.txt","r")中f就是句柄),使用句柄直接操作,非常方便
    
    
    dict1 = {"k1": "v1"}
    # 1.json dumps 序列化方法 , loads 反序列化方法    数字 字符串 字典,元组  集合转换不了报错
    print(type(dict1), dict1)  # <class 'dict'> {'k1': 'v1'}
    import json
    
    str_d = json.dumps(dict1)
    print(type(str_d), dict1)  # <class 'str'> {'k1': 'v1'} 转化成了字符串
    # loads 反序列化
    dic_d = json.loads(str_d)
    print(type(dic_d), dic_d)  # <class 'dict'> {'k1': 'v1'} 将字符串转化成了字典
    
    # json dump 往文件写
    dict2 = {1: "a", 2: "b"}
    f = open("fff.txt", "w", encoding="utf-8")
    json.dump(dict2, f)  # 正常情况下字典是不能直接写入文件,必须转化成字符串,json.dump就是做了转化字符串直接写入进去
    f.close()
    
    # json load 读文件(一次性读出来)
    f = open("fff.txt", "r", encoding="utf-8")
    res = json.load(f)
    print(type(res), res)  # <class 'dict'> {'1': 'a', '2': 'b'}读出来是字典
    f.close()
    
    # 2.pickle 在用 dump 写文件和 load读文件 都需要用二进制方式,wb,rb,支持分次dunp和load,
    
    
    # 3.shelve  # 序列化句柄(f=open("text.txt","r")中f就是句柄),使用句柄直接操作,非常方便
    import shelve
    
    f = shelve.open("wukai.txt")
    f["key"] = {"int": 10, "float": 9.9, "string": "Sample data"} # 直接对文件句柄操作,就可以存入数据类型
    f.close()
    
    import shelve
    f1 = shelve.open("wukai.txt")
    existing = f1["key"]  # 取出数据的时候也只需要直接用key获取即可,但是如果key不存在直接报错
    f1.close()
    print(existing)

    import sys
    try:
        sys.exit(1)
    except SystemExit as e:
        print(e)
  • 相关阅读:
    java.lang.NoSuchMethodError:antlr.collections.AST.getLine() I
    T7 java Web day01 标签HTML
    T6 s1 day19
    T5 s5 Day18
    T5 s4 Day 17
    T5 s3 day16
    T5 s2 Day 15
    T5 s1 day14
    T4 S03 day 12
    T4 S01 day1
  • 原文地址:https://www.cnblogs.com/wukai66/p/11208778.html
Copyright © 2011-2022 走看看