一. 模块
模块: 是把装有特定功能的代码进行归类的结果, 从代码编写的单位来看我们的程序, 从小到大的顺序: 一条代码 < 语句块 < 代码块(函数, 类) < 模块. 我们目前写的所有py文件都是模块
引入模块的方式:
1. import 模块
2. from xxx import 模块
二. collections模块
collections模块主要封装了一些关于集合类的相关操作和一些除了基本数据类型以外的数据集合类型
1. Counter
计数器, 主要用来计数
collections.Counter()
之前的做法:
s = "alex like pig"
dic = {}
for c in s:
dic[c] = dic.get(c, 0) + 1
print(dic)
# {‘a‘: 1, ‘l‘: 2, ‘e‘: 2, ‘x‘: 1, ‘ ‘: 2, ‘i‘: 2, ‘k‘: 1, ‘p‘: 1, ‘g‘: 1}
现在的做法:
print(collections.Counter(s))
# Counter({‘l‘: 2, ‘e‘: 2, ‘ ‘: 2, ‘i‘: 2, ‘a‘: 1, ‘x‘: 1, ‘k‘: 1, ‘p‘: 1, ‘g‘: 1})
2. deque
先看一下栈和队列
(1).栈: Stack, 先进后出
(2).队列: queue, 先进先出
python中没有给出Stack模块, 手动写一个粗略版本(注意: 此版本有严重的并发问题)
class StackFullException(Exception):
pass
class StackEmptyException(Exception):
pass
class Stack:
def __init__(self, size):
self.size = size
self.top = 0
self.list = []
def push(self, el):
if self.top >= self.size:
raise StackFullException
self.list.insert(self.top, el)
self.top += 1
def pop(self):
if self.top == 0:
raise StackEmptyException
self.top -= 1
el = self.list[self.top]
return el
python中给出了queue模块, 使用起来很方便
import queue
q = queue.Queue()
再来看deque, 双向队列
import cellections import deque
q.append()
q.appendleft()
q.pop()
q.popleft()
3. namedtuple
命名元祖, 就是给元祖内的元素进行命名
from collections import namedtuple
nt = namedtuple("point", ["x", "y"])
p = nt(1, 2)
print(p)
print(p.x)
print(p.y)
# point(x=1, y=2)
# 1
# 2
4. OrderDict 和 defaultdict
orderdict是有序化的, 字典的key是无序的
defaultdict: 可以给字典设置默认值, 当key不存在时, 直接获取默认值
from collections import defaultdict
dd = defaultdict(list)
print(dd["娃哈哈"])
# []
三. time 时间模块
在python中时间有三种表现形式:
1. 时间戳(timestamp): 时间戳使用的是从1970年01月01日00点00分00秒到现在一共经过了多少秒, 使用float来表示
2. 格式化时间(strftime): 这个时间可以根据我们的需要对时间进行任意的格式化
3. 结构化时间(struct_time): 得到元祖的形式, 这个时间主要可以把时间进行分类划分
import time
time.time() 返回当前时间的时间戳
time.localtime(s) 将一个时间戳转换为当前时区的结构化时间struct_time
#time.struct_time(tm_year=2018, tm_mon=12, tm_mday=26, tm_hour=20, tm_min=11, tm_sec=32, tm_wday=2, tm_yday=360, tm_isdst=0)
time.gmtime(s) 将一个时间戳转换为UTC时区(0时区)的结构化时间struct_time
time.mktime(st) 将一个struct_time转换为时间戳
time.sleep(s) 线程推迟指定的时间运行
time.strftime("时间格式", st) 把一个代表时间的元祖或者struct_time转换成格式化的时间字符串
time.strptime(st, "时间格式") 把一个格式化时间字符串转换成struct_time
涉及时间转换的都要通过结构化时间st在中间过度
(1). 时间戳s --> 格式化时间ft
a. 时间戳s --> 结构化时间st
st = time.localtime(s)
b. 结构化时间st --> 格式化时间ft
ft = time.strftime("时间格式", st)
(2). 格式化时间ft --> 时间戳s
a. 格式化时间ft --> 结构化时间st
st = time.strptime(st, "时间格式")
b. 结构化时间st --> 时间戳s
s = time.mktime(st)
综上: localtime(s) 和 strftime("timeformat", st) 一起用
strptime(st, "timeformat") 和 mktime(st) 一起用
四. random 模块
所有关于随机的相关内容都在random中
random.seed(x)
#产生随机数时，需要提供一个基础数然后根据此季楚书产生伪随机数
#random.seed(x)可以让你提供基础数，需要你手动调用random.seed(x)
#如果没有手动调用random.seed(x)，则系统默认使用系统时间为基础数
random.randint(n,m)
#生成n，m之间的随机整数int，结果∈[n, m)
#n和m必须都是整数，且a>b或者a==b，而a<b将语法错误
random.random()
#生成0,1之间的随机浮点数float，结果∈[0.0, 1,0)
random.uniform(a,b)
#生成a,b之间的随机浮点数float，结果属于(float)[a,b]
#a,b不用必须都是整数(或浮点数)，a>b，a<b，a==b都合法
random.choice(seq)
#从序列中随机选一个元素，序列中元素类型无限定
random.randrange(start, stop, step)
#生成一个从start止到stop(不包括stop)，间隔为step的一个随机整数
#start，stop，step必须都是整数
#必须start < stop
#start默认是0，step默认是1
#制定step时，必须指定start
#效果等同random.choice(range(start, stop, step))
random.randrange(start, stop) 等效random.randrage(start, stop, 1)
random.randrange(stop) 等效random.randrange(0, stop, 1)
random.sample([], k)
#从population序列中，随机获取k各元素，生成一个新序列
random.shuffle(seq)
#效果是把seq中的元素顺序打乱
#lst = [1, 2, 3, 4, 5]
#random.shuffle(lst)
#print(lst)
五. functools 模块 https://blog.csdn.net/hang916/article/details/80301303
1. 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用法:https://www.cnblogs.com/weiman3389/p/6047095.html
reduce()函数原型是reduce(function,sequence),它的作用是用function对序列进行累积操作。它返回值可以直接输出，不像map和filter返回的是一个迭代对象，还得去转化。
所谓的累计操作就是就是第 1、2 个元素用 function 函数运算，得到的结果再与第三个数据用 function 函数运算，然后得到的结果再与第四个进行运算，一次类推。
下面通过一个具体的例子来说明所谓的累计操作是怎么样的。
#函数功能是实现阶乘
from functools import reduce
print(reduce(lambda x,y:x*y, [1,2,3,4])
#输出是24
#整个过程如下：
1、操作第1，2个元素，即1*2 得到2
2、操作1的结果和第3个元素，即 2*3 得到6
3、操做2的结果和第4个元素，即 6*4 得到24
4、返回24
3. partial(func, *args, **kwargs) 详情: https://blog.csdn.net/appleyk/article/details/77609114
对函数局部进行控制，这个局部最常见的就是对参数的控制
from functools import partial
def run(name, age):
print(name, age)
run2 = partial(run, age=18)
run2("laowang")
输出：
laowang, 18
原文地址：https://www.cnblogs.com/guyannanfei/p/10182518.html