python基礎-函數（一）--python3

python基礎---函數(一)

目錄 python基礎---函數(一)1.函數的定義2.函數 的參數詳解3.return4.lambda匿名函數

1.函數的定義

function  功能，函數
    函數就是對代碼進行一個封裝，把實現某一功能的相同代碼，進行封裝到一塊兒。下次須要使用時，就不須要進行代碼編寫，直接調用便可。
好處：
    增長代碼的複用性，增長代碼的可讀性減小代碼的編寫量，下降維護成本。
    函數能夠當作，解決某類問題的‘工具’
定義方法：
'''
def function_name(params):
    block
    return expression(表達式)/value
'''
def 關鍵字表示定義一個函數
function_name 函數名，和變量的命名規則相同，以字母和_開頭，能夠包含字母，數字和_
params 表示參數，能夠是零個，一個或者多個參數，函數參數不用指定參數類型

#examples
    def dieDai(iter):
        for i in iter:
            print(i)
    >>> li=(1,2,3,4)
    >>> dieDai(li)
    1
    2
    3
    4

2.函數 的參數詳解

1.必備參數：參數沒有默認值
2.默認參數：參數是有默認值，調用函數是能夠傳參也能夠不傳參，不傳時，參數是默認值
3.不定長參數：可在定義是定義，也可在傳入時定義傳入
    定義方法：def function_name(*args,**kwargs)
    *args 將傳入參數包裝成元祖
    **kwargs  將傳入參數包裝成字典

• [ ] #1.不傳參數
  def fun1():
  print('不能傳參數')

  fun1('q')
  Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
  fun1('q')
  TypeError: fun1() takes 0 positional arguments but 1 was given
  fun1()
  不能傳參數
  #2.必備參數
  def fun2(a):
  print('必須傳參數：',a)
  fun2(2)
  必須傳參數： 2
  #3.默認參數 參數可傳也可不傳
  def fun3(b=2):
  print('默認參數：',b)
  fun3()
  默認參數： 2
  fun3(4)
  默認參數： 4
  fun3(b=10)
  默認參數： 10
  ##4.可選參數 可傳0-多個，包裝成元祖
  def fun4(arg):
  print('能夠穿0個到多個',arg)
  fun4() #返回一個空元祖
  能夠穿0個到多個 ()
  fun4(1) #返回一個元祖
  能夠穿0個到多個 (1,)
  fun4(2,3)
  能夠穿0個到多個 (2, 3)
  fun4(4,5,6,7,8)
  能夠穿0個到多個 (4, 5, 6, 7, 8)
  fun4([1,2])
  能夠穿0個到多個 ([1, 2],)
  fun4('sdf')
  能夠穿0個到多個 ('sdf',)
  fun4({'q':123})
  能夠穿0個到多個 ({'q': 123},)
  fun4((1,2))
  能夠穿0個到多個 ((1, 2),)
  #可選參數，傳參時加號，就把裏面的殼去掉(解包)
  fun4((1,2))
  能夠穿0個到多個 (1, 2)
  fun4({'q':123})
  能夠穿0個到多個 ('q',)
  fun4([1,2])
  能夠穿0個到多個 (1, 2)
  fun4('sdf')
  能夠穿0個到多個 ('s', 'd', 'f')
  ##5.關鍵字參數
  def fun5(a,b): #定義的時候跟必備參數同樣
  print(a,b) #必須放到最後
  fun5(a=1,b=2)
  1 2

  def fun6(**kwarg):
        print('關鍵字參數：',kwarg)     #包裝成字典(可傳0-多個)
        >>> fun6()
        關鍵字參數： {}
        >>> fun6(a=1,b=2)     #遵循變量名規則
        關鍵字參數： {'a': 1, 'b': 2}
        >>> fun6(**{'a':123,'b':'wer'})
        關鍵字參數： {'a': 123, 'b': 'wer'}
        >>> fun6(**{1:123,2:'wer'})       #key必須是字符串
        Traceback (most recent call last):
          File "<pyshell#48>", line 1, in <module>
            fun6(**{1:123,2:'wer'})
        TypeError: fun6() keywords must be strings
    ##參數混合時 關鍵字參數必須在後面，根據定義的書序，確保必備參數能拿到值且只有一個
    #1.必備參數+默認參數：默認參數必須在必備參數的後面
        def fun7(b,a=1):
            print(a,b)
        >>> fun7(1,)
        1 1 
        >>> fun7('q',a='we')
        we q
        >>> fun7(a='we',b='ert')
        we ert
        >>> fun7('q','w')
        w q
  
    #2
        def fun8(b,m=1,*a):
            print(b)
            print(m)
            print(a)
         ==================
        >>> fun8(1,2,3,4,5,6,7,8)
        1
        2
        (3, 4, 5, 6, 7, 8)
        >>> 
    #3
        def fun9(*a,b,m): #b,m爲關鍵自參數
            print(a,b,m)
            print(b)
            print(m)
        >>> fun9(1,2,3,4,5,b='q',m='w')
        (1, 2, 3, 4, 5) q w
        q
        w

3.return

return 有兩個做用：
    1.用來返回函數的運行結果，或者調用另一個函數。好比max()函數
    2.函數結束的標誌。主要運行了return，就強制結束了函數。return後面的程序都不會執行
若是函數中沒有寫return，其實函數運行結束時，默認執行了 return None
return 語句的位置是可選的，不是固定出現再函數的最後，能夠自定義在函數的任何地方。

#返回函數的運行結果
    >>> def fun1(a,b):      #返回a=2
        if a>b:
            return a
    >>> fun1(2,1)
    2
    >>> a=fun1(2,1)
    >>> a
    2
    >>> def fun1(a,b):      #返回b=None
        if a>b:
            print(a)
    >>> fun1(2,1)
    2
    >>> b=fun1(2,1)
    2
    >>> b
#函數結束的標誌 能夠放在任何地方
    >>> def fun10(a,b):
        if a>b:
            print(a)
    >>> fun10(2,1)
    2
    >>> def fun10(a,b):
        return('我不下去了') #函數結束標誌
        if a>b:
            print(a)
    >>> fun10(2,1)
    '我不下去了'

4.lambda匿名函數

沒有函數名的函數
g = lamdba x:x+1
lambda 簡化了函數定義的書寫形式。是代碼更爲簡潔，可是使用函數的定義方式更爲直觀，易理解

lambda的應用場景：
1.有些函數若是隻是臨時一用，並且它的業務邏輯也很簡單時，就沒有必要用def來定義，這個時候就能夠使用lambda。
2.函數都支持函數做爲參數。lambda函數就能夠應用

>>> fun10           #函數體
<function fun10 at 0x0000000003429D08>
>>> g=lambda x:x+1  #函數體
>>> g
<function <lambda> at 0x00000000034371E0>
>>> g(1)
2