python--内置常用模块(一) collections 队列 time模块 functiontools
一. 模块的简单认识
模块就是我们把装有特定功能的代码进行归类的结果.从代码编写的单位来看我们的程序,从小到大的顺序:一条代码 < 语句块 < 代码块(函数,类) < 模块,我们目前写的所有的py文件都是模块,引入模块的方式:
1.import模块
2.from xxx import 模块
二. collections模块
collections模块主要封装了一些关于集合类的相关操作.比如,terable,Iterator等等.除了这些意外,collections还提供了一些除了基本数据类型以外的数据集合类型.Counter,deque,OrderDict,defaultdict以及namedtuple
1. Counter
counter是一个计数器,主要用来计数
from collections import Counter
print(Counter("哈哈哈你还好啊")) # 计算一个字符串中字符出现的个数 Counter({'哈': 3, '你': 1, '还': 1, '好': 1, '啊': 1})
lst = ["jay","jay","jay","哈哈","你好"]
dic = {"a":"你好","b":"你好","c":"真的好"}
l = Counter(lst)
c = Counter(dic.values())
print(l) # Counter({'jay': 3, '哈哈': 1, '你好': 1})
print(c) # Counter({'你好': 2, '真的好': 1})
2. deque 双向队列
1.先介绍两种数据结构 1.栈 2.队列
1.栈: FILO. 先进后出
2.队列:FIFO.先进先出
python中并没有给出Stack模块,所以我们写一个大概意思(这个版本有非常严重的并发问题,仅供粗略观看)
栈:
class StackFullException(Exception):
pass
class StackEmptyExcepiton(Exception):
pass
class Stack:
def __init__(self,size):
self.size = size
self.lst = []
self.top = 0 # 栈顶指针
def push(self,el): # 入栈
if self.top >= self.size:
raise StackFullException("栈已放满")
self.lst.insert(self.top,el)
self.top +=1
def pop(self): #出栈
if self.top == 0:
raise StackEmptyExcepiton("栈已放空")
self.top -= 1
el = self.lst[self.top]
return el
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
deque: 双向队列
from collections import deque
d = deque() # 创建双向队列
d.append("1") # 在右侧添加
d.append("2")
d.append("3") # deque(['1', '2', '3'])
d.appendleft("0") # 在左侧添加 deque(['0', '1', '2', '3'])
print(d.pop()) # 从右边拿数据 3
print(d.popleft()) # 从左边拿数据 0
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
3. orderdict 有序字典 , defaultdict默认值字典
字典的key是默认无序的在python3.3以前体现的很明显,时常打印出的字典顺序混乱,orderdict是有序的
from collections import OrderedDict
dic = OrderedDict()
dic["a"] = "你好"
dic["b"] = "哈哈"
print(dic) # OrderedDict([('a', '你好'), ('b', '哈哈')])
print(dic.get("a")) # 你好
print(dic.values()) # odict_values(['你好', '哈哈'])
print(dic["a"]) # 你好
4. defaultdict:
可以给字典设置默认值.当key不存在时.直接获取默认值:
from collections import defaultdict
dd = defaultdict(list)
print(dd["哇哈哈"]) # []
print(dd) # defaultdict(<class 'list'>, {'哇哈哈': []})
dd2 = defaultdict(lambda : 0) # callable 可调用的,字典是空的
print(dd2["优乐美"]) # 0
print(dd2) # defaultdict(<function <lambda> at 0x000001ECF0571E18>, {'优乐美': 0})
三. time时间模块
时间有三种:
结构化时间: gmtime() localtime()
时间戳: time.time() time.mktime()
格式化时间: time.strftime() time.strptime()
时间转化的思路:
数字 - > 字符串
struct_time = time.localtime(数字)
str = time.strftime("格式",struct_time)
字符串 - > 数字
struct_time = time.strptime(字符串,"格式")
num = time.mktime(struct_time)
时间模块是我们日常使用中经常用到的模块.
1.时间戳(timestamp).使用的是从1970年01月01日 00点00分00秒到现在一共经过了多少秒...使用float来表示
2.格式化时间(strftime).这个时间可以根据我们的需要对时间进行任意的格式化.
3.结构化时间(strct_time).这个时间主要可以把时间进行分类划分.比如.1970年01月01日 00点00分00秒 这个时间可以被细分为年,月,日...一大堆东西
时间戳我们已经见过了就是time.time().一般,我们不会把这样的时间展示给客户,所以,我们要对时间进行格式化操作
import time
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 当前时区的名称 %% %号本身
所有的转化都要通过结构化时间来转化,(结构化时间就是python中识别的时间)
import time t = time.localtime(1488484848) s = time.strftime("%Y-%m-%d %H:%M:%S") print(t) #结果(结构化时间): # time.struct_time(tm_year=2017, tm_mon=3, tm_mday=3, tm_hour=4, tm_min=0, tm_sec=48, tm_wday=4, tm_yday=62, tm_isdst=0) print(s) # 2018-12-26 21:14:55
如果让用户输入一个时间,我们来把它转化为我们数据库存储的时间戳,就要用到结构化时间,流程为
# 数据库里存储一个数字. 把它还原成我们的格式化时间
a = 0
# 先把这个时间戳转化成python中的结构化时间
# t = time.localtime(a) # 本地化的东八区的时间
t = time.gmtime(a) # 格林尼治时间
# 把一个结构化时间转化成格式化时间
s = time.strftime("%Y-%m-%d %H:%M:%S", t)
print(s)
现在我们举个例子用一下
s = "2018-12-26 21:16:33"
t = time.strptime(s,"%Y-%m-%d %H:%M:%S") # 转化为结构时间 print(time.mktime(t)) # 转化为时间戳
计算时间差
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-12 11:00:00','%Y-%m-%d %H:%M:%S'))
dif_time=time_now-true_time
struct_time=time.localtime(dif_time)
print(struct_time)
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,
struct_time.tm_min,struct_time.tm_sec))
四. functools
1.wraps
装饰器装饰的函数名字会变为inner,为了让装饰的函数名还原,我们用到了@wraps,这样打印出的函数名就还是原来的函数名了
from functools import wraps # 可以改变一个函数的名字, 注释...
def wrapper(fn):
@wraps(fn) # 把inner的名字改变成原来的func
def inner(*args, **kwargs):
print("前")
ret = fn(*args, **kwargs)
print("后")
return ret
return inner
@wrapper # func = wrapper(func)
def func():
print('哈哈哈')
print(func.__name__) # func
2. reduce 归纳.
# map 映射 reduce 归纳
print(list(map(lambda x: x**2, [i for i in range(10)])))
from functools import reduce
def func(a, b):
return a + b # 0+1 +4 +7+2+5+8+3+6+9 # 累加
# 会把我们每一个数据交给func去执行, 把默认值作为第一个参数传递给函数
# 第二个参数就是你这个序列中的第一个数据
# 接下来. 把刚才返回的结果作为第一个参数传递个a
# 继续吧刚才的结果给第一个参数. 把第三个数据传递给b
ret = reduce(func, [1,4,7,2,5,8,3,6,9])
# 工作流程
func(func(func(0, 1),4),7)
print(ret) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(reduce(lambda x, y:x + y, [i for i in range(101)]))
3. partial 偏函数
固定函数中某些参数的值
from functools import partial def chi(zhushi, fushi): print(zhushi, fushi) # 固定函数中某些参数的值 chi = partial(chi, fushi="辣鸡爪") chi("大米饭") # 大米饭 辣鸡爪
#坑
chi("大米饭","烤猪蹄") # 如果填入第二个参数就会报错, TypeError: chi() got multiple values for argument 'fushi'
chi("大米饭",fushi = "烤猪蹄") # 大米饭 烤猪蹄 如果第二个参数这样赋值,就可以把值传进去
