python学习之路---day21--模块和栈

                                        模块和栈

一：计数模块collections
    基础版本：
        s="qwewsfdfjiehrfqweqweqwqewq"
        dic={}
        for el in s:
            dic[el]=dic.setdefault(el,0)+1
        print(dic)

    升级版本：
        import collections
        from collections import Counter
        s="qwewsfdfjiehrfqweqweqwqewq"
        qq=Counter(s)
        print("__iter__" in dir(qq))
        for item in qq:
            print(item,qq[item])

    # 同时列表也可以用counter
    # # 列表也可以用Counter
        import collections
        lst=["1","2","1","1","4","1"]
        q=collections.Counter(lst)
        print(q)  #打印： Counter({'1': 4, '2': 1, '4': 1})

二：栈和队列
  001：栈
    栈的进出原则：先进后出
    栈的基本知识点总结：
    栈是一种先进后出的序列表，先放进去的元素，只能通过栈指针去取出来，每当放入一个元素的时候当往栈里面添加一个元素时，
    栈指针会往上移动一个（index会变成 index+1--〉放元素时），取元素的时候，也是通过栈指针，取指针的下一个元素，此时栈
    顶指针是：  index=index-1（取元素时），，，空栈的时候添加元素只能用插入--〉insert()

    自定义栈满了之后的异常
    class StackFullError(Exception):
        pass

    class StackEmptyError(Exception):
        pass

    class Stack:  #定义一个栈类
        def __init__(self,size):
            self.index=0  #栈顶指针
            self.lst=[]
            self.size=size

        def push(self,item):  #往栈里面添加元素
            if self.index==self.size:
                #栈已经满了   需要报错
                raise StackFullError("the Stack is full")

            self.lst.insert(self.index,item)  #空列表需要用insert
            self.index+=1

        #从栈中获取数据
        def pop(self):
            if self.index==0:
                raise StackEmptyError("the stack is empty")  #这里也需要自定义一个异常（栈空了需要报异常）
            self.index-=1  #指针向下移动
            item=self.lst.pop(self.index)  #获取元素删除
            return item

    s=Stack(5)  #给栈一个大小
    s.push("q")
    s.push("w")
    s.push("e")
    s.push("r")
    s.push("t")  #往栈里面添加元素

    print(s.pop())   #从栈里面拿数据元素
    print(s.pop())
    print(s.pop())
    print(s.pop())
    print(s.pop())
    print(s.pop())

    print(s.pop())  #超出栈大小，抛出异常

  02）：队列
    队列数据进出原则：先进先出
   例子01：
    import queue   #引入队列模块
    q=queue.Queue()  #创建一个队列，固定模板（在queue模块中有一个）
    q.put("张三")
    q.put("李四")
    q.put("王五")
    q.put("旺财")
    q.put("小白")

    print(q.get())
    print(q.get())
    print(q.get())
    print(q.get())
    print(q.get())
    #打印：张三  李四   王五  旺财  小白
    #
    print(q.get())  #造成阻塞
    print("没有了")
    #在队列里面已经没有元素了，还继续拿元素的时候，队列会一直处于执行状态，等待着元素的进入，这个时候就是阻塞了

  03):双向队列
    from collections import deque  #从系统中自带的collections 模块 引入 deque
    q=deque() #创建一个双向队列

    q.append("张三")  #从右边末尾开始加元素
    q.append("李斯特") #加在最右边，提取数据时候，总是从最右边开始获取

    q.appendleft("王五")  #加在最左边，提取的时候总是从最左边开始获取数据
    q.appendleft("旺财")

    print(q.pop())  #从最右边开始获取
    print(q.popleft()) #从最左边开始获取


  04）：namedtuple  #命名元组
    from collections import namedtuple
    Point=namedtuple("点",["x","y","z"])
    p=Point("zhangshan","lisu","王五")
    print(p)
    print(p.x)
    print(p.y)
    print(p.z)

    类似于：
    class Point:
        def __init__(self,x,y):
            self.x=x
            self.y=y
    p=Point(2,3)
    p.z=12
    print(p.z)

  05):默认字典 defaultdict
    例子01：
    from collections import defaultdict
    lst=[11,22,33,44,55,66,77,88,99]
    d=defaultdict(list)   #d是一个空列表
    for el in lst:
        if el<66:
            d["key1"].append(el)   #d["key1"]  是一个字典的键，将el 添加到其所对应的键值的列表中
        else:
            d["key2"].append(el)  #key1 key2 是不存在的，但是可以拿到key1 key2
    print(d)

  例子2：
    from collections import defaultdict
    d=defaultdict(list)
    #d=defaultdict(abc)    abc 可以是list、set、str等等，作用是当key不存在时，
    # 返回的是abc的默认值，比如list对应[ ]，str对应的是空字符串，
    d["wangwu"]="王五"
    print(d["zhangsan"])  #打印：[]
    print(d["wangwu"])  #打印：王五

  06）：orderdict和defaultdict
    orderdict 顾名思义. 字典的key默认是⽆序的. ⽽OrderedDict是有序的
    dic = {'a':'娃哈哈', 'b':'薯条', 'c':'胡辣汤'}
    print(dic)
    from collections import OrderedDict
    od = OrderedDict({'a':'娃哈哈', 'b':'薯条', 'c':'胡辣汤'})  #从这个3.6版本是看不出来的，但是内部是无序的
    print(od)

三：时间模块
    获取当前时间 （时间戳）
  001：打印本地时间（时间有localtime 和 gmtime ）
    import time
    print(time.time()) #d打印的时当前时间：1542167144.751588

  002格式化时间：
    s=time.strftime("%Y/%m/%d %H:%M:%S")  #string format time
    print(s)  #打印：2018/11/14 11:48:02
    相似类等待时间 ：wait()  #傻等，必须要是 notify()
    例子：
    while 1:   #这是一个计时器
        s=time.strftime("%Y-%m-%d %H:%M:%S")
        print(s)
        time.sleep(2)  #每隔（睡眠） 2秒 然后再执行打印

  003:结构化时间：
    import time
    t=time.localtime()
    print(t)
    #打印：time.struct_time(tm_year=2018, tm_mon=11, tm_mday=14, tm_hour=11, tm_min=55, tm_sec=22, tm_wday=2, tm_yday=318, tm_isdst=0)
    print(t.tm_year)  #只获取年份，其他的分 秒类似写法

  004：将时间戳转换成格式化时间
    时间戳--〉格式化时间：
    import time
    a=19888899
    t=time.localtime(a)
    #t=time.gmtime(0)   #时区   gmtime() 格林尼治时间
    print(t)  #打印：time.struct_time(tm_year=1970, tm_mon=8, tm_mday=19, tm_hour=12, tm_min=41, tm_sec=39, tm_wday=2, tm_yday=231, tm_isdst=0)
    str_time=time.strftime("%Y/%m/%d %H:%M/%S:%A/%Z",t)
    print(str_time)  #打印：1970/08/19 12:41/39:Wednesday

    格式化时间--〉时间戳(思路：格式化时间--〉结构化时间--〉时间戳)

    import time
    # 格式化时间--〉结构化时间
    s="2017-2-23 13:45:34"
    t=time.strptime(s,"%Y-%m-%d %H:%M:%S")
    print(t)  #打印：time.struct_time(tm_year=2017, tm_mon=2, tm_mday=23, tm_hour=13, tm_min=45, tm_sec=34, tm_wday=3, tm_yday=54, tm_isdst=-1)
    # 结构化时间--〉时间戳
    tt=time.mktime(t)
    print(tt) #打印：1487828734.0

  案例：
    时间戳和格式化   结构化时间的相互转换（用两种方法写）
    例子：
    计算时间差(用户输入起始时间和结束时间. 计算时间差(小时),
    例如, 用户输入 2018-10-08 12:00:00 2018-10-08 14:30:00 输出 2 小时30分
  方法一：
    思路：格式化时间--〉结构化时间-->时间戳  然后时间戳相减，得到差值，将差值进行转为结构化时间输出
    import time
    a1="2018-10-08 12:00:00"
    a2="2018-10-08 14:30:00"
    t1=time.strptime(a1,"%Y-%m-%d %H:%M:%S")  #格式化时间转换为结构化时间  time.strptime(string,format)
    #print(t1) #time.struct_time(tm_year=2018, tm_mon=10, tm_mday=8, tm_hour=12, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=281, tm_isdst=-1)
    t2=time.strptime(a2,"%Y-%m-%d %H:%M:%S")  #格式化时间转换为结构化时间  time.strptime(string,format)
    #print(t2) #time.struct_time(tm_year=2018, tm_mon=10, tm_mday=8, tm_hour=14, tm_min=30, tm_sec=0, tm_wday=0, tm_yday=281, tm_isdst=-1)

    tt1=time.mktime(t1)  #将结构化时间通过time.mktime() 转换为时间戳
    # print(tt1)  #1538971200.0
    tt2=time.mktime(t2) #将结构化时间通过time.mktime() 转换为时间戳
    # print(tt2)   #1538980200.0
    tt_new=int(abs(tt1-tt2))   #不知道=谁减去谁，直接一个abs（）绝对值就可以了
    # print(tt_new)  #9000
    tt_last=time.gmtime(tt_new) #在将时间戳转换为结构化时间（不要用time.localtime()  不然会有8小时的时区差）
    print(tt_last)  #  time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=2, tm_min=30, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)
    print("时间差了%d年%d月%d天%d小时%d分钟%d秒" % (tt_last.tm_year-1970,tt_last.tm_mon-1, tt_last.tm_mday-1,tt_last.tm_hour, tt_last.tm_min, tt_last.tm_sec))

  方法二：
    思路：也是分别将给定的格式化时间转换为时间戳，然后将时间戳转换为结构化时间
    import time
    a1="2018-10-08 12:00:00"
    a2="2018-10-08 14:30:00"
    t1=time.strptime(a1,"%Y-%m-%d %H:%M:%S")  #格式化时间转换为结构化时间  time.strptime(string,format)
    t2=time.strptime(a2,"%Y-%m-%d %H:%M:%S")  #格式化时间转换为结构化时间  time.strptime(string,format)
    tt1=time.mktime(t1)  #将结构化时间通过time.mktime() 转换为时间戳
    tt2=time.mktime(t2) #将结构化时间通过time.mktime() 转换为时间戳
    tt_new=int(abs(tt1-tt2))   #不知道谁减去谁，直接一个abs（）绝对值就可以了
    print(tt_new)  #9000  这个是秒
    tt_Hour=tt_new//3600
    print(tt_Hour)  #显示出：小时  2
    tt_Min=int((tt_new-tt_Hour*3600)/60) #显示出来还剩下多少分钟
    print(tt_Min)  #显示出来分钟  30
    print("时间差是%s小时%s分钟" % (tt_Hour,tt_Min))

  ⽇期格式化的标准:
    %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 当前时区的名称
    %% %号本身

四：random 模块
    import random  #引入随机数模块
    print(random.randint(1,9))  #1到9 随机产生 一个整数  （前闭后闭  可以取到9）
    print(random.random())  #随机产生一个（0，1）之间的小树
    print(random.choice([1,"张三",["李四","王五","赵四"]]))  # 从这些元素中随机产生一个
    print(random.sample([["1","2","3"],"旺财","小白",123],2))   #2 代表从这些数据中随机产生2个出来组成，可也可以改成其他3等等

    lst=[14,6,8,2,32,1,90,7]
    random.shuffle(lst)
    print(lst)  #每次返回的数据都不一样。random对其顺序打乱了
    lst的返回值为None


五：os模块(所有的和操作系统相关的内容都在os模块)
    import os
    os.makedirs("123/345")  #可⽣成多层递归⽬录
    os.removedirs("123")   #FileExistsError: [WinError 183] 当文件已存在时，无法创建该文件。: '123/345'
    os.removedirs("123/345")  #删除123文件夹下的345文件夹或则文件，如果文件夹下有其他文件，则无法进行删除操作
    os.mkdir('123') #生成单级目录；相当于shell中mkdir dirname
    os.rmdir('123') #删除单级空⽬录，若⽬录不为空则⽆法删除，报错；相当于shell中
    print(os.listdir("../整理--day019 约束和异常处理/"))  #返回指定的文件夹包含的文件或文件夹的名字的列表。这个列表以字母顺序
    os.remove("123/234")  #删除123文件夹下的234文件（或则文件夹） ，当234文件夹内有内容时，无法删除
    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.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
    os.linesep 输出当前平台使⽤的⾏终⽌符，win下为"\r\n",Linux下为"\n"
    os.pathsep 输出⽤于分割⽂件路径的字符串 win下为;,Linux下为:
    os.name 输出字符串指示当前使⽤平台。win->'nt'; Linux->'posix'

    os.stat() 属性解读:
    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）是创建时间（详细信息参⻅平台的⽂档）。

六. sys模块
    所有和python解释器相关的都在sys模块.
    sys.argv 命令⾏参数List，第⼀个元素是程序本身路径
    sys.exit(n) 退出程序，正常退出时exit(0),错误退出sys.exit(1)
    sys.version 获取Python解释程序的版本信息
    sys.path 返回模块的搜索路径，初始化时使⽤PYTHONPATH环境变量的值
    sys.platform 返回操作系统平台名称