1.函數：
作用：函數是組織好的，可重複使用的，用來實現單一，或相關聯功能的代碼。
（淺顯理解：把具有獨立功能的代碼塊，分裝爲一個小模塊，在需要的時候調用)
可以把數據類型給到變量，可以把代碼放到函數裏面，後面在任何地方都可以調用。
函數能提高應用的模塊性，和代碼的重複利用率。
print()是python內建的許多函數的一種。
規則：
1.函數必須先定義後調用，否則報錯 ###注意：程序在執行時，由上到下，遇到函數會直接跳過，如果遇到調用函數的代碼，會返回到函數執行函數，再繼續執行剩下代碼
2.函數名命名規則同變量的命名規則
3.函數體內可以寫任意代碼，不受限制
python定義函數使用 def 關鍵字
小知識點：：：
（1）文檔註釋：
1.文檔註釋的格式和多行註釋格式完全相同
2.文檔註釋書寫的位置是函數體的第一行
3.查看函數的文檔註釋是按住鍵盤Ctrl鍵後，
鼠標放置在書寫調用函數位置的函數名上
（2）函數調用過程分析：
DEBUG過程進入函數內部兩種方式：
在函數內部打斷點，配合F8進行（不會忘）
在進入函數執行時，使用快捷鍵F7（容易忘）
點按鈕（巨LOW，太土，不專業，忘了吧）
重點來啦：：：
首先定義函數，然後才能調用函數：：：
定義某一個函數的公式：
定義函數
def 函數名(參數1，參數2，……)：
____函數體
……
調用函數
函數名(參數1，參數2，……)
（小知識點：如果沒有寫函數體，可以寫個pass就不會報錯）
知識點一：：： 參數
帶有參數的函數：
1.函數外面的數據通過參數傳遞到函數中
2.一個函數在定義時，可以帶有多個參數
3.函數定義多個參數時，參數之間使用，(逗號)分隔
4.調用帶有參數的函數時，傳入的數據之間使用，(逗號)分隔
帶有參數的函數的注意事項：
1.參數的數量一定要一一對應，不然會報錯
2.函數定義的位置，參數只能寫變量，直接寫數據會報錯
3.函數調用的位置，參數可以寫數據，也可以寫變量
形參與實參：
1.形參是定義函數時規定的參數，僅在函數體內有效
2.實參是調用函數時使用的參數，該值將傳遞給函數的形參
參數分類：：：
（1）必備參數：
如果定義函數的時候有參數，則稱之爲必備參數。
（2）默認參數：
如果函數調用的時候，沒有給默認參數傳值，那麼使用的就是默認值；如果給了。就使用給的值。
def func(x, y=None):
print(x)
print(y)
函數調用：
func(1)
func(1, 2)
注意：默認參數要位於必備參數
列表的後面
（3）不定長參數：
*args不定長參數，接收多個實參
*作用：把單個的值，化爲整體；也可以把一個整體拆分出來。 代表元組。
def fun1(*args)：
print(args) #如果print裏面只是args則把單個的值化爲一個整體，變爲元組的格式；如果裏面是args則把一個整體拆分爲一個個的單個的值。
fun1(1,2,3,4,5,6,7,8)
**kwargs 接收賦值的形式，把他變爲字典。
def fun2(**kwargs):
print(kwargs)
#print(**kwargs) 不能這樣寫，會報錯
fun2(name = ‘乾乾’,age = 18,sex = ‘NAN’)
書面化的講解：
def func(args, **kwargs):
print(args)
print(kwargs)
調用1：func(1, 2, 3, a=4, b=5, c=6)
調用2：func((1, 2, 3), **{‘a’: 4, ‘b’: 5, ‘c’: 6})
延伸講解：
*接受多個值
a,*b = [1,2,3,4,5]
a爲1
b爲[2,3,4,5]
（4）關鍵字參數：
def func(x):
print(x)
函數調用：
func(x=1)
小知識點：：：
（1）定義參數：
必備參數
默認參數
不定長參數
（2）參數的調用：
位置參數
關鍵字參數
（3）在python中參數 無類型，參數可以接受 任意對象，只有函數中代碼纔會對參數類型有限制
知識點二：：： return
1.函數將數據從函數內部輸送到函數外部，需要使用關鍵字return
2.函數的運行結果可以使用變量接收，也可以不接收
3.如果一個函數沒有設置返回值，使用變量接收時結果爲None
4.同一個函數執行過程中能執行一次return語句，執行return
語句後，函數執行完畢，程序繼續執行
例如：
定義函數 例子：計算面積。
def 函數名(參數1，參數2，……)： def area(width,height):
____函數體 return width*height
____return 函數運行結果返回值 如何執行：print(area(3,4)) 輸出爲：12
……
調用函數
變量名 = 函數名(參數1，參數2，……)
重點：
1.return 後面可以返回任意表達式，但不能是賦值語句。
2.return是函數的返回值，返回值可以賦值給變量；但print只是打印出來。
知識點三：：：
作用域：
全局變量（全局作用域）與局部變量（局部作用域）
1.局部變量是定義在函數內部的，在函數內部有效
2.全局變量是定義在函數外部的，在整個文件中有效
注意：
1.局部變量只在定義的函數內部有效，函數間的局部變量不能共享使用
2.全局變量可以在函數內直接使用
3.函數內部和外部定義了同名的變量時，函數內部使用的是局部變量
昇華：：：
4.函數內部和外部定義了同名的變量時，使用全局變量必須在函數內聲
明，格式：global 全局變量名
聲明局部變量 nonlocal
如果在函數內部聲明瞭全局變量，那麼在函數內部就可以更改全局變量，因爲現在函數內部使用的就是全局變量，指向了同一片內存空間。
外部不能訪問函數內部變量。
函數內部的變量能夠訪問函數外部的變量。
函數內部不可以修改函數外部的變量。
函數裏面和函數外部變量名相同時：指向同一個地址；類型淺複製。
def zhangsan():
x = 4 #內部變量賦值 局部變量
def wumou():
nonlocal x #聲明局部變量，如果不聲明這個局部變量，就會報錯，用不到這個局部變量x
x = x+1
print(x)
return x
return wumou()
知識點四：：：
常見函數： 進制轉換函數： 高級內置函數：
len求長度 bin轉換爲二進制 enumerate返回一個可以枚舉的對象 dict(enumerate(序列類型))
min求最小值 oct轉換爲八進制 eval取字符串中的內容，將字符串str當成有效的表達式來求指並返回計算結果，不能賦值。
max 求最大值 hex轉換爲十六進制 exec 執行字符串編譯過的字符串
sorted排序 ord字符轉ASCII碼 filter 過濾器
reversed 反向 char ASCII碼轉字符 map()
sum 求和 zip將對象逐一配對
舉例講解一些：
普通的：
之前列表裏的sort和reverse會改變原來的值，沒有返回值 列表的方法
sorted和reversed不會改變原來的值，有返回值 內置函數
例子：
li = [1,2,3,4]
print(sorted(li)) 從小到大排序
print(sorted(li,reverse = True)) 從大到小排序
print(list(reversed(li)))
轉化爲二進制：
print(bin(3))
輸出爲ob11
轉換爲八進制：
print(oct(9))
輸出爲0o11
轉化爲十六進制：
print(hex(15))
輸出爲15
字符轉化爲ASCII碼：
print(ord(‘寒’))
ASCII轉化爲字符：
print(char(‘23565’))
高級的：
（1）枚舉：會把索引值給拿出來
li = [‘寒沙’,‘劍來’,‘低調’]
a = enumerate(li)
print(tuple(a)) 輸出爲：((0, ‘寒沙’), (1, ‘劍來’), (2, ‘低調’))
###tuple可換爲dict，list等
（2）eval和exec
eval 取出字符串的內容，將字符串當做有效的表達式來計算，返回結果。
a = eval(‘1+1’)
print(a) 輸出爲2
exec 將字符串當做代碼執行
a = exec(‘aa = 1 + 1’)
print(aa) 輸出爲2
（3）filter 過濾器
def aa(obj):
pass
f = filter(aa,‘adfsfaaf’)
用參數二過濾返回爲true的元素
list(f) ：類型轉換的時候調用
例子：
def func(x):
if x>3:
return True
else:
return False
li = [1,2,3,4,5,6]
f = filter(func,li) filter有兩個參數，第一個參數是函數名字，第二個參數是可迭代對象（序列類型和散列類型）
作用：把列表裏面的每一個元素放到函數裏面進行過濾。
如果是True就保留下來；如果是False就不要。
print(list(f)
上爲filter:::
filter 根據True或者是False過濾列表裏面的東西，列表不變
map 把列表放到函數裏面運算，返回結果
下爲map:::
（4）map 跟filter差不多，它拿到的是放回值
對於參數iterable中的每個元素都應用fuction函數，並將結果作爲列表返回
例子：
li = [1,2,3,4,5,6]
def fun(x)：
return x + x
m = map(fun,li) 把列表裏面每一個元素放到函數裏面計算運算，返回運算的結果
print(list(m)
拓展：
list(map(abs,[-1,-2,0,1,2]))
把後面的列表裏的所有數都經過函數abs。
（5）zip 將對象逐一配對
li1 = [‘寒沙’,‘羅漢’，‘龍雨’,‘劍威’]
li2 = [‘小姐姐’,‘鱷魚’,‘大漢’,‘劍來’]
z = zip(li1,li2) #zip可以配對多個，大於兩個也可以。
print(list(z))
輸出爲{‘寒沙’: ‘小姐姐’, ‘羅漢’: ‘鱷魚’, ‘龍雨’: ‘大漢’, ‘劍威’: ‘劍來’}
函數再升級的騷操作啦：：：！！！
（1）閉包
小知識點：
函數引用：
def fun1():
print(‘this is fun1’)
fun1() #這樣可以調用
fun = fun1 #賦值 能夠讓fun和fun1指向同一片內存空間
fun() #通過賦值之後的也可以調用函數
引入的話看這個例子：
def fun1():
print(‘this is fun1’)
def fun2():
print(‘this is fun2’)
fun2() #如果要使用函數裏嵌套的函數fun2，就要調用，這樣在調用fun1的時候纔會使用到內層函數fun2
fun1()
仔細看看，現在我要把這個例子變成閉包了：：：
def fun1():
print(‘this is fun1’)
def fun2():
print(‘this is fun2’)
return fun2 #在函數fun1下面返回裏面函數的名字
fun1() ()
注意：：：
return fun2相當於fun1()裏面有了fun2()
現在如果調用fun1()的時候直接fun1()，就相當於fun1() = fun2 。這樣還是隻執行了fun1()。
所以等號兩邊同時加個括號，看可以把fun2()函數也執行了:fun1()() = fun2()
昇華一下啦：：：！！！
內嵌函數：
閉包是函數裏面嵌套函數，外層函數返回裏層函數的函數名，這種情況稱爲閉包。
閉包是概念，不是某種函數類型，和遞歸的概念類似，就是種特殊的函數調用
閉包可以得到外層函數的局部變量，是函數內部和函數外部溝通的橋樑
例子：
def zhangxinyi(x):
x + 2000
def wuhan(y):
return y+x
return wuhan
（2）遞歸：
函數自己調用自己，如果不做限制，就一直調用自己，直到超出最大的遞歸深度而報錯。
引入例子：
def fun():
print(‘this is fun’)
fun()
fun()
下面講到正題：：：！！！
階乘factorical：：： 5！ = 54321
例子：
def fun(n):
if n == 1:
return 1
return n*fun(n-1)
print(fun(5))
解釋下：：：
#nfun(n-1)
#fun(5)返回5fun(4)
#fun(4)返回4fun(3)
#fun(3)返回4fun(2)
#fun(2)返回4*fun(1)
#fun(1)返回 1 #如果不加限制，就會一直往下遞歸，所以應該加個限制，就是上面的if語句
在來個例子：：：
#遞歸求高斯求和
def sum(n):
if n == 1:
return 1
return n + sum(n-1)
print(sum(100))
#n = 100 return 100 + sum(99)
#n = 99 return 99 + sum(98)
#n = 98 return 98 + sum(97)
#…
#n = 1 return 1
（3）回調
def funa():
print(‘清水白石廈寒沙’)
def funb(fun,flag): #把funa給到fun
if flag == 1:
fun() #這裏fun加括號，相當於funa加括號，即fun() = funa()。在上面函數的引用有講解哦
else:
print(111)
funb(funa,1)
關於那個加括號，深化結合理解下：：：
1.嵌套函數
def a():
def b():
print(111)
return b()
a()
2.閉包
def a():
def b():
print(111)
return b
a()()
（4）關鍵字傳參
def wuhan(str): 跟type的功能一樣，如果直接傳入一個關鍵字，會告訴python解釋器輸出他們的類型。
print(str)
return
wuhan(str)
輸出爲： <class,'str>
（5）匿名函數
python中使用lambda來創建匿名函數。
lambda函數的語法只包含一個語句。
語法規則：lambda 參數：表達式
例如：
函數體： lambda形式：
def wuhan(x): wuhan = lambda x:x+1 #第一個x是形參，後面x+1相當於return x+1
#代碼塊
return x+1 print(wuhan(3))
print(wuhan(3))
優點：lambda只是一個表達式，函數體比def簡單很多。
匿名函數的合理利用能夠讓那個代碼更加簡潔。
缺點：lambda表達式中封裝有限的邏輯進去。
簡單的函數就用lambda來操作。
類似於filter,map等函數裏面可以使用匿名函數來處理。例如：filter(lambda x: x>10, li)
拓展個知識點：
函數或者方法調用過程中，一般放到if name == 'main’下面
成爲主函數的入口；程序的窗口 規範一些
在導包的過程中 if name == 'main’下面的內容不會在導包的這個文件中顯示。
if name == ‘main’:
print(11)
輸出爲：
11