一、函數的簡介

我們寫一個計算字符串或列表等長度的方法，方法類似len()方法，發現實現的代碼幾乎相同：

1 s1=‘1234567890‘
2 def my_len():
3     count = 0
4     for i in s1:
5         count+=1
6     print(count)
7 my_len()
8 print(len(s1))

首先，之前只要我們執行len方法就可以直接拿到一個字符串的長度了，現在為了實現相同的功能我們把相同的代碼寫了好多遍 —— 代碼冗余

其次，之前我們只寫兩句話讀起來也很簡單，一看就知道這兩句代碼是在計算長度，但是剛剛的代碼卻不那麽容易讀懂 —— 可讀性差

使用函數可以解決以上問題：

函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。

函數能提高應用的模塊性，和代碼的重復利用率。你已經知道Python提供了許多內建函數，比如print()，len()等。但你也可以自己創建函數，這被叫做用戶自定義函數。

1、格式

del 關鍵字 函數名(設定與變量相同):
    函數體

return:函數的返回值 
函數名(): 執行函數
函數名會加載到內存，函數體不會執行

2、return

1）遇到return，結束函數。
2）給函數的調用者(執行者)返回值。
   無return 返回None
   return 不寫或者None 返回None
 
   return 返回單個數
   return 返回多個數 將返回的數據放在元組中返回

 1 # 例1
 2 def func1():
 3     print(111)
 4     return
 5     print(222)#此行代碼不會執行
 6 func1()
 7 
 8 # 例2
 9 s1=‘1234567890‘
10 def my_len():
11     count = 0
12     for i in s1:
13         count+=1
14     return count
15 print(my_len())
 
16 
17 #例3
18 s1 = ‘1234567890‘
19 def my_len():
20     count = 0
21     for i in s1:
22         count+=1
23     return count,111,222
24 print(my_len(),type(my_len()))#>>>(10, 111, 222) <class ‘tuple‘>
25 ret1,ret2,ret3=my_len()#分別賦值
26 print(ret1)#>>>10
27 print(ret2)#>>>111
28 print(ret3)#>>>222

二、函數的參數

 1 #以下函數實現了len()計算元素長度的功能，但是不能動態的計算
 2 s1 = ‘1234567890‘
 3 def my_len():
 4     count = 0
 5     for i in s1:
 6         count+=1
 7     return count
 8 print(my_len())
 9 print(len(s1))
10 #修改如下，通過函數的參數，可以動態的計算元素的長度
11 s1 = ‘1234567890‘
12 l1=[111,222,3333,‘aaaa‘]
13 def my_len(a):#函數的定義（形參）
14     count = 0
15     for i in a:
16         count+=1
17     return count
18 ret = my_len(s1)#函數的執行（實參）
19 print(ret)#>>>10
20 print(my_len(l1))#>>>4

1、從實參角度

 1 #1.位置參數。必須一一按順序對應
 2 def func1(x,y):
 3    print(x,y)
 4 func1(1,2)#>>>1 2
 5 
 6 #2.關鍵字參數。必須一一對應，不分順序
 7 def func2(x,y,z):
 8     print(x,y,z)
 9 func2(y=2,x=1,z=5)#>>>1 2 5
10 
11 #練習 比較兩個數大小
12 def max(x,y):
13     if x>y:
14         return  x
15     else:
16         return y
17 print(max(4,2))#>>>4
18 
19 #三元表達式
20 # def max(a,b):return a if a>b else b
21 
22 #3.混合參數 一一對應 並且關鍵字參數必須在位置參數後面
23 def func2(argv1,argv2,argv3):
24     print(argv1,argv2,argv3)
25 func2(1,2,argv3=4)#>>>1 2 4

2、從形參角度

 1 #1.位置參數，與實參相同 必須一一對應 按順序
 2 
 3 #2.默認參數，必須在位置參數後面。
 4 #例：統計人員的姓名和性別，統計在文件當中
 5 def register(name,sex=‘男‘):
 6     with open(‘register‘,encoding=‘utf-8‘,mode=‘a‘) as f1:
 7         f1.write(‘{} {}\n‘.format(name,sex))
 8 while True:
 9    name = input(‘請輸入姓名（輸入/q 或者 Q 退出）：‘)
10    if name.upper()==‘Q‘:break
11    if ‘a‘ in name:
12        sex = input(‘請輸入性別：‘)
13        register(name, sex)
14    else:
15        register(name)
16 #3.動態參數 *args， **kwargs 萬能參數
17 # 當參數個數不固定時，可以用萬能參數
18 def func2(*args,**kwargs):
19      print(args)#元組（接收所有的位置參數，並一起放在元組中）
20      print(kwargs)#字典（接收所有關鍵字參數，並一起放在字典中）
21 func2(1,2,3,‘alex‘,c=‘222‘,v=‘3333‘)
22 #順序：位置參數 *args 默認參數 **kwargs，
23 def func3(a,b,*args,sex=‘男‘,**kwargs):
24     print(a)
25     print(b)
26     print(sex)
27     print(args)
28     print(kwargs)
29 func3(1,2,‘hello‘,‘world‘,‘你好‘,sex=‘女‘,name=‘Lucy‘,age=18)
30 #>>>1
31 #>>>2
32 #>>>女
33 #>>>(‘hello‘, ‘world‘, ‘你好‘)
34 #>>>{‘name‘: ‘Lucy‘, ‘age‘: 18}
35 
36 #傳入3個列表，將每一個列表元素添加到args裏
37 def func1(*args,**kwargs):#函數的定義：*變量 聚合功能，將所有的實參的位置參數聚合到元組裏。**變量 聚合功能，將實參的所有的鍵值對的參數聚合到字典裏。
38     print(args)
39     print(kwargs)
40 l1=[1,2,3,4]
41 l2=[‘a‘,‘b‘,‘c‘,5]
42 l3=(6,7,8,9,0)
43 func1(*l1,*l2,*l3)#函數的執行：*變量 打散功能。
44 #>>>(1, 2, 3, 4, ‘a‘, ‘b‘, ‘c‘, 5, 6, 7, 8, 9, 0)
45 #>>>{}
46 dic1={‘name1‘:‘Lucy‘}
47 dic2={‘name2‘:‘Lily‘}
48 func1(**dic1,**dic2)
49 #>>>()
50 #>>>{‘name1‘: ‘Lucy‘, ‘name2‘: ‘Lily‘}

三、函數的進階

python不是內存級別的編程語言，C語言是內存級別的編程語言，有指針的概念。

我們首先回憶一下Python代碼運行的時候遇到函數是怎麽做的，從Python解釋器開始執行之後，就在內存中開辟裏一個空間，每當遇到一個變量的時候，就把變量名和值之間對應的關系記錄下來，但是當遇到函數定義的時候，解釋器只是象征性的將函數名讀如內存，表示知道這個函數存在了，至於函數內部的變量和邏輯，解釋器根本不關心。
　　等執行到函數調用的時候，Python解釋器會再開辟一塊內存來儲存這個函數裏面的內容，這個時候，才關註函數裏面有哪些變量，而函數中的變量回儲存在新開辟出來的內存中，函數中的變量只能在函數內部使用，並且會隨著函數執行完畢，這塊內存中的所有內容也會被清空。
我們給這個‘存放名字與值的關系’的空間起了一個名字-------命名空間。
代碼在運行伊始，創建的存儲“變量名與值的關系”的空間叫做全局命名空間；
在函數的運行中開辟的臨時的空間叫做局部命名空間。

名稱空間：包括全局名稱空間，局部名稱空間，內置名稱空間。

全局名稱空間：程序運行時，存放變量與值的關系
臨時名稱空間：也叫局部名稱空間。存入函數裏面的變量與值的關系，隨著函數的執行結束，臨時名稱空間消失
內置名稱空間：創建py文件後，就會把內置名稱空間加載到內存

作用域：全局作用域：包括全局名稱空間 、內置名稱空間
局部作用域：局部名稱空間
加載順序：內置名稱空間--->全局名稱空間--->局部名稱空間（函數執行時）
取值順序：局部名稱空間--->全局名稱空間--->內置名稱空間

 1 #內置函數
 2 #globals() 把全局變量和值的關系放在字典中
 3 #locals() 把局部變量與值的關系放在字典中
 4 name1=‘Lucy‘
 5 def func1():
 6     name2 = ‘Lily‘
 7     print(globals())
 8     print(locals())
 9 func1()
10 #>>>{‘__name__‘: ‘__main__‘, ‘__doc__‘: ‘\n\n‘, ‘__package__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x000001E474CEC2B0>, ‘__spec__‘: None, ‘__annotations__‘: {}, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__file__‘: ‘C:/Users/28163/PycharmProjects/python21期/day3/day3筆記.py‘, ‘__cached__‘: None, ‘name1‘: ‘Lucy‘, ‘func1‘: <function func1 at 0x000001E474DC5F28>}
11 #>>>{‘name2‘: ‘Lily‘}
12 #關鍵字 ： global    nonlocal

Python筆記三（函數）