day20 模块 collections time sys os

1.模块

　　1.  模块的定义:我们把装有特定功能的代码进行归类的结果.我们目前写的所有py文件都是模块

　　2. 引入模块的方式:

 　　　　1.import  模块名

　　　　 2.from xxx import 模块名

2. collections模块
    1.Counter  Counter是一个计数器,主要用来计数
例.计算字符串中每个字符出现的次数

常规写法
s="alex like pig"
dic={}
foc c in s:
    dic[c]=dic.get(c,0)+1
print(dic)
这样的过程比较繁琐

Counter
s="alex like pig"
print(Counter(s))    #获取到的可以像字典一样使用

    2.stack  栈  先进后出
例.
class StackFullError(Exception):
　　pass
class StackEmptyError(Exception):
　　pass
class stack:                    #定义一个类,栈
　　def __init__(self,index,size):
　　self.index=index
　　self.size=size
　　self.list=[]

　　def push(self,item)    #往栈里面添加一个元素
 　　　if self.size==self.index              #先判断栈是否装满了
　　　　　　raise StackFullEorr("满了,装不下了")
　　　　self.list.inser(self.index,item)
　　　　self.index+=1                     装完指针上移
　　def pop(self):
　　　　if self.idex==0
　　　　　　raise StackEmptyError("没有了")
　　　　selt.index-=1　　　　　　　　　　　　#指针下移到有值的地方去取值
　　　　item=selt.list.pop(self.index)    #弹出
　　　　return item                       #返回值
　　　　
这是默认情况下指针的指向

　　3.queue 队列    特点是先进先出
     import queue
　　　q.queue.Queue.()
　　　q.put("张三")
　　　q.put("李四")
　　　q.put("王五")　
　　　print(q)
　　　print(q.get())
　　　print(q.get())
　　　print(q.get())
　　　print(q.get())   #获取完了,里面没有元素了,此时程序会阻塞

　　　4.deque  双向队列  两边都可进可出

　　　from collections import deque

　　　q=deque()
　　　q.append("张三")      #默认右边添加
　　　q.append("李四")
　　　q.appendleft("王五")　　
　　　q.appendleft("马六")   #从左边添加　　
　　　print(q)
　　　print(q.pop())        #默认右边删除
　　　print(q.pop())        #可以从左边删除
　　5.namedtuple 就是对元组里面的元素进行命名 
　　　from collections import namedtuple
　　　nt=namedtuple("point",["x","y"])　
　　　p=nt(1,2)     #k可以表示一个点的坐标
　　　print(p.x)
　　　print(p.y) 
　　　p.x=233     #不可行,会报错,因为是元组

     #类似的
     #

　　　#Circle = namedtuple('Circle', ['x', 'y', 'r'])

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

　　lst=[11,22,33,44,55,66,77,88,99]

　　d=defaultdict(list)
　　for el in lst:
    　　if el<66:
        　　d["key1"].append(el)  #key1默认是不存在的,但是可以拿到key1,[]  执行可执行的创作-->创建一个列表
    　　else:
        　　d["key2"].append(el)
　　print(d)

 　　　　#原生字典的解决方案

　　　　values = [11, 22, 33,44,55,66,77,88,99,90]

　　　　my_dict = {}

　　　　for value in values:
　　　　　　if value>66:
　　　　　　　　if my_dict.has_key('k1'):
　　　　　　　　　my_dict['k1'].append(value)
　　　　　　　　else:
　　　　　　　　　　my_dict['k1'] = [value]
　　　　　　else:
　　　　　　　　if my_dict.has_key('k2'):
　　　　　　　　　　my_dict['k2'].append(value)
　　　　　　　　else:
　　　　　　　　　　my_dict['k2'] = [value]

　　7.Orderdict  字典是无序的

　　　　在对dict做迭代时，我们无法确定Key的顺序。

　　　　如果要保持Key的顺序，可以用OrderedDict：　　　　

　　　　>>> from collections import OrderedDict
　　　　>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
　　　　>>> d # dict的Key是无序的
　　　　{'a': 1, 'c': 3, 'b': 2}
　　　　>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
　　　　>>> od # OrderedDict的Key是有序的
　　　　OrderedDict([('a', 1), ('b', 2), ('c', 3)])

　　　　注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：　　　

3.时间模块
　　

　　　在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：

　　　　　(1)时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

　　　　　(2)格式化的时间字符串(Format String)： ‘1999-12-06’   (strftime)%Y-%m-%d %H:%M:%S 注意大小写

　　　　　(3)元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

　　　　　　

例.1

 print(time.time())  #获取当前时间,1542167410.2138798  从1970-01-01 00:00:00到现在经过多少秒

                    #数据库储存 数据库存储的就是这个时间
例.2

while 1:
    s=time.strftime("%Y-%m-%d %H:%M:%S")   #使用频率最高  格式化时间
    print(s)
    time.sleep(1)
例.3

print(time.localtime())   #结构化时间 获取当前时间的结构化时间
tt=time.localtime(1888888888) 
ttt=time.strftime("%Y-%m-%d %H:%M:%S",tt)        把获得的当前时间结构后之后再进行格式化
print(ttt)

例.4

s="2018-11-22 12:12:33"
t=time.strptime(s,"%Y-%m-%d %H:%M:%S")   #把字符串时间格式化为格式化时间
print(t)                                    
tt=time.mktime(t)                       #把结构化时间化为时间戳
print(tt)

　　　　　　　　　　　　　　　

例.5 时间计算
(这种方法会因为月份天数的不同而产生误差,慎用)

s="2018-10-22 13:23:32"
s1="2018-11-23 14:12:32"
ss=time.strptime(s,"%Y-%m-%d %H:%M:%S")   #结构化时间
ss1=time.strptime(s1,"%Y-%m-%d %H:%M:%S")

t1=time.mktime(ss)                    #转换成时间戳
t2=time.mktime(ss1)

_t=t2-t1                           #用时间戳相减  秒级的时差

ttt=time.gmtime(_t)               #时间戳相减后(时间差)再结构化时间
print(ttt)
print("过去了%d年%d月%d天%d时%d分%d秒"%(ttt.tm_year-1970,ttt.tm_mon-1,ttt.tm_mday-1,ttt.tm_hour,ttt.tm_min,ttt.tm_sec))

例.6 时间计算(比较推荐这一种,不会出错)

s="2018-10-22 13:23:32"
s1="2018-11-23 14:12:32"
ss=time.strptime(s,"%Y-%m-%d %H:%M:%S")   #结构化时间
ss1=time.strptime(s1,"%Y-%m-%d %H:%M:%S")

t1=time.mktime(ss)                    #转换成时间戳
t2=time.mktime(ss1)

_t=t2-t1                           #用时间戳相减  秒级的时差

#转换成分钟
min=int(_t//60)　　　　　　#把秒级时间差转换成分钟
print(min)

_hour=min//60    #再把分钟差转化成多少小时,多少分钟
_min=min%60

print("时间差是%s小时,%s分钟%(_hour,_min))

附:日期格式化标准
%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 当前时区的名称
%% %号本身

小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的

#时间戳-->结构化时间
#time.gmtime(时间戳) #UTC时间，与英国伦敦当地时间一致
#time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间
>>>time.gmtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
>>>time.localtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

#结构化时间-->时间戳　
#time.mktime(结构化时间)
>>>time_tuple = time.localtime(1500000000)
>>>time.mktime(time_tuple)
1500000000.0

#结构化时间-->字符串时间
#time.strftime("格式定义","结构化时间")  结构化时间参数若不传，则显示当前时间
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 14:55:36'
>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
'2017-07-14'

#字符串时间-->结构化时间
#time.strptime(时间字符串,字符串对应格式)
>>>time.strptime("2017-03-16","%Y-%m-%d")
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
>>>time.strptime("07/24/2017","%m/%d/%Y")
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1

#这里的了解就好

#结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
>>>time.asctime(time.localtime(1500000000))
'Fri Jul 14 10:40:00 2017'
>>>time.asctime()
'Mon Jul 24 15:18:33 2017'

#时间戳 --> %a %b %d %H:%M:%S %Y串
#time.ctime(时间戳)  如果不传参数，直接返回当前时间的格式化串
>>>time.ctime()
'Mon Jul 24 15:19:07 2017'
>>>time.ctime(1500000000)
'Fri Jul 14 10:40:00 2017'

4.random
import random

print(random.randint(1,4))   #[star:end]1-4都有
print(random.uniform(1,5))   #(1,5)随机小数
print(random.random())       #产生0-1的随机小数

print(random.randrange(1, 10, 2)) # 1-10奇数 [1,10)

print(random.choice([1,2,["水电费","华盛顿"]]))   #从一个元素里面随机选择一个
print(random.sample([1,2,["水电费","华盛顿"]],2))  #从两个元素中随机取两个

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

5.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下为"\r\n",Linux下为"\n"
os.pathsep 输出⽤于分割⽂件路径的字符串 win下为;,Linux下为:
os.name 输出字符串指示当前使⽤平台。 win->'nt'; Linux->'posix' 

6.sys模块
sys.argv 命令⾏参数List，第⼀个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version 获取Python解释程序的版本信息
sys.path 返回模块的搜索路径，初始化时使⽤PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称