day 019 常用模块

主要内容：

   1模块的简单认识

    2collection模块

    3time时间模块

　4random模块

　5os模块

　6sys模块

一  模块的简单认识

• 引入模块的方式：

   　　  1import （常见方式）

 　　　2 from xxx  import 

  例子：

from collections import Iterable（可迭代的）, Iterator（迭代器） 

lst = []
print(isinstance(lst, Iterable))   #  True
print(isinstance(lst, Iterator))   # False

二 collection模块 （conllection模块主要封装了一些关于集合类的相关操作。比如 iterable,iterator等。除此之外 collections还提供了一些基本数据类型以外的数据集合类型。

例如：

•           Counter
• 　　　deque
• 　　　Orderdict
• 　　　defaultdict
• 　      namedtuple）

   1.Counter(是一个计数器，主要用来激计数)

  例如 计算一个字符串中某个字符出现的次数

# 传统
s='sjkdjajdaksj'
dic={}
for el in s:
    dic[el]=dic.get(el,0)+1
print(dic) #{'s': 2, 'j': 4, 'k': 2, 'd': 2, 'a': 2}

# 牛逼的
from collections import Counter # 引入模块
s='sjkdjajdaksj'
print( Counter(s))  #Counter({'j': 4, 's': 2, 'k': 2, 'd': 2, 'a': 2})

2. deque(双向队列)

 说过这个之前先看看 什么是 ：队列 （先进先出）first in first out fifo

   　　　　　　　　　　　　　栈  (先进后出） first  in last out filo

# import queue
# a=queue.Queue() # 创建队列
# a.put("里鱼") #放入元素
# a.put("声卡")
# a.put('加快')
#
# print(a.get())   #里鱼       # 获取元素
# print(a.get())   # 声卡
# print(a.get())    #加快
# # print(a.get()) #         阻塞了在等下一个元素,和他一样的有 input()
  

#装馒头的桶
#入栈
#出栈
#属性 1 列表(容器)  2大小  3 栈顶指针(下一个装元素的位置)
class StackFullError(Exception):
    pass
class StackEmptyError(Exception):
    pass
class stack:
    def __init__(self,size):
        self.size=size
        self.index = 0  #栈顶指针
        self.list=[]# 容器

    def push(self,el):# 入栈
        if self.index<self.size: #没装满 判断其是否到顶了  上限
            self.list.insert(self.index,el)
            self.index+=1
        else: # 装满了   抛个异常
            raise StackFullError("the stack is full满了!")

    def pop(self):# 出栈
        if  self.index>0: #  不能低于下限
            self.index-=1
            return self.list[self.index]
        else: # 否则 抛个异常 说明这个 栈 是空的
            raise StackEmptyError("the stack is empty空了!")

#实例化栈
s=stack(6)
s.push("1")
s.push("2")
s.push("3")
s.push("4")
s.push("5")
s.push("6")
print(s.pop()) #6
print(s.pop())# 5
print(s.pop())#4
print(s.pop())#3
print(s.pop())#2
print(s.pop())#1
#print(s.pop())    #"the stack is empty空了!"  

接下来看queue (双向队列)

接下来看deque(双向队列)
from collections import deque # 引入模块
q=deque ()# 创建双向列表
q.append("张开")#右侧添加
q.append("李二")
q.appendleft("张三") # 左侧添加
q.appendleft("王麻子") # 左侧添加
print(q) #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

4 orderdict和defaultdict (orderdict 顾名思义. 字典的key默认是⽆序的. ⽽OrderedDict是有序的)

# dic = {'a':'娃哈哈', 'b':'薯条', 'c':'胡辣汤'}
# print(dic)
# from collections import OrderedDict
# od = OrderedDict({'a':'娃哈哈', 'b':'薯条', 'c':'胡辣汤'})
# print(od)

# from collections import defaultdict
# dd = defaultdict(list) # 默认值list
# print(dd['娃哈哈']) # [] 当key不存在的时候. 会⾃动执⾏构造⽅法中传递的内容.

三 time 时间模快

import  time
print(time.time())    #   1538996895.8780088 系统时间

#此时, 我们已经获取到了系统时间, 但是这个时间....看不懂. 怎么办呢. 需要对时间进
#⾏格式化. 那这样就引出了另⼀种时间的格式. 在python中时间分成三种表现形式:

#1. 时间戳(timestamp). 时间戳使⽤的是从1970年01⽉01⽇ 00点00分00秒到现在
#⼀共经过了多少秒... 使⽤float来表⽰
#
#2. 格式化时间(strftime). 这个时间可以根据我们的需要对时间进⾏任意的格式化.
#
#3. 结构化时间(struct_time). 这个时间主要可以把时间进⾏分类划分. 比如. 1970
#年01⽉01⽇ 00点00分00秒 这个时间可以被细分为年, ⽉, ⽇.....⼀⼤堆东⻄.

# 格式化时间
s=time.strftime("%Y-%m-%d %H:%M:%S")
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 本地完整星期名称
# %b 本地简化的⽉份名称
# %B 本地完整的⽉份名称
# %c 本地相应的⽇期表示和时间表示
# %j 年内的⼀天（001-366）
# %p 本地A.M.或P.M.的等价符
# %U ⼀年中的星期数（00-53）星期天为星期的开始
# %w 星期（0-6），星期天为星期的开始
# %W ⼀年中的星期数（00-53）星期⼀为星期的开始
# %x 本地相应的⽇期表示
# %X 本地相应的时间表示
# %Z 当前时区的名称
# %% %号本身

#结构化时间
print(time.localtime())  # 用来计算的

时间的转换:

 时间转换
# t = time.localtime(1888888888) # 结构化时间
# s = time.strftime("%Y-%m-%d %H:%M:%S", t) # 格式化这个时间
# print(s)
# 用户输入时间
s = "2020-10-01 12:18:12"
t = time.strptime(s, "%Y-%m-%d %H:%M:%S")# 转化成结构化时间
print(time.mktime(t)) # 转换成时间戳

计算时间差:

计算时间差(用户输入起始时间和结束时间. 计算时间差(小时),
#          例如, 用户输入2018-10-08 12:00:00   2018-10-08 14:30:00 输出2小时30分
# import time
# start_str = "2018-10-08 12:00:00"
# end_str = "2018-10-08 14:30:00"
#
# start_float = time.mktime(time.strptime(start_str, "%Y-%m-%d %H:%M:%S"))
# end_float = time.mktime(time.strptime(end_str, "%Y-%m-%d %H:%M:%S"))
#
# diff_second = end_float - start_float # 计算相差的秒数
#
# diff_min = diff_second // 60 # 计算出分钟  150
#
# show_hour = diff_min // 60
# show_min = diff_min % 60
#
# print(show_hour, show_min)

四 random模块

import random
print(random.random()) # 0-1的小数
print(random.uniform(3,11)) # 3-11的小数
print(random.randint(3,11)) # 3-11的整数
print(random.randrange(3,11,2)) # 3-11的奇数 步长是2
print(random.choice([3,'周杰伦',["盖伦",'德玛西亚']])) # 随机选一个
print(random.sample([1, '23', [4, 5],'嘻哈'], 3)) # 列表元素任意2个组合
print(random.sample(list(range(1, 37)), 7))  # 36选7

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

五 os模块

import os
# os.makedirs('a/b/c') #生成多层递归目录
# os.removedirs('a/b/c') # 若⽬录为空，则删除，并递归到上⼀级⽬录，如若也为空，则删除，依此类推

# 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.chdir("dirname")# 改变当前脚本⼯作⽬录；相当于shell下cd
os.getcwd() #获取当前⼯作⽬录，即当前python脚本⼯作的⽬录路径

print(__file__)# 拿到当前文件的绝对路径
##  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) 如果文件存在，返回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 返回操作系统平台名称

 homework

 1.请将时间'2018-11-11 0:0:0'转换成时间戳时间

import time
str_t= '2018-11-11 0:0:0'
strut_t = time.strptime(str_t,'%Y-%m-%d %H:%M:%S')  # 结构化时间 格式:(string, format)

stamp = time.mktime(strut_t) # print(stamp)

2.请将时间1111111111转换成格式化时间

 import time
struct_t =time.localtime(1111111111) #结构化时间  直接localtimes时间戳
str_t = time.strftime('%Y-%m-%d %H:%M:%S',struct_t) #格式(format, p_tuple=None)
print(str_t)

 3.请写一个扑克牌列表[('红桃',2),('黑桃',2),('方板',2),...,('梅花','A')],并从中随机抽取一张牌

ranks = [i for i in range(2,11)] + ['J','Q','K','A'] # 创建一个数字列表
# suits = ['红桃','黑桃','方板','梅花']  # 创建所需花色
# l = [] 
# for r in ranks:
#     for s in suits:
#         l.append((s,r)) # 以元祖的形式传到新列表中
# import random
# print(random.choice(l))  #  random.choice(i)随机在列表中抽取一个 抽一个放一个
                                        #每次有可能抽到同一个

 4.创建一个目录结构,具体结构如目录结构图所示

　　

import os  
os.makedirs('glance/api',exist_ok=True)
# os.makedirs('glance/db',exist_ok=True)
# os.makedirs('glance/cmd',exist_ok=True) 
             os.makedirs()    # 创建多级目录  exist_ok=False 
默认是False 意思是你没注释上面的继续执行创建程序会报错,如果改成True 则不会报错 也不会创建相同的      

open('glance/api/__init__.py','w').close()
open('glance/api/versions.py','w')).close()
open('glance/api/policy.py','w')).close()
open('glance/cmd/__init__.py','w')).close()
open('glance/cmd/manage.py','w')).close()
open('glance/db/__init__.py','w')).close()
open('glance/db/models.py','w')).close()
open('glance/__init__.py','w')).close()

 5.使用代码删除上题目录结构中的db文件夹

import  os
# del_dir='glance/db'
def func(n):
    path_lst=os.listdir(n)
    for i in path_lst:
        full_path=os.path.join(n,i)
        os.remove(full_path)
    os.rmdir('glance/db')
func('glance/db')

 6.获取当前文件的绝对路径

 　print(__file__) # 获取当前文件所在的的绝对路径

　7 获取当前文件所在目录的绝对路径

　　

print(os.getcwd())  #  在哪个路径下执行的py文件,
                        # 得到的目录就是哪个目录==工作目录

8写函数,根据目录参数,显示当前文件夹下的所有文件和文件夹

 dic={}
# lst=[]
# lst1=[]
# def func(n):
#    path=os.listdir(n)
#    # print(path)
#    for el in path:
#         path_n = os.path.join(n,el) # 拼路径
#         if os.path.isdir(path_n):
#             lst.append(el)
#             dic['文件夹'] = lst
#             func(path_n)
#
#         else:
#             lst1.append(path_n)
#             dic['文件']=lst1
#    return dic
# print(func('glance'))

# 9.遍历文件夹,找到这个文件夹下size最大的文件

max_size=0
# max_file_name=''
# lst = os.listdir('glance')
# for i in lst:
#    full_path =os.path.join('glance',i)
#    if os.path.isfile(full_path):
#        if os.path.getsize(full_path)>max_size:
#              max_size=os.path.isfile(full_path)
#              max_file_name=i
#
# print(max_size,max_file_name)

 10.用sys模块的argv实现登陆功能

import sys

print(sys.argv)

if sys.argv[1]=='alex' and sys.argv[2]=='123':
    print('登录成功')
else:
    print('登录失败')
    exit()