函数知识点学习

函数：解决代码的冗杂度

实际传递的叫做实参，定义函数中的参数叫做形参

def myfunc(o,vt,s):

        return "".join(s,vt,o)

myfunc('我'，'打了'，'小甲鱼')

'小甲鱼打了我'

函数定义中，位置参数必须在关键词参数前面，而关键字参数不存在先后顺序。用法如下。

myfunc(a,/,b,c)：

        print(a,b,c)

myfunc(a=1,b=2,c=3) //报错，斜杠右边必须是位置参数

myfunc(1,b=2,c=3） //正确。

右边放关键字参数的用法

myfunc(a,*,b,c):    //这里的b和c只能使用关键字参数。

        print(a,b,c)

myfunc(a=1,b=2,c=3) 

红字提示，这个星号其实就是一个匿名的收集参数，后面不加参数名的话会被一起收进去、

收集参数，类似于元组(具有打包和解包的能力)，用法为

def myfunc(*args)//*其实就是实现打包的作用，其中*args就是一个元组。

可以通过连续的星号将myfunc函数打包为字典，用法如下。

myfunc(a,*b,**c):

        print(a,b,c)

myfunc(1,2,3,4,x=5,y=6)

输出的结果为：1，（2，3，4），{x:5，y:6}

*号具有解包的作用，用法如下。

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

        print(a,b,c,d)

//将元组解包为关键字参数

myfunc(*args)

def myfunc(a,b,c,d)

        print(a,b,c,d)

//将字典解包为关键字参数

args= {'a':1,'b':2,'c':3,'d':4}  //使用两个*号解包两次

myfunc(**args)

输出的值为：1 2 3 4

 全局变量与局部变量的使用

x =880

myfunc():

        x = 250  //这里的x是在函数中的局部变量，因此x的值不改变

        print(x)

x=880

myfunc():

        global x =250 //这里的x是定义在函数中的全局变量，因此x的值改变

        print(x)

 嵌套函数的使用

def myfuncA():       

        x=250

        def myfuncB():

                x=550

                print("in funb，x="，x)

        myfuncB()

        print("in funA，x="，x)

利用nonelocal可以修改外部函数中的同名变量值

LEGB法则(leg-b规则)

L-local ，是局部作用域

E-enclosed，是嵌套函数的外层函数作用域，

G-global，是全局作用域，

B-buliding，内置作用域。

将函数作为返回值返回时只需要写出他的名字就行。

闭包的使用

def power(exp):

        def exp_of(base):

                return base ** exp

        return exp_of

square = power(2)

cube = power(3)

square(2) 

cube(2)

输出结果为：4和8

def myfunc():

        print("正在调用myfunc...")

def report(func):

        print("开始调用函数...")

        func()

        print("调用完函数...")

report(func)

输出结果为：

正在调用myfunc...

开始调用函数...

调用完函数...

装饰器的用法1： 

import time 

def time_master(func):

        def call_func();

                print("开始运行程序..")

                start = time.time()

                func()

                stop =time.time()

                print("结束程序运行...")

                print(f"一共耗费了{stop-time:.2f}秒。")

        return call_func

@time_master  //装饰器:相当于语法糖

def myfunc():

        time.sleep(2)

        print("I love fishC.")

myfunc()

注：装饰器原有的样子为：

myfunc = time_master(myfunc)

装饰器用法2：

import time 

def logger(msg):

        def time_master(func):

                def call_func();

                        print("开始运行程序..")

                        start = time.time()

                        func()

                        stop =time.time()

                        print("结束程序运行...")

                        print(f"一共耗费了{stop-time:.2f}秒。")

                return call_func

        return time_master

@logger(msg='A')

def funcA():

        time.sleep(1)

        print("正在调用funA...")

@logger(msg='B')

def funcB():

        time.sleep(1)

        print("正在调用funB...")  

funcA()

funcB()

装饰器的原型为：funcA = logger(msg='A')(funcA)

                             funcB = logger(msg='B')(funcB)

lambda表达式

y=[lambda x:x*x,2,3]

y[0](y[1])

输出结果为4

利用map和filter函数的机制学习lambda

mapped = map(lambda x:ord(x)+10 , "Fishc")

listed(mapped)

输出的结果为：[80,115,125,114,77]

list(filter(lambda x:x%2,range(10))) //x%2==1，即为奇数时才执行filter函数

输出结果为[1,3,5,7,9]

 for语句是从一个可迭代的对象里面依次获取数据。

生成器

利用生成器获得斐波那契数列

def febo():

        back1 ,back2=0,1

        while true:

                yiled back1

                back1,bakc2=back2,back1+back2

f =febo()        

生成器表达式

t=(i**2 for i in range(10))

t是一个生成器

for i in t 

        print(i)

输出为：0-9的平方值

递归

递归的效率比迭代低

汉诺塔递归

def Hanoi(n,x,y,z):

        if n==1:

                print(x,'-->',z)

        else:

                Hanoi(n-1,x,z,y)

                print(x,'-->'z)

                Hanoi(n-1,y,x,z)

函数文档

 def exchange(dollar,rate=6.32):

        """   //字符串内的是函数文档

        功能：汇率转换，美元->人民币

        参数：

        -dollar 美元数量

        -rate 汇率，默认值是6.32(2022-03-08)

        返回值：

        -人名币的数量

        """

        return dollar * rate

类型注释

def times(s:list[int],n:int=3)->list: //红色部分为类型注释，记录形式参数和返回值的类型。

        return s * n

time._name_

times._annotation_ //anonotation表示标注,以字典的形式输出每一个参数的类型

exchange._doc_  //doc表示文档

高阶函数的使用：

import functools 

      result = functools.reduce(lambda y: y *x , range(1,11))

输出的结果为10的阶乘。

偏函数的使用:

import functools

        result = functools.partial(pow，2)  //partial的作用相当于闭包

wrap装饰器是装饰器的装饰器。

wrap的作用是还原函数的真实名字。

import time

import functools

def time_master(func):

        @functools.wrap(func) //作用是使myfunc的真实名字从call_func变为myfunc

        def call_func():

                pass

        return call_func

@time_master 装饰器

def myfunc():

        time.sleep(2)

        print("i love fishc")

myfunc()