python D21 基本模板、time/os/sys

今日大纲：
# 1、关于模块
#     import
#     from xxx import xxx
# 2、Collections
#     1、Counter 计数器
#     2、栈：先进后出
#         队列：先进先出
#         deque:双向队列
#     3、defaultdict 默认值字典
#     4、namedtuple命名元组， struct time结构化时间就是命名元组
#     5、OrederedDict 有序字典。 按照我们存储的顺序保存. 和3.6以后的字典一样的
# 3、time 时间模块
#     1、获取系统时间 time.time() 时间戳
#     2、格式化时间 strftime() 时间格式: %Y-%m-%d %H:%M:%S       %Y-%m-%d
#     3、结构化时间 time.gmtime() time.localtime()
#     strptime() 把格式化时间转化成结构化时间
#     mktime()  把结构化时间转化成时间戳
#     时间差的计算

# 一、模块的简单认识
#     什么是模块，模块就是我们把特定功能代码进行归类的结果，从代码编写单位来看
# 我们的程序，从小到大的顺序：一条代码 < 语句块 < 代码块（函数、类）< 模块。
# 我们之前写的所有的py文件都是模块
#     引入模块的方式：
#     1、import
#     from xxx improt模块

# 二、collections模块
#     collections模块主要封装一些关于集合类的相关操作，比如，我们学过的Iterable
# Iterator等等，collections还提供了一些除了一些基本数据以外的数据集合类型
# Conter, deque, OrderDict, defaultdict以及namedtuple

# 1、Counter
# counter是一个计算器，主要来计数
# 计算一个字符串中美俄字符出现的次数：
# from collections import Counter
# # low:
# s = "alex like pig"
# dic = {}
# for c in s:
#     dic[c] = dic.get(c, 0) + 1
# print(dic)  # {'a': 1, 'l': 2, 'e': 2, 'x': 1, ' ': 2, 'i': 2, 'k': 1, 'p': 1, 'g': 1}
#
# # nb:
# s = "alex like pig"
# print(Counter(s))  #  Counter({'l': 2, 'e': 2, ' ': 2, 'i': 2, 'a': 1, 'x': 1, 'k': 1, 'p': 1, 'g': 1}) # 获取到的结果可以像字典⼀样进⾏使⽤ [key]

# 2、deque双向队列
# 先了解两种数据结构：1.栈 2.队列
#     1、栈：FILO先进后出 ->砌墙的砖头，做馒头
#     2、对列：FIFO 先进先出-> 买火车票排队，所有排队的场景
# python中没有栈、自定义栈(粗略版本)

class StockEmptyError(Exception): # 自定义异常
    pass
class StackFullError(Exception):
    pass
class Stack:  # 定义一个类（简易的栈）
    def __init__(self, size):
        self.size = size
        self.index = 0
        self.lst = []

    def push(self, items):
        self.index += 1
        if self.index <= self.size:
            self.lst.append(items)
        else:
            raise StockEmptyError("装满了")

    def pop(self):
        self.index -= 1
        if self.index >= 0:
            self.lst.pop()
        else:
            raise StackFullError("拿完了")

s = Stack(5)
s.push("一号")
s.push("2号")
s.push("3号")
s.push("4号")
s.push("5号")
# s.push("6号")  # 超过报错
# s.push("7号")

s.pop()
s.pop()
s.pop()
s.pop()
s.pop()
s.pop() # 拿完了

# 队列：python提供了queue模板，使用起来非常方便
# import queue  # 引入模块 创建队列
# dui = queue.Queue()  # 固定搭配 创建队列
# dui.put("剑圣")  # put() 往队列里放东西
# dui.put("微恩")
# dui.put("小丑")
# dui.put("赵信")

# print(dui.get())  # get()往队列里拿东西
# print(dui.get())
# print(dui.get())
# print(dui.get())
# # print(dui.get())  # 拿完了 程序会阻塞在这里 阻塞：程序没有结束，一直卡在那

# 双向队列 deque,此队列是collections中的
# from collections import deque  # 从collections模板应用deque（双向队列）
# x = deque() # 创建双向队列
# x.append("jay")  # 右边加元素
# x.append("周杰伦")
#
# x.appendleft("jj")
# x.appendleft("林俊杰")  # 左边加元素
#
# print(x.pop())  # 右边拿元素
# print(x.popleft()) # 左边拿元素

# 3、namedtuple命名元组
# 命名元组，顾名思义，给元组内的元素进行命名，比如，我们说(x,y)这是一个元组，同时
# 我们还可以认为这是一个点坐标，这时，我们可以使用namedtuple对元素进行命名

# from collections import namedtuple  # 从collections应用命名元组
# point = namedtuple("点点", ["x", "y", "z"])  # 里面的参数个数无限制、参数类型无限制
# p = point(4, 7, 9)
# print(p) # 点点(x=4, y=7, z=9)
#
# point = namedtuple("点点", ["x", "y", "z"])
# p = point("你好啊", 7, 9)
# print(p)  # 点点(x='你好啊', y=7, z=9)

# 4、orderdict和defaultdict
# orderdict 顾名思义，字典key默认是无序的，而OrderedDict是有序的
# dic = {'a': '娃哈哈', 'b': '薯条', 'c': '胡辣汤'}  # 在python3以后的版本中字典显示是有序的，但在底层python底层代码中排列还是无序的
# print(dic)
# from collections import OrderedDict
# od = OrderedDict({'a': '娃哈哈', 'b': '薯条', 'c': '胡辣汤'})
# print(od)

# defaultdict:可以给字典设置默认值，当key不存在时，直接获取默认值
# d = defaultdict(list)  # 给字典d设置一个默认值，如果在d中拿不到key,则返回list()
# print(d["周杰伦"])  # []
#
# d = defaultdict(str)
# print(d["周杰伦"])
#
# from collections import defaultdict #调用defaultdict
# # d = {"周杰伦": "昆凌"}  # 字典默认为空字典
# d = defaultdict(list)  # defaultdict 参数必须是可调用的（可调用:表示参数+()能运行）
# d["周杰伦"] = "昆凌"
# print(d["周杰伦"]) # 昆凌

# 三、time时间模块
#     时间模块使我们要熟记的，到后面写程序的时候经常能用到,
# 比如，如何计算时间差，如何按照客户的要求展示时间，等等
import time
# print(time.time()) # 1538927647.483177 系统时间:时间戳

# 在python中时间分成三种表现形式:
# 1. 时间戳(timestamp). 时间戳使⽤的是从1970年01⽉01⽇ 00点00分00秒到现在
# ⼀共经过了多少秒... 使⽤float来表⽰
# 2. 格式化时间(strftime). 这个时间可以根据我们的需要对时间进⾏任意的格式化
# 3. 结构化时间(struct_time). 这个时间主要可以把时间进⾏分类划分. 比如. 1970
# 年01⽉01⽇ 00点00分00秒 这个时间可以被细分为年, ⽉, ⽇.....⼀⼤堆东⻄.
# 时间戳我们已经⻅过了就是time.time(). ⼀般, 我们不会把这样的时间显⽰给客户. 那
# 就需要对时间进⾏格式化操作.
# s = time.strftime("%Y-%m-%d %H:%M:%S")  # 2018-11-15 17:41:48 # 必须记住
# print(s)

# 日期格式化的标准
# %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 本地完整星期名称
# %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 本地完整星期名称

# 看⼀下结构化时间:
# print(time.localtime())
# 结果:
# time.struct_time(tm_year=2017, tm_mon=05, tm_mday=8, tm_hour=10, tm_min=24,
#                  tm_sec=42, tm_wday=0, tm_yday=126, tm_isdst=0)
# 显示当前格式化时间:
# time_now = time.strftime("%Y-%m-%d %H:%M:%S")

# while True:  # 计时器
#     time_now = time.strftime("%Y-%m-%d %H:%M:%S")  # strftime == string fromat time
#     print(time_now)
#     time.sleep(1)  #休眠一秒

# 时间戳->结构化时间->格式化时间
# t1 = time.time()  #2018-11-14 12:23:15 显示当前时间
# t = time.localtime(1888888)
# print(t) # 打印结构化时间
# t2 = time.strftime("%Y-%m-%d %H:%M:%S", t)  # 将结构化时间转换成格式化时间
# print(t2) # 打印格式化时间

# 格式化时间->结构化时间->时间戳
# s = "2018-11-4 12:18:56"
# s1 = time.strptime(s, "%Y-%m-%d %H:%M:%S") # 将格式化时间转化为结构化时间
# print(s1)
# s2 = time.mktime(s1) # 将结构化时间转化为时间戳
# print(s2)   #1541305136.0

# 1、time 模板
# time.time():显示当前时间
# time.strftime("%Y-%m-%d %H:%M:%S") # 显示格式化时间/结构化时间转化为格式化时间
# time.localtime()/time.gmtime()(没有时间差的) # 将时间戳转化为结构化时间  用time.localtime()中国处在东8区会有8小时时差
# time.strptime() #格式化时间转化为结构时间
# time.mktime()  # 将结构化时间转化为时间戳

# 四、random模板
# import random
# print(random.random())  # 0-1之间的小数
# print(random.uniform(1, 10)) # 1-10之间的小数
# print(random.randint(1, 2))  # [1,2]的整数 （前闭后闭区间）
# print(random.randrange(1, 10, 2)) # 1-10里面的奇数（前闭后开区间）
# print(random.choice([1, 2, 3, 5, 8, 11, ["烧饼"]]))  # 列表随机取出一个元素
# print(random.sample([1, 2, 3, 5, 8, 11, ["烧饼"]], 2)) # 列表中任意取两个

# 五. 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.sep 输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
# os.linesep 输出当前平台使⽤的⾏终⽌符，win下为"
",Linux下为"
"
# 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 返回操作系统平台名称