1 def sayName(name,age,sex):  #name,age,sex就是形式引數
2     # name,age,sex函式的引數型別是位置引數、必填引數
3     print('姓名：%s'%name)
4     print('年齡：%s'%age)
5     print('性別：%s'%sex)
6     #上面這個就是函式體
7 
8 
9 sayName('星星',18,'男')  #'星星',18,'男'這三個就是實際引數，呼叫的時候傳進來的引數

• 函式裡，只要遇到return就結束，不會再往下執行
• 如果函式沒有指定return返回值，那麼函式預設返回的是None

• 　

   1 def call(a,b):
   2     return a+b
   3     return a*b
   4 def call2(a,b):
   5     print('函式內a,b執行結果：',a+b)
   6 
   7 print('call函式return結果：',call(1,2))
   8 print('call2函式return結果：',call2(1,2))
   9 
  10 #call函式return結果： 3    #因為函式裡return了a+b的結果，所以這裡的結果是3
  11 #函式內a,b執行結果： 3     #這個是call2函式體裡執行的結果
  12 #call2函式return結果： None    #因為函式裡沒有return，所以這裡的結果是None
  

  　　

  　

1.  1 def play():
    2     print('出去浪')
    3 def study():
    4     print('好好學習')
    5 def_method={'1':play,'2':study}
    6 while True:
    7     choice = input('請輸入你的選擇：1代表出去浪，2代表好好學習')
    8     if choice =='1' or choice =='2':
    9         def_method[choice]()
   10         print(type(def_method[choice]()))
   11         break
   12     else:
   13         print('請輸入正確的選擇')
   14         continue
   

   　　

2. while True：是死迴圈，這裡只是寫一個迴圈，真實的工作場景中，需要填寫正確的條件判斷
   　　

• 位置引數：這個引數就和格式化輸出裡的佔位一樣，形參先把位置站好，然後就等著使用者呼叫的時候輸入實參，排隊填坑，如果實參和形參個數不一致，多了或者少了都會報錯，如下：

  1 def add(a,b):
  2     print('%s+%s=%s'%(a,b,a+b))
  3     return a*b
  4 add(1,2)    #列印結果：1+2=3
  5 add(6,2)    #列印結果：6+2=8
  6 add(1,2,3)  #列印結果：報錯，引數多了
  7 add(2)      #列印結果：報錯，引數少了
  

  　　

這個引數就是程式會先給一個預設的，不傳不會報錯，會直接使用預設的這個引數值，如果傳了就用你傳的這個值；等於是定義函式的時候先定義了一個引數變數，呼叫的時候沒傳就用之前定義好的，如果傳了就是覆蓋之前的值，用傳入的引數值：

• 1 def multi(a,b=2):
  2     print('%s**%s=%s'%(a,b,a**b))
  3 
  4 multi(3)   #不傳參的時候預設b=2，這裡求的是平方
  5 multi(4,3) #傳的時候b=3，這裡求的是立方
  6 multi(2,b=4) #和上面的這個呼叫是一樣的，但是一般這樣寫，如果預設引數較多時，不會因為位置而出錯
  7 multi(b=4,2) #報錯，位置引數必須在前（positional argument follows keyword argument）
  

  　　

• 可變引數：這裡一般用的少，可變就是引數是變化的，考慮到了程式的擴充套件性，定義函式的時候並不確定會有多少個引數，這裡就用到了可變引數，既然可變，那麼在呼叫函式的時候也是可以不輸入的：

  •  1 # 可變引數
     2 def user(name,passwd,*args):   #一般是用args來命名的，當然也可以用其他你想要的名字
     3     print('使用者名稱：%s,密碼：%s'%(name,passwd))
     4     print('還有如下屬性：\n',args)   #這裡的args，就是使用者輸入引數的一個元祖
     5 
     6 user('chenmeng',12334,'男','180cm','60kg')
     7 # 列印結果：
     8 # 使用者名稱：chenmeng,密碼：12334
     9 # 還有如下屬性：
    10 # ('男', '180cm', '60kg')
    

    　　

    　　
• 關鍵字引數，也不是必填的，他是一個key-value的字典形式：

  • 1 # 關鍵字引數:也不是必填的，他是一個key-value的字典形式
    2 def user(name,passwd,**args):
    3     print('使用者名稱：%s，密碼：%s'%(name,passwd))
    4     print('還有如下屬性：\n',args)
    5 user('xingxing',123456,sex='男',height='180cm')
    6 # 列印結果：
    7 # 使用者名稱：xingxing，密碼：123456
    8 # 還有如下屬性：
    9 # {'sex': '男', 'height': '180cm'}
    

    　　

• 1 # 全域性作用域
  2 hys=['螢幕','主機'] #全域性變數
  3 def add(thing):
  4     hys.append(thing)
  5 add('麥克')
  6 print(hys)  #列印結果為：['螢幕', '主機', '麥克']
  

  　　

• 1 # 區域性作用域
  2 def add(thing):
  3     desk=['顯示器','滑鼠']  #區域性變數
  4     desk.append(thing)     #函體內修改區域性變數      
  5 add(223)
  6 print(desk)                #函式體外呼叫區域性變數報錯
  

  　　

• 值得一提的是，當全域性變數是一個不可編輯的引數時，需要先申明才可以用全域性變數（str/int/float等不可變變數函式在呼叫全域性變數時，需要global才可以修改）

•  1 # 不可變變數的全域性變數引用，如int、float、str
   2 money = 500
   3 def chage():
   4     money=1000
   5     print('函式內的money：',money)   #列印結果是1000，因為函式內部作用域中money=1000，不能修改外面的money
   6 chage()
   7 print('函式外的money：',money)   #列印結果為500，因為函式不可修改外部作用域中不可變變數的全域性變數引用，如int、float、str
   8 
   9 def chage():
  10     global money    #global後就可以引用了，這就聲明瞭money是一個全域性變數，函式內可以修改
  11     money =1000
  12     print('函式內的money：',money)   #列印結果是1000
  13 chage()
  14 print('函式外的money：',money)     #列印結果是1000,因為global聲明瞭全域性變數，所以可以修改

1. 函式迭代，就是自己呼叫自己，一個死迴圈，一直呼叫下去，最多迭代999次，超過999次程式自動停止執行（while沒有次數限制）

1. 必須有一個明確的結束條件
2. 每次進入更深一層遞迴時，問題規模相比上次遞迴都因有所減少
3. 遞迴效率不高，遞迴層次過多會導致棧溢位（在計算機中，函式呼叫是通過棧（stack）這種資料結構實現的，每當進入一個函式呼叫，棧就會加一層棧幀，每當函式返回，棧就會減一層棧幀。由於棧的大小不是無限的，所以，遞迴呼叫的次數過多，會導致棧溢位）

4. 1 # 函式迭代，就是自己呼叫自己，一個死迴圈，呼叫下去
   2 def dd():
   3     print('學習學習努力學習')
   4     dd()    #函式內，又呼叫了函式本身，那麼就會一直呼叫下去
   5 dd()   #迭代函式最多會呼叫999次，這裡會列印999次'學習學習努力學習'
   

   　　

5. 用函式迭代寫斐波拉契數列：[1, 1, 2, 3, 5, 8, 13, 21, 34],數列從第3項開始，每一項都等於前兩項之和。
6. 先用之前的知識來寫

   1.  1 list=[]
       2 def fb(num):
       3     a=1
       4     b=1
       5     while num >0:
       6         list.append(a)
       7         a,b=b,a+b
       8         print(b)
       9         num-=1
      10 fb(9)
      11 print(list)　

7. 用迭代來寫

   1.  1 list=[]
       2 a=1
       3 b=1
       4 def fb(num):
       5     global a,b
       6     list.append(a)
       7     a,b=b,a+b
       8     num-=1
       9     if num>0:
      10         fb(num)
      11 
      12 fb(9)
      13 print(list)