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

2022-09-19 07:47:33

关于模块
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 返回操作系统平台名称

码农公寓

相关文章