21 模块（collections,time,random,os,sys）

关于模块
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() 把结构化时间转化成时间戳

4. os和sys
os.sep 文件路径分隔符
sys.path python查找模块的路径

一  、collections

1.  Counter    计数

lst=["a","a","b","g"]
ret=Counter(lst) #lst中的元素必须为可哈希，不然会报错
print(dict(ret))  #可将其转换成字典的形式  #{'a': 2, 'b': 1, 'g': 1}.

from collections import Counter
# #Counter 计数
s="sdffgds sdggdggdgerhumu34$3*7"
q=Counter(s)
for i in q:
    print(i,q[i])
dic={}
for i in s:
    dic[i]=dic.setdefault(i,0)+1  #用字典value 计数 ，setdefault 存在就不做任何操作
print(dic)

# li2=["a","a","b","g"]
# ret=Counter(li2)
# print(ret)

lst=["a","a","b","g"]
ret=Counter(lst) #lst中的元素必须为可哈希，不然会报错
print(dict(ret))  #可将其转换成字典的形式  #{'a': 2, 'b': 1, 'g': 1}

Counter

2.defaultdict 默认值字典

from collections import defaultdict
# lst=[11,32,22,45,66,77,78]
# d=defaultdict(list)  #d=defaultdict(可调用的对象或可执行对象）
# for el in lst:
#     if el>66:
#         d["key1"].append(el) #如果key1不存在时，就会去执行list(),所以d["key1"]=[]
#     else:
#         d["key2"].append(el)
# print(d)  #defaultdict(<class 'list'>, {'key2': [11, 32, 22, 45, 66], 'key1': [77, 78]})
# print(dict(d))  #将其变成字典

def func():
    return "胡辣汤"

d=defaultdict(func)
print(d["a"]) # 胡辣汤 相当d["a"]=func()
print(d["b"]) # 胡辣汤 相当d["a"]=func()
print(dict(d))  #{'a': '胡辣汤', 'b': '胡辣汤'}

defaultdict

3.队列 queue

#队列
import queue
#
q = queue.Queue() # 创建队列
q.put("李嘉诚")
q.put("陈冠希")
q.put("周润发")
q.put("吴彦祖")

print(q.get())
print(q.get())
print(q.get())
print(q.get())
# print(q.get()) # 队列中如果没有元素了. 继续获取的话. 会阻塞
print("拿完了")

4.双向队列

from collections import deque

q = deque() # 创建一个双向队列
q.append("高圆圆")
q.append("江疏影")
q.appendleft("赵又廷")
q.appendleft("刘大哥")
#  刘大哥 赵又廷 高圆圆 江疏影
print(q.pop()) # 从右边获取数据
print(q.pop())
print(q.popleft()) # 从左边获取数据
print(q.popleft())
print(q.pop())

5.命名元组namedtuple

from collections import namedtuple
# point=namedtuple("Point",["x","y"])    #命名元组  相对于写了一个类    可用于  写菜单
# p=point(2,5)
# print(p.x)
# print(p.y)

person=namedtuple("Person","name age")
# p=person(name="deng",age=12)
p=person("deng",123)
print(p.name)
print(p.age)

6.orderdict

from collections import OrderedDict
# 按照我们存储的顺序保存数据
od = OrderedDict({ 'b':'薯条','a':'娃哈哈', 'c':'胡辣汤'})
print(od)

dic = {}
# print(dic["周润发"]) # 报错
print(dic.get("周润发", "英雄本色")) # None

二.time模块

1.获取当前系统时间, 时间戳   t=time.time()

2.  获取格式化时间   t= time.strftime("%Y-%m-%d %H:%M:%S")

3.获取结构化时间   t = time.localtime()

格式化时间 -> 时间戳

import time
#获取系统时间  时间戳  time.time()
print(time.time())
#格式化时间  strftime  string   format time   time.strftime(格式）
t=time.strftime("%Y-%m-%d %H:%M:%S")
print(t)
# count=0
# while 1:
#     t2=time.strftime("%S")
#     time.sleep(1)
#     count+=1
#     print(t2)

#结构化时间  time.localtime()
t=time.localtime(1888888000)  #时间戳---》转化成结构化时间
t2=time.gmtime(0) #格林尼治时间
print(t2)
print(t)#tm_year=2029, tm_mon=11, tm_mday=9, tm_hour=11, tm_min=6, tm_sec=40, tm_wday=4, tm_yday=313, tm_isdst=0
print(t.tm_year)
print(t.tm_mon)
print(t.tm_mday)
print(t.tm_min)
print(t.tm_sec)
print(t.tm_wday)
print(t.tm_yday)

str_time=time.strftime("%Y-%m-%d %H:%M:%S",t)  #将结构化时间转化成格式化时间，此处的t必须为结构化时间
print(str_time)

#格式化时间转化成结构化时间     strptime  string parse time      time.strptime(格式化时间，格式化的方式）
s="2018-12-11 8:30:43"
tt=time.strptime(s,"%Y-%m-%d %H:%M:%S")
print(tt)
# #结构化时间转化成时间戳     time.mktime(结构化时间）
ss=time.mktime(tt)
print(ss)

time模块

import time
#小时 分钟
t1="2018-10-11 11:12:33"
t2="2020-12-19 8:12:34"
#格式化时间--》结构化时间
struct_time1=time.strptime(t1,"%Y-%m-%d %H:%M:%S")
# print(struct_time1)
struct_time2=time.strptime(t2,"%Y-%m-%d %H:%M:%S")
#结构化时间---》时间戳
t11=time.mktime(struct_time1)
# print(t11)
t12=time.mktime(struct_time2)

# 时间差：
t=t12-t11  #  60  60
# print(t)
h=t//(60*60)
m=(t-h*3600)//60
s=t%60
print(h)
print(m)
print(s)
print("t2和t1的时间差为：%s小时，%s分，%s秒"%(h,m,s))

def time_than(t1,t2):
    '''
    计算时间差的函数
    :param t1: 为格式化时间点1  "%Y-%m-%d %H:%M:%S"
    :param t2:  为格式化时间点2  "%Y-%m-%d %H:%M:%S"
    :return:  以字典形式返回时间差
    '''
    #格式化时间-->结构化时间
    struct_time1 = time.strptime(t1, "%Y-%m-%d %H:%M:%S")
    struct_time2 = time.strptime(t2, "%Y-%m-%d %H:%M:%S")
    #结构化时间--->时间戳
    t11 = time.mktime(struct_time1)
    t12 = time.mktime(struct_time2)
    t=t12-t11
    day=t//(3600*24)
    h=(t-day*3600*24)//3600
    min=(t-day*3600*24-3600*h)//60
    s = t % 60
    return {"day":day,"h":h,"m":m,"s":s}
print(time_than(t1,t2))

时间差

import time
begin = "2019-11-14 16:30:00"
end = "2018-11-14 18:00:00"
# 用时间戳计算出时间差(秒)
begin_struct_time = time.strptime(begin, "%Y-%m-%d %H:%M:%S")
end_stract_time = time.strptime(end, "%Y-%m-%d %H:%M:%S")

begin_second = time.mktime(begin_struct_time)
end_second = time.mktime(end_stract_time)

# 秒级的时间差  180000
diff_time_sec = abs(begin_second - end_second)

# 转化成结构化时间
t = time.gmtime(diff_time_sec) # 最好用格林尼治时间。 否则有时差
print(t)

print("时间差是%s年%s月 %s天 %s小时%s分钟" % (t.tm_year-1970, t.tm_mon-1, t.tm_mday-1,t.tm_hour, t.tm_min ))

时间差二

三. random模块

import random
print(random.random())  #产生0-1的随机小数
print(random.randint(1,9)) #产生一个   1-9 包括1和9 的整数
print(random.randrange(1,9)) ##产生一个   1-9 不包括1和9 的整数
print(random.randrange(1,9,2)) #产生1个  [1,3,5,7]

lst=["a","b",[1,2,"a"],"g"]
print(random.choice(lst))  #从列表lst中随机取一个元素
print(random.sample(lst,2)) #从列表lst中随机取2个元素
random.shuffle(lst)    #打乱顺序
print(lst)

import random
# #四位随机码
# veify_code=""
# for i in range(4):
#     v=chr(random.randint(65.,90))
#     veify_code+=v
# print(veify_code)

#用random.random 生成[n,m]随机整数
def suijizheng(n,m):
    return int(random.random()*(m-n+1)+n)

#随机红包  100  随机分给30人
def hongbao(money,num):
    m=money
    lst=[]
    for i in range(num-1):
        ret = random.random() * (money / num)
        lst.append(ret)
        num-=1
        money-=ret
    last=m-sum(lst)
    lst.append(last)

    lst2=[]
    for i in range(len(lst)-1):
        l=float(format(lst[i],"0.2f"))
        lst2.append(l)
    last2=float(format(m-sum(lst2),"0.2f"))
    lst2.append(last2)
    # print(lst2)
    # print(sum(lst2))
    random.shuffle(lst2)
    return lst2
print(hongbao(100,30))
print(sum(hongbao(100,30)))

随机红包

四  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.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'

五.SYS 模块

所有和python解释器相关的都在sys模块.  sys.argv

命令行参数List，第⼀一个元素是程序本身路路径 sys.exit(n)

退出程序，正常  退出时   exit(0),          错误   退出sys.exit(1)

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

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

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