精华内容
下载资源
问答
  • (一)函数的定义调用 1、【为什么要创建新的函数】python中已存在了一些内置函数(built-in functions),但当这些内置函数不够用时,需要创建新的函数,以方便调用。 如之前判断输入的号码是不是一个手机号的代码...

    (一)函数的定义和调用

    1、【为什么要创建一个新的函数】

    python中已存在了一些内置函数(built-in functions),但当这些内置函数不够用时,需要创建新的函数,以方便调用。
    如之前判断输入的号码是不是一个手机号的代码:

    number = input("请输入一个电话号码:")  
    if number.isdigit() and len(number) == 11:
        print("这是一个电话号码")
    else:
        print("这不是一个电话号码")
    

    如果以后需要反复用到这部分代码块,总不可能每次都把代码写一遍,而且一个大程序也不可能只有判断电话号码这一个功能,也不能为了这一个功能中断运行。因此,有必要简化代码,方便以后反复调用,让逻辑思维更清晰,及方便维护
    【创建新函数的好处】:
    ①简化代码;
    ②方便以后反复调用;
    ③逻辑思维更清晰;
    ④方便今后程序的维护

    2、【定义函数】

    如上面判断是否手机号的代码,为了方便调用,现定义这部分代码的函数名(function)为num_mobile.

    def num_mobile():   #第一行
        number = input("请输入一个电话号码:")  #第二行
        if number.isdigit() and len(number) == 11:
            print("这是一个电话号码")
        else:
            print("这不是一个电话号码")    
    

    【注意】函数名(此处为num_mobile) 要符合变量的命名规则(详见第一课)
    如何定义一个函数
    定义一个函数有以下简单规则:
    1)函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()。
    2)任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
    3)函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
    4)函数内容以冒号起始,并且缩进。
    5)return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

    3、【调用函数

    函数定义决定了函数如何调用

    上例中,由于定义函数时()内没有参数,而是在函数内部用input方式输入参数,所以调用时括号无参数。

    >>> num_mobile()  #调用上例中的函数num_mobile
    请输入一个电话号码:123456  #这是input要求输入内容
    这不是一个电话号码   #这是函数调用运行的结果
    

    如果上例中第一、二行代码修改如下:

    def num_mobile(number):  #此时上面第二行代码不必要了
        if number.isdigit() and len(number) == 11:
            return '这是一个电话号码' #比较上面print时的不同
        else:
            return '这不是一个电话号码'
    

    则 num_mobile函数的调用方式变为:

    >>> num_mobile("13312312334") #这里括号内必须输入参数
    这是一个电话号码  #运行结果
    

    此时函数num_mobile括号内就必须输入参数number(变量),因为前面def num_mobile(number)定义函数时括号有形参,因此调用时就要输入实际参数(实参)。

    这样以后再需要判断电话号码时,只需要调用 函数num_mobile就可以了,而不需要重复输入代码。

    print和return的区别

    return是关键字,其结果可以赋值给一个变量,有返回值和退出函数的功能;而print是函数没有返回的功能,其打印的结果不可以赋值给变量。
    上例中的代码再修改如下:

    def num_mobile(number):  #此时上面第二行代码不必要了
        if number.isdigit() and len(number) == 11:
            print ('这是一个电话号码') 
        else:
            return '这不是一个电话号码' #比较上面print时的不同,没有括号了
        print ("*******")
    

    调用函数后结果如下:

    
    >>> num_mobile("13312312334")
    这是一个电话号码
    *******     #注意末尾ptint的结果有打印出来。
    >>> b = num_mobile("13312312334")  #把结果赋值给变量b
    这是一个电话号码
    *******    #末尾的print结果也打印出来了,说明print没有结束的功能
    >>> b        #虽然没报错,调用b时,发现没有结果
    >>> print(b)    #用print打印b,显示结果为None。
    None
    

    这是因为上面代码中“这是一个电话号码”是用print输出的。而如下代码中“这不是一个电话号码”是用return输出时,则可调用赋值后的变量a。

    >>> num_mobile("324458")
    '这不是一个电话号码'  #会发现此时,末尾print的结果并没有打印出来,这是因为前面一句用了return语句,return表结束,其后的程序不运行。
    >>> a = num_mobile("324458")
    >>> a   #调用a时,会出现结果
    '这不是一个电话号码'
    

    与前面b变量的结果相比较,此时会发现,末尾print的结果“*******”并没有打印出来,这是因为其前面一句用了return语句,return执行后有结束作用,同一代码块其后的代码就不会运行了,而print则没有这一功能。

    4【type查看类型,函数赋值变量】

    如上,num_mobile是函数名,num_mobile()是调用函数。可以通过type查看其类型:如下

    >>> type(num_mobile),type(num_mobile("324458")) #逗号在 Python 中不是运算符,而是表达式之间的分隔符。
    (<class 'function'>, <class 'str'>)
    >>> type(num_mobile("324458"))  #type查看类型
    <class 'str'>  #这里显示的是调用函数后return返回的结果(字符串)
    >>> type(num_mobile)
    <class 'function'>  #不带括号,其类型是函数名
    

    函数也可赋值给一个变量,这个变量也具有该函数的功能,也能被调用。如下:

    >>> num_mobile    #直接运行函数名,结果是函数名所在的地址
    <function num_mobile at 0x0000026CE3C68670>
    >>> x = num_mobile  #将函数赋值给一个变量x
    >>> x("1234abbd")   #变量x也能如函数num_mobile一样调用
    '这不是一个电话号码'
    

    (二)函数参数

    1、参数类型

    argument – 参数。在调用函数时传给 function (或 method )的值。默认情况下,参数值和参数名称是按函数声明中定义的顺序匹配起来的。
    【函数参数的四种类型】调用函数时可使用的正式参数类型:
    ①必备参数:须以正确的顺序传入函数。调用时的数量必须和定义时的一样。
    ②默认参数:调用函数时,默认参数的值如果没有传入,则被认为是默认值
    ③不定长参数:主要有元组和字典两种形式。不传入时默认是空元组和空字典。

    函数参数列表中的 和 ** 说明符收集参数;这会将位置参数作为元组,将关键字参数作为字典。然后,您可以使用 * 和 ** 调用另一个函数时传递这些参数:
    加了星号(
    )的变量名会存放所有未命名的变量参数

    ④关键字参数:函数调用使用关键字参数赋予传入的值(如x=“haha”)。使用关键字参数允许函数调用时参数的顺序与声明时不一致

    2、传入参数

    在这里插入图片描述
    如下:

    def f1(x, y=10, *args, **kwargs) -> None:
        print(x)  # x 是必须要传入的内容 必备参数
        print(y)  # y 是默认参数,有默认值 可传可不传
        print(args)  # *args 不定长参数元组 超过的单个元素都会被元组接受
        print(kwargs)  # **kwargs  不定长参数字典  键值对的形式传入 只能放在最后的位置
    

    【注】-> None 这个语法表示函数的返回值是什么类型。在调用help查看时可以看到。通常在看python源码会看到。

    运行后调用函数f1,当只输入必备参数时,结果如下:

    >>> f1("haha")  #只输入了必备参数x
    haha
    10    #这是默认参数,当缺失时,输出f1定义时的默认值为10
    ()   #不定长参数。默认时输出空元组
    {}   #不定长参数。默认时输出字典
    

    可以给默认参数重新赋值,并对x进行关键字参数传入数据,如下代码:

    >>> f1(x = 20, 'a', 30, 40, 50, 60, a=1, b=2, c=3, d=4, e=5)
    20   #必备参数x传入的值
    a    #默认参数y传入的值,此处不再是默认值10
    (30, 40, 50, 60)  #多出的参数自动将键值对前面的接收为元组。
    {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5} 
    

    形参 是指出现在函数定义中的名称,而 实参 则是在调用函数时实际传入的值。 形参定义了一个函数能接受何种类型的实参。如上面的x、y、*args、**kwargs就是形参,而20、“a”等就是实参。

    【拆包】

    类似于元组的拆包,在传入时也可通过解包来传入参数。
    有现成的元组、字典如何传入函数呢?在这里插入图片描述

    3、参数传递的类型:可变mutable对象和不可变immutable对象

    【不可变对象】如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。
    【可变对象】如 列表,字典。变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了

    (三)函数作用域 global和nonlocal

    1、两种最基本的变量作用域

    一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

    变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下:
    全局变量
    局部变量:
    定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。
    局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中

    2、global和nonlocal

    global ——是全局变量申明,声明之后可以在全局使用(当前py文件中),此时要注意,函数内外名字要一致,否则就是一个新变量。
    nonlocal——局部作用域。如果是嵌套的函数,则不能使用global,而需要使用nonlocal关键字。出现的情况比较少

    variable = [1, 2, 3]
    def f2(var):
       var = var + ['a'] # var 在函数内部,函数外部是不可以使用的,局部变量
        return var
    

    运行后,var在函数内部,调用时会报错,而函数外部的变量variable是不可变对象,其值没有改变。运行结果如下:
    在这里插入图片描述
    如果想要在函数内部改变外面不可变对象变量的话,则需要在函数内部使用用global关键字。
    global ——是全局变量申明,声明之后可以在全局使用(当前py文件中),此时要注意,函数内外名字要一致,否则就是一个新变量。如下代码

    var = [1, 2, 3]
    def f2():
        global var  # global全局,申明var为全局变量
        var = var + ['a'] 
        return var
    

    使用了global申明后,var的值与当初赋值时的值有区别,被改变了:
    在这里插入图片描述
    nonlocal——局部作用域。如果是嵌套的函数,则不能使用global,而需要使用nonlocal关键字。出现的情况比较少

    def f4():
        var1 = 10
        def f5():
            nonlocal var1  #
            var1 += 1
            print("***", var1)
            return var1  # 这个是f5的return,和f4没有关系
        f5()
        print("f4 is var1:", var1)
        return var1  # 这个print是f4的return 和 f5没关系
    

    运行后,var1的值被改变了(原来赋值为10):
    在这里插入图片描述
    而下面的代码中仅是调用var1而不改变其值,则不需要用到nonlocal。

    ef f4():
        var1 = 10
        def f5():
            a = 5
            print("***", var1 + a)
            return var1 + a  # 这个是f5的return,和f4没有关系
        f5()  #归f4管
        print("f4 is var1:", var1)
        return var1  # 这个print是f4的return 和 f5没关系
    

    在这里插入图片描述

    【闭包】

    def f4():
        var1 = 10
        def f5():
            a = 5
            print("***", var1 + a)
            return var1 + a  # 这个是f5的return,和f4没有关系
        return f5()  # f5 ->return var1 + a
    

    在这里插入图片描述
    将上例函数稍微修改,将f4的返回值改为函数f5,调用f4之后的变量值,可以再次调用。这种把内部函数(f5)和外部变量(var1)都称为闭包。

    def f4():
        var1 = 10
        def f5():
            a = 5
            print("***", var1 + a)
            return var1 + a  
        return f5  # 此处表示返回函数f5,注意去掉了原来f5()中的括号
    

    正常情况下,f5因为在函数内部是不能调用的。调用后会报错在这里插入图片描述
    但如上代码,当把f4的return返回值为f5这个函数后(而不是f5()),将f4的结果赋值给一个变量后,就可以调用了。
    在这里插入图片描述
    【闭包的作用】可以在外部修改函数内部的变量值,是函数内部与外界沟通的桥梁。

    def f4():
        var1 = 10
        def f5(x):   #括号输入了必备参数
            print("***", var1 + x)
            return var1 + x  
        return f5  # 此处去掉了原来f5()中的括号()
    

    在这里插入图片描述
    闭包的运用

    (四)递归函数和匿名函数lambda

    1、递归函数

    :简单来说就是函数内部调用自己,和while循环类似,也需要一个结束条件,否则超出递归深度就会报错。
    求一个阶乘:
    在这里插入图片描述

    2、匿名函数

    使用 lambda 来创建匿名函数。主要用来定义那种不是特别复杂的函数,常用于函数的参数中。

    lambda函数的语法只包含一个语句:
    lambda [arg1 [,arg2,…argn]]:expression

    举例如下:
    在这里插入图片描述

    li = [2, 'ab', 1, 'bb', '9', 5]
    li.sort(key = lambda x: str(x)[0]) #[0]可要可不要,结果都一样
    

    在这里插入图片描述
    在上例中,key是可以接受函数的,所以可直接写成匿名函数

    总结

    掌握函数的定义和调用及其返回值;
    函数参数的各种类型和调用
    掌握函数作用域的规则和改变方法
    了解递归函数的作用和使用
    掌握匿名函数的作用和使用

    day06 05函数作业


    1、一个列表由四个元组组成,每个元组都是四个数字组成,现在要求对这个列表排序,排序规则是按照每个元组的第二个元素排序
    2、实现isPrime()函数,参数是整数,如果整数是质数,返回True,否则返回False
    3、定义一个函数,输入字符串,如果字符串是顺序的则返回‘UP’,如果是倒叙的则返回‘DOWN’, 如果是乱序的则返回False

    *4、利用递归函数,实现一个阶乘函数,支持正数和负数的阶乘

    后面再专门整理作业的笔记。

    说明:
    这个markdown编辑器不太会用,原来写笔记的地方发现写代码和插入图片有点费劲,还是这里好用点!

    01~04课的笔记链接,最好用电脑看,手机看的话好像格式 有点不一样:

    学习python第1课,01基本概念和基本数据类型
    学习python第2课,条件语句、while循环笔记整理
    学习python第3课:循环语句、列表元组笔记
    学习python第4课:字符串和散列类型(字典dict、集合set)

    展开全文
  • 函数定义 1.定义式 function print(){ return '1111'; } console.log(print());//先定义调用 可以先调用定义 console.log(print()); function print(){ return '1111'; } //先调用定义 2.变量式 ...

    函数定义

    1.定义式     

    function print(){
        return '1111';
    }
    console.log(print());//先定义再调用

     可以先调用再定义   

    console.log(print());
    function print(){
        return '1111';
    }                   //先调用再定义

    2.变量式

    必须先定义再使用                    

    var doHomework = function(){
    
        console.log("测试");
    
    }
    
    doHomework();

    注:函数参数列表和返回值

    1.函数参数列表:JavaScript中函数参数列表中的参数不允许有数据类型或var关键字修饰;参数之间用逗号分割;

    function study(var name){            //报错
    
        console.log(name);
    
    }
    
    study("mm");

    2.js参数列表可以不一致,可多可少,传入参数按顺序赋值                    

    function study(name,mobile){
    
        console.log(name);
    
    }
    
    study("mm");

    3.函数返回值:

           JavaScript函数没有定义函数的返回值类型部分,JavaScript函数根据函数体中return返回值语句来判断返回值类型;若不存在return返回值语句,则函数无返回值。

     

    4. 函数内部声明变量时,如果忽略var关键字,则该变量为全局变量  

    function print(){
    
        age = 12;
    
        console.log("函数内部:"+age);
    
    }
    
    print();
    
    console.log("函数外部:"+age);     //如果print函数内age变量使用var关键字,则该行代码出错。

     

    3.匿名函数

    (function(i){
    
        console.log(i);
    
    })(2);

     

    展开全文
  • 函数可以一次定义,多次调用函数的声明 JavaScript 有三种声明函数的方法。 (1)function 命令 function是一个关键字,和var、typeof一样,都是关键字,后面要加空格。 函数名字的命名规定,和变量的...

    JS函数概述

    函数,是一种封装;就是将一些语句,封装到函数里面;通过调用的形式,执行这些语句;函数可以一次定义,多次调用,这样就可以实现大量代码的重复使用。

    函数的声明

    JavaScript 有三种声明函数的方法:

    通过 function 命令

    function 是一个关键字,和 var、typeof 一样,都是关键字,后面要加空格,函数名就在空格后定义,函数名字的命名规定和变量的命名规定一样。只能是字母、数字、下划线、美元符号的组合,不能以数字开头。

    后面有一对儿空的小括号,里面是放参数用的,需要参数时在里面添加即可,多个参数要用英文逗号 , 隔开。大括号里面,是这个函数的语句。

    function functionName([参数1][,参数2][,参数N]){
    	函数的功能代码;
    	[return 参数r]
    }
    

    说明:

    • function 关键字是必须的,全小写。

    • functionName 函数的名称。函数名的命名规则与变量命名一样。

    • () 是定义函数时接收数据用的参数。是否定义参数根据实际情况而定,多个参数之间用逗号隔开。

    • {} 存放函数实现某种功能的代码块。

    • [参数1][,参数2][,参数N] 可选的参数,根据实际情况来决定是否添加,这里的参数就是形参用于接收调用函数时传过来的数据,使用方式与变量相同(添加了形参就相当于定义了变量)

    • [return 参数r] 可选的语句,一般放在函数代码块的最后,可用于立即结束函数的运行(就像break语句,可以立即结束循环),也可设置向函数调用者返回的值;如果返回值不写,函数返回的结果就是 undefined;使用时将需要返回的内容通过空格追加在 return 后面即可,需要注意的是 return 只能返回单一内容,就是只能返回一个变量或值

    形参(形式参数):
    • 定义函数时的参数就是"形参";主要用来接收调用函数者传过来的数据。

    • 形参的名称,与变量的命名规则一样;但形参不能用 “var” 关键字定义。

    • 参数只能存在于函数中。

    • 参数不需要声明,直接使用。

    示例:

    //定义函数,设置形参(用于接收传入的数据)
    function getSum(x,y) {
    	var sum = x+y; // 功能代码
    	return sum; // 结束函数,返回结果
    }
    
    var num = getSum(2,3); //调用函数,传入实参,得到返回结果,赋值给 num
    coonsole.log(num); // 5
    
    实参(实际参数):

    调用函数时的参数称为"实参"。实参就是真正的数据。

    函数的调用:

    • 函数定义是不会执行的,那么,函数必须调用,才会有效果。
    • 调用方法就是 直接写函数名后跟小括号(),如果有参数则写参数。
    • 小括号不能省略;如果省略小括号返回的是函数本身。
    参数存在的作用 :

    在一些函数的内部某些值不能固定,就需要在调用函数时通过参数传入不同的值。

    一般函数中的形参与调用时的实参个数保持一致,参数会逐个顺次对应匹配;JS 属于弱类型语言,在 JS 中函数的形参与调用时传的形参的数量可以不一致

    参数个数 说明
    实参个数等于形参个数 一 一对应匹配
    实参个数小于形参个数 未匹配的形参值为 undefined
    实参个数大于形参个数 形参对应匹配后,剩余的实参不再进行匹配

    形参的个数可以和实参个数不匹配,但是结果不可预计,所以在使用参数时:

    • 形参的个数,要与实参的个数一致;

    • 形参的顺序,要与实参的顺序一致;因为传入的数据的数据类型可能不一样。

    通过函数表达式(变量赋值)

    可以通过变量赋值的方式,将一个匿名函数(匿名函数就是没有函数名的函数)赋值给变量。这个匿名函数又称函数表达式。

    var fun = function([参数1][,参数2][,参数N]){
    	函数的功能代码;
    	[return 参数r]
    };
    

    调用该函数:

    fun(); // 与普通函数的调用一样,只需要将函数名改成变量名即可。
    

    示例:

    var fun = function(){
    	console.log('我是函数'); // 我是函数
    };
    
    fun();
    
    匿名函数:

    所谓的匿名函数就是没有设置函数名的函数

    function(){
    	console.log('我是匿名函数');
    }
    

    匿名函数的执行:

    小括号将匿名函数括起来,然后在匿名函数后面加上一个括号即可立即执行。

    如:

    (function(){
    	console.log('我是匿名函数');
    })()
    
    通过 Function() 构造函数

    函数也可以通过Function()构造函数来定义( Function() 构造函数并不常用)。

    	var www = Function("x","y","var num = x*y;return num;");
    	console.log(www(2,3)); // 6
    

    等价于:

    function www(x,y){
    	var num = x*y;
    	return num;
    }
    console.log(www(2,3)); // 6
    

    说明:

    Function() 构造函数可以传入任意数量的字符串参数,最后一个参数所表示的文本是函数体;它可以包含任意的Javascript 语句,每条语句之间用分号分割。传入构造函数的其他所有的参数字符串是指定函数的名字的字符串。如果定义的函数不包含任何参数,只需给构造函数简单地传入 一个字符串函数体即可。

    注意:

    Function() 构造函数允许JavaScript在运行时动态的创建并编译函数。

    每次调用 Function() 构造函数都会解析函数体,并创建新的函数对象。如果是在一个循环或者多次调用的函数中执行这个构造函数,执行效率会降低。相比之下,循环中的嵌套函数和函数定义表达式则不会每次执行时都重新编译。

    Function() 构造函数非常重要的一点,它所创建的函数并不使用词法作用域,函数体代码的编译总是会在顶层函数执行。

    扩展: 函数的定义可以整个代码中的任意位置,在整个代码执行时会优先将定义的函数加载到内存中(就像变量的提升)

    // 调用函数
    func();
    
    // 定义函数
    function func() {
    	console.log('调用了该函数!')
    }
    

    全局变量和局部变量

    全局变量:

    • 可以在网页的任何地方(函数内部和函数外部)使用的变量,就是"全局变量"。
    • 在函数外部定义的变量,就是"全局变量"。
    • 在函数内部,省略关键字var定义的变量是"全局变量"。
    • "全局变量"既可以在函数外使用,也可以在函数内部使用。
    • "全局变量"在网页关闭时,自动消失(释放空间)。

    局部变量:

    • 只能在函数内部使用的变量,称为"局部变量"。
    • "局部变量"在函数内部定义,在函数内部使用。
    • "局部变量"在函数外部无法访问。
    • "局部变量"在函数执行完毕就消失了,所以局部变量更节省内存空间,函数中的形参就是局部变量。

    注意: var 关键字尽量别省略,省略后"全局变量"和"局部变量"会搞不清楚;全局变量与局部变量不可同名。

    展开全文
  • 匿名函数前言上次咱们基本说了一下函数的定义及简单使用,Python中的基本函数及其常用用法简析,现在咱们整点进阶一些的。同样都是小白,咱也不知道实际需要不,但是对于函数的执行顺序以及装饰器的理解还是很有必要...

    匿名函数

    前言

    上次咱们基本说了一下函数的定义及简单使用,Python中的基本函数及其常用用法简析,现在咱们整点进阶一些的。同样都是小白,咱也不知道实际需要不,但是对于函数的执行顺序以及装饰器的理解还是很有必要的。

        首先咱们先简单复习一下:

    函数的定义:

    def 函数名字(参数):  具体的函数语句块  return [需要返回的数据]

    函数的执行:

    # 函数只有被调用的时候才执行,函数可以执行多次函数名称()

    局部与全局变量:

        不同的函数有不同的作用域

    def test1():    name = 'XXX'    print(name)def test2():    name = 'YYY'    print(name)test1()test2()
    局部想使用全局变量 使用global 变量名局部与全局变量同名仍要同时使用全局变量局部变量 globals()['变量名']

        还有一种情况就是函数内嵌套了函数想使用上次层函数的变量。

    def test1():   name = 'XXX'   def test2():       # 使用上一层的变量并打印查看       nonlocal name       print(name)   # 在函数test1中调用执行test2   test2()test1()# 直接调用test2会抛出异常test2 未定义# test2()

    2993f88560ca7c486b3ed459a755b3b3.png

        因为箭头那里有空格,Python也是根据这种格式来判断作用域的,只能像红色框那样在同一级的地方调用。

    一个函数内返回另一个函数:

    def test1():   print("in the test1")def test2():   print("in the test2")   return test1()test2()

    想把上面的这段代码解释清楚,咱们插播一个递归。

    递归的特性:

    • 递归就是自己调用自己

    • 必须有个明确的结束条件,不然会导致栈溢出

    • 每次递归问题都有所减少

    • 递归效率不高,但是有时候真的好用

    来个最经典的斐波拉契数组。

    # 斐波拉契数组长这样:1,1,2,3,5,8,13,21,34,55...def fabonacci(n):   # 结束条件   if n <= 2:       # 因为前两个数字都是1,所以当n小于等于2时返回1       v = 1       return v   # 大于2的话就自己调用自己,斐波拉契第n个数字等于n-1的数字+n-2数字的和   v = fabonacci(n-1)+fabonacci(n-2)   return vprint(fabonacci(6))

    dc24a3ecf2d412f1e86a224157fe6c79.png

    import sys# 打印当前递归深度,默认为1000print(sys.getrecursionlimit())# 设置最大递归深度sys.setrecursionlimit(999999999)print(sys.getrecursionlimit())

        其实就是表达函数内调用另一个函数,会等待另一个函数执行完毕,该函数再执行到结束...感觉递归讲不讲都一样了...so,咱们还是赶紧回到正题,代码的执行顺序是这样子的....

    f7052d3695687a49e069c462dfc0f0fd.png

    当然还能这么玩:

    def test1():   print("in the test1")def test2():   print("in the test2")   # 此处返回test1的内存地址   return test1test2()()# 先执行test2(),返回test1的内存地址# 加上小括号执行test1

    匿名函数

    1. 使用lambda 创建

    2. 简单来说匿名函数就是一个没有名字的简单函数

    3. 匿名函数只有一个表达式,return 表达式计算的值

        创建一个简单的匿名函数,命令如下所示。

    格式       lambda 参数列表:表达式
    lambda num1, num2: num1+num2

        使用一个变量接收一下,就是保存的内存地址,加上小括号传入参数就能运行了。

    func = lambda num1, num2: num1+num2print(func(1, 2))

        我使用的编辑器是VS Code ,发现了一个问题,格式化代码的时候把匿名函数改成了函数...具体原因及细节未知。

    格式化前:

    40a034475794b90ff19f10fc4f9302c2.png

    格式化后:

    20b48dd3107e8d9d735dc22019b77ac7.png

    map 映射(循环让每一个函数执行函数,结果保存到新的列表)

    map(匿名函数,可迭代对象)

    map()处理序列中的每个元素,得到的结果是一个可迭代对象,该对象个数和位置与原来一样。

    li = [1, 5, 3, 2, 3]res = map(lambda x: x+1, li)print(type(res))# 返回的map对象print(list(res))

    filter 判断

    filter()遍历序列中的每个元素,得到的结果是True则留下来。

    people = ['sb_laowang', 'sb_xiaozhang', 'sb_laozhang', 'xiaoliu']# 将满足以帅比开头的保存为新的对象res = filter(lambda x: x.startswith('sb'), people)print(type(res))print(list(res))

    reduce:将序列进行合并操作

    from functools import reducenum_li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]str_li = list('hello')res_num = reduce(lambda x, y: x+y, num_li)res_str = reduce(lambda x, y: x+y, str_li)print(str_li)print(type(res_num), res_num)print(type(res_str), res_str)

        第一次运行的时候x,y是可迭代对象的前两个,后面x都是之前的累加,y则是没有进行累加的第一个,说一下reduce(lambda x, y: x+y, num_li)这个吧,可以打个断点看一下。

    第一次x = 1 , y = 2第二次x = 3 , y = 3第三次x = 6 , y = 4第四次x = 10 , y = 5...
    匿名函数的好处:
    • 简化代码

    • 没有名字,避免函数名字冲突

    查看某个模块的所有方法:
    # print(dir(模块名字))# 例如:import timeprint(dir(time))print(dir(list))

    提取数据结构:

    # 可能有这种需求,一个人给你个文件,读取出来是文本,或者是需要计算的公式,但是他是字符串# 假如是个字典格式的 {'name':'sb'},但是他是个文本temp1 = "{'name':'sb'}"print(temp1,type(temp1))temp2 = eval(temp1)print(temp2, type(temp2))temp3 = "1+2"print(eval(temp3))# 注意只能提取出来格式与要提取的格式一样的文本

    总结:

    本文基于Python,主要讲解了递归思想和匿名函数相关知识,例举了几个常用的匿名函数及其基本用法,如lambda、map、reduce、filter等,并简述了匿名函数的优点。关于匿名函数,还有以下一点需要注意。

    匿名函数书写简单,适用于仅有一个简单表达式的函数,并且避免了函数名字冲突的问题,两个函数名字冲突下面函数会覆盖上面函数的功能,如:

    def func():   print('aaa')def func():   print('bbb')func()

    1aa69f22c04bd678c455c37d37e44394.png

    1aa69f22c04bd678c455c37d37e44394.png

    1dd3ea6a10a608270cd5e76b0e5e700b.png

    但是编辑器能检测出两个同名的函数,有一个编辑异常,虽然能正常运行,但是显然不符合代码开发规范。匿名函数没有名字肯定不会出现函数名字重复。

    End

    22c69896124e3143c3989465cb0de251.png

    8fddbae30228794a3d36d60c34de0649.png
    展开全文
  • javascript学习之函数的定义方式及调用 (一)函数的定义 1、自定义函数(命名函数) 定义格式如下: function 函数名 (参数1,参数2,...) { 函数体 }; 2、函数表达式(匿名函数) 定义格式如下: var 变量名 = ...
  • JS之匿名函数

    2017-10-09 21:31:36
    匿名函数的定义及调用
  • 函数需要传出几个重要的数据(就是调用函数的人希望得到的数据),这些数据应该被定义成返回值。 函数的内部实现过程。 2.函数的创建和调用 3.变量作用域 4.函数参数传递 5.匿名函数 6.递归函数 ...
  • 代码示例如下: ==============================================       ... 函数的定义:  1.采用关键字function来定义  2.采用匿名函数的方式(采用function作为名字)  3.(了解) 采用n
  • Python中的lambda表达式及匿名函数的使用1.lambda表达式的使用(1)常规函数定义:def ds(x):return 2 * x + 1ds(5)11(2)lambda表达式定义:g = lambda x : 2 * x + 1g(5)11由此可见,使用lambda表达式可以省去定义...
  • Go 匿名函数的概念应用

    千次阅读 2020-06-28 20:29:13
    匿名函数 匿名函数基本概念 Go 支持匿名函数,... 求两个数的和, 使用匿名函数的方式完成 res1 := func (n1 int, n2 int) int { return n1 + n2 }(10, 20) 匿名函数使用方式 2 将匿名函数赋给一个变量.
  • js中定义函数的方式有很多种,函数直接量就是其中一种,下面通过本文给大家介绍匿名函数是如何调用及匿名函数的n中写法,对js匿名函数调用,js匿名函数写法相关知识感兴趣的朋友一起学习吧
  • 文章目录一、函数的递归调用(一)什么是函数的递归调用(二)递归的两个阶段1.回溯:2.递归:(三)递归的应用:二分法二、三元表达式(一)什么是三元表达式(二)如何使用三元表达式三、匿名函数(一)什么是匿名...
  • 语法lambda [arg1 [,arg2,.....argn]]:expression如何使用我们正常定义一个函数时是这样def add(a,b):return a+b使用lambda定义匿名函数是这样add = lambda a,b:a+b # 和上面函数功能一样按正常的调用方式即可。...
  • 前言:上次咱们基本说了一下函数的定义及简单使用,想要了解的伙伴可以去看看。Cc大战桃花怪:Python中最基本的函数及其常用用法简析(新手必备)小本本记起来​zhuanlan.zhihu.com现在咱们整点进阶一些的。同样都是...
  • 函数的定义调用 函数的定义方式 自定义函数 (命名函数) function fn() {}; 函数表达式 (匿名函数) var fun = function() {}; 利用 new Function(‘参数1’,‘参数2’,‘函数体’) var f = new Function('a', ...
  • 2、匿名函数 =》将函数当做一个变量 var add = function(paramerer_list){ democode; }; add(5,6); 3、使用js中内置对象,Function var add = new Function(“参数列表”, “方法体返回值”); js函数调用方法
  • 匿名函数及匿名函数的调用 : js 中定义函数的方式有多种,函数直接量就是其中一种。如var fun = function(){}, 这里function 如果不赋值给fun 那么它就是一个匿名函数。 好,看看匿名函数的如何被调用...
  • 匿名函数优点运用

    2018-11-03 10:46:32
    匿名函数:就是定义时未直接指定名称的函数 因为非匿名函数在定义时,就已经创建函数对象和...匿名函数的应用 回调函数:将一个函数作为另一个函数的参数叫做回调函数 function fn(num1,num2){ console.log...
  • 匿名函数 当我们在传入函数时,有些时候不...匿名函数也是一个函数对象,可以把匿名函数赋值给一个变量,再利用变量来调用该函数; 可以把匿名函数作为返回值返回 匿名函数定义规则: lambda 形参:返回值 eg: ...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 344
精华内容 137
关键字:

匿名函数的定义及调用