函數

函數是一堆組織好的、可重復利用的、用來實現某一功能的代碼。

python中的input()、print()、type()、bool()、len()等都是函數。且是python的內置函數。

我們也可以封裝自己的函數。

目錄

作用

將常用的一段代碼組織好封裝到一個函數中重復利用
通過傳入不同的參數、經過相同的計算，得到不同的結果。

可以將一個程序拆分成多個不同的函數，某些函數可以重復利用。在代碼復用上看，極大的減少了代碼的冗余量。

函數定義

我們來嘗試定義自己獨一無二的函數：

偽代碼

形參是函數參數的變量。
函數參數可以有多個、不限量

def 函數名(形參1,形參2...):
  函數體（要執行的內容）
  return 返回值

示例代碼

# 函數定義
def summation(a,b):
  return a + b

注意事項

一、定義：

def的意思是定義(define)，用來聲明定義一個函數。

二、函數名：

1. summation是函數名，是自定義的變量。
2. 名字最好能體現函數的功能，一般用小寫字母和單下劃線、數字等組合
3. 不可與內置函數重名（內置函數不需要定義即可直接使用）

三、參數：

1. 函數名后是英文的括號，括號內部定義參數變量。
2. 括號里可以有多個參數，也可以不帶參數。
3. 參數的命名規則與函數名相同
4. 括號后邊是英文冒號

四、函數體：

1. 冒號下邊是縮進后的代碼塊，即是函數的函數體。
2. 函數體是函數的執行過程，體現函數功能的語句，要縮進，一般是四個空格
3. 函數體內部的代碼是調用函數時才會被執行的代碼。不調用不會執行

五、返回值：

1. 函數體內部的return是用來返回值的。可以指定函數執行完畢后最終會返回什么值或表達式
2. return語句：后面可以接多種數據類型，如果函數不需要返回值的話，可以省略
3. 函數在執行過程中遇到第一個return語句就會停止執行，return后邊的第二個return永遠不會被執行。

函數調用

我們定義了函數后，想要使用這個函數就是調用函數。

比如我們常用的print()函數，我們傳入參數后就能幫我們打印出參數部分的內容，這就是函數調用了。

偽代碼

函數名+括號+可能的參數。

函數名(函數參數1,...更多參數)

示例代碼

# 函數定義
def summation(a,b):
  return a + b

# 函數調用
summation(1,2) 

函數調用后將得到函數內部的返回值。

函數參數

參數可以有多個，也可以沒有。視參數功能的情況而定。

參數傳遞

在函數調用時在括號中傳入的不同的值，這個值就是參數。

函數在接受到參數后，對其進行處理，并經過一定計算后返回不同的值。

如下，比如len()函數會根據括號里放的參數的不同，輸出（返回）不同的值。

var1 = '這是第一個示例變量'
print(len(var1)) # 9，得到字符串的長度為9
var2 = ['小石頭','xing.org1^','郭菊鋒']
print(len(var2)) # 3，得到數組的長度為3

上例中，len后邊括號里的var1、var2就是參數傳遞。

參數接收

函數調用時將參數傳遞過去、則函數定義時，也要準備好接收的變量，那就是形參。

def summation(a,b): # a,b就是對應接收的變量，是函數的形參。
  return a + b # 接收數據后，在函數內部被運用。

summation(1,2) # 1，2就是傳遞參數

無參函數

有的函數其功能不需要參數，就沒有參數預定和傳遞了。

def haha():
  print('只打印一句話，不用參數。')

haha()

參數類型

位置參數

當有多個參數的時候，我們就必須按照順序和數量傳遞，這也是最常見的參數類型。

如下案例：

def you(name,age,sex):
  print('your name is:', name)
  print('your age is:', age)
  print('your sex is:', sex)

you('小石頭','19','female')

# 打印結果如下：
# your name is: 小石頭
# your age is: 19
# your sex is: female

我們傳遞的三個參數必須和形參需要的內容一一對應，這就是位置參數。

一旦不對應就搞笑了

you('female','小石頭','19')

# 打印結果如下：
# your name is: female
# your age is: 小石頭
# your sex is: 19

默認參數

有時候我們有的參數多數情況下就用一個固定的值，有他的默認值。只有特殊情況下調用時才會需要不同的值，這時我們就可以定義默認參數。而不用每次都傳遞相同的參數了：

def newYou(name,age,sex='female'): # sex='female'就是默認參，參數的默認值是'female'。
  print("your's name:", name)
  print("your's age:", age)
  print("your's sex:", sex)

# 當不傳遞第三個參數時，取默認值'female'
newYou('小石頭','10')
# 打印結果：
# your's name: 小石頭
# your's age: 10
# your's sex: female

# 當傳遞了第三個參數時，取傳遞的參數male。
newYou('大石頭','29', 'male') 
# 打印結果
# your's name: 大石頭
# your's age: 29
# your's sex: male

sex='female'就是默認參，參數的默認值是'female'。
當不傳參數時，第三個參數默認取值為'female'。當傳遞了第三個參數時，取傳遞的參數。

??需要注意的是：默認參數必須放在位置參數之后。

不定長度參數

顧名思義，就是傳遞給參數的數量是可選的、不確定的。

不定長參數可以接收任意數量的值。
它的格式比較特殊，是一個星號*加上參數名，它的返回值也比較特殊，

def noLen(*variables):
    return variables

noLenResult = noLen('參數1','參數2','參數3')
#括號里的這幾個值都會傳遞給參數variables

print(noLenResult) # ('參數1', '參數2', '參數3')
print(type(noLenResult)) # <class 'tuple'>

<class 'tuple'>這種數據類型叫作元組(tuple)。見該篇章

在不定長參數后邊還可以放默認參

def noLenDefault(*variables, defaultVar = 123):
  print(variables)
  print(defaultVar)
  return variables
noLenDefault('a',15,6)

# ('a', 15, 6)
# 123

函數返回值

定義返回值

函數一定要有返回值，返回值寫在return后邊

有返回值的案例：

def summation(a,b):
  return a + b # return返回值、返回的是a+b的和。

result = summation(1,2) 
print(result) # 3。就是1+2的結果

沒有返回值

如果沒有明確寫return 返回值,那么Python也會在末尾隱性地加上return None，那么函數默認就會返回None值

沒有返回值的案例：

def summation(a,b):
  a + b 
  # 沒有return返回值

result = summation(1,2) 
print(result) # None
print(type(result)) # <class 'NoneType'>

調用函數之后，得到的結果是None。且結果的數據類型是'NoneType'

返回多個值

用return語句來返回多個值。

要返回多個值，只需將返回的值寫在return語句后面，用英文逗號隔開：

def returnmore(a,b,c):
  return a,b,c
returnResult = returnmore(1,3,4)
print(returnResult)

# 返回結果
# (1, 3, 4) 

可見返回結果也是元祖類型的

多個return

函數在執行過程中遇到第一個return語句就會停止執行，return后邊的第二個return永遠不會被執行。

def oneReturn():
  return 1
  print('這句不會執行')
  return 2

oneResult = oneReturn()
print(oneResult) # 1

可見，return返回值 不是2，而是1。這是因為第一個return后邊的內容不會再執行了。包括print和return 2

作用域

程序中的變量并不是在哪個位置都可以被使用的，使用權限決定于這個變量是在哪里賦值的。

局部變量與全局變量

1. 一個在函數內部賦值的變量僅能在該函數內部使用（局部作用域），它們被稱作【局部變量】
2. 在所有函數之外賦值的變量，可以在程序的任何位置使用（全局作用域），它們被稱作【全局變量】
3. 使用不在該函數作用域也不在全局作用域內的變量時，就會報錯“變量名未定義”

quanjuVar = '我是全局變量'
def jubuFn1():
  jubuVar1 = '我是局部變量1'
  print(quanjuVar,jubuVar1) # 我是全局變量 我是局部變量1

def jubuFn2():
  jubuVar2 = '我是局部變量2'
  print(quanjuVar,jubuVar2) # 我是全局變量 我是局部變量2
  print(jubuVar1) # 這段代碼放開就會報錯：NameError: name 'jubuVar1' is not defined

jubuFn1()
jubuFn2()

將局部變量全局化

怎么解決“局部變量”和”全局變量“之間的矛盾，實現函數間變量的相互傳遞呢？

1. 把局部變量都放在函數外，變成全局變量。
2. 使用global語句將局部變量聲明為全局變量
3. 函數嵌套

# 局部變量全局化
quanjuVar2 = '我是全局變量2'
jubuVar3 = '局部變量全局化，第一種方法'
def jubuFn3():
  # 在頂部將其全局化
  global jubuVar4
  jubuVar1 = '我是局部變量1'
  # 在下邊賦值全局化后的局部變量
  jubuVar4 = '我是局部變量4，我被global全局化了'
  print(quanjuVar,jubuVar1,jubuVar3) # 我是全局變量 我是局部變量1 局部變量全局化，第一種方法

def jubuFn4():
  jubuVar2 = '我是局部變量222'
  print(quanjuVar,jubuVar2) # 我是全局變量 我是局部變量222
  print(jubuVar3) # 局部變量全局化，第一種方法
  print(jubuVar4) # 這段代碼這次就能正常執行了，因為jubuVar4這個變量被全局化了。打印：我是局部變量4，我被global全局化了

jubuFn3()
jubuFn4()

global語句一般寫在函數體的第一行，它會告訴Python，“我希望jubuVar4是個全局變量，所以請不要用這個名字創建一個局部變量”。

所以jubuFn4()函數內部現在可以直接使用聲明后的全局變量jubuVar4。

函數嵌套

函數嵌套也可以實現函數間變量的相互傳遞

# 函數嵌套
quanjuVar3 = '我是全局變量3'
def jubuFn5():
  jubuVar5 = '我是局部變量5'
  print(quanjuVar,jubuVar5) # 我是全局變量 我是局部變量5
  def jubuFn6():
    jubuVar6 = '我是局部變量666'
    print(quanjuVar3,jubuVar6) # 我是全局變量3 我是局部變量666
    print(jubuVar5) # 我是局部變量5 (因為嵌套，內部的函數可以用全局的變量、也可以用父級函數內部的變量)
  jubuFn6()

jubuFn5()

以上是函數定義的嵌套。

下邊還有函數調用的嵌套

# 函數調用的嵌套
def one(a):
  return a

def two(a,b):
  return one(a) + b

andResult = two(1,2)
print(andResult) # 3

在函數two中，調用了one函數之后的結果，與b參數相加后再return出去

練習題

仿寫len()函數

實現具有相同功能的函數
思路：

1. 設置一個初始為0的計數器；
2. 遍歷字符串，每遍歷一次，計數器加一；
3. 返回計數器的值。

源代碼

本文使用 mdnice 排版