函數基礎知識（python）

本篇文章的內容是Python的函數基礎知識，現在分享給大家，有需要的小夥伴可以參考一下文章中的內容

函數：如果在開發程式時，需要某塊程式碼多次，但是為了提高編寫的效率以及程式碼的重用，所以把具有獨立功能的程式碼區塊組織為一個小模組
這就是函數

函數定義與呼叫

定義函數
    訂函數的格式如下：

        def 函數名稱():
    2>呼叫函數

    定義了函數之後，就相當於有了一個具有某些功能的程式碼，想要讓這些程式碼能夠執行，需要呼叫它

    呼叫函數很簡單的，透過函數名稱() 即可完成呼叫


函數參數(一)

    為了讓一個函數更通用，也就是想讓它計算哪兩個數的和，就讓它計算哪兩個數字的和，在定義函數的時候可以讓函數接收數據，
    就解決了這個問題，這就是函數的參數

     定義帶有參數的函數

    範例如下：

        def add2num(a, b):
           gt; 呼叫帶有參數的函數

    以召喚上面的add2num(a, b)函數為例:


        def add2num(a, b):
  
##        add2num(11, 22) #呼叫具有參數的函數時，需要在小括號中，傳遞資料
     小摘要

   時號，用來接收參數用的，稱為「形參」

        呼叫時小括號中的參數，用來傳遞給函數用的，稱為「實參」

函數返回值(一)

    “返回值”介紹

    所謂“返回值”，就是程式中函數完成一件事情后，最後給調用者的結果

    有回傳值的函數

    想要在函數中將結果回傳給呼叫者，在函數中需要使用return

#    如下範例:

        def add2num(a, b):
            c = a+b
         a, b):
            return a+b

    保存函數的回傳值

    在本小節剛開始的時候，說過的「買煙」的例子中，最後兒子給你煙時，你一定是從兒子手中接過來對麼，程式也是如此，如果一個函數回傳了一個數據，那麼想要用這個數據，那麼就需要保存

    保存函數的回傳值範例如下:

        #定義函數
        def add2num(a, b):
            return a+b

      #1 #調用函數，順便儲存函數的回傳值
#        #因為result已經儲存了add2num的回傳值，所以接下來就可以使用了
        print result

    結果：
#函數回傳值(二)
    在python中我們可不可以傳回多個值？

    >>> def pid(a, b):
    ...     shang = a//b
    ...   , yushu
    ...
    >>> sh, yu = pid(5, 2)
#    >>> sh##  ; yu
    1

    本質是利用了元組



4種函數的型別

    函數根據有沒有參數，有沒有回傳值，可以相互組合，一共有4種

#無參數，無回傳值
        無參數，再回傳
        有參數，無回傳值
       

        這類函數，無法接收參數，也沒有回傳值，一般情況下，列印提示燈類似的功能，使用這類的函數

    無參數，有回值的函數

        此類函數，不能接收參數，但是可以返回某個數據，一般情況下，像採集數據，用此類函數

##            # 獲取溫度
            def getTemperature():

                #這裡是針對溫度下                return 24

            temperature = getTemperature()
            print('目前的溫度為:%d'%temperature)

        結果:
o# ;3>有參數，無回傳值的函數

        此類函數，能接收參數，但不可傳回數據，一般情況下，為某些變數設定資料而不需結果時，以此類函數

        有參數，有回傳值的函數

        此類函數，不僅接收參數，也可傳回某個數據，一般情況下，像資料處理且需要結果的應用，使用這類函數


            # 計算1~num的累積與
                          i = 1
                而i
                    result = result + i

              return result

            result = calculateNum(100)
          '1~100的累積和為:%d'%result)

        結果:

            1~100的累積和為: 50500
#)
            1. 預設參數

                所呼叫函數時，因預設值而被視為預設值。下例會印上預設的age，若age沒有被傳入：
##                def printinfo( name, age = 35 ):
                 print "Name: ", name
                   print "Age ", age

             ki" )
                printinfo( age=9,name="miki" )

                以上實例輸出結果：

                Name:                  Name:  miki
                Age  9# 

                >>> def printinfo(name, age=35, sex):
                 ...
                  File "", line 1
                SyntaxError: non-default argument follows default argument

            有時可能需要一個函數能處理比當初宣告時更多的參數。這些參數叫做不定長參數，宣告時不會命名。

                基本語法如下：

                    def functionname([formal_args,] *args, **kwargs):
                       "函數_文檔字符串"
                       function_suite
                       return [ expression]

                加了星號（*）的變數args會儲存所有未命名的變數參數，args為元組；而加**的變數key=value的參數， kwargs為字典。

                >>> def fun(a, b, *args, **kwargs):
       1             ... print "a =", a
                ...     print "b =", b
#                  ...     print "kwargs: "
                ...     for key , value in kwargs.items():
                ...         print key, "=", value        >>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8)  # 注意力傳遞的參數對應
                a = 1
         = (3, 4, 5)
                kwargs:
p = 8
                m = 6
                              >>>
                > ; ; c = (3, 4, 5)
                >>> d = {"m":6, "n":7, "p":8}
#>>> fun(1, 2, *c, **d)    # 注意元組與字典的傳參方式
                        args = (3, 4                kwargs:
                p            n = 7
                >>>
         >> ;>
                >>> fun(1, 2, c, d) # 注意不加星號與上方的差異
       b = 2
                args = ( (3, 4, 5), {'p': 8, 'm': 6, 'n': 7})
                kwar ;         >>> ;

            3. 引用傳參

                  
                    Python中與沒有類似C語言的指標所傳參呢？

                >>> def selfAdd(a):
            ...     a += a
                ...












#也
# >>> a_int = 1
                >>> a_int
       ;>> selfAdd(a_int)
                >>> a_int
      
                >>> a_list = [1, 2]
              [1, 2]
                >>> selfAdd(a_list)
>>> a_list
                [1, 2, 1, 2]

             對於不可變類型，因變數不能修改，所以運算不會影響變數本身
                ；而對變動型別來說，函數體內的運算有可能會改變傳入的參數變數。


函數的巢狀呼叫

    def testB():
        print('---- testB start----')
     是testB函數執行的程式碼')
        print('---- testB end----')


    def testA():

#       def testA():
####    print('-  print('- --- testA start----')#######testB()

        print('---- testA end----')

    testA()

    結果：## - testA start----
        ---- testB start----
        這裡是testB函數執行的程式碼
        ---- end----# testA end----



        思考&實現1

        寫一個函數列印一條橫線
  #   # ##        參考代碼1


        # 列印一條橫向
        def    # 列印多條橫線
        def printNumLine(num):
            i=0

#         多次呼叫此函數即可
while i                printOneLine()
                  思考&實現2

            寫出一個函數求三個數的和
            寫函數求三個數字的平均值

        參考代碼2


     c):
            return a+b+c # return 的後面可以是數值，也可是一個表達式

        # 完成對3個數字/編號c):

            # 因為sum3Number函數完成了3個數字的就和，所以只需呼叫即可
            # 即傳遞 3個數字，並接收到的參實數，當做參實請問##            sumResult = sum3Number(a,b,c)
            aveResult = sumResult/3.0##         # 呼叫函數，完成對3個數字求平均值
        result = average3Number( 11,2,55)
        print("average is %d"%result)

局部變數
    
    局部變數，為在函數內部定義的變數## c  ，可以定義相同的名字的局部變量，但是各用個的不會產生影響
    局部變量的作用，為了臨時保存數據需要在函數中定義變量來進行存儲，這就是它的作用

全域變數
    如果一個變量，既能在一個函數中使用，也能在其他的函數中使用，這樣的變數就是全域變數

    demo如下:

        #定義全域變數
        a = 100

        def test1():
           #(a)#           #(a)#                print(a)

        # 呼叫函數
        test1()
        test2()

     ## c 如果在函數中修改全域變量，那麼就需要使用global進行聲明，否則出錯
    如果全域變數的名字和局部變數的名字相同，那麼使用的是局部變數的，小技巧強龍不壓地頭蛇


遞迴函數
    如果一個函數在內部不呼叫其它的函數，而是自己本身的話，這個函數就是遞歸函數。
    舉個例子，我們來計算階乘n! = 1 * 2 * 3 * ... * n
    def calNum(num):
       i = 1
#  ##        while i            return *= i
           calNum(3)
    print(ret)


匿名函數

    用lambda關鍵字能建立小型匿名函數。這種函數得名於省略了用def宣告函數的標準步驟。

    lambda函數的語法只包含一個語句，如下：

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

    如下實例：# 如下實例：

        sum = lambda arg1, arg2: arg1 + arg2

        # sum函, ##       # print "print of # total : ", sum( 20, 20 )
##    以上實例輸出結果：

        Value of total :  30
     數量的參數但只能回傳一個表達式的值

    匿名函數不能直接呼叫print，因為lambda需要一個表達式
    應用場合
    函數作為參數傳遞
##  應用場合
    函數作為參數傳遞
##  定義函數

        >>> def fun(a, b, opt):
        ...     print "a =" a## #        ...     print "result =", opt(a, b)
        ...
#        & = 1
        b = 2
        result = 3

        為內建函數的參數
# # 

    stus = [
        {"name":"zhangsan", "age":18},
        {"name":"lisi", "age":19}, ## {"name":"wangwu", "age":17}
    ]

    依name排序：

    >>> stus.sort(key = lambda x: x['name'])
    >>> stus
    [{'age': 19, 'name': 'lisi'}, {'age': 17, 'name': 'wangwu '}, {'age': 18, 'name': 'zhangsan'}]

    依age排序：

    >>> stus.sort(key = lambda x: x['age'])
    >>> stus
    [{'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan '}, {'age': 19, 'name': 'lisi'}]

函數使用注意事項

    1. 自訂函數

        無參數、無回值

            def 函數名稱():
                      def 函數名稱():
                語句
                return 注意力中的數值  函數到底有沒有回傳值，就看有沒有return，因為只有return可以回傳資料
在開發中常根據需求來設計函數需不需要回傳值
            函數中，可以有多個return語句，但是只要執行到一個return語句，那麼就表示這個函數的呼叫完成

有參數、無回值

                在呼叫函數時，如果需要將一些資料一起傳遞過去，被呼叫函數就需要用參數來接收
            參數清單中變數的數量根據實際傳遞的資料的數量來決定

        有參數、有回傳;值

            def 函數名稱(形參考表):
                語句#      函數名稱不能重複

    2.呼叫函數

        調用的方式為：

            函數名稱([實參清單])# 

            如果被定義的函數在定義時有形參，那麼當呼叫的時候就應該傳遞參數

        呼叫時，實參的數量和先後順序應該和定義函數先後順序應該和定義函數中要求的一致性
        
        如果所呼叫的函數有回傳值，那麼就可以用一個變數來進行儲存此值

  ;1>在一個函數中定義的變量，只能在本函數中用(局部變量)

        在函數外定義的變量，可以在所有的函數中使用(全局變量)
相關推薦：


關於Python基礎函數的介紹

以上是函數基礎知識（python）的詳細內容。更多資訊請關注PHP中文網其他相關文章！