函数高级.pdf

1.有名函数

image.png

断点

image.png
打断点
启动断点 鼠标右键
ctrl +F5 重启程序
ctrl +F2 停止
F9绿色 的三角形是调到下一个断点
F8 蓝色朝下的箭头是单步走
Alt + shift +F7蓝色朝右下角的箭头是进入函数自己定义的函数。
F7蓝色朝右下角的箭头是进入函数
shift+F8 跳出函数
Alt+F9 跳到光标
Alt+F10 光标将定位到当前 正在调试的位置。
Alt + F8 搜索数据

2.匿名函数

image.png
image.png
也就是没有名字的函数 ，除了没有名字外，其他因素都有，
常用于临时使用一次的场景，没有重复使用的需求。
由 lambda 函数引导，一行代码图省事。
语法： lambda +参数+冒号+函数 体代码（表达式或者函数 ）

  1. print((lambda x,y:x+y))
  2. #表达式：
  3. print((lambda x,y:x+y)(2.3,5))
  4. # 函数：
  5. (lambda x,y:print(x+y))(1,2)
  7. 结果：
  8. <function <lambda> at 0x01C456B8>
  9. 7.3
  10. 3

调用内存地址加括号（它虽然没有名字），但加括号可以调用。
image.png

匿名函数的精髓就是省略了名字，简化过程，为其绑定名字没有任何意义

匿名函数与内置函数 结合使用

max，min，sorted
image.png
image.png查字典时，默认返回的值是key值，比较的也是key值。
所以，需要获取字典的value值进行比较，再返回key值。

  1. salaries={'xiaoluo':35025,"xishi":4566,"dafu":5600,'fan':3688,"dahai":30000}
  2. def fun(n):
  3.     return salaries[n]
  4. print(max(salaries,key=fun))
  5. print(max(salaries,key=lambda name:salaries[name]))
  7. 结果：
  8. xiaoluo
  9. xiaoluo

sorted

排序，

  1. nums=[1,15,0,22,546]
  2. res=sorted(nums)
  3. re=sorted(nums,reverse=True)
  4. print(res)
  5. print(re)
  7. 结果：
  8. [0, 1, 15, 22, 546]
  9. [546, 22, 15, 1, 0]

循环遍历薪资
image.png
image.png
image.png

  1. salaries={'xiaoluo':35025,"xishi":4566,"dafu":5600,'fan':3688,"dahai":30000}
  2. for v in salaries.values():
  3.     print(v)
  4.     print(sorted(salaries.values(),reverse=True))
  5.     print(sorted(salaries,key=lambda name:salaries[name],reverse=True))
  7.     结果：
  8.     35025
  9.     4566
  10.     5600
  11.     3688
  12.     30000
  13.     [35025, 30000, 5600, 4566, 3688]
  14. ['xiaoluo', 'dahai', 'dafu', 'xishi', 'fan']

3.递归函数

image.png
函数的递归调用是函数嵌套调用的一种特殊形式，在调用一个函数的过程中又直接或者间接地调用该函数本身，称之为函数 的递归调用

递归循环是没有意义的。
image.png
image.png
递归调用必须有两个明确的阶段：

  1. 回溯：一次次的递归调用下去，这是一个重复的过程，但每一次调用后，重复的规模应当减少，直到逼近一个最终 的结果 。即回溯阶段一定要有一个明确的结束条件。
  2. 递推：往回一层一层地推算出结果。

image.png

3.递归与循环的区别，循环每一次都要判断，需要考虑多少次
而递归只需要确定结束条件就行，按照规律进行重复调用，不需要考虑次数。
递归是函数的定义里面嵌套函数的调用
image.pngimage.pngimage.png

4.闭包函数

闭指的是该函数 是一内部函数
包指的是：该内部的函数名在外部被 引用
image.png

  2. def outer():       #没有调用outer（），但是创造了outer这个函数
  3.     # 1.只检测函数体的语法，不执行函数体的代码。
  4.     print("外部的函数被调用")
  5.     def inner ():
  6.         print("内部的函数被调用")
  7.         #3.返回inner函数的内存地址
  8.         return inner
  9.     # 执行了outer这个函数体代码，inner定义了
  10.     in1=outer()   #得到了里面的inner钥匙，取名字inner,也可以是任意名
  11. in1()

为函数传值的方式：参数

image.png
每次都传入同样的参数时，为函数体传值的方式二：闭包
image.png
image.png

  1. def outer(x,y):
  2.     def func():
  3.         print(x+y)
  4.         return func
  5.     func1=outer(3,2)
  6.     func1()
  7.     func1()
  9.     结果 ：
  10.     5
  11. 5

5.装饰器

image.pngimage.png

1.定义

装饰器是一个特殊的闭包函数，只不过这个函数 不是给自己使用的，而是给其他函数添加功能的

器指的是工具，而程序中的函数就具备某一功能的工具

装饰指的是为被装饰的对象添加额外功能。

2 使用装饰器的目的：

软件的维护应该遵循开放封闭原则

开放封闭原则指的是：

  1. 软件一旦上线运行后对修改源代码是封闭的，对扩展功能是开放的，

这时就用到了装饰器

装饰器的实现必须遵循两大原则 ：

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

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

name='大海'
def run(name):
    print("=========")
    print("我是%s"%name)
    print("=========")
    #定义decorate，检测decorate语法，
    def decorate(func):   #func将要传入的值是run
        def new_func(name):    #也是run（name）中的name
            print("我是装饰函数前面的代码")
            func(name)      #run（name）
            print("我是装饰函数后面的代码")
            return new_func
        # 定义了new_func(name)函数，
        # 返回了new_func的内存地址 ，
        # 传入了一个run函数作为名称

        run=decorate(run)
        run(name)

        结果：
        我是装饰函数前面的代码
        =========
        我是大海
        =========
我是装饰函数后面的代码

def for1(n):
    b = 0
    for i in range(n+1):
        b=b+i
        print(b)

        from datetime import datetime

        def run_time(func):
            def new(n):
                start_time=datetime.now()
                print("开始时间%s"%start_time)
                func(n)
                end_time=datetime.now()
                print("结束时间%s"%end_time)
                time=end_time-start_time
                print("花费时间%s"%time)
                return new
            for1=run_time(for1)
            for1(100000)

            结果：
            开始时间2022-03-28 22:21:51.944271
            5000050000
            结束时间2022-03-28 22:21:51.949258
花费时间0:00:00.004987

装饰器的调用：

被装饰的函数放在装饰器后边，前边@装饰器名称即可使用

from datetime import datetime

def run_time(func):
    def new(n):
        start_time=datetime.now()
        print("开始时间%s"%start_time)
        func(n)
        end_time=datetime.now()
        print("结束时间%s"%end_time)
        time=end_time-start_time
        print("花费时间%s"%time)
        return new

@run_time
def for1(n):
   b = 0
   for i in range(n+1):
      b=b+i
      print(b)
for1(100000)

结果：
     开始时间2022-03-28 22:36:09.874281
            5000050000
            结束时间2022-03-28 22:36:09.879267
花费时间0:00:00.004986

image.pngimage.png

image.png