Python 函數
1、函數的瞭解
1)函數是組織好的，可重複使用的，用來實現單一，或相關聯功能的代碼段
2)函數能提高應用的模塊性，和代碼的重複利用
3)Python提供了許多內建函數，比如print()
4)自己創建函數，這被叫做用戶自定義函數
2、定義一個函數
1)函數代碼塊以 def 關鍵詞開頭，後接函數標識符名稱和圓括號 ()。
2)任何傳入參數和自變量必須放在圓括號中間，圓括號之間可以用於定義參數。
3)函數的第一行語句可以選擇性地使用文檔字符串—用於存放函數說明。
4)函數內容以冒號起始，並且縮進。
5)return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當於返回 None。一般格式：
def 函數名（參數列表）:
函數體
3、參數傳遞
1) 在 python 中，對象纔有類型，變量是沒有類型的
例如：
a = [m,n,k]
b = '1234'
以上代碼中，[m,n,k] 是 List 類型，'1234' 是 String 類型，
而變量 a 是沒有類型，它僅僅是一個對象的引用（一個指針），可以是指向 List 類型對象，
也可以是指向 String 類型對象。
2) 可更改(mutable)與不可更改(immutable)對象
在 python 中，字符串、元組和 Number 是不可更改的對象，而 list,dict 等則是可以修改的對象。
不可變類型：
變量賦值 a=5 後再賦值 a=10，這裏實際是新生成一個 int 值對象 10，
再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當於新生成了a。
可變類型：
變量賦值 la=[1,2,3,4] 後再賦值 la[2]=5 則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。3) python 函數的參數傳遞：
不可變類型：
類似 c++ 的值傳遞，如 整數、字符串、元組。如fun（a），傳遞的只是a的值，沒有影響a對象本身。
比如在 fun（a）內部修改 a 的值，只是修改另一個複製的對象，不會影響 a 本身。
可變類型：
類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改後fun外部的la也會受影響
3.1 python 傳對象實戰
print('3.1 python 傳不可變對象實例')
def ChangeInt(a): #定義一個函數
a = 10 #在 a=10 時，則新生成一個 int 值對象 10，並讓 a 指向它
b = 2 # 定義一個變量 實例中有 int 對象 2，指向它的變量是 b
ChangeInt(b) # 調用函數 按傳值的方式複製了變量 b，a 和 b 都指向了同一個 Int 對象，
print(f'b的值爲{b}:') # 格式化字符串輸出， 結果依舊是 2 並沒有改變對象的值
#3.2 傳可變對象實例
print()
print('3.2 傳可變對象實例')
def changeme(mylist): #定義一個函數
mylist.append([1, 2, 3, 4])
print("函數內取值: ", mylist)
return
# 調用changeme函數
mylist = [10, 20, 30]
changeme(mylist)
print("函數外取值: ", mylist)
3.3參數類型
以下是調用函數時可使用的正式參數類型：
必需參數
關鍵字參數
默認參數
不定長參數
3.3.1 必須參數
#3.3.1 必需參數
print()
print('3.3.1 必需參數')
#必需參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。
def power(x): #參數x就是一個必須參數，如果調用的時候不傳入 就會報錯
return x*x
#調用並打印結果 如果 pow()不傳參數就會報錯
print('4的平方是：',power(4))
3.3.2 關鍵字參數
1)關鍵字參數和函數調用關係緊密，函數調用使用關鍵字參數來確定傳入的參數值。
2)使用關鍵字參數允許函數調用時參數的順序與聲明時不一致，因爲 Python 解釋器能夠用參數名匹配參數值
3)關鍵字參數與普通參數混合的時候，只能從參數的最後面匹配,否則報錯
注意：
是在調用的時候指定某個參數的值
def printStr(str,str1):
print('輸出的字符串：',str,'和',str1)
#調用該函數 printStr(str=23,'abc') 如果這樣調用則報錯，關鍵字參數與普通參數混合的時候，只能從參數的最後面匹配
printStr('abc',str1=123)
printStr(str1=123,str='abc')
3.3.3 默認參數
調用函數時，如果沒有傳遞參數，則會使用默認參數
注意：
定義函數的時候就指定了某個參數的值
def printInfo(name,age=12):
print('名字：',name)
print('年齡：',age)
#調用 關鍵參數使用 全是關鍵參數的時候 參數傳入順序可以打亂
printInfo(age=20, name='XiaoMing')
print("------------------------")
#關鍵參數+默認參數 使用
printInfo(name="XiaoMing")
#默認參數 使用
printInfo("XiaoMing")
3.3.4 不定長參數
一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數，聲明時不會命名
語法格式一：
def functionname([formal_args,] *var_args_tuple ):
function_suite
return [expression]這種語法傳入的其實是一個元組，加了星號 * 的參數會以元組(tuple)的形式導入，存放所有未命名的變量參數
語法格式二：
def functionname([formal_args,] **var_args_dict ):
function_suite
return [expression]
這種語法參數帶兩個星號 **的會以 字典 的形式導入
# 語法格式一：傳遞一個元組
def printInfo(arg1, *vartuple):
print("輸出參數arg1: ",end='')
print(arg1)
print("輸出元組參數vartuple: ",end='')
print(vartuple)
# 調用printInfo 函數
printInfo(70, 60, 50)
# 這個時候 參數 vartuple並沒有被賦值，所以打印出來就是一個空的元組
printInfo('abc')
# 語法格式二 傳遞一個字典
def printInfo(arg1, **vardict):
print("輸出參數arg1: ", end='')
print(arg1)
print("輸出元組參數vardict: ", end='')
print(vardict)
# 調用printinfo 函數
printInfo(1, a=2, b=3)
3.3.5 匿名函數
python 使用 lambda 來創建匿名函數。
所謂匿名，意即不再使用 def 語句這樣標準的形式定義一個函數。1) lambda 只是一個表達式，函數體比 def 簡單很多
2) lambda 的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去
3) lambda 函數擁有自己的命名空間，且不能訪問自己參數列表之外或全局命名空間裏的參數
4) 雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，後者的目的是調用小函數時不佔用棧內存從而增加運行效率
#lambda 函數的語法只包含一個語句
'''
語法格式：
lambda [arg1 [,arg2,.....argn]]:expression
'''
#定義一個函數
sum = lambda arg1, arg2: arg1 + arg2
#調用函數
print('兩數相加後之和爲:',sum(3,2))
4、給大佬奉茶
實例如下：
#1、函數的瞭解
print()
print('1、函數的瞭解')
'''
1)函數是組織好的，可重複使用的，用來實現單一，或相關聯功能的代碼段
2)函數能提高應用的模塊性，和代碼的重複利用
3)Python提供了許多內建函數，比如print()
4)自己創建函數，這被叫做用戶自定義函數
'''
#2、定義一個函數
print()
print('2、定義一個函數')
'''
1)函數代碼塊以 def 關鍵詞開頭，後接函數標識符名稱和圓括號 ()。
2)任何傳入參數和自變量必須放在圓括號中間，圓括號之間可以用於定義參數。
3)函數的第一行語句可以選擇性地使用文檔字符串—用於存放函數說明。
4)函數內容以冒號起始，並且縮進。
5)return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當於返回 None。
一般格式：
def 函數名（參數列表）:
函數體
'''
# 計算面積函數
#定義一個函數
def area(width, height):
return width * height
#調用函數 並打印出結果
print('長方形的面積=',area(212,369))
#3、參數傳遞
print()
print('3、參數傳遞')
'''
1)在 python 中，對象纔有類型，變量是沒有類型的
例如：
a = [m,n,k]
b = '1234'
以上代碼中，[m,n,k] 是 List 類型，'1234' 是 String 類型，
而變量 a 是沒有類型，它僅僅是一個對象的引用（一個指針），可以是指向 List 類型對象，
也可以是指向 String 類型對象。
2)可更改(mutable)與不可更改(immutable)對象
在 python 中，字符串、元組和 Number 是不可更改的對象，而 list,dict 等則是可以修改的對象。
不可變類型：
變量賦值 a=5 後再賦值 a=10，這裏實際是新生成一個 int 值對象 10，
再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當於新生成了a。
可變類型：
變量賦值 la=[1,2,3,4] 後再賦值 la[2]=5 則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。
3)python 函數的參數傳遞：
不可變類型：
類似 c++ 的值傳遞，如 整數、字符串、元組。如fun（a），傳遞的只是a的值，沒有影響a對象本身。
比如在 fun（a）內部修改 a 的值，只是修改另一個複製的對象，不會影響 a 本身。
可變類型：
類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改後fun外部的la也會受影響
'''
#3.1 python 傳不可變對象實例
print()
print('3.1 python 傳不可變對象實例')
def ChangeInt(a): #定義一個函數
a = 10 #在 a=10 時，則新生成一個 int 值對象 10，並讓 a 指向它
b = 2 # 定義一個變量 實例中有 int 對象 2，指向它的變量是 b
ChangeInt(b) # 調用函數 按傳值的方式複製了變量 b，a 和 b 都指向了同一個 Int 對象，
print(f'b的值爲{b}:') # 格式化字符串輸出， 結果依舊是 2 並沒有改變對象的值
#3.2 傳可變對象實例
print()
print('3.2 傳可變對象實例')
def changeme(mylist): #定義一個函數
mylist.append([1, 2, 3, 4])
print("函數內取值: ", mylist)
return
# 調用changeme函數
mylist = [10, 20, 30]
changeme(mylist)
print("函數外取值: ", mylist)
#3.3參數類型
'''
以下是調用函數時可使用的正式參數類型：
必需參數
關鍵字參數
默認參數
不定長參數
'''
#3.3.1 必需參數
print()
print('3.3.1 必需參數')
#必需參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。
def power(x): #參數x就是一個必須參數，如果調用的時候不傳入 就會報錯
return x*x
#調用並打印結果 如果 pow()不傳參數就會報錯
print('4的平方是：',power(4))
#3.3.2 關鍵字參數
print()
print('3.3.2 關鍵字參數')
'''
1)關鍵字參數和函數調用關係緊密，函數調用使用關鍵字參數來確定傳入的參數值。
2)使用關鍵字參數允許函數調用時參數的順序與聲明時不一致，因爲 Python 解釋器能夠用參數名匹配參數值
3)關鍵字參數與普通參數混合的時候，只能從參數的最後面匹配,否則報錯
注意：
是在調用的時候指定某個參數的值
'''
def printStr(str,str1):
print('輸出的字符串：',str,'和',str1)
#調用該函數 printStr(str=23,'abc') 如果這樣調用則報錯，關鍵字參數與普通參數混合的時候，只能從參數的最後面匹配
printStr('abc',str1=123)
printStr(str1=123,str='abc')
#3.3.3 默認參數
print()
print('3.3.3 默認參數')
'''
調用函數時，如果沒有傳遞參數，則會使用默認參數
注意：
定義函數的時候就指定了某個參數的值
'''
def printInfo(name,age=12):
print('名字：',name)
print('年齡：',age)
#調用 關鍵參數使用 全是關鍵參數的時候 參數傳入順序可以打亂
printInfo(age=20, name='XiaoMing')
print("------------------------")
#關鍵參數+默認參數 使用
printInfo(name="XiaoMing")
#默認參數 使用
printInfo("XiaoMing")
#3.3.4 不定長參數
print()
print('3.3.4 不定長參數')
'''
一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數，聲明時不會命名
語法格式一：
def functionname([formal_args,] *var_args_tuple ):
"函數_文檔字符串"
function_suite
return [expression]
這種語法傳入的其實是一個元組，加了星號 * 的參數會以元組(tuple)的形式導入，存放所有未命名的變量參數
語法格式二：
def functionname([formal_args,] **var_args_dict ):
"函數_文檔字符串"
function_suite
return [expression]
這種語法參數帶兩個星號 **的會以 字典 的形式導入
'''
# 語法格式一：傳遞一個元組
def printInfo(arg1, *vartuple):
print("輸出參數arg1: ",end='')
print(arg1)
print("輸出元組參數vartuple: ",end='')
print(vartuple)
# 調用printInfo 函數
printInfo(70, 60, 50)
# 這個時候 參數 vartuple並沒有被賦值，所以打印出來就是一個空的元組
printInfo('abc')
# 語法格式二 傳遞一個字典
def printInfo(arg1, **vardict):
print("輸出參數arg1: ", end='')
print(arg1)
print("輸出元組參數vardict: ", end='')
print(vardict)
# 調用printinfo 函數
printInfo(1, a=2, b=3)
#3.3.5 匿名函數
print()
print('3.3.5 匿名函數')
'''
python 使用 lambda 來創建匿名函數。
所謂匿名，意即不再使用 def 語句這樣標準的形式定義一個函數。
1)lambda 只是一個表達式，函數體比 def 簡單很多
2)lambda 的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去
3)lambda 函數擁有自己的命名空間，且不能訪問自己參數列表之外或全局命名空間裏的參數
4)雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，後者的目的是調用小函數時不佔用棧內存從而增加運行效率
'''
#lambda 函數的語法只包含一個語句
'''
語法格式：
lambda [arg1 [,arg2,.....argn]]:expression
'''
#定義一個函數
sum = lambda arg1, arg2: arg1 + arg2
#調用函數
print('兩數相加後之和爲:',sum(3,2))
所有輸出結果
C:\Users\Administrator\AppData\Local\Programs\Python\Python38-32\python.exe F:/python-space/test/Function_study.py
1、函數的瞭解
2、定義一個函數
長方形的面積= 78228
3、參數傳遞
3.1 python 傳不可變對象實例
b的值爲2:
3.2 傳可變對象實例
函數內取值: [10, 20, 30, [1, 2, 3, 4]]
函數外取值: [10, 20, 30, [1, 2, 3, 4]]
3.3.1 必需參數
4的平方是： 16
3.3.2 關鍵字參數
輸出的字符串： abc 和 123
輸出的字符串： abc 和 123
3.3.3 默認參數
名字： XiaoMing
年齡： 20
------------------------
名字： XiaoMing
年齡： 12
名字： XiaoMing
年齡： 12
3.3.4 不定長參數
輸出參數arg1: 70
輸出元組參數vartuple: (60, 50)
輸出參數arg1: abc
輸出元組參數vartuple: ()
輸出參數arg1: 1
輸出元組參數vardict: {'a': 2, 'b': 3}
3.3.5 匿名函數
兩數相加後之和爲: 3223
Process finished with exit code 0