模块(一) 模块的引入 collections(Counter计数 deque双向队列FIFO,栈FILO namedtuple命名元组 orderdict有序字典 defaultdict默认值字典 ) #时间模块# #random随机模块#

模块(一)

时间模块(自动跳转)

一.模块的简单认识

　　什么是模块. 模块就是我们把装有特定功能的代码进行归类的结果. 从代码编写的单位来看我们的程序, 从小到大的顺序: 一条代码 < 语句块 < 代码块(函数, 类) < 模块. 我们目前写的所有的py文件都是模块

　　引入模块的⽅式:

　　1. import 模块

　　2. from xxx import 模块

　　关于这两种写法. 我们后面还要继续介绍. 在之前的学习中, 我们已经用过了一些基本的模块了. 比如, random, os, sys, collections等等. 那我们⽬前用到的所有模块都是python内置的模块.不需要额外安装. 在后面学习⾼级框架的内容的时候. 可能需要我们⾃行安装⼀些第三方提供的模块.

二.collections模块　　

　　collections模块主要封装了一些关于集合类的相关操作. 比如, 我们学过Iterable,Iterator等等. 除了这些以外, collections还提供了一些除了基本数据类型以外的数据集合型.Counter,deque,OrderDict, defaultdict以及namedtuple

　　1. Counter
counter是一个计数器. 主要用来计数
计算一个字符串中每个字符出现的次数:

from collections import Counter

print(Counter("宝宝今年特别喜欢王宝强")) # 计数
lst = ["jay",'jay',"jay","宝宝","宝宝", "胡辣汤", "上官婉儿", "上官婉儿"]
dic = {"a":"哈哈", "b":"哈哈", "c":"车牌"}
c = Counter(dic.values())
print(c)

low:
s = "alex like pig"
dic = {}
for c in s:
dic[c] = dic.get(c, 0) + 1
print(dic)
nb:
s = "alex like pig"
print(Counter(s)) # 获取到的结果可以像字典一样进行使用 [key]

　　2. deque 双向队列.

(重点)说双向队列之前我们需要了解两种数据结构.    1. 栈,2. 队列

1. 栈: FILO.      先进后出 -> 砌墙的砖头, 老师傅做馒头

2. 队列: 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("宝宝")
s.push("我还")
s.push("记得")
s.push("你")
s.push("刚刚")
s.push("说的话")
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("李嘉诚1")
q.put("李嘉诚2")
q.put("李嘉诚3")
q.put("李嘉诚4")
q.put("李嘉诚5")

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

#李嘉诚1
#李嘉诚2
#李嘉诚3
#李嘉诚4
#李嘉诚5

接下来,. 我们来看⼀下deque, 注意, 此队列是collections中的.

from collections import deque

d = deque() # 创建双向队列
d.append("宝宝") #  在右侧添加
d.append("no")
d.append("way")
d.append("哈哈")
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()) # 从左边拿数据
#哈哈
#way
#no
#宝宝
#优酸乳
#爽歪歪
#娃哈哈

　　3. namedtuple 命名元组
　　命名元组, 顾名思义. 给元组内的元素进行命名. 比如. 我们说(x, y) 这是一个元组. 同
时. 我们还可以认为这是⼀个点坐标. 这时, 我们就可以使用namedtuple对元素进行命名

from collections import namedtuple
# ⾃己定义了一个元组, 如果灵性够好, 这其实就是创建了一个类
nt = namedtuple("point", ["x", "y"])
p = nt(1, 2)
print(p)
print(p.x)
print(p.y)

from collections import namedtuple

# 类
p = namedtuple("Point", ["x", "y","z"])
# 对象
p1 = p(10, 20,30)
print(p1)

print(p1.x)
print(p1.y)

car = namedtuple("Car", ["pai", "color", "pailiang"])
c = car("京C-10000", "绿色", "1.8T")
print(c)

import time
print(time.localtime())

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
Point(10,20)

　　4. orderdict和defaultdict  默认值字典
orderdict 顾名思义. 字典的key默认是无序的. 而OrderedDict是有序的

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

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

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

　

from collections import defaultdict

# 默认值字典
dd = defaultdict(lambda: 0) # callable 可调用的, 字典是空的

print(dd["张无忌"]) # 从字典向外拿数据. 字典是空的. key:callable()
print(dd["宝宝"]) # 这里的[] 和get()不是一回事儿
print(dd)


from collections import OrderedDict

dic = OrderedDict()  # 有序字典
dic["b"] = "哈哈"
dic['a'] = "呵呵"
print(dic)
print(dic.get("a"))
print(dic.values())
print(dic["a"])
# OrderedDict([('b', '哈哈'), ('a', '呵呵')])
# 呵呵
# odict_values(['哈哈', '呵呵'])
# 呵呵

三. time 时间模块(重点)

　　时间模块是我们要熟记的. 到后⾯写程序的时候经常能用到. 比如, 如何计算时间差.
如何按照客户的要求展示时间. 等等.

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

　　此时, 我们已经获取到了系统时间, 但是这个时间....看不懂. 怎么办呢. 需要对时间进
行格式化. 那这样就引出了另一种时间的格式. 在python中时间分成三种表现形式:
　　1. 时间戳(timestamp). 时间戳使用的是从1970年年01⽉月01⽇日 00点00分00秒到现在
一共经过了多少秒... 使用float来表示

　　2. 格式化时间(strftime). 这个时间可以根据我们的需要对时间进行任意的格式化.

　　3. 结构化时间(struct_time). 这个时间主要可以把时间进行分类划分. 比如. 1970
年01⽉月01日 00点00分00秒 这个时间可以被细分为年, 月, 日.....一⼤堆东西.
时间戳我们已经⻅过了就是time.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 当前时区的名称
%% %号本身

看一下结构化时间:

print(time.localtime())
结果:
time.struct_time(tm_year=2017, tm_mon=05, tm_mday=8, tm_hour=10, tm_min=24,
tm_sec=42, tm_wday=0, tm_yday=126, tm_isdst=0)

时间格式转化

重点:
# 数据库里存储一个数字. 把它还原成我们的格式化时间
a = 0
# 先把这个时间戳转化成python中的结构化时间
# t = time.localtime(a) # 本地化的东八区的时间
t = time.gmtime(a) # 格林尼治时间
# 把一个结构化时间转化成格式化时间
s = time.strftime("%Y-%m-%d %H:%M:%S", t)
print(s)


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

计算时间差

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_mday1,struct_time.tm_hour,
struct_time.tm_min,struct_time.tm_sec))

四. random模块
所有关于随机相关的内容都在random模块中.

import random
print(random.random()) # 0-1小数
print(random.uniform(3, 10)) # 3-10小数
print(random.randint(1, 10)) # 1-10整数 [1, 10]
print(random.randrange(1, 10, 2)) # 1-10奇数 [1,10)
print(random.choice([1, '周杰伦', ["盖伦", "胡辣汤"]])) # 1或者23或者[4,5])
print(random.sample([1, '23', [4, 5]], 2)) # 列表元素任意2个组合
lst = [1, 2, 3, 4, 5, 6, 7, 8]
random.shuffle(lst) # 随机打乱顺序
print(lst)

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))