模块

一 模块的简单认识

1.什么是模块?

　　模块就是我们把装有特定功能的代码进行归类,从代码编写的单位来看我们的程序:

　　　　　　一条代码 < 语句块 < 代码块(函数,类) < 模块 ,我们写的所有的 py 文件都是模块

　　引入模块的方法:

　　　　1.import 模块

　　　　2. from 模块  import 功能

二 collections 模块

　　collections 模块  主要封装 了 一些 关于集合的相关 操作, 比如, iterable,iterator 等等, 除了这些以外,

collections 还提供了一些糊了 基本数据类型以外的数据集合类型,Counter , deque , OrderDict,defaultdict

以及 namedtuple

　　1.Counter

　　　　counter是一个计数器,主要用来计数

　　　　计算一个字符串中 每个字符出现大的次数

# low:

# s = "hahage like pig,hahaha"
# dic = {}
# for i in s:
#     dic[i] = dic.get(i,0) + 1
# print(dic)
# # 结果 {'h': 5, 'a': 5, 'g': 2, 'e': 2, ' ': 2, 'l': 1, 'i': 2, 'k': 1, 'p': 1, ',': 1}

# # nb:
# 
# from collections import Counter
# s = "hahage like pig,hahaha"
# 
# print(Counter(s))
# 
# # 结果 Counter({'h': 5, 'a': 5, 'g': 2, 'e': 2, ' ': 2, 'i': 2, 'l': 1, 'k': 1, 'p': 1, ',': 1})

# 获取的结果 可以像字典一样 进行使用 [key]

　　2.deque 双向队列

　　　　　　(重点)  说双向队列之前,我们需要了解下 1.栈 2. 队列

　　　　　　　　1. 栈  FILO  先进后出,---> 好比 砌墙的砖头,老师傅做馒头

　　　　　　　　2. 双向队列  FIFO 先进先出--> 好比,买火车票排队,所有排队的场景

　　由于 python 没有给出 Stack 模块,所以我们自己动手写一个 粗略版本(注意此版本有严重的 并发问题)

class StopFullException(Exception):
    pass

class StopEmptyException(Exception):
    pass


class Stack:
    def __init__(self,size):
        self.size = size       # 定 容量
        self.lst = []          # 存放 元素的 列表
        self.top = 0           # 栈顶指针  初识为0 ,栈顶指针永远 指向 你要操作的 下一个位置
 
    # 出栈
    def pop(self):　　　　　　　　　# 取 元素
        if self.top == 0:
            raise StopEmptyException("your size is empty!!!")  # 报错用的
        self.top -= 1
        el = self.lst[self.top]
        return el

    # 入栈
    def push(self,el):               # 放元素
        if self.top >= self.size:     # 栈顶指针 超出了  size 容量 范围,就会报错
            raise StopFullException("your size is full!!!")
        self.lst.insert(self.top,el)   # 放元素  的时候 注意 ,必须使用 insert  插入
        self.top += 1　　　　　　　　　　　　　　是在 self.top 的位置插入,而不是  添加

s = Stack(5)
s.push("哈哈哥")                      # 放入 "哈哈哥" 的 元素
print(s.pop())
print(s.pop())  # 此时 就会 报错,因为 你的 size 是空的,继续取值就会报错

　　列队:python 提供了 queue 模块 ,使用起来 非常 方便

from collections import deque

q = deque()
q.append("哈哈哥")    # 右侧添加
q.append("嘻嘻姐")
q.appendleft("张曼玉")  # 左侧添加
q.appendleft("朱茵")
print(type(q),q)
# 结果 <class 'collections.deque'> deque(['朱茵', '张曼玉', '哈哈哥', '嘻嘻姐'])

print(q.pop())     # 右侧删除   嘻嘻姐
print(q.popleft())  # 左侧删除   朱茵

　　3.namedtuple 命名 元祖

　　　　　　命名元祖,顾名思义,给元祖内的 元素 进行命名,比如,我们说(x,y) 这是一个元祖,同时,我们还可以认为

　　　　　　　　　　这是一个 坐标,这时,我们就可以 使用 namedtuple 对元素 进行 命名

from collections import namedtuple

# 自己定义一个元祖,如果想的到的话,这其实就是创建了一个类

nt = namedtuple("point",["x","y"])
p = nt(1,2)
print(p)    #  结果  point(x=1, y=2)
print(p.x)  # 1
print(p.y)  # 2

print(type(p))   # <class '__main__.point'>

　　4.OrderDict  和  defaultdict

　　　　OrderDict  有序字典,其实在 python 3.6 版本,字典 默认有序的 ,就是你存储的时候的 顺序

dic = {"a":"葫芦娃","b":"黑猫警长","c":"舒克贝塔"}
# print(dic)

from collections import OrderedDict

od = OrderedDict({"a":"葫芦娃","b":"黑猫警长","c":"舒克贝塔"})
print(od)  
# OrderedDict([('a', '葫芦娃'), ('b', '黑猫警长'), ('c', '舒克贝塔')])

 　　defaultdict  可以给 字典设置 默认值,当 key  不存在时,  直接获取默认值

from collections import defaultdict

dd = defaultdict(list)   # 默认值  list
print(dd["哈哈哥"])     # 当 key 不存在 的时候,会自动 执行构造方法中传递的内容

print(dd)               #   defaultdict(<class 'list'>, {'哈哈哥': []})

 三  time 时间模块 

　　　　时间模块是我们经常用到的,比如,如何 计算时间差,如何按照 要求展示 时间等 

import time

print(time.time())
# 1548066502.7162604    系统时间

print(time.gmtime())
# time.struct_time(tm_year=2019, tm_mon=1, tm_mday=21,
# tm_hour=10, tm_min=28, tm_sec=22, tm_wday=0, tm_yday=21, tm_isdst=
# 格林尼治 结构化时间   2019-1-21  10:28:28

# 格林尼治时间  从 1970 年 1月 1 日 00点 00分 00秒 开始计时的
#  和我们所在 时区 相差 8 小时

print(time.localtime())
# time.struct_time(tm_year=2019, tm_mon=1, tm_mday=21,
# tm_hour=18, tm_min=28, tm_sec=22, tm_wday=0, tm_yday=21, tm_isdst=0)
# 当地  结构化时间  2019-1-21  18:28:28

   　　　在 python中  时间 分为 3种 表现形式:

　　　　1.时间戳(timestamp)   时间戳 使用的 是 1970年01月01日 00点00分00秒 到现在一共经过了多少秒

　　　　　　　　　　　　　　使用 float 表示

　　　　2.格式化时间(strftime) 这个时间可以根据我们的 需要 对时间进行任意的 格式化

　　　　3.结构化时间(struct_time) 这个时间 主要 可以把 时间进行类 划分,比如 1970年01月01日  00点00分

　　　　　　　　　　　　　　　　00秒,这个时间可以被 细分为 年 月 日 ...一大堆东西

　　日期格式化的 标准:

%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 当前时区的名称
%% %号本身

　　　　　　　　　　　　　　　　

 　　时间的转化 : 比如给出 一个时间  123456789 ,如何转化成 我们 平时看到的 xx年xx 月 xx 日的时间呢

import time

t = time.localtime(1548066502.7162604)
s = time.strftime("%Y-%m-%d %H:%M:%S",t)
print(s)  # 2019-01-21 18:28:22

import time

# 现在给出了 时间怎么转化为 时间戳呢

s = "2019-01-21 18:28:22"
t = time.strptime(s,"%Y-%m-%d %H:%M:%S")
time = time.mktime(t)
print(time)   # 1548066502.0

 　　计算时间差

import time

true_time = time.mktime(time.strptime("2017-09-11 08:30:00","%Y-%m-%d %H:%M:%S"))
time_now = time.mktime(time.strptime("2017-09-11 11:30:00","%Y-%m-%d %H:%M:%S"))

dif_time = time_now - true_time

struct_time = time.localtime(dif_time)
print(struct_time)
# time.struct_time(tm_year=1970, tm_mon=1, tm_mday=2, tm_hour=10,
# tm_min=30, tm_sec=0, tm_wday=4, tm_yday=2, tm_isdst=0)

print("过去了%d年%d月%d天%d⼩小时%d分钟%d秒" %
      (struct_time.tm_year - 1970,struct_time.tm_mon-1,struct_time.tm_mday-1,struct_time.tm_hour-8,
struct_time.tm_min,struct_time.tm_sec))

# 过去了0年0月0天3⼩小时0分钟0秒

四 random 模块

　　所有的随机相关的内容都在 random 模块中

import random

# print(random.random())        # 0 - 1 之间的小数  [0,1)
# print(random.uniform(3,4))   # 指定 区间的 小数   [3,4)
#
# print(random.randint(1,10))        # 指定区间的 随机整数 [1,10]
# print(random.randrange(1,10,2))    # 1 - 10 之间的奇数    [1,10)
# print(random.randrange(2,10,2))    # 1 - 10 之间的偶数    [1,10)
#
# print(random.choice([1,"哈哈哥",["朱茵","张曼玉"]])   # 1 或者 "哈哈哥" 或者 ["朱茵","张曼玉"]
# print(random.sample([1,"123",[4,5]],2))   # [[4, 5], 1] 列表任意 两个 组合

# # shuffle 洗牌,随机打破lst 顺序
# lst = [1,2,3,4,5,6,7,8,9]
# random.shuffle(lst)
# print(lst)

#  35 选 7

count = 0
tt = set()
while count < 7:
    s = random.randint(1,35)
    tt.add(s)
    count += 1
print(tt)

五 os 模块

　　所有的操作系统相关的内容都在 os 模块

import os

# os.makedirs("a/b/c")   # 可生成多层迭代目录
# os.removedirs("a/b/c")   # 若 目录为空 则删除 ,并递归到上一目录,若为空,继续删除,依次 类推

# os.mkdir("张曼玉")     # 创建一个单级目录  相当于 shell 中 mkdir dirname
# os.rmdir("张曼玉")      # 删除单级目录,若为空则删除,不为空则 报错:相当于shell 中的 rmdir dirname

# print(os.listdir("D:learn-pyidea青春练习册"))
# # 列出 指定目录下的 所有 文件和子目录,包括 隐藏文件,并以列表方式 打印

# os.remove()  # 删除一个文件,文件操作 的 时候用到过
# os.rename("副本","原文件名称") # 改名字
# print(os.stat("D:learn-pyidea青春练习册"))  # 获取文件/ 目录信息

# os.system("D:learn-pyidea青春练习册")   # 运行 shell 命令,直接显示
# os.popen("D:learn-pyidea青春练习册").read() #运行 shell 命令,获取执行结果
# print(os.getcwd())  # 获取当前工作目录,即当前 python 脚本工作 的目录 路径
# os.chdir("dirname")   # 改变当前脚本工作 目录,相当于 shell 下 cd


# #####  os.path
# print(os.path.abspath("02天  运算符 和 编码.py"))
# #  结果 D:learn-pyidea青春练习册2天  运算符 和 编码.py
# # 返回 path 规范化的 绝对 路径

# print(os.path.split("D:learn-pyidea青春练习册2天  运算符 和 编码.py"))
# # ('D:\learn-py\idea', '青春练习册x02天  运算符 和 编码.py')
# # 将  path 分割成 目录 和   文件名     以元组 返回

# print(os.path.dirname("D:\learn-py\idea', '青春练习册x02天  运算符 和 编码.py"))
# #  结果   ('D:learn-py
# # 返回 path 的 目录,其实就是  os.path.split(path)  的 第一个 元素

# print(os.path.basename("D:\learn-py\idea', '青春练习册x02天  运算符 和 编码.py"))
# # 结果  idea', '青春练习册天  运算符 和 编码.py
# # 返回  path 最后的文件名,如果 path 以/或结尾,那么就会返回 空值
# # 即 os.path.split(path) 的  第二个  元素

# print(os.path.exists("D:\learn-py\idea', '青春练习册x02天  运算符 和 编码.py"))
# # False
# #  如果 path 存在,返回 True,如果 path 不存在,返回 False

# print(os.path.isabs("D:\learn-py\idea', '青春练习册x02天  运算符 和 编码.py"))
# # True
# # 如果 path 是 绝对 路径 ,返回  True

# print(os.path.isfile("D:\learn-py\idea', '青春练习册x02天  运算符 和 编码.py"))
# # False
# # 如果 path 文件 存在  返回 True 否则 返回 False

# print(os.path.isdir("D:\learn-py\idea', '青春练习册x02天  运算符 和 编码.py"))
# #  False
# # 如果 path 是一个存在的 目录,返回True  ,否则 返回 False

# print(os.path.join("D:\learn-py\idea", "青春练习册x02天  运算符 和 编码.py"))
# # 结果  D:learn-pyidea青春练习册天  运算符 和 编码.py
# # 将多个 路径 组合后返回,第一个 绝对路径之前的 参数 将 被 忽略

# print(os.path.getatime("D:learn-pyidea青春练习册"))
# # 结果  1548081536.3541353
# # 返回 path 所指向的 文件 或者 目录 的 最后 访问时间

# print(os.path.getmtime("D:learn-pyidea青春练习册"))
# # 结果  1548082056.9019089
# # 返回 path 所指向的文件 或者 目录 的 最后 修改时间

# print(os.path.getsize("D:learn-pyidea青春练习册"))
# # 12288
# # 返回 path  的大小

# # 特殊 属性

# os.sep("D:learn-pyidea青春练习册")      # 输出操作系统特定的路路径分隔符，win下为"\",Linux下为"/"
# os.linesep("D:learn-pyidea青春练习册")   # 输出当前平台使⽤用的⾏行行终⽌止符，win下为"
",Linux下为"
"
# os.pathsep("D:learn-pyidea青春练习册")   # 输出⽤用于分割⽂文件路路径的字符串串 win下为;,Linux下为:
# os.name("D:learn-pyidea青春练习册")       # 输出字符串串指示当前使⽤用平台。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 返回操作系统平台名称