python常用模块一

导入整个模块

import 模块名

导入模块中的某个具体的功能

from 模块名 import 模块中的方法名(功能)

import random
from random import randint

random 随机模块

import random
#取随机小数

print(random.random())                #0~1 之间的随机小数
print(random.uniform(1,10))           #1~10 之间的随机小数

取随机整数

import random
print(random.randint(0,1))              #0~1之间的整数
print(random.randrange(0,5))          #0~5之间的整数
print(random.randrange(0,5,2))       #0~5之间步长为2 的整数

随机抽取

l = [1,2,"a",{"k":"v"},(1,2,4)]
print(random.choice(l))                #随机抽取一个
print(random.sample(l,3))            #随机抽取n个

打乱顺序

import random
k = [1,2,"ac",{"k","v"},(1,2,3)]
random.shuffle(k)
print(k)

事例: 输出6位纯数字

import random
def get_code(n=6):
    s = ""
    for i in range(n):
        num = random.randint(0,9)
        s += str(num)
    return s
print(get_code(6))

Collections

1.Counter 计数器

2.defaultdict 默认值字典

3.OrderedDict 有序字典

Counter 计数

from collections import Counter
print(Counter("凌寒独自开,哈哈哈"))

lst = ["selina","Jerome","Jerry","selina"]
c = Counter(lst)
print(c)

运行结果:
 Counter({'哈': 3, '凌': 1, '寒': 1, '独': 1, '自': 1, '开': 1, ',': 1})
 Counter({'selina': 2, 'Jerome': 1, 'Jerry': 1})
 Process finished with exit code 0

defaultdict 默认值字典

from collections import defaultdict
selina = defaultdict(lambda:6)        #callable 可调用的, 字典是空的
print(selina["LL"])　　　　　　　　　　　#从字典向外拿数据, 字典是空的, key:callable()
print(selina["Frank"])　　　　　　　　　#这里的[] 和get() 不是一回事儿
print(selina)
print(selina.get("LL"))

运行结果:
 6
 defaultdict(<function <lambda> at 0x0000027CAB741E18>, {'ll': 6, 'Frank': 6})

OrderedDict  有序字典

from collections import OrderedDict
dic = OrderedDict()
dic["selina"] = "新加坡"
dic["evelyn"] = "法国"
print(dic)
print(dic.get("selina"))
print(dic.values())
print(dic["evelyn"])

运行结果:
 OrderedDict([('selina', '新加坡'), ('evelyn', '法国')])
 新加坡
 odict_values(['新加坡', '法国'])
 法国

栈Stack(FILO)
特点: 先进后出

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('bob')
s.push('jack')
s.push('Peak')
s.push('jary')
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())


import queue
q= queue.Queue()
q.put('中国')
q.put('法国')
q.put('美国')
print(q.get())
print(q.get())
print(q.get())

结果
jary
Peak
jack
bob
中国
法国
美国

队列Queue(FIFO)
特点: 先进先出

from collections import deque
d = deque()         # 创建双向队列
d.append('娃哈哈')  # 在右侧添加
d.append('QQ星')
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())
结果
爽歪歪
QQ星
娃哈哈
苹果
榴莲
芒果

time时间模块

python程序中,时间一共有三种格式
时间戳时间,float时间(给计算机用的): 1542072130.3895912
    英国伦敦 1970-1-1 0:0:0  0时区
    北京时间 1970-1-1 8:0:0
结构化时间(tuple时间)
格式化时间,str时间(给用户看的): '2018-11-13 9:21:50'
时间格式转换
    时间戳时间 <-结构化时间(tuple时间)-> 格式化时间

时间格式:
%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 当前时区的名称
%% %号本身


导入时间模块
import time
认识一下三种时间格式
print(time.time())      # 时间戳时间(从1970-01-01 00:00:00开始经过的秒)
print(time.strftime('%Y-%m-%d %H:%M:%S'))  # 格式化时间
print(time.localtime())  # 北京时间(结构化时间)
结果
1545826164.0164113
2018-12-26 20:09:24
time.struct_time(tm_year=2018, tm_mon=12, tm_mday=26, tm_hour=20, tm_min=9, tm_sec=24, tm_wday=2, tm_yday=360, tm_isdst=0)

print(time.strftime('%c'))
time.gmtime(时间戳)    #UTC时间,与英国伦敦当地时间一致
time.localtime(时间戳) #当地时间,例如我们现在在北京执行这个方法:与UTC时间相差8小时,UTC时间+8小时 = 北京时间


结构化时间(python的时间)
print(time.localtime())
t = time.localtime()
print(t.tm_year)
print(t.tm_mon)
print(t.tm_min)
结果
time.struct_time(tm_year=2018, tm_mon=12, tm_mday=26, tm_hour=20, tm_min=23, tm_sec=20, tm_wday=2, tm_yday=360, tm_isdst=0)
2018
12
23


时间格式之间的转换问题
格式化时间转换戳时间
#先将格式化时间转换为结构化时间,然后将结构化时间转换为时间戳时间
ret = time.strptime('2008-8-8','%Y-%m-%d')
print(ret)
stmp = time.mktime(ret)
print(stmp)
结果
time.struct_time(tm_year=2008, tm_mon=8, tm_mday=8, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=221, tm_isdst=-1)
1218124800.0


时间戳转换格式化时间
先将时间戳转换为结构化时间,然后将结构化看时间转换为格式化时间
ret = time.localtime(1500000000)
print(ret)
str_time = time.strftime('%Y-%m-%d %H:%M:%S',ret)
print(str_time)
结果
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)
2017-07-14 10:40:00


1.显示当前时间24小时之前的 年月日 时分秒
方法一　：
计算出1970年到现在经过的秒,然后减去一天的秒,然后转换为格式化时间
t1 = time.time()
print(t1)
t2 = t1 - (60*60*24)
print(t2)
t3 = time.localtime(t2)
print(t3)
t4 = time.strftime('%Y-%m-%d %H:%M:%S',t3)
print(t4)
结果
1545826916.4369211
1545740516.4369211
time.struct_time(tm_year=2018, tm_mon=12, tm_mday=25, tm_hour=20, tm_min=21, tm_sec=56, tm_wday=1, tm_yday=359, tm_isdst=0)
2018-12-25 20:21:56

方法二
打印结构化时间,然后print进行填充,填充tm_mday天减1
t1 = time.localtime()
print(t1)
print('%s-%s-%s %s:%s:%s'%(
t1.tm_year,
t1.tm_mon,
t1.tm_mday-1,
t1.tm_hour,
t1.tm_min,
t1.tm_sec))
结果
time.struct_time(tm_year=2018, tm_mon=12, tm_mday=26, tm_hour=20, tm_min=13, tm_sec=24, tm_wday=2, tm_yday=360, tm_isdst=0)
2018-12-25 20:13:24


2.显示当前月的第一天的0:0:0的时间戳时间
先将时间转化为结构化时间,然后转化为格式化时间
now = time.localtime()
print(now)
str3 = time.strftime('%Y-%m-1 0:0:0',now)
print(str3)
ret2 = time.strptime(str3,'%Y-%m-%d 0:0:0')
print(ret2)
print(time.mktime(ret2))
结果
time.struct_time(tm_year=2018, tm_mon=12, tm_mday=26, tm_hour=20, tm_min=14, tm_sec=16, tm_wday=2, tm_yday=360, tm_isdst=0)
2018-12-1 0:0:0
time.struct_time(tm_year=2018, tm_mon=12, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=335, tm_isdst=-1)
1543593600.0

方法二
now = time.localtime()
print(now)
str1 = time.strftime('%Y-%m',now)
print(str1)
str2 = time.strptime(str1,'%Y-%m')
print(str2)
print(time.mktime(str2)
结果
time.struct_time(tm_year=2018, tm_mon=12, tm_mday=26, tm_hour=20, tm_min=14, tm_sec=40, tm_wday=2, tm_yday=360, tm_isdst=0)
2018-12
time.struct_time(tm_year=2018, tm_mon=12, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=335, tm_isdst=-1)
1543593600.0

functools模块
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('bob')
print(func.__name__)
结果
func

map 映射 reduce 归纳

from functools import reduce
def func(a, b):
    return a + b    # 0+1+4+7+2+5+8+3+6+9 累加
ret = reduce(func, [1,4,7,2,5,8,3,6,9])
func(func(func(0, 1),4),7)
print(ret)
print(reduce(lambda x, y:x + y, [i for i in range(101)]))

执行流程
会把我们每一个数据交给func去执行,把默认值作为第一个参数传递给函数
第二个参数就是你这个序列中的第一个数据
接下来,把刚才返回的结果作为第一个参数传递个a
继续吧刚才的结果给第一个参数,把第三个数据传递给b

结果
45
5050

partial偏函数,把函数的参数固定

from functools import partial
def chi(zhushi, fushi):
    print(zhushi, fushi)
# 固定函数中某些参数的值
chi2 = partial(chi, fushi="小辣椒")
chi2("大米饭")
chi2("小米饭")
chi2("白米饭")
结果
大米饭 小辣椒
小米饭 小辣椒
白米饭 小辣椒