首页  思维导图  详情

内置函数(二)装饰器及模块(一)

2019-07-28 16:27:28   0  举报





仅支持查看

AI智能生成

内置函数(二),装饰器及模块(一)

Python

作者其他创作

大纲/内容

模块

模块分类

内置模块

标准库,python解释器自带的.py文件(模块)

第三方模块

各种大神写的,需要额外下载的(并发编程开始讲解)(pypi)

自定义模块

自己写的,不需要额外下载

自定义模块

导入

import test

test是模块名

test.func()

func() 是test模块中的函数调用

导入的过程

当前的名称空间中开辟一个新的空间(test)

将模块中所有的代码执行

通过模块名,进行查找函数(工具)

别名的使用

import test as t

兼容性

msg = """
1.扳手
2.螺丝刀
"""
choose = input(msg)
if choose == "1":
import test as t
elif choose == "2":
import meet as t
t.func()

import 和 from的区别

import test

把工具箱拿过来

from test import func

把工具拿过来

import的优缺点

优点

不会和当前文件定义的变量或者函数发生冲突

缺点

占用内存比较大

from的优缺点

优点

占用内存比较小

缺点

会和当前文件定义的变量或者函数发生冲突

from 模块名 import *

注意会出现覆盖现象

获取内存地址

from test import foo
print(foo)

模块的用法

脚本(在cmd中执行 python test.py)

模块(不使用或者导入)

测试接口

if __name__ == "__main__"

在当前模块中使用__name__就是"__main__"

当模块被导入的时候__name__就是被导入的模块名

路径

导入路径

import meet

使用相对路径

from day15.t1 import meet

使用绝对路径

from sys import path
path.insert(0,"D:\\")
import meet

模块的查找顺序

自定义模块 > 内置模块 > 第三方

time模块(内置模块)

time的方法

时间戳
print(time.time())
# 时间戳浮点数可计算
print(time.time() + 5000)

睡眠
time.sleep(3)
# 睡眠以秒为单位

时间节点
print(time.strftime("%Y-%m-%d %H:%M:%S"))
# 年-月-日时:分:秒
# 2019-07-25 16:43:24

结构化时间
时间戳转结构化
print(time.gmtime()) / print(time.localtime())
# time.struct_time(tm_year=2019, tm_mon=7, tm_mday=25, tm_hour=8,
# tm_min=46, tm_sec=15, tm_wday=3, tm_yday=206, tm_isdst=0)
print(time.gmtime()[0]) / print(time.localtime()[0])
# 2019
print(time.gmtime().tm_year) / print(time.localtime().tm_year)
# 2019

字符串时间转结构化
print(time.strptime("2008-9-1 12:30:30","%Y-%m-%d %H:%M:%S"))

时间戳转换成字符串
print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime(156156641.46854)))
# 1974-12-13 08:50:41

字符串转结构化转换成时间戳
print(time.mktime(time.strptime("2008-9-1 12:30:30","%Y-%m-%d %H:%M:%S")))
# 1220243430.0

datetime(对象)

datetime的方法

获取当前时间(浮点数)
print(datetime.now())
# 2019-07-25 17:24:58.037219

计算时间差距
print(datetime(2019,5,20,13,14,00) - datetime(2019,5,20,14,20,00))
# -1 day, 22:54:00

将当前时间转化成时间戳
print(datetime.now().timestamp())
# 1564047101.042584

将时间戳转化成当前时间
print(datetime.fromtimestamp(1564047101.042584))
# 2019-07-25 17:31:41.042584

将对象转成字符串
print(str(datetime.now()))
print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
# 2019-07-25 17:40:47

时间加减(datetime加减)
from datetime import datetime,timedelta
print(datetime.now() + timedelta(hours=30)) # 当前时间加30个小时
# 2019-07-27 00:19:38.461757

random(随机)

random的方法

0-1随机取值(浮点数)
print(random.random())
# 0.04233141839466259

0-10随机取值(浮点数)
print(random.uniform(1,10))
# 1.0434503538907838

1-3随机取值(包含1和3)
print(random.randint(1,3))
# 1/2/3

randrange(起始,终止,步长)(顾头不顾尾)
print(random.randrange(1,5,2))
# 1/3

随机选择一个元素
print(random.choice([1,2,3,4,5]))
# 1/2/3/4/5

随机选择两个元素(会重复)
print(random.choices([1,2,3,4,5],k=2))
# 从列表中随机选择两个元素(会有重复元素,比如:[1,1])

随机选择两个元素(不会重复)
print(random.sample([1,2,3,4,5],k=2))
# 从列表中随机选择两个元素(不会有重复元素,除非列表只有两个重复元素,比如[1,1])

顺序打乱
lst = [1,2,3,4,5,6,7,8,9,0]
random.shuffle(lst)
print(lst)
# [4, 3, 9, 5, 1, 2, 8, 7, 6, 0]
# 随机打乱

序列化

json

dumps loads

dumps 将对象转换成字符串(序列化)

lst = [1,2,3,4,5]
print(repr(json.dumps(lst)))
"[1,2,3,4,5]"

loads 将字符串转换成对象(反序列化)

str_lst = '[1, 2, 3, 4, 5]'
lst = json.loads(str_lst)
print(repr(lst))
# [1,2,3,4,5]

dump load

dump 将对象转换成字符串写入文件当中(序列化)

lst = [1,2,3,4,5,6]
with open("info","w",encoding="utf-8")as f:
json.dump(lst,f)
# info文件中写入一行[1,2,3,4,5,6]

load 将文件中的字符串转换成对象(反序列化)

lst = [1,2,3,4,5,6]
with open("info","r",encoding="utf-8")as f:
lst1 = json.load(f)
print(lst1)
# [1,2,3,4,5,6]

同时读取多个内容进行反序列

with open("info","r",encoding="utf-8")
for i in f:
l = json.loads(i)
print(l)

pickle

序列化(可对python所有对象进行转换)
python自带的(只有python可以用)

dumps loads

dumps对象转换成类似字节

lst = [1,2,3,4,5]
b_lst = pickle.dumps(lst)
print(b_lst)
# b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04K\x05e.'

loads类似字节转换成对象

import pickle
lst = [1,2,3,4,5]
b_lst = pickle.dumps(lst)
t_lst = pickle.loads(b_lst)
print(t_lst)
# [1,2,3,4,5]

dump load

dump将对象转换成乱码写入对象

dic = {"user":"baoyuan"}
pickle.dump(dic,open("info","wb"))
# �}q X userqX baoyuanqs.

load将乱码转换成对象输出

dic = {"user":"baoyuan"}
pickle.dump(dic,open("info","wb"))
print(pickle.load(open("info","rb")))
# {'user': 'baoyuan'}

os模块 -- 程序员通过python向操作系统发送指令(与操作系统交互的接口)

工作目录

当前工作路径 ***

print(os.getcwd())

路径切换 **

os.chdir(r"D:\pycharm demo\123")

文件夹

创建一个文件夹 ***

os.mkdir("ttt")

删除一个文件夹 ***

os.rmdir("ttt")

递归创建文件夹 ***

os.makedirs("ttt/sss/ddd/ee")

递归删除文件夹 ***

os.removedirs("ttt/sss/ddd/ee")

获取当前文件夹下所有文件名 ***

print(os.listdir())

文件

修改名字 ***

os.rename("123","info")

删除文件 ***

os.remove("info")

路径

通过相对路径获取绝对路径 ***

print(os.path.abspath("info"))

获取路径 ***

print(os.path.dirname("D:\pycharm demo\info"))

获取文件名 **

print(os.path.basename("D:\pycharm demo\info"))

判断路径是否存在 ***

print(os.path.exists("D:\pycharm demo\info"))

判断是不是路径 ***

print(os.path.isdir(r"D:\pycharm demo"))

判断是不是文件名 ***

print(os.path.isfile("info"))

判断是不是绝对路径 ***

print(os.path.isabs("D:\pycharm demo\info"))

路径拼接 *****

print(os.path.join("D:\\","pycharm demo","info"))

获取当前文件的大小(返回字节b) ***

print(os.path.getsize("D:\pycharm demo\代码练习.py"))

sys

sys -- 与python解释器交互的接口

脚本本身,当前文件运行(返回一个绝对路径) ***

print(sys.argv)

加密和校验 hashlib

常用的加密

md5

sha1

sha256

sha512

加密的过程

加密的内容

将要加密的内容转成字节

md5

import hashlib
md5 = hashlib.md5()
md5.update("alex123".encode("utf-8"))
print(md5.hexdigest())

sha1

sha1 = hashlib.sha1()
sha1.update("alex123".encode("utf-8"))
print(sha1.hexdigest())

加盐(二次加密)

加固定盐

md5 = hashlib.md5("alex".encode("utf-8"))
md5.update("wusir".encode("utf-8"))
print(md5.hexdigest())

加动态盐

user = input("user")
pwd = input("pwd")
import hashlib
md5 = hashlib.md5(user.encode("utf-8"))
md5.update(pwd.encode("utf-8"))
print(md5.hexdigest())

子主题

counter

c = Counter('abcdeabcdabcaba')
print(c)
# Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

内置函数

内置函数(二)

abs( )

绝对值 -- 返回的都是正数

print([abs(i) for i in lst])

enumerate( )

枚举("可迭代对象","序号的起始值") 默认的起始值是 0

lst = [(0,1)(1,2)(2,3)]
print([i for i in enumerate(lst,10)])

max( )

求最大值

print(max([1,2,3,4,56,7,8]))

key指定查找最大值的规则

print(max([1,2,-33,4,5],key=abs))

min( )

求最小值

print(min([1,2,3,4,-56,7,8]))

sum( )

求和

print(sum([1,2,3,4,5],100))

range( )

python2

range( )

获取的是一个列表

Xrange( )

获取的是一个可迭代对象

python3

获取的是一个可迭代对象

open( )

文件操作

print( )

打印

print(sep=" ",end="\n" )
print(1,2,3,sep=" ")

sep是多个元素的连接符

len( )

公共方法,求长度的函数(除数字和bool值)

list( )

列表

dict( )

字典

print(dict((1,2),(2,3)(3,4)))
print(dict([i for i in enumerate(range(20),1)]))

zip( )

拉链 -- 按照最少的进行合并

lst = [1,2,3,4,5]
lst1 = ["a","b","c","d","f","e"]
print(dict(list(zip(lst,lst1))))

dir( )

查看当前函数的方法

print(dir(list))

匿名函数

定义及拆解

f = lambda x,y:(x,y)

print(f(1,2))
# 3

print(f.__name__)
# lambda

print((lambda x:x)(2))
# 2

同一行定义同一行调用

lambda拆解

lambda

关键字 -- 定义函数

x,y

形参

:x+y

返回值 -- 只能返回一个数据类型

示例

lst = [lambda i:i*i for i in range(10)]
print(lst[2])
print(lst[2](2))

一条内存地址
4

拆解

lst = []
for i in range(10):
def func(i):
return i*i
lst.append(func)
print(lst[2](2))

示例2

lst = [lambda :i*i for i in range(10)]
print(lst[2])
print(lst[2]())

一条内存地址
81

拆解

lst = []
for i in range(10):
def func(i):
return i*i
lst.append(func)
print(lst[2]())

重要内置函数

format( )

格式

左对齐

print(format(13,"<20"))

居中

print(format(13,"^20"))

右对齐

print(format(13,">20"))

进制转换

2进制

print(format(13,"08b"))

10进制

print(format(13,"08d"))

8进制

print(format(13,"08o"))

16进制

print(format(12,"08x"))

filter( )

过滤

lst = [1,2,3,4,5,6,7]
print(list(filter(lambda x:x % 2 == 1,lst)))

拆解

lst = [1,2,3,4,5,6]
def func(s):
return s > 3
print(list(filter(func,lst)))

func就是自己定义一个过滤条件,lst 要迭代的对象

map( )

对象映射加工

list(map(lambda x : x*x,[1,2,3,8,4,5]))

对可迭代对象中的每个元素进行加工

排序

sort( )

sorted( )

指定规则的排序

dic = {"key":1,"key1":2,"key3":56}
print(sorted(dic,key=lambda x:dic[x],reverse=True))

反转

reverse( )

reversed( )

累计算

reduce( )

from functools import reduce
print(reduce(lambda x,y:x+y,[1,2,3,4,5]))

闭包

定义

在嵌套函数内,使用非全局变量(且不是本层变量) -- 就是闭包

print(foo()()().__closure__)判断是否闭包

示例

def func():
a = 1
def f1():
def foo():
print(a)
return foo
return f1

获取自由变量

print(ret.__code__.co_freevars)

获取局部变量

print(ret.__code__.co_varnames)

作用

保证数据的安全性

装饰器

普通装饰器

定义

用来装饰的工具

在不改变源代码及调用方式的基础上额外增加新的功能

开放封闭原则

扩展是开放的(增加新功能)

修改源码是封闭的(修改已经实现的功能)

标准版装饰器

def func(a): #a是要被装饰的函数名
def foo(*args,**kwargs):
"装饰之前的操作"
ret = a(*args,**kwargs)
"装饰之后的操作"
return ret
return foo

@func
def f1(*args,**kwargs):
print(f"这是一个{args}")
return "我可以返回了"
f1(1,2,3,34,4,5)

语法糖

语法糖必须放在被装饰的函数正上方

@wrapper 就等于 func = wrapper(func)

有参装饰器

基本版

def auth(argv):
def wrapper(f):
def inner(*args,**kwargs):
f(*args,**kwargs)
return inner
return wrapper

@auth(chose)

相等于以下两行代码的解构
wrapper = auth(chose)
foo = wrapper(foo)

多个装饰器装饰一个代码

示例

def wrapper1(func):
def inner1(*args,**kwargs):
print(1)
func(*args,**kwargs)
print(11)
return inner1

def wrapper2(func):
def inner2(*args,**kwargs):
print(2)
func(*args,**kwargs)
print(22)
return inner2

def wrapper3(func):
def inner3(*args,**kwargs):
print(3)
func(*args,**kwargs)
print(33)
return inner3

@wrapper3
@wrapper2
@wrapper1
def foo():
print("这是一个被装饰的函数")

foo()

# 3
# 2
# 1
# 这是一个被装饰的函数
# 11
# 22
# 33