python函数

什么是函数？

  函数相当于具备某一功能的工具
  函数使用原则：先定义，后调用

为什么要使用函数？

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

函数使用

函数定义

# 定义函数发生的事情
# 1、申请内存空间保存函数体代码
# 2、将上述内存地址绑定函数名
# 3、定义函数不会执行函数体代码，但是会检测函数体语法
def 函数名(参数1，参数2，...):
  """文档描述"""
  函数体
  return 值

无参函数

def func():
  """文档描述"""
  ### 函数体

有参函数

def func(x,y):
  """文档描述"""
  ### 函数体
func(1,2)

空函数

def func(x,y):
  pass

函数调用

调用函数发生的事情
1、通过函数名找到函数的内存地址
2、然后加口号就是在触发函数体代码的执行

# 1、语句的形式:只加括号调用函数
# interactive()
# add(1,2)

# 2、表达式形式：
# def add(x,y): # 参数-》原材料
#     res=x + y
#     return res # 返回值-》产品
# 赋值表达式
# res=add(1,2)
# print(res)
# 数学表达式
# res=add(1,2)*10
# print(res)

# 3、函数调用可以当做参数
# res=add(add(1,2),10)
# print(res)

函数返回值

return是函数结束的标志，即函数体代码一旦运行到return会立刻终止函数的运行，并且会将return后的值当做本次运行的结果返回

返回None: return None或 return
返回单个值：return 值
返回多个值：return 值1，值2，值3得到一个tulp元组类型（值1，值2，值3）

函数参数

形参
1. 位置形参
2. 默认形参：在定义阶段中被赋值内存地址，规范-赋值类型为不可变类型
混用时，位置形参必须在默认形参左边
1. 可变位置参数：*argsargs是一个元组
2. 可变关键字参数：**kwargskwargs是一个字典
实参
1. 位置实参
2. 关键字实参
混合使用是，位置实参必须在关键字实参前，并且不能为同一个参数重复赋值
1. 实参中带*: func(*[11,2,3])会将参数与形参一一对应func(11,2,3)
2. 实参中带**:func(**{"a":1,"b":4}) func(a=1,b=4)

混用*和**，*args必须在**kwargs之前

命名关键字参数（了解）：func(a,b,*,c,d)，*号后定义的参数，c/d称为关键字参数，必须按照key=value为其传参
组合使用（了解）：func(a,y=111,*args,z,**kwargs)

函数对象

函数可以当成一个变量func=内存地址

# 1、可以赋值
f=func
print(f,func)
f()

# 2、可以当做函数当做参数传给另外一个函数
def foo(x): # x = func的内存地址
    # print(x)
    x()

foo(func) # foo(func的内存地址)

# 3、可以当做函数当做另外一个函数的返回值
def foo(x): # x=func的内存地址
    return x # return func的内存地址

res=foo(func) # foo（func的内存地址）
print(res) # res=func的内存地址

res()

# 4、可以当做容器类型的一个元素
l=[func,]
# print(l)
l[0]()

函数嵌套

# 1、函数的嵌套调用：在调用一个函数的过程中又调用其他函数
def max2(x,y):
    if x > y:
        return x
    else:
        return y

def max4(a,b,c,d):
    # 第一步：比较a，b得到res1
    res1=max2(a,b)
    # 第二步：比较res1，c得到res2
    res2=max2(res1,c)
    # 第三步：比较res2，d得到res3
    res3=max2(res2,d)
    return res3

res=max4(1,2,3,4)
print(res)


# 2、函数的嵌套定义:在函数内定义其他函数
def f1():
    def f2():
        pass

函数闭包

"闭"函数指的该函数是内嵌函数,"包"函数指的该函数包含对外层函数作用域名字的引用（不是对全局作用域）

def f1():
    x = 111
    def f2():
        print(x)
    f2()


x=11111
def bar():
    x=444444
    f1()

def foo():
    x=2222
    bar()

foo()

装饰器

什么是装饰器

器指的是工具，可以定义成成函数
    装饰指的是为其他事物添加额外的东西点缀
    
    合到一起的解释：
        装饰器指的定义一个函数，该函数是用来为其他函数添加额外的功能

为何要用装饰器

开放封闭原则
        开放：指的是对拓展功能是开放的
        封闭：指的是对修改源代码是封闭的
        
    装饰器就是在不修改被装饰器对象源代码以及调用方式的前提下为被装饰对象添加新功能

如何用

需求：在不修改index函数的源代码以及调用方式的前提下为其添加统计运行时间的功能


def index(x,y):
    time.sleep(3)
    print('index %s %s' %(x,y))

index(111,222)
# index(y=111,x=222)
# index(111,y=222)

解决方案一：失败

问题：没有修改被装饰对象的调用方式，但是修改了其源代码

import time

def index(x,y):
    start=time.time()
    time.sleep(3)
    print('index %s %s' %(x,y))
    stop = time.time()
    print(stop - start)

index(111,222)

解决方案二：失败

问题：没有修改被装饰对象的调用方式，也没有修改了其源代码，并且加上了新功能但是代码冗余

import time

def index(x,y):
    time.sleep(3)
    print('index %s %s' %(x,y))

start=time.time()
index(111,222)
stop=time.time()
print(stop - start)



start=time.time()
index(111,222)
stop=time.time()
print(stop - start)


start=time.time()
index(111,222)
stop=time.time()
print(stop - start)

解决方案三：失败

问题：解决了方案二代码冗余问题，但带来一个新问题即函数的调用方式改变了

import time

def index(x,y):
    time.sleep(3)
    print('index %s %s' %(x,y))

def wrapper():
    start=time.time()
    index(111,222)
    stop=time.time()
    print(stop - start)

wrapper()

方案三的优化一：将index的参数写活了

import time

def index(x,y,z):
    time.sleep(3)
    print('index %s %s %s' %(x,y,z))

def wrapper(*args,**kwargs):
    start=time.time()
    index(*args,**kwargs) # index(3333,z=5555,y=44444)
    stop=time.time()
    print(stop - start)

# wrapper(3333,4444,5555)
# wrapper(3333,z=5555,y=44444)

方案三的优化二：在优化一的基础上把被装饰对象写活了，原来只能装饰index

import time

def index(x,y,z):
    time.sleep(3)
    print('index %s %s %s' %(x,y,z))

def home(name):
    time.sleep(2)
    print('welcome %s to home page' %name)


def outter(func):
    # func = index的内存地址
    def wrapper(*args,**kwargs):
        start=time.time()
        func(*args,**kwargs) # index的内存地址()
        stop=time.time()
        print(stop - start)
    return wrapper

index=outter(index) # index=wrapper的内存地址
home=outter(home) # home=wrapper的内存地址


home('egon')
# home(name='egon')

方案三的优化三：将wrapper做的跟被装饰对象一模一样，以假乱真

import time

def index(x,y,z):
    time.sleep(3)
    print('index %s %s %s' %(x,y,z))

def home(name):
    time.sleep(2)
    print('welcome %s to home page' %name)

def outter(func):
    def wrapper(*args,**kwargs):
        start=time.time()
        res=func(*args,**kwargs)
        stop=time.time()
        print(stop - start)
        return res



    return wrapper

偷梁换柱：home这个名字指向的wrapper函数的内存地址

home=outter(home)
res=home('egon') # res=wrapper('egon')
print('返回值--》',res)

大方向：如何在方案三的基础上不改变函数的调用方式

语法糖：让你开心的语法

import time

# 装饰器
def timmer(func):
    def wrapper(*args,**kwargs):
        start=time.time()
        res=func(*args,**kwargs)
        stop=time.time()
        print(stop - start)
        return res
    return wrapper

# 在被装饰对象正上方的单独一行写@装饰器名字
# @timmer # index=timmer(index)
def index(x,y,z):
    time.sleep(3)
    print('index %s %s %s' %(x,y,z))

# @timmer # home=timmer(ome)
def home(name):
    time.sleep(2)
    print('welcome %s to home page' %name)


index(x=1,y=2,z=3)
home('egon')

总结无参装饰器模板

def outter(func):
    def wrapper(*args,**kwargs):
        # 1、调用原函数
        # 2、为其增加新功能
        res=func(*args,**kwargs)
        return res
    return wrapper

偷梁换柱，即将原函数名指向的内存地址偷梁换柱成wrapper函数所以应该将wrapper做的跟原函数一样才行

from functools import wraps

def outter(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        """这个是主页功能"""
        res = func(*args, **kwargs) # res=index(1,2)
        return res

    # 手动将原函数的属性赋值给wrapper函数
    # 1、函数wrapper.__name__ = 原函数.__name__
    # 2、函数wrapper.__doc__ = 原函数.__doc__
    # wrapper.__name__ = func.__name__
    # wrapper.__doc__ = func.__doc__

    return wrapper



@outter # index=outter(index)
def index(x,y):
    """这个是主页功能"""
    print(x,y)


print(index.__name__)
print(index.__doc__) #help(index)

有参装饰器：三层函数

@语法糖只接收一个参数，要想传参需要在外包裹一层函数，

def auth(db_type):
    def deco(func):
        def wrapper(*args, **kwargs):
            name = input('your name>>>: ').strip()
            pwd = input('your password>>>: ').strip()

            if db_type == 'file':
                print('基于文件的验证')
                if name == 'egon' and pwd == '123':
                    res = func(*args, **kwargs)  # index(1,2)
                    return res
                else:
                    print('user or password error')
            elif db_type == 'mysql':
                print('基于mysql的验证')
            elif db_type == 'ldap':
                print('基于ldap的验证')
            else:
                print('不支持该db_type')
        return wrapper
    return deco


@auth(db_type='file')  # @deco # index=deco(index) # index=wrapper
def index(x, y):
    print('index->>%s:%s' % (x, y))

@auth(db_type='mysql')  # @deco # home=deco(home) # home=wrapper
def home(name):
    print('home->>%s' % name)


@auth(db_type='ldap')  # 账号密码的来源是ldap
def transfer():
    print('transfer')

# index(1, 2)
# home('egon')
# transfer()

有参装饰器模板

def 有参装饰器(x,y,z):
    def outter(func):
        def wrapper(*args, **kwargs):
            res = func(*args, **kwargs)
            return res
        return wrapper
    return outter

@有参装饰器(1,y=2,z=3)
def 被装饰对象():
    pass

多个装饰器

# 一、叠加多个装饰器的加载、运行分析（了解***）

def deco1(func1): # func1 = wrapper2的内存地址
    def wrapper1(*args,**kwargs):
        print('正在运行===>deco1.wrapper1')
        res1=func1(*args,**kwargs)
        return res1
    return wrapper1

def deco2(func2): # func2 = wrapper3的内存地址
    def wrapper2(*args,**kwargs):
        print('正在运行===>deco2.wrapper2')
        res2=func2(*args,**kwargs)
        return res2
    return wrapper2

def deco3(x):
    def outter3(func3): # func3=被装饰对象index函数的内存地址
        def wrapper3(*args,**kwargs):
            print('正在运行===>deco3.outter3.wrapper3')
            res3=func3(*args,**kwargs)
            return res3
        return wrapper3
    return outter3


# 加载顺序自下而上(了解)
@deco1      # index=deco1(wrapper2的内存地址)        ===> index=wrapper1的内存地址
@deco2      # index=deco2(wrapper3的内存地址)        ===> index=wrapper2的内存地址
@deco3(111) # ===>@outter3===> index=outter3(index) ===> index=wrapper3的内存地址
def index(x,y):
    print('from index %s:%s' %(x,y))

# 执行顺序自上而下的，即wraper1-》wrapper2-》wrapper3
index(1,2) # wrapper1(1,2)

posted @ 2022-11-01 00:24 转角90 阅读(19) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· python模块

· python基础

· 02 函数

· 函数-周末小结

· 0225-0306函数

阅读排行：
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· C#/.NET/.NET Core优秀项目和框架2025年2月简报
· DeepSeek在M芯片Mac上本地化部署

转角90

python函数

什么是函数？

为什么要使用函数？

函数使用

函数定义

函数调用

函数返回值

函数参数

函数对象

函数嵌套

函数闭包

装饰器

什么是装饰器

为何要用装饰器

如何用

需求：在不修改index函数的源代码以及调用方式的前提下为其添加统计运行时间的功能

解决方案一：失败

解决方案二：失败

解决方案三：失败

方案三的优化一：将index的参数写活了

方案三的优化二：在优化一的基础上把被装饰对象写活了，原来只能装饰index

方案三的优化三：将wrapper做的跟被装饰对象一模一样，以假乱真

偷梁换柱：home这个名字指向的wrapper函数的内存地址

语法糖：让你开心的语法

总结无参装饰器模板

偷梁换柱，即将原函数名指向的内存地址偷梁换柱成wrapper函数所以应该将wrapper做的跟原函数一样才行

有参装饰器：三层函数

有参装饰器模板

多个装饰器

公告

搜索

常用链接

最新随笔

我的标签

随笔分类

随笔档案

最新评论