python--内置常用模块

一 . 简单的了解模块

　　你写的每一个py文件都是一个模块. 还有一些我们一直在使用的模块.

　　buildins  内置模块. print, input.

　　random  主要是和随机相关的的内容

　　　　random() 随机小数
　　　　uninform(a,b) 随机小数
　　　　randint(a,b) 随机整数
　　　　choice() 随机选择一个
　　　　sample() 随机选择多个
　　　　shuffle() 打乱

import random
print(random.randint(10,20))

from random import randint
print(randint(10,20))

import random
print(random.randint(10,20)) # 随机整数
print(random.random()) # python中所有随机数的根 随机小数 0-1
print(random.uniform(10,20)) # 10-20的随机小数
lst = ["宝宝", "宝强", "宝浪", "包拯"]
random.shuffle(lst)  # 随机打乱顺序
print(lst)
# 从列表中随机选择一个
print(random.choice(["林志玲", "刘一菲", "王昭君", "艾米", "宝宝"]))
print(random.sample(["林志玲", "刘一菲", "王昭君", "艾米", "宝宝"], 3))

二 .  Collections 　　

　　1. Counter 计数器

# from collections import Counter

# print(Counter("我我我你你他")) # 计数  Counter({'我': 3, '你': 2, '他': 1})
# lst = ["jay",'jay',"jay","宝宝","宝宝", "胡辣汤", "上官婉儿", "上官婉儿"]
# print(Counter(lst)) # Counter({'jay': 3, '宝宝': 2, '上官婉儿': 2, '胡辣汤': 1})

　　2. defaultdict 默认值字典

from collections import defaultdict
# 默认值字典
dd = defaultdict(lambda: '武林盟主') # callable 可调用的, 字典是空的
dic = dd['张无忌']
print(dd)  # defaultdict(<function <lambda> at 0x0000007BEA451EA0>, {'张无忌': '武林盟主'})

　　3. OrderedDict 有序字典

from collections import OrderedDict
# 有序字典
dic = OrderedDict()
dic["笑傲江湖"] = "令狐冲"
dic['天龙八部'] = "乔峰"
print(dic) # OrderedDict([('笑傲江湖', '令狐冲'), ('天龙八部', '乔峰')])
print(dic.get("笑傲江湖")) # 令狐冲
print(dic.values()) # odict_values(['令狐冲', '乔峰'])
print(dic['天龙八部']) # 乔峰

　　数据结构(队列, 栈(重点))

　　栈:先进后出
　　　　Stack

# 特点: 先进后出
class StackFullException(Exception):
    pass
class StackEmptyException(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("your stack is full!!!!!")
        self.lst.insert(self.top, el) # 放元素
        self.top += 1 # 栈顶指针向上移动一下
    # 出栈
    def pop(self):
        if self.top == 0:
            raise StackEmptyException("your stack is empty!!!!!")
        self.top-=1
        el = self.lst[self.top]
        return el

s = Stack(4)
s.push("笑")
s.push("傲")
s.push("江")
s.push("湖")
print(s.pop()) # 湖
print(s.pop()) # 江
print(s.pop()) # 傲
print(s.pop()) # 笑

　　

　　队列: 先进先出
　　　　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()) # 传

 　　双向队列

from collections import deque

d = deque() # 创建双向队列
d.append("书剑") #  在右侧添加
d.append("恩仇")
d.append("录")
d.appendleft("娃哈哈") # 在左边添加
d.appendleft("爽歪歪")
d.appendleft("优酸乳")

print(d.pop()) # 从右边拿数据   录
print(d.pop()) # 从右边拿数据  恩仇
print(d.pop()) # 从右边拿数据  书剑
print(d.popleft()) # 从左边拿数据  优酸乳
print(d.popleft()) # 从左边拿数据  爽歪歪
print(d.popleft()) # 从左边拿数据  娃哈哈

　　

3. Time模块

　　时间有三种:
　　结构化时间 gmtime() localtime()
　　时间戳 time.time() time.mktime()
　　格式化时间 time.strftime() time.strptime()

import time

# 时间戳: 从1970-01-01 00:00:00开始计算. 未来存储的时候用是时间戳
print(time.time())  # 显示的是从1970-01-01 00:00:00开始计算到现在是多少秒

# 格式化时间
print(time.strftime("%Y-%m-%d %H:%M:%S"))  # 用来显示的  # 2018-12-26 12:38:56

# 结构化时间(python的时间)
print(time.localtime()) 
t = time.localtime()
print(t.tm_year)  # 2018
print(t.tm_mon)   # 12
print(t.tm_mday)  # 26

　　时间转化:
　　数字 -> 字符串
　　struct_time = time.localtime(数字)
　　str = time.strftime("格式", struct_time)

import time
 # 数据库中存储一个数字,把它还原成我们的格式化时间
a = 1541952464
# 先把这个时间戳转化成python中的结构化时间
t = time.localtime(a)  # 东八区时间
# 把这个结构化时间转化成格式化时间
s = time.strftime('%Y-%m-%d %H:%M:%S', t)
print(s) # 2018-11-12 00:07:44

　　

# 数据库里存储一个数字. 把它还原成我们的格式化时间
a = 0  # 可以在范围内随便设
# 先把这个时间戳转化成python中的结构化时间
t = time.gmtime(a) # 格林尼治时间
# 把一个结构化时间转化成格式化时间
s = time.strftime("%Y-%m-%d %H:%M:%S", t)
print(s)  # 1970-01-01 00:00:00

　　

　　字符串 -> 数字
　　struct_time = time.strptime(字符串, "格式")
　　num = time.mktime(struct_time)

　　无论是由时间戳转化成格式化时间 还是由 格式化时间转化成时间戳都需要经过结构化时间

# 用户输入一个时间,然后把时间转化成时间戳
strf = input('请输入一个时间:')  # 2018-12-12 21:12:43
# 把字符串转化成结构化时间
t = time.strptime(strf,'%Y-%m-%d %H:%M:%S')
print(time.mktime(t)) # 1544620363.0

　

四 . functools

　　wraps 给装饰器中的inner改名字

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  如果没有@wraps 打印的就是inner

　　

　　reduce 归纳.

from functools import reduce
def func(a, b):
    return a + b # 0+1+2+3+4+5+6# 累加

# 会把我们每一个数据交给func去执行, 把默认值作为第一个参数传递给函数
# 第二个参数就是你这个序列中的第一个数据
# 接下来. 把刚才返回的结果作为第一个参数传递个a
# 继续吧刚才的结果给第一个参数. 把第三个数据传递给b
ret = reduce(func, [1,2,3,4,5,6])
# 工作流程
# func(func(func(0, 1),2),4)
print(ret)
print(reduce(lambda x, y:x + y, [i for i in range(101)])) # 5050

　

　　偏函数 把函数的参数固定.

from functools import partial

def eat(zhushi, fushi):
    print(zhushi, fushi)
# 固定函数中某些参数的值
eat2 = partial(eat, fushi="辣鸡爪")
eat2("大米饭") # 大米饭 辣鸡爪
eat2("小米饭") # 小米饭 辣鸡爪
eat2("黑米饭") # 黑米饭 辣鸡爪