函数与装饰器Python学习

Posted 冷风中行走~

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了函数与装饰器Python学习相关的知识,希望对你有一定的参考价值。

1.1 文件处理

1.1.1 打开文件过程

在Python中,打开文件,得到文件句柄并赋值给一个变量,默认打开模式就为r

f=open(ra.txt,w,encoding=utf-8)

print(f.writable())

 

通过句柄对文件进行操作
f.write(1111\n)

f.write(2222\n)

f.writelines([3333\n,444\n])

 

关闭文件
f.close()

 

1.1.2 打开文件过程分析

1、由应用程序向操作系统发起系统调用open(...)
2、操作系统打开该文件,并返回一个文件句柄给应用程序
3、应用程序将文件句柄赋值给变量f

1.1.3 注意要点:

第一点:
打开一个文件包含两部分资源:操作系统级打开的文件+应用程序的变量。在操作完毕一个文件时,必须把与该文件的这两部分资源一个不落地回收,回收方法为:
1、f.close() #回收操作系统级打开的文件
2、del f #回收应用程序级的变量
其中del f一定要发生在f.close()之后,否则就会导致操作系统打开的文件还没有关闭,白白占用资源,而python自动的垃圾回收机制决定了我们无需考虑del f,这就要求我们,在操作完毕文件后,一定要记住f.close()
为避免忘记忘记f.close(),使用with关键字来帮我们管理
with open(a.txt,w) as f:

    pass

 

with open(a.txt,r) as read_f,open(b.txt,w) as write_f:

    data=read_f.read()

    write_f.write(data)

 

强调第二点:
f=open(...)是由操作系统打开文件,那么如果我们没有为open指定编码,那么打开文件的默认编码很明显是操作系统说了算了,操作系统会用自己的默认编码去打开文件,在windows下是gbk,在linux下是utf-8。
这就用到了上节课讲的字符编码的知识:若要保证不乱码,文件以什么方式存的,就要以什么方式打开。
f=open(a.txt,r,encoding=utf-8)

 

1.1.4 三种模式:a,r,b

打开文件的模式有(默认为文本模式)

1.1.5 a:之追加写模式(不可读;不存在则创建;存在则只追加内容)

文件不存在则创建,文件存在那么在打开文件后立刻将光标移动到文件末尾,进行追加写

f=open(rb.txt,a,encoding=utf-8)

print(f.writable())

f.write(4444\n)  

f.write(5555\n)

f.writelines([66666\n,7777\n]) 

f.close()

 

 

1.1.6 r:只读模式(默认模式,文件必须存在,不存在则抛出异常)

f=open(rb.txt,r,encoding=utf-8)

print(f.writable())

print(f.read())

print(f.readlines())

print(f.readline(),end=‘‘)

print(f.readline(),end=‘‘)

f.close() 
 
with open(b.txt,r,encoding=utf-8) as f:

    while True:

        line=f.readline()

        if len(line) == 0:break

        print(line)

 

    print(f.readline())

    print(f.readline())

    print(f.readline())

    print(f.readline())

    print(f.readline())

    print(f.readline())

    print(f.readline())

    print(第八次,f.readline())

#

    for line in f:

        print(line)

 

 

1.1.7 w,只写模式(不可读;不存在则创建;存在则清空内容)

1.1.8 b:bytes表示以字节的方式操作(而所有文件也都是以字节的形式存储的,使用这种模式无需考虑文本文件的字符编码、图片文件的jgp格式、视频文件的avi格式)

with open(111.png,rb) as f:
    print(f.read())

 

 

with open(b.txt,rb,) as f:

    print(f.read().decode(utf-8))

 

 

with open(b.txt,rt,encoding=utf-8) as f:

    print(f.read())

 

with open(b.txt,wb) as f:

    res=中问.encode(utf-8)

    print(res,type(res))

    f.write(res)

 

with open(b.txt,ab) as f:

    res=哈哈哈.encode(utf-8)

    print(res,type(res))

    f.write(res)

 

 

注:以b方式打开时,读取到的内容是字节类型,写入时也需要提供字节类型,不能指定编码

 

 

 

1.2 字符编码补充

#encoding:utf-8

with open(b.txt,rt,encoding=utf-8) as f:

    print(f.read())

 

 

1.3 操作文件的方法

1.3.1 文件修改

文件的数据是存放于硬盘上的,因而只存在覆盖、不存在修改这么一说,我们平时看到的修改文件,都是模拟出来的效果,具体的说有两种实现方式:

1.3.1.1  利用b模式,编写一个cp工具,要求如下:

1. 既可以拷贝文本又可以拷贝视频,图片等文件

2. 用户一旦参数错误,打印命令的正确使用方法

提示:可以用import sys,然后用sys.argv获取脚本后面跟的参数

方式一:将硬盘存放的该文件的内容全部加载到内存,在内存中是可以修改的,修改完毕后,再由内存覆盖到硬盘(word,vim,nodpad++等编辑器)

import os

with open(info.txt,r,encoding=utf-8) as read_f,open(.info.txt.swap,w,encoding=utf-8) as write_f:

    data=read_f.read()

    write_f.write(data.replace(alex,SB))

 

os.remove(info.txt)

os.rename(.info.txt.swap,info.txt)

 

 

方式二:将硬盘存放的该文件的内容一行一行地读入内存,修改完毕就写入新文件,最后用新文件覆盖源文件

import os

 

with open(info.txt, r, encoding=utf-8) as read_f, open(.info.txt.swap, w, encoding=utf-8) as write_f:

    for line in read_f:

        if SB in line:

            line=line.replace(SB,alex)

        write_f.write(line)

 

os.remove(info.txt)

os.rename(.info.txt.swap, info.txt)

 

 

cp复制命令的实现

1、源大小的问题:

2、文件打开模式的问题:b

#!/usr/bin/env python

import sys

_,src_file,dst_file=sys.argv

 

with open(src_file,rb) as read_f,
        open(dst_file,wb) as write_f:

    # data=read_f.read()

    # write_f.write(data)

 

    for line in read_f:

        write_f.write(line)

        write_f.flush()

 

 

1.3.2 文件内光标的移动

f.read() #读取所有内容,光标移动到文件末尾

f.readline() #读取一行内容,光标移动到第二行首部

f.readlines() #读取每一行内容,存放于列表中

 

f.write(‘1111\n222\n‘) #针对文本模式的写,需要自己写换行符

f.write(‘1111\n222\n‘.encode(‘utf-8‘)) #针对b模式的写,需要自己写换行符

f.writelines([‘333\n‘,‘444\n‘]) #文件模式

f.writelines([bytes(‘333\n‘,encoding=‘utf-8‘),‘444\n‘.encode(‘utf-8‘)]) #b模式

1.3.2.1  : read(3):

1. 文件打开方式为文本模式时,代表读取3个字符

2. 文件打开方式为b模式时,代表读取3个字节

1.3.2.2  : 其余的文件内光标移动都是以字节为单位如seek,tell,truncate

注意:

1. seek有三种移动方式0,1,2,其中1和2必须在b模式下进行,但无论哪种模式,都是以bytes为单位移动的

2. truncate是截断文件,所以文件的打开方式必须可写,但是不能用w或w+等方式打开,因为那样直接清空文件了,所以truncate要在r+或a或a+等模式下测试效果

1.3.2.3      基于seek实现tail -f功能

with open(a.txt,r,encoding=utf-8) as f:

    data1=f.read()

    print(==1==>,data1)

    print(f.tell())

 

    data2=f.read()

    print(==2==>,data2)

 

只有一种情况光标以字符为单位:文件以rt方式打开,read(3)
with open(c.txt,rt,encoding=utf-8) as f:

    print(f.read(6))

    print(f.tell())

    f.seek(0,0)

    print(f.read(6))

 

    f.seek(6,0)

    f.seek(8,0)

    print(f.read())

 

 
with open(c.txt,rb,) as f:

    f.seek(6,0)

    # f.seek(8,0)

    print(f.read())

 

with open(c.txt,rb) as f:

    print(f.read(6))

    f.seek(2,1)

    print(f.tell())

    print(f.read().decode(utf-8))

 

 

1.4 函数基础

1.4.1 为什么要有函数?没有函数带来的困扰?

组织结构不清晰,可读性差
代码冗余
可扩展性差
 

1.4.2 什么是函数

   具备某一个功能的工具---》函数
    事先准备工具-》函数的定义
    拿来就用、重复使用-》函数的调用
    ps:先定义后调用
 

1.4.3 函数的分类:

    内置函数:len,max(10,11),help(函数名)
    自定义函数:def
        语法:

            def 函数名(参数1,参数2,...):

                """注释"""

                函数体

                return 返回值

‘‘‘

#‘函数即是变量‘
def print_tag():

    print(**20)

 

def print_msg(): #print_msg=<function print_msg at 0x00000000027EA8C8>

    print(hello world)

 

 

print(print_msg)

print(print_tag)

 

print_tag()

print_msg()

print_tag()

 

 

1.4.4 定义函数阶段都发生了什么事:只检测语法,不执行代码

1.4.4.1  定义阶段

sex=male

def auth():

    sex

 

    name=input(name>>: ).strip()

    password=input(password>>: ).strip()

    if name ==egon and password == 123:

        print(login successfull)

    else:

        print(user or password err)

 

 

1.4.4.2  调用阶段

auth()

 

 

1.4.5 函数的使用:先定义后调用

def bar():

    print(from bar)

 

def foo():

    print(from foo)

    bar()

 

foo()

 

 
定义阶段
def foo():

    print(from foo)

    bar()
定义阶段
def bar():

    print(from bar)
调用
def bar():

    print(from bar)

 

 
 

1.4.6 定义函数的三种形式

1、无参:应用场景仅仅只是执行一些操作,比如与用户交互,打印

2、有参:需要根据外部传进来的参数,才能执行相应的逻辑,比如统计长度,求最大值最小值

3、空函数:设计代码结构

1.4.6.1  第一种:无参函数

 
def auth():

    name=input(name>>: ).strip()

    password=input(password>>: ).strip()

    if name ==egon and password == 123:

        print(login successfull)

    else:

        print(user or password err)

 

1.4.6.2  第二种:有参函数

def my_max(x,y):

    if x >= y:

        print(x)

    else:

        print(y)

 

my_max(1,2)

 

 

1.4.6.3  第三种:空函数

def auth(name,password):

    if name ==egon and password == 123:

        print(login successfull)

    else:

        print(user or password err)

 

def interactive():

    name=input(name>>: ).strip()

    password=input(password>>: ).strip()

    auth(name,password)

 

interactive()

 

1.4.7 结论:

1、定义时无参,意味着调用时也无需传入参数
2、定义时有参,意味着调用时则必须传入参数

1.4.8 程序的体系结构

def auth():

    pass

 

def put():

    pass

 

def get():

    pass

 

def ls():

    pass

 

1.5 函数的返回值

无return->None

return 1个值->返回1个值

return 逗号分隔多个值->元组

1.5.1 return的特点:

1、 函数内可以有多个return,但是只能执行一次return

2、 执行return函数就立刻结束,并且return的后值当做本次调用的结果返回

1.5.1.1  什么时候该有返回值?

  调用函数,经过一系列的操作,最后要拿到一个明确的结果,则必须要有返回值

  通常有参函数需要有返回值,输入参数,经过计算,得到一个最终的结果

1.5.1.2  什么时候不需要有返回值?

  调用函数,仅仅只是执行一系列的操作,最后不需要得到什么结果,则无需有返回值

  通常无参函数不需要有返回值

1.5.2 函数调用的三种形式

1.5.2.1  语句形式:foo()

def foo(x,y):

    return x+y

 

res=foo(1,2)

 

def my_max(x,y):

    if x >= y:

        return x

    else:

        return y

 

res=my_max(1,2)

print(res)

 

 

def foo():

    print(first)

    return 1

    print(second)

    return 2

    print(third)

    return 3

 

res=foo()

print(res)

 

 

1.6 函数的参数

1.6.1 函数的参数分类两种:

形参:在定义阶段括号内指定的参数,相当于变量名
实参:在调用阶段括号内传入的值称之为实参,相当于值

1.6.2 在调用阶段,实参的值会绑定给形参,在调用结束后解除绑定

def foo(x,y): #x=1,y=2

    print(x,y)

 

foo(1,2)

 

1.6.3 在python中参数的分类:

1.6.3.1  位置参数:按照从左到右的顺序依次定义的参数

位置形参:必须被传值,多一个少一个都不行
位置实参:与形参一一对应传值
def foo(x,y):

    print(x,y)

 

foo(2,1)

 

1.6.3.2  关键字参数:在函数调用时,按照key=value的形式定义的实参

特点:指名道姓地给形参传值,不再依赖与位置
def foo(name,age,sex):

    print(name,age,sex)

 

foo(egon,18,male)

foo(sex=male,age=18,name=egon,)

 

注意:
1、 关键字实参必须在位置实参的后面
2、 不能为同一个参数赋值多次
foo(egon,sex=male,age=18,name=egon

1.6.3.3  默认参数:在函数定义阶段,就已经为形参赋值了

特点:定义阶段已经有值意味着调用阶段可以不用传值
位置参数通常用于经常变化的参数,而默认参数指的是大多数情况下都一样的
def foo(x,y=1):

    print(x,y)

 

foo(1,2)

foo(y=3,x=1)

foo(111)

foo(x=1111)

 

def register(name,age,sex=male):

    print(name,age,sex)

 

register(egon1,18)

register(egon2,18)

register(egon3,18)

register(alex,38,female)
注意:
1、默认参数必须放到位置形参的后面
def register(name,sex=male,age,):
    print(name,age,sex)

 

2、默认参数的值只在定义时被赋值一次
3、默认的参数的值通常应该是不可变类型
res=1

def foo(x,y=res):

    print(x,y)

 

res=10

foo(aaaaaaaa)

1.6.3.4  可变长参数:在调用函数时,实参值的个数不固定

实参的形式有:位置实参和关键字实参,
形参的解决方案:*,**
?  *args的用法
def foo(x,y,*args): #z=(3,4,5,6)

    print(x,y)

    print(args)

 

foo(1,2,3,4,5,6)

 

foo(1,2,*[3,4,5,6]) #foo(1,2,3,4,5,6)

foo(*[1,2,3,4,5,6]) #foo(1,2,3,4,5,6)

 
def foo(x,y):

    print(x,y)

 

foo(*(1,2)) #foo(1,2)

 

 
?  **kwargs
def foo(x,y,**kwargs): #kwargs={‘c‘:5,‘a‘:3,‘b‘:4}

    print(x,y)

    print(kwargs)

 

foo(y=2,x=1,a=3,b=4,c=5)

 

foo(y=2,**{c:5,x:1,b:4,a:3}) #foo(y=2,a=3,c=5,b=4)

 

def foo(name,age):

    print(name,age)

 

foo(**{name:egon,age:18})

foo({name:egon,age:18})

 

def bar(x,y,z):

    print(x,y,z)

 

 

def wrapper(*args,**kwargs): #args=(1,),kwargs={‘z‘:2,‘y‘:3}

    # print(args,kwargs)

    bar(*args,**kwargs) #bar(*(1,),**{‘z‘:2,‘y‘:3}) #bar(1,z=2,y=3,)

 

wrapper(1,z=2,y=3)
 

 

1.6.3.5  命名关键字参数:指的是定义在*后的参数,该参数必须被传值(除非有它有默认值),而且必须按照key=value的形式传值

def foo(x,y,*args,m=100000,n):

    print(x,y)

    print(args)

    print(m,n)

 

foo(1,2,3,n=4,)

 

 

1.7 函数的对象

1.7.1 函数是第一类对象:指的是函数可以当做数据传递

1.7.1.1  可以被引用 x=1,y=x

def func(x,y):

    print(x,y)

 

f=func

f(1,2)

 

1.7.1.2  可当做函数的参数传入

def foo():

    print(from foo)

 

def bar(func):

    # print(func)

    func()

 

bar(foo)

 

 

1.7.1.3  可以当做函数的返回值

def foo():

    print(from foo)

 

def bar():

    return foo

 

f=bar()

f()

 

 

1.7.1.4  可以当做容器类型的元素

def foo():

    print(from foo)

 

def bar():

    return foo

 

l=[foo,bar]

print(l)

l[0]()

 

 

def get():

    print(get)

 

def put():

    print(put)

 

def ls():

    print(ls)

 

cmd=input(>>: ).strip()

if cmd == get:

    get()

elif cmd == put:

    put()

elif cmd == ls:

    ls()

 

 

def get():

    print(get)

 

def put():

    print(put)

 

def ls():

    print(ls)

 

def auth():

    print(auth)

 

func_dic={

    get:get,

    put:put,

    ls:ls,

    auth:auth

}

# func_dic[‘put‘]()

cmd = input(>>: ).strip()

if cmd in func_dic:

    func_dic[cmd]()

 

 

1.8 函数的嵌套

1.8.1 函数的嵌套调用

def my_max(x,y):

    if x >= y:

        return x

    else:

        return y

 

 
def my_max4(a,b,c,d):

    res1=my_max(a,b)

    res2=my_max(res1,c)

    res3=my_max(res2,d)

    return res3

 

 

1.8.2 函数的嵌套定义

def f1():

    def f2():

        print(from f2)

        def f3():

            print(from f3)

        f3()

    # print(f2)

    f2()

 

 

f1()

 

 

1.9 名称空间

名称空间指的是:存放名字与值绑定关系的地方,

1.9.1 内置与全局名称空间

内置名称空间(python解释器启动就有):python解释器内置的名字,max,len,print

全局名称空间(执行python文件时生效):文件级别定义的名字

x=1

def func():pass

import time

if x == 1:

    y=2
 

#局部名称空间(函数调用时生效,调用结束失效):函数内部定义的名字

func()

 

 

1.9.2 加载与访问顺序

加载顺序:内置---》全局----》局部名称空间

访问名字的顺序:局部名称空间===》全局----》内置

x=1

print(x)

 

 

#print(max)

 

max=2

def func():

    # max=1

    print(max)

 

func()

 

x=gobal

def f1():

    # x=1

    def f2():

       # x=2

       def f3():

           # x=3

           print(x)

       f3()

    f2()

 

f1()

 

1.9.3 全局与局部作用域

全局作用域(全局范围):内置名称空间与全局名称空间的名字,全局存活,全局有效,globals()

局部作用域(局部范围):局部名称空间的名字,临时存活,局部有效,locals()

#xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=111111111111111111111

print(globals())

print(dir(globals()[__builtins__]))

 

print(locals() is globals())

 

def func():

  #  yyyyyyyyyyyyyyyyyyyyyyyy=22222222

    print(globals())

    print(locals())

 

func()

 

x=100

def func():

    global x

    x=1

 

func()

print(x)

 

x=global

def f1():

    # x=1

    def f2():

        nonlocal x

        x=0

    f2()

    print(===f1 innter--->,x)

 

f1()

print(x)

 

 

1.9.4 强调两点:

1.9.4.1  打破函数层级限制来调用函数

def outter():

    def inner():

        print(inner)

    return inner

 

f=outter()

# print(f)

 

def bar():

    f()

bar()

 

 

1.9.4.2  函数的作用域关系是在函数定义阶段就已经固定了,与调用位置无关

x=1

def outter():

    # x=2

    def inner():

        print(inner,x)

    return inner

 

f=outter()

# print(f)

# x=1111111111111111111111111111111111111111111111111111111111111111111111111111111111

def bar():

    x=3

    f()

# x=1111111111111111111111111111111111111111111111111111111111111111111111111111111111

bar()

x=1111111111111111111111111111111111111111111111111111111111111111111111111111111111 

 

1.10 闭包函数

闭包函数:

1 定义在函数内部的函数

2 该函数的函数体代码包含对外部作用域(而不是全局作用域)名字的引用

3 通常将闭包函数用return返回,然后可以在任意使用

z=1

def outer():

    x=1

    y=2

    def inner():

        print(x,y)

        # print(z)

    return inner

 

f=outer()

print(f.__closure__[0].cell_contents)

print(f.__closure__[1].cell_contents)

print(f.__closure__)

 

 

def bar():

    x=111121

    y=2222

    f()

 

bar()

 

 

def foo(x,y):

    print(x+y)

 

foo(1,2)

 

 

 

def outter():

    x=1

    y=2

    def foo():

        print(x+y)

    return foo

 

 

f=outter()

 

f()

 

1.10.1 闭包的意义:

返回的函数对象,不仅仅是一个函数对象,在该函数外还包裹了一层作用域,这使得,该函数无论在何处调用,优先使用自己外层包裹的作用域

1.10.2 应用领域:

延迟计算(原来我们是传参,现在我们是包起来)

1.10.3 爬页面:闭包函数为我们提供了一种新的为函数传参的方式

import requests #pip3 install requests

 

def get(url):

    response=requests.get(url)

    if response.status_code == 200:

        print(len(response.text))

 

get(https://www.baidu.com)

get(https://www.baidu.com)

get(https://www.baidu.com)

 

def outter(url):

    # url = ‘https://www.baidu.com‘

    def get():

        response=requests.get(url)

        if response.status_code == 200:

            print(len(response.text))

    return get

 

baidu=outter(https://www.baidu.com)

python=outter(https://www.python.org)

# baidu()

# baidu()

# baidu()

 

 

1.11 装饰器

1.11.1 开放封闭原则:

对扩展开放,对修改是封闭

1.11.2 装饰器:

装饰它人的,器指的是任意可调用对象,现在的场景装饰器-》函数,被装饰的对象也是-》函数

1.11.3 原则:

1、不修改被装饰对象的源代码

2、不修改被装饰对象的调用方式

1.11.4 装饰器的目的:

在遵循1,2的前提下为被装饰对象添加上新功能

 

错误的示范

import time

 

def index():

    time.sleep(3)

    print(welecome to index)

 

def timmer(func):

    start=time.time()

    func()

    stop=time.time()

    print(run time is %s %(stop-start))

 

timmer(index)

 

 

1.11.5 正确的示范

import time

def index():

    time.sleep(3)

    print(welecome to index)

 

def timmer(func):

    # func=index #最原始的index

    def inner():

        start=time.time()

        func() #最原始的index

        stop=time.time()

        print(run time is %s %(stop-start))

    return inner

 

index=timmer(index) #index=inner

# print(f)

index() #inner()

 

 

1.12 装饰器的修订

1.12.1 装饰器语法:

在被装饰对象正上方单独一行写上,@装饰器名

@deco1

        @deco2

        @deco3

        def foo():

            pass

 

        foo=deco1(deco2(deco3(foo)))

 

1.12.2 改进一:

import time

def timmer(func):

    def inner():

        start=time.time()

        res=func()

        stop=time.time()

        print(run time is %s %(stop-start))

        return res

    return inner

 

@timmer #index=timmer(index)

def index():

    time.sleep(1)

    print(welecome to index)

    return 1111

 

res=index() #res=inner()

print(res)

 

 

1.12.3 改进二:

import time

def timmer(func):

    def inner(*args,**kwargs):

        start=time.time()

        res=func(*args,**kwargs)

        stop=time.time()

        print(run time is %s %(stop-start))

        return res

    return inner

 

@timmer #index=timmer(index)

def index(name):

    time.sleep(1)

    print(welecome %s to index %name)

    return 1111

res=index(egon) #res=inner(‘egon‘)

print(res)

 

@timmer #home=timmer(home)

def home(name):

    print(welcome %s to home page %name)

 

home(egon) #inner(‘egon‘)

 

 

1.13 有参装饰器

import time

def auth(func): # func=index

    def inner(*args,**kwargs):

        name=input(name>>: ).strip()

        password=input(password>>: ).strip()

        if name == egon and password == 123:

            print(login successful)

            return func(*args,**kwargs)

        else:

            print(login err)

    return inner

 

@auth

def index(name):

    time.sleep(1)

    print(welecome %s to index %name)

    return 1111

 

res=index(egon)

print(res)

 

 

#有参装饰器

import time

 

def auth2(engine=file):

    def auth(func): # func=index

        def inner(*args,**kwargs):

            if engine == file:

                name=input(name>>: ).strip()

                password=input(password>>: ).strip()

                if name == egon and password == 123:

                    print(login successful)

                    return func(*args,**kwargs)

                else:

                    print(login err)

            elif engine == mysql:

                print(mysql auth)

            elif engine == ldap:

                print(ldap auth)

            else:

                print(engin not exists)

        return inner

    return auth

 

@auth2(engine=mysql) #@auth #index=auth(index) #index=inner

def index(name):

    time.sleep(1)

    print(welecome %s to index %name)

    return 1111

 

res=index(egon) #res=inner(‘egon‘)

print(res)

 

 

1.14 并列多个装饰器

import time

def timmer(func):

    def inner(*args,**kwargs):

        start=time.time()

        res=func(*args,**kwargs)

        stop=time.time()

        print(run time is %s %(stop-start))

        return res

    return inner

 

def auth2(engine=file):

    def auth(func): # func=index

        def inner(*args,**kwargs):

            if engine == file:

                name=input(name>>: ).strip()

                password=input(password>>: ).strip()

                if name == egon and password == 123:

                    print(login successful)

                    return func(*args,**kwargs)

                else:

                    print(login err)

            elif engine == mysql:

                print(mysql auth)

            elif engine == ldap:

                print(ldap auth)

            else:

                print(engin not exists)

        return inner

    return auth

 

 

@auth2(engine=file)

@timmer

def index(name):

    time.sleep(1)

    print(welecome %s to index %name)

    return 1111

 

res=index(egon)

print(res)

 

 

 

1.15 wraps补充

from functools import wraps

import time

def timmer(func):

    @wraps(func)

    def inner(*args,**kwargs):

        start=time.time()

        res=func(*args,**kwargs)

        stop=time.time()

        print(run time is %s %(stop-start))

        return res

    # inner.__doc__=func.__doc__

    # inner.__name__=func.__name__

    return inner

 

@timmer

def index(name): #index=inner

    ‘‘‘index 函数。。。。。‘‘‘

    time.sleep(1)

    print(welecome %s to index %name)

    return 1111

 

# res=index(‘egon‘)

# print(res)

 

print(help(index))

 

 




以上是关于函数与装饰器Python学习的主要内容,如果未能解决你的问题,请参考以下文章

python之循序渐进学习装饰器

python装饰器学习

安全牛学习笔记python装饰器

安全牛学习笔记python学习笔记

Python学习笔记(yield与装饰器)

Python学习笔记012——装饰器