Python函数

作者: 网络编程  发布:2019-09-03

Python函数

二零一四-9-8相逢的标题计算:

Python函数

函数是组织好的,可重复使用的,用来兑现单一,或相关联效率的代码段。

函数能加强利用的模块性,和代码的再一次利用率。你早就了然Python提供了众多内建函数,比方print()。但您也能够自个儿创建函数,那被堪当客户自定义函数。


华语展现乱码建设方案:在源代码顶上部分增添以投注释

概念一个函数

你能够定义叁个由本身想要成效的函数,以下是粗略的条条框框:

  • 函数代码块以def关键词初步,后接函数标记符名称和圆括号()。
  • 其余传入参数和自变量必得放在圆括号中间。圆括号之间能够用于定义参数。
  • 函数的率先行语句能够采纳性地应用文书档案字符串—用于贮存函数表明。
  • 函数内容以冒号发轫,並且缩进。
  • Return[expression]竣事函数,选择性地回去八个值给调用方。不带表明式的return也就是重返None。


    ### 语法

    def functionname( parameters ):
       "函数_文档字符串"
       function_suite
       return [expression]
    

    暗许情况下,参数值和参数名称是按函数注解中定义的的一一匹配起来的。

    ### 实例

    以下为二个轻松的Python函数,它将四个字符串作为传播参数,再打字与印刷到标准展现设备上。

    def printme( str ):
       "打印传入的字符串到标准显示设备上"
       print str
       return
    

    函数调用

    概念三个函数只给了函数二个称号,钦赐了函数里带有的参数,和代码块结构。

    本条函数的基本构造完毕未来,你能够通过另三个函数调用推行,也足以一向从Python提醒符施行。

    正如实例调用了printme()函数:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    # 定义函数
    def printme( str ):
       "打印任何传入的字符串"
       print str;
       return;
    
    # 调用函数
    printme("我要调用用户自定义函数!");
    printme("再次调用同一函数");
    

    如上实例输出结果:

    我要调用用户自定义函数!
    再次调用同一函数
    

    按值传递参数和按引用传递参数

    全数参数(自变量)在Python里都以按援用传递。假如您在函数里修改了参数,那么在调用那个函数的函数里,原始的参数也被转移了。比如:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    # 可写函数说明
    def changeme( mylist ):
       "修改传入的列表"
       mylist.append([1,2,3,4]);
       print "函数内取值: ", mylist
       return
    
    # 调用changeme函数
    mylist = [10,20,30];
    changeme( mylist );
    print "函数外取值: ", mylist
    

    盛传函数的和在终极增加新剧情的对象用的是同一个引用。故输出结果如下:

    函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
    函数外取值:  [10, 20, 30, [1, 2, 3, 4]]
    

    参数

    以下是调用函数时可使用的正式参数类型:

    • 须求参数
    • 取名参数
    • 缺省参数
    • 不定长参数

      ### 必备参数

      供给参数须以正确的各类传入函数。调用时的数码必需和注明时的一律。

      调用printme()函数,你无法不传入几个参数,不然会油不过生语法错误:

      #!/usr/bin/python
      # -*- coding: UTF-8 -*-
      
      #可写函数说明
      def printme( str ):
         "打印任何传入的字符串"
         print str;
         return;
      
      #调用printme函数
      printme();
      

      如上实例输出结果:

      Traceback (most recent call last):
        File "test.py", line 11, in 
          printme();
      TypeError: printme() takes exactly 1 argument (0 given)
      

      ### 命名参数

      取名参数和函数调用关系密不可分,调用方用参数的命名分明传入的参数值。你能够跳过不传的参数或许乱序传参,因为Python解释器能够用参数名相配参数值。用命名参数调用printme()函数:

      #!/usr/bin/python
      # -*- coding: UTF-8 -*-
      
      #可写函数说明
      def printme( str ):
         "打印任何传入的字符串"
         print str;
         return;
      
      #调用printme函数
      printme( str = "My string");
      

      以上实例输出结果:

      My string
      

      下例能将命名参数顺序不主要浮现得更驾驭:

      #!/usr/bin/python
      # -*- coding: UTF-8 -*-
      
      #可写函数说明
      def printinfo( name, age ):
         "打印任何传入的字符串"
         print "Name: ", name;
         print "Age ", age;
         return;
      
      #调用printinfo函数
      printinfo( age=50, name="miki" );
      

      以上实例输出结果:

      Name:  miki
      Age  50
      

      ### 缺省参数

      调用函数时,缺省参数的值若无传到,则被感到是暗中同意值。下例会打字与印刷私下认可的age,要是age未有被传出:

      #!/usr/bin/python
      # -*- coding: UTF-8 -*-
      
      #可写函数说明
      def printinfo( name, age = 35 ):
         "打印任何传入的字符串"
         print "Name: ", name;
         print "Age ", age;
         return;
      
      #调用printinfo函数
      printinfo( age=50, name="miki" );
      printinfo( name="miki" );
      

      上述实例输出结果:

      Name:  miki
      Age  50
      Name:  miki
      Age  35
      

      ### 不定长参数

      您只怕要求贰个函数能管理比那时声称时越多的参数。那个参数叫做不定长参数,和上述2种参数分歧,表明时不会取名。基本语法如下:

      def functionname([formal_args,] *var_args_tuple ):
         "函数_文档字符串"
         function_suite
         return [expression]
      

      加了星号(*)的变量名会存放全体未命名的变量参数。选用十分少传参数也可。如下实例:

      #!/usr/bin/python
      # -*- coding: UTF-8 -*-
      
      # 可写函数说明
      def printinfo( arg1, *vartuple ):
         "打印任何传入的参数"
         print "输出: "
         print arg1
         for var in vartuple:
            print var
         return;
      
      # 调用printinfo 函数
      printinfo( 10 );
      printinfo( 70, 60, 50 );
      

      如上实例输出结果:

      输出:
      10
      输出:
      70
      60
      50
      

      佚名函数

      python 使用 lambda 来成立佚名函数。

      • lambda只是贰个表明式,函数体比def简单相当多。
      • lambda的着入眼是八个表明式,并不是二个代码块。仅仅能在lambda表明式中封装有限的逻辑进去。
      • lambda函数具备本人的名字空间,且不能访谈自有参数列表之外或全局名字空间里的参数。
      • 虽说lambda函数看起来只能写一行,却不平等C或C++的内联函数,前者的目标是调用小函数时不占用栈内部存款和储蓄器进而扩充运维成效。

        ### 语法

        lambda函数的语法只包罗多个言辞,如下:

        lambda [arg1 [,arg2,.....argn]]:expression
        

        如下实例:

        #!/usr/bin/python
        # -*- coding: UTF-8 -*-
        
        # 可写函数说明
        sum = lambda arg1, arg2: arg1 + arg2;
        
        # 调用sum函数
        print "相加后的值为 : ", sum( 10, 20 )
        print "相加后的值为 : ", sum( 20, 20 )
        

        如上实例输出结果:

        相加后的值为 :  30
        相加后的值为 :  40
        

        return语句

        return语句[表达式]剥离函数,采用性地向调用方再次回到一个表明式。不带参数值的return语句重临None。在此以前的例子都不曾身体力行怎么回到数值,下例便报告您怎么办:

        #!/usr/bin/python
        # -*- coding: UTF-8 -*-
        
        # 可写函数说明
        def sum( arg1, arg2 ):
           # 返回2个参数的和."
           total = arg1 + arg2
           print "函数内 : ", total
           return total;
        
        # 调用sum函数
        total = sum( 10, 20 );
        print "函数外 : ", total 
        

        上述实例输出结果:

        函数内 :  30
        函数外 :  30
        

        变量成效域

        叁个程序的具有的变量实际不是在哪些岗位都得以访谈的。访谈权限决定于那个变量是在哪个地方赋值的。

        变量的功用域决定了在哪部分前后相继你能够访谈哪个特定的变量名称。两种最基本的变量功效域如下:

         

        • 全局变量
        • 某个变量


          变量和一部分变量

          概念在函数内部的变量具备多少个有些成效域,定义在函数外的富有全局效能域。

          一部分变量只可以在其被声称的函数内部访问,而全局变量能够在方方面面程序范围内访谈。调用函数时,全数在函数内注解的变量名称都将被到场到效能域中。如下实例:

          #!/usr/bin/python
          # -*- coding: UTF-8 -*-
          
          total = 0; # 这是一个全局变量
          # 可写函数说明
          def sum( arg1, arg2 ):
             #返回2个参数的和."
             total = arg1 + arg2; # total在这里是局部变量.
             print "函数内是局部变量 : ", total
             return total;
          
          #调用sum函数
          sum( 10, 20 );
          print "函数外是全局变量 : ", total 
          

          以上实例输出结果:

          函数内是局部变量 :  30
          函数外是全局变量 :  0
          

Python函数 函数是团组织好的,可重复使用的,用来兑现单一,或相关联作用的代码段。 函数能升高运用的模块性,和代码的重复利...

1 #coding=utf-8

Python函数

函数是公司好的,可重复使用的,用来贯彻单一,或相关联作用的代码段。

函数能拉长运用的模块性,和代码的重新利用率。你早就精晓Python提供了众多内建函数,比方print()。但您也得以和谐创设函数,那被喻为客户自定义函数。

一、定义三个函数

您能够定义二个由友好想要功效的函数,以下是归纳的法则:

  • 函数代码块以 def 关键词最初,后接函数标记符名称和圆括号()
  • 另外传入参数和自变量必得放在圆括号中间。圆括号之间能够用于定义参数。
  • 函数的首先行语句能够选拔性地选取文档字符串—用于贮存函数表达。
  • 函数内容以冒号起初,何况缩进。
  • return [表达式] 停止函数,选取性地再次来到叁个值给调用方。不带表明式的return约等于重回None。

语法

1 def functionname( parameters ):
2    "函数_文档字符串"
3    function_suite
4    return [expression]

暗许情况下,参数值和参数名称是按函数表明中定义的的逐个匹配起来的。

实例

1 def printme( str ):
2    "打印传入的字符串"
3    print str
4    return

二、函数调用

概念叁个函数只给了函数三个名称,钦赐了函数里带有的参数,和代码块结构。

那么些函数的主题构造造成之后,你可以经过另二个函数调用实行,也足以直接从Python提醒符实践。

正如实例调用了printme()函数:

 1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3  
 4 # 定义函数
 5 def printme( str ):
 6    "打印任何传入的字符串"
 7    print str;
 8    return;
 9  
10 # 调用函数
11 printme("我要调用用户自定义函数!");
12 printme("再次调用同一函数");

如上实例输出结果:

1 我要调用用户自定义函数!
2 再次调用同一函数

值传递和参数字传送递:(重难题,懂了就简单了)

具备参数(自变量)在Python里都以按援用传递。倘诺您在函数里修改了参数,那么在调用那几个函数的函数里,原始的参数也被更换了。

例如:

 1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3 # 以上是另外一种中文显示方式,多好几个字呢。。。
 4 # 可写函数说明
 5 def changeme( mylist ):
 6    "修改传入的列表"
 7    mylist.append([1,2,3,4]);
 8    print "函数内取值: ", mylist
 9    return
10  
11 # 调用changeme函数
12 mylist = [10,20,30];
13 changeme( mylist );#参数传递
14 print "函数外取值: ", mylist

传播函数的和在结尾增加新剧情的对象用的是同三个引用。故输出结果如下:那正是援用传递;

1 函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
2 函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

上边举多少个值传递的例子:

 1 def addSum(AL,a=1,b=2):
 2     AL.append(4)
 3     c = a +b
 4     print "AL'= ",AL
 5     return(c,a,b)
 6 if __name__ == '__main__':
 7     AL = [1,2,3]
 8     c,a,b = addSum([1,2,3],5)  
 9     print "c =",c,"a =",a,"b =",b 
10     print "AL =",AL

出口结果:

1 AL'=  [1, 2, 3, 4]
2 c = 7 a = 5 b = 2
3 AL = [1, 2, 3]

三、参数

以下是调用函数时可选取的行业内部部参照他事他说加以考察音信数类型:

  • 须求参数
  • 驷不如舌字参数
  • 暗中认可参数
  • 不定长参数

须求参数

要求参数须以科学的次第传入函数。调用时的多少必需和申明时的等同。

调用printme()函数,你不能够不传入二个参数,不然会现出语法错误:

 1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3  
 4 #可写函数说明
 5 def printme( str ):
 6    "打印任何传入的字符串"
 7    print str;
 8    return;
 9  
10 #调用printme函数
11 printme();

以上实例输出结果:

1 Traceback (most recent call last):
2   File "test.py", line 11, in <module>
3     printme();
4 TypeError: printme() takes exactly 1 argument (0 given)

最主要字参数

首要字参数和函数调用关系密不可分,函数调用使用主要字参数来规定传入的参数值。

应用主要字参数允许函数调用时参数的顺序与注脚时差异样,因为 Python 解释器能够用参数名相称参数值。

以下实例在函数 printme() 调用时使用参数名:

 1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3  
 4 #可写函数说明
 5 def printme( str ):
 6    "打印任何传入的字符串"
 7    print str;
 8    return;
 9  
10 #调用printme函数
11 printme( str = "My string");

如上实例输出结果:

1 My string

下例能将首要字参数顺序不首要显示得更驾驭:

 1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3  
 4 #可写函数说明
 5 def printinfo( name, age ):
 6    "打印任何传入的字符串"
 7    print "Name: ", name;
 8    print "Age ", age;
 9    return;
10  
11 #调用printinfo函数
12 printinfo( age=50, name="miki" );

如上实例输出结果:

1 Name:  miki
2 Age  50

缺省参数

调用函数时,缺省参数的值若无传来,则被认为是私下认可值。下例会打印暗许的age,若是age未有被流传:

 1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3  
 4 #可写函数说明
 5 def printinfo( name, age = 35 ):
 6    "打印任何传入的字符串"
 7    print "Name: ", name;
 8    print "Age ", age;
 9    return;
10  
11 #调用printinfo函数
12 printinfo( age=50, name="miki" );
13 printinfo( name="miki" );

如上实例输出结果:

1 Name:  miki
2 Age  50
3 Name:  miki
4 Age  35

不定长参数

你可能须要三个函数能管理比那时候宣称时更加的多的参数。这么些参数叫做不定长参数,和上述2种参数差异,评释时不会取名。基本语法如下:

1 def functionname([formal_args,] *var_args_tuple ):
2    "函数_文档字符串"
3    function_suite
4    return [expression]

加了星号(*)的变量名会寄存全体未命名的变量参数。选用比相当少传参数也可。如下实例:

 1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3  
 4 # 可写函数说明
 5 def printinfo( arg1, *vartuple ):
 6    "打印任何传入的参数"
 7    print "输出: "
 8    print arg1
 9    for var in vartuple:
10       print var
11    return;
12  
13 # 调用printinfo 函数
14 printinfo( 10 );
15 printinfo( 70, 60, 50 );

以上实例输出结果:

1 输出:
2 10
3 输出:
4 70
5 60
6 50

四、佚名函数

python 使用 lambda 来成立佚名函数。

  • lambda只是三个表明式,函数体比def轻巧比较多。
  • lambda的关键性是多个表达式,并非八个代码块。仅仅能在lambda表明式中封装有限的逻辑进去。
  • lambda函数具备自个儿的命名空间,且无法访谈自有参数列表之外或全局命名空间里的参数。
  • 即使lambda函数看起来只可以写一行,却不一样等C或C++的内联函数,前者的目标是调用小函数时不占用栈内部存款和储蓄器进而扩张运转效能。

语法

lambda函数的语法只饱含二个说话,如下:

1 lambda [arg1 [,arg2,.....argn]]:expression

一般来讲实例:

1 #!/usr/bin/python
2 # -*- coding: UTF-8 -*-
3  
4 # 可写函数说明
5 sum = lambda arg1, arg2: arg1 + arg2;
6  
7 # 调用sum函数
8 print "相加后的值为 : ", sum( 10, 20 )
9 print "相加后的值为 : ", sum( 20, 20 )

上述实例输出结果:

1 相加后的值为 :  30
2 相加后的值为 :  40

五、return 语句

return语句[表达式]脱离函数,选拔性地向调用方再次来到二个表明式。不带参数值的return语句重临None。以前的例证都未有身体力行怎样回到数值,下例便告诉你如何做:

 1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3  
 4 # 可写函数说明
 5 def sum( arg1, arg2 ):
 6    # 返回2个参数的和."
 7    total = arg1 + arg2
 8    print "函数内 : ", total
 9    return total;
10  
11 # 调用sum函数
12 total = sum( 10, 20 );

以上实例输出结果:

1 函数内 :  30

变量成效域

一个主次的持有的变量并非在哪个地方都足以访谈的。访问权限调节于那个变量是在何地赋值的。

变量的作用域决定了在哪一部分前后相继你能够访问哪个特定的变量名称。二种最主旨的变量功效域如下:

  • 全局变量
  • 部分变量

全局变量和有个别变量

概念在函数内部的变量具有贰个片段作用域,定义在函数外的具有全局功用域。

局地变量只可以在其被声称的函数内部访谈,而全局变量能够在整整程序范围内访谈。调用函数时,全部在函数内注脚的变量名称都将被投入到成效域中。如下实例:

 1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3 
 4 total = 0; # 这是一个全局变量
 5 # 可写函数说明
 6 def sum( arg1, arg2 ):
 7    #返回2个参数的和."
 8    total = arg1 + arg2; # total在这里是局部变量.
 9    print "函数内是局部变量 : ", total
10    return total;
11  
12 #调用sum函数
13 sum( 10, 20 );
14 print "函数外是全局变量 : ", total 

如上实例输出结果:

1 函数内是局部变量 :  30
2 函数外是全局变量 :  0

本文超过十分之五剧情转发于网络,如有雷同,请文告我删除!

 

本文由王中王开奖结果发布于网络编程,转载请注明出处:Python函数

关键词: