首页  思维导图  详情

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

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