python --经常使用内置模块01

一、简单了解模块

        模块就是咱们把装有特定功能的代码进行归类的解构，从代码编写的单位来看咱们的程序

从小到大的顺序：一条代码< 语句块<代码块（函数，类） < 模块

咱们目前写的全部py文件都是模块，还有一些内置的模块

引入模块
# from XXX import XXXX
# from school import student # 导入一个具体的功能
# import school # 导入整个模块

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

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

   

  二、random模块

 　 全部关于随机相关的内容都在random模块中

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

       

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

　　

import random

print(random.randint(10,20))  # 随机整数
print(random.randrange(1,10,2))  # 1-10的奇数[1，10）
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

 

   collections 模块主要封装了一些关于集合类的相关操做。例：Iterable，Iterator，还有出了基本数据类型之外的数据集合类型， Counter，deque，OrderDict，default以及namedtuple

 

　　一、counter（）计数器

from collections import Counter
print(Counter('中心广场的中心的公共的场所'))
lst = ['苹果','苹果','香蕉','梨','荔枝','芒果']
print(Counter(lst))
# Counter({'苹果': 2, '香蕉': 1, '梨': 1, '荔枝': 1, '芒果': 1})

　　二、defaultdic（） 默认值字典，能够给字典设置默认值，当key不存在的时候，直接获取默认值 

from collections import defaultdict

# 默认值字典
d = defaultdict(lambda:0)  # callable 可调用的，字典是空的
print(d)  # defaultdict(<function <lambda> at 0x00000183A97B1E18>, {})
print(d['zhangmeng']) # 从字典往外拿数据，字典是空的  key:callable()
print(d['sunqian']) # 这里的[]和get（）不是一回事
print(d)
# defaultdict(<function <lambda> at 0x000001AD70AD1E18>, {'zhangmeng': 0, 'sunqian': 0})

　　三、OrderDic（）有序字典

from collections import OrderedDict
dic = OrderedDict() # 有序字典
dic['a'] = 'A'
dic['b'] = 'B'
print(dic)  # OrderedDict([('a', 'A'), ('b', 'B')])
print(dic.get('a'))
print(dic.values())  # odict_values(['A', 'B'])
print(dic["a"])

　　四、deque 双向队列

 

          数据结构：

 

                一、栈：FILO 先进后出 --》砌墙的砖头，蒸馒头

                二、队列：FIFO 先进先出 --》排队

栈

# 栈
# 因为python没有给出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(6)

s.push('sunny')
s.push('ANNA')
s.push('zhouyou')
s.push('hutong')
s.push('wangying')
s.push('zhangmeng')

print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
# print(s.pop())

栈

队列：python提供了queue模块

import queue
q = queue.Queue()
q.put('a1')
q.put('a2')
q.put('a3')
q.put('a4')
q.put('a5')
q.put('a6')
q.put('a7')
q.put('a8')

print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())

队列

注：若是队列中没有元素了，再去拿元素，此时程序会阻塞

 

collections 中的deque

from collections import deque

d = deque() # 建立双向队列
d.append("认识")
d.append("人生")
d.append("想象")
d.append("心门")
d.appendleft("周末")  # 从左边添加
d.appendleft("周四")
d.appendleft("周一")
d.appendleft("周二")

print(d.pop())  # 从右边拿数据
print(d.pop())  # 从右边拿数据
print(d.pop())  # 从右边拿数据
print(d.pop())  # 从右边拿数据
print(d.popleft())  # 从左边拿数据
print(d.popleft())  # 从左边拿数据
print(d.popleft())  # 从左边拿数据
print(d.popleft())  # 从左边拿数据

deque

 

四、Time模块

 

    时间有三种：

        结构化时间  gmtime（）  localtime（）

        时间戳  time.time（）  time.mktime（）

        格式化时间 time.strftime（）time.strptime（）

import time
# 时间戳 ：从1970-01-01 00：00：00 开始计算，将来存储的时候用的是时间戳
print(time.time())
# print(time.mktime())

# 格式化时间
print(time.strftime('%Y-%m-%d %H:%M:%S'))  # 通常用来显示
# print(time.strptime('%Y-%m-%d %H:%M:%S'))
# 结构化时间（python时间）
print(time.localtime())  # 本地化的东八区时间
# time.struct_time(tm_year=2018, tm_mon=12, tm_mday=26, tm_hour=21, tm_min=5, tm_sec=30, tm_wday=2, tm_yday=360, tm_isdst=0)
print(time.gmtime()) # 格林尼治时间
t = time.localtime()
print(t.tm_year)
print(t.tm_mon)
print(t.tm_min)

View Code

时间格式化的标准

%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 当前时区的名称
%% %号自己

　　

  时间转化：

                数字 -->字符串

                struct_time = time.location（数字）

                str = time.strftime("格式",struct_time)

# 数据库中存储一个数字，把他还原成咱们的格式化时间
a = 0
# 先把这个时间戳转化成python中的解构化时间
t = time.localtime(a)
# t = time.gmtime(a) # 格林尼治时间
# 把一个结构化时间转化成格式化时间
s = time.strftime('%Y-%m-%d %H:%M:%S',t)
print(s)

 　　　　 字符串 -->数字

                struct_time = time.strptime(字符串,"格式")

                num = time.mktime(struct_time)

# 让用户输入一个时间，把这个时间转化成时间戳
user_input = input("请输入一个时间：")
# 把用户输入的字符串转化成格式化时间
struct_time = time.strptime(user_input,"%Y-%m-%d %H:%M:%D") # p :parse
# 转化成时间戳
num = time.mktime(struct_time)
print(num)

　　　　计算时间差

# 输入两个时间，计算两个时间之间的时间差
import time
first_time= input('请输入第一个时间:')
second_time = input('请输入第二个时间:')
time1 = time.mktime(time.strptime(first_time,'%Y-%m-%d %H:%M:%S'))
time2 = time.mktime(time.strptime(second_time,'%Y-%m-%d %H:%M:%S'))
time_cha = abs(time1-time2)
struct_time = time.localtime(time_cha)
print(struct_time)
print(f"过去了{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

 

      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('hhhh')

print(func.__name__)

# 不加@wraps 时结果为 inner
# 加@wraps 时结果为func

      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  # 累加

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

      偏函数  把函数的参数固定 

from functools import partial

def eat(zhushi,fushi):
    print(zhushi,fushi)

# 固定函数中某些参数的值
eat2 = partial(eat,fushi = '冒菜')
eat2("大米饭")
eat2("小米饭")
eat2("黑米饭")
eat2("紫米饭")
eat2("糯米饭")