2. 程式人生 > >python第四章：函數--小白博客

python第四章：函數--小白博客

阿新 • • 發佈：2019-03-19
新的 err 簡單 包含 pos variable uno sig required

Python函數

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

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

定義一個函數

你可以定義一個由自己想要功能的函數，以下是簡單的規則：

  • 函數代碼塊以 def 關鍵詞開頭，後接函數標識符名稱和圓括號 ()。
  • 任何傳入參數和自變量必須放在圓括號中間，圓括號之間可以用於定義參數。
  • 函數的第一行語句可以選擇性地使用文檔字符串—用於存放函數說明。
  • 函數內容以冒號起始，並且縮進。
  • return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當於返回 None。

語法

Python 定義函數使用 def 關鍵字，一般格式如下：

def 函數名（參數列表）:
    函數體

默認情況下，參數值和參數名稱是按函數聲明中定義的順序匹配起來的。

實例

讓我們使用函數來輸出"Hello World！"：

def hello_world():
    print(‘Hello World‘)

hello_world()

執行結果如下

Hello World

更復雜點的應用，函數中帶上參數變量:

技術分享圖片 
def area(width, height):
    return width * height

def print_welcome(name):
    print(
 
"Welcome", name)

print_welcome("ken")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))
技術分享圖片

執行結果如下

Welcome ken
width = 4  height = 5  area = 20

函數調用

定義一個函數：給了函數一個名稱，指定了函數裏包含的參數，和代碼塊結構。

這個函數的基本結構完成以後，你可以通過另一個函數調用執行，也可以直接從 Python 命令提示符執行。

如下實例調用了 printme() 函數：

技術分享圖片 
def printme( str ):
   # 打印任何傳入的字符串
   print (str)
   
 
return

# 調用函數
printme("我要調用用戶自定義函數!")
printme("再次調用同一函數")
技術分享圖片

執行結果如下

我要調用用戶自定義函數!
再次調用同一函數

參數傳遞

在 python 中，類型屬於對象，變量是沒有類型的：

a=[1,2,3]

a="Runoob"

以上代碼中，[1,2,3] 是 List 類型，"Runoob" 是 String 類型，而變量 a 是沒有類型，她僅僅是一個對象的引用（一個指針），可以是指向 List 類型對象，也可以是指向 String 類型對象。

可更改(mutable)與不可更改(immutable)對象

在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是可以修改的對象。

  • 不可變類型：變量賦值 a=5 後再賦值 a=10，這裏實際是新生成一個 int 值對象 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當於新生成了a。

  • 可變類型：變量賦值 la=[1,2,3,4] 後再賦值 la[2]=5 則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。

python 函數的參數傳遞：

  • 不可變類型：類似 c++ 的值傳遞，如 整數、字符串、元組。如fun（a），傳遞的只是a的值，沒有影響a對象本身。比如在 fun（a）內部修改 a 的值，只是修改另一個復制的對象，不會影響 a 本身。

  • 可變類型：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改後fun外部的la也會受影響

python 中一切都是對象，嚴格意義我們不能說值傳遞還是引用傳遞，我們應該說傳不可變對象和傳可變對象。

python 傳不可變對象實例

def ChangeInt( a ):
    a = 10
 
b = 2
ChangeInt(b)
print( b ) # 結果是 2

實例中有 int 對象 2，指向它的變量是 b，在傳遞給 ChangeInt 函數時，按傳值的方式復制了變量 b，a 和 b 都指向了同一個 Int 對象，在 a=10 時，則新生成一個 int 值對象 10，並讓 a 指向它。

傳可變對象實例

可變對象在函數裏修改了參數，那麽在調用這個函數的函數裏，原始的參數也被改變了。例如：

技術分享圖片 
# 可寫函數說明
def changeme( mylist ):
   "修改傳入的列表"
   mylist.append([1,2,3,4])
   print ("函數內取值: ", mylist)
   return
 
# 調用changeme函數
mylist = [10,20,30]
changeme( mylist )
print ("函數外取值: ", mylist)
技術分享圖片

傳入函數的和在末尾添加新內容的對象用的是同一個引用。故輸出結果如下：

函數內取值:  [10, 20, 30, [1, 2, 3, 4]]
函數外取值:  [10, 20, 30, [1, 2, 3, 4]]

參數

以下是調用函數時可使用的正式參數類型：

  • 必需參數
  • 關鍵字參數
  • 默認參數
  • 不定長參數

必需參數

必需參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。

調用printme()函數，你必須傳入一個參數，不然會出現語法錯誤：

技術分享圖片 
#函數說明
def printme( str ):
   "打印任何傳入的字符串"
   print (str)
   return
 
#調用printme函數
printme()
技術分享圖片

輸出結果為

Traceback (most recent call last):
  File "D:/python/ken.py", line 203, in <module>
    printme()
TypeError: printme() missing 1 required positional argument: ‘str‘

關鍵字參數

關鍵字參數和函數調用關系緊密，函數調用使用關鍵字參數來確定傳入的參數值。

使用關鍵字參數允許函數調用時參數的順序與聲明時不一致，因為 Python 解釋器能夠用參數名匹配參數值。

以下實例在函數 printme() 調用時使用參數名：

技術分享圖片 
#可寫函數說明
def printme( str ):
   "打印任何傳入的字符串"
   print (str)
   return

#調用printme函數
printme( str = "ken")
技術分享圖片

輸出結果為

ken

以下實例中演示了函數參數的使用不需要使用指定順序：

技術分享圖片 
def printinfo( name, age ):
   "打印任何傳入的字符串"
   print ("名字: ", name)
   print ("年齡: ", age)
   return
 
#調用printinfo函數
printinfo( age=50, name="runoob" )
技術分享圖片

輸出結果為

名字:  runoob
年齡:  50

默認參數

調用函數時，如果沒有傳遞參數，則會使用默認參數。以下實例中如果沒有傳入 age 參數，則使用默認值：

註意：默認參數必須放在最後面，否則會報錯！

技術分享圖片 
def printinfo( name, age = 23 ):
   "打印任何傳入的字符串"
   print ("名字: ", name)
   print ("年齡: ", age)
   return

#調用printinfo函數
printinfo( age=50, name="ken" )
print ("------------------------")
printinfo( name="ken" )
技術分享圖片

輸出結果為

名字:  ken
年齡:  50
------------------------
名字:  ken
年齡:  23

不定長參數

你可能需要一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數，和上述 2 種參數不同，聲明時不會命名。

技術分享圖片 
# 可寫函數說明
def printinfo( arg1, *vartuple ):
   "打印任何傳入的參數"
   print ("輸出: ")
   print (arg1)
   print (vartuple)
 
# 調用printinfo 函數
printinfo( 70, 60, 50 )
技術分享圖片

輸出結果為

輸出: 
70
(60, 50)

如果在函數調用時沒有指定參數，它就是一個空元組。我們也可以不向函數傳遞未命名的變量。如下實例：

技術分享圖片 
# 可寫函數說明
def printinfo( arg1, *vartuple ):
   "打印任何傳入的參數"
   print ("輸出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return

# 調用printinfo 函數
printinfo( 10 )
printinfo( 70, 60, 50 )
技術分享圖片

輸出結果為

輸出: 
10
輸出: 
70
60
50

加了兩個星號 ** 的參數會以字典的形式導入。

技術分享圖片 
# 可寫函數說明
def printinfo( arg1, **vardict ):
   "打印任何傳入的參數"
   print ("輸出: ")
   print (arg1)
   print (vardict)

# 調用printinfo 函數
printinfo(1, a=2,b=3)
技術分享圖片

輸出結果為

輸出: 
1
{‘a‘: 2, ‘b‘: 3}

聲明函數時，參數中星號 * 可以單獨出現，例如:

def f(a,b,*,c):
    return a+b+c

如果單獨出現星號 * 後的參數必須用關鍵字傳入，否則會報錯。

def ken(a,b,*,c):
    return a+b+c
print(ken(1,2,3))

輸出結果報錯

Traceback (most recent call last):
  File "D:/python/ken.py", line 274, in <module>
    print(ken(1,2,3))
TypeError: ken() takes 2 positional arguments but 3 were given

使用關鍵字傳入

def ken(a,b,*,c):
    return a+b+c
# print(ken(1,2,3))
print(ken(1,2,c=3))

輸出返回

6

匿名函數

python 使用 lambda 來創建匿名函數。

所謂匿名，意即不再使用 def 語句這樣標準的形式定義一個函數。

  • lambda 只是一個表達式，函數體比 def 簡單很多。
  • lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
  • lambda 函數擁有自己的命名空間，且不能訪問自己參數列表之外或全局命名空間裏的參數。
  • 雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，後者的目的是調用小函數時不占用棧內存從而增加運行效率。

語法

lambda 函數的語法只包含一個語句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

如下實例：

# 可寫函數說明
sum = lambda arg1, arg2: arg1 + arg2

# 調用sum函數
print ("相加後的值為 : ", sum( 10, 20 ))
print ("相加後的值為 : ", sum( 20, 20 ))

輸出結果為

相加後的值為 :  30
相加後的值為 :  40

return語句

return [表達式] 語句用於退出函數，選擇性地向調用方返回一個表達式。不帶參數值的return語句返回None。之前的例子都沒有示範如何返回數值，以下實例演示了 return 語句的用法：

技術分享圖片 
# 可寫函數說明
def sum( arg1, arg2 ):
   # 返回2個參數的和."
   total = arg1 + arg2
   print ("函數內 : ", total)
   return total

# 調用sum函數
total = sum( 10, 20 )
print ("函數外 : ", total)
技術分享圖片

輸出結果為

函數內 :  30
函數外 :  30

變量作用域

Python 中，程序的變量並不是在哪個位置都可以訪問的，訪問權限決定於這個變量是在哪裏賦值的。

變量的作用域決定了在哪一部分程序可以訪問哪個特定的變量名稱。Python的作用域一共有4種，分別是：

  • L （Local） 局部作用域
  • E （Enclosing） 閉包函數外的函數中
  • G （Global） 全局作用域
  • B （Built-in） 內建作用域

以 L –> E –> G –>B 的規則查找，即：在局部找不到，便會去局部外的局部找（例如閉包），再找不到就會去全局找，再者去內建中找。

技術分享圖片 
x = int(2.9)  # 內建作用域
 
g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 閉包函數外的函數中
    def inner():
        i_count = 2  # 局部作用域
技術分享圖片

Python 中只有模塊（module），類（class）以及函數（def、lambda）才會引入新的作用域，其它的代碼塊（如 if/elif/else/、try/except、for/while等）是不會引入新的作用域的，也就是說這些語句內定義的變量，外部也可以訪問，如下代碼：

if True:
    msg=‘this is ken‘
print(msg)

實例中 msg 變量定義在 if 語句塊中，但外部還是可以訪問的。

如果將 msg 定義在函數中，則它就是局部變量，外部不能訪問：

def ken ():
    msg=‘this is ken‘

print(msg)

輸出結果為

Traceback (most recent call last):
  File "D:/python/ken.py", line 298, in <module>
    print(msg)
NameError: name ‘msg‘ is not defined

從報錯的信息上看，說明了 msg_inner 未定義，無法使用，因為它是局部變量，只有在函數內可以使用。

全局變量和局部變量

定義在函數內部的變量擁有一個局部作用域，定義在函數外的擁有全局作用域。

局部變量只能在其被聲明的函數內部訪問，而全局變量可以在整個程序範圍內訪問。調用函數時，所有在函數內聲明的變量名稱都將被加入到作用域中。如下實例：

技術分享圖片 
total = 0 # 這是一個全局變量
# 可寫函數說明
def sum( arg1, arg2 ):
    #返回2個參數的和."
    total = arg1 + arg2 # total在這裏是局部變量.
    print ("函數內是局部變量 : ", total)
    return total

#調用sum函數
sum( 10, 20 )
print ("函數外是全局變量 : ", total)
技術分享圖片

輸出結果為

函數內是局部變量 :  30
函數外是全局變量 :  0

global 和 nonlocal關鍵字

當內部作用域想修改外部作用域的變量時，就要用到global和nonlocal關鍵字了。

不建議在函數內部使用global提升全局變量，定義全局變量還是在外面

以下實例修改全局變量 num：

技術分享圖片 
num = 1
def fun1():
    global num  # 需要使用 global 關鍵字聲明
    print(num)
    num = 123
    print(num)
fun1()
print(num)
技術分享圖片

輸出結果為

1
123
123

如果要修改嵌套作用域（enclosing 作用域，外層非全局作用域）中的變量則需要 nonlocal 關鍵字了，如下實例：

技術分享圖片 
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal關鍵字聲明
        num = 100
        print(num)
    inner()
    print(num)
outer()
技術分享圖片

輸出結果為

100
100

另外有一種特殊情況，假設下面這段代碼被運行：

a = 10
def test():
    a = a + 1
    print(a)
test()

執行之後，報如下的錯誤信息

Traceback (most recent call last):
  File "D:/python/ken.py", line 331, in <module>
    test()
  File "D:/python/ken.py", line 329, in test
    a = a + 1
UnboundLocalError: local variable ‘a‘ referenced before assignment

錯誤信息為局部作用域引用錯誤，因為 test 函數中的 a 使用的是局部，未定義，無法修改。

修改 a 為全局變量，通過函數參數傳遞，可以正常執行輸出結果為：

a = 10
def test(a):
    a = a + 1
    print(a)
test(a)

輸出結果為

11

轉載自：技術流ken
https://www.cnblogs.com/kenken2018/

python第四章：函數--小白博客

相關推薦

python第四章：函數--小白博客

新的 err 簡單 包含 pos variable uno sig required Python函數 函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。 函數能提高應用的模塊性，和代碼的重復利用率。你已經知道Python提供了許多內建函數，比如pr

R學習筆記 第四篇：函數，分支和循環

匿名 操作數 play 控制 als layers null 操作 str 變量用於臨時存儲數據，而函數用於操作數據，實現代碼的重復使用。在R中，函數只是另一種數據類型的變量，可以被分配，操作，甚至把函數作為參數傳遞給其他函數。分支控制和循環控制，和通用編程語言的風格很相似

python之socket模塊詳解--小白博客

電話 機器 -- 創建服務 rec bsp 基本 start read 主要是創建一個服務端，在創建服務端的時候，主要步驟如下：創建socket對象socket——》綁定IP地址和端口bind——》監聽listen&mdash

python 第四章 函數

reduce 最好 函數傳遞 obj 什麽 __name__ type 內建函數 模塊 函數 函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。 函數能提高應用的模塊性，和代碼的重復利用率。你已經知道Python提供了許多內建函數，比如print()。但你也

python四：函數練習--小白博客

當前 字符串 smtp 大小 imp password 不用 close sub 為什麽要有函數？函數式編程定義一次，多出調用函數在一定程度上可以理解為變量函數的內存地址加上()就是調用函數本身也可以當做參數去傳參不用函數：組織結構不清晰代碼的重復性 def test

Python基礎第三篇：函數

turn 說明 代碼 名稱 維護 span 大小寫 div 邏輯 一、Python函數介紹 1.函數的作用 規範代碼使代碼變得邏輯性更強 提高可讀性，方便管理，降低維護成本，以及降低代碼冗余 函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。 2.函

python 培訓第三章 ，函數，裝飾器，模塊，內置函數之一函數

python目錄： 函數示例裝飾器模塊內置函數一、函數示例： 　1、定義函數：　　　　def fun(args):　　　　　　‘描述信息‘　　　　　　函數體　　　　return 返回值 　　定義函數的三種形式：　　　　無參函數def foo():print(‘in the foo‘)

Python開發【第四篇】函數

鍵值 utf-8 nonlocal auth for循環 lambda test 覆蓋 我會 函數的作用 函數可以讓編程邏輯結構化以及模塊化 無論是C、C++，Java還是Python，函數是必不可少的知識點，也是很重要的知識點，函數是完成一個功能的代碼塊，使用函數可以

C#本質論6.0第四章：方法和參數

有助於 異常 名稱 別名 不同的 元素 寫入 轉換 參數順序 方法和參數 方法組合一系列語句以執行特定操作或計算特定結果，它能夠為構成程序的語句提供更好的結構和組織。 方法總是和類型——通常是類關聯。 方法通過實參接收數據，實參由方法的參數或形參定義，參數是調用者用於向被

Python--Redis實戰：第四章：資料安全與效能保障：第7節：非事務型流水線

之前章節首次介紹multi和exec的時候討論過它們的”事務“性質：被multi和exec包裹的命令在執行時不會被其他客戶端打擾。而使用事務的其中一個好處就是底層的客戶端會通過使用流水線來提高事務執行的效能。本節將介紹如何在不使用事務的情況下，通過使用流水線來進一步提升命令的執行效能。 之前章節曾經介紹過一

卜若的程式碼筆記-python系列-第四章：Function

#1.不帶引數不返回 def outMyName():     print('我是doge'); #2.不帶引數返回 def outMyNameAndReturen():     print('我不是doge');     return '真的假的？？'; #3.

Python--Redis實戰：第四章：資料安全與效能保障：第8節：關於效能方面的注意事項

習慣了關係資料庫的使用者在剛開始使用Redis的時候，通常會因為Redis帶來的上百倍的效能提升而感到欣喜若狂，卻沒有認識到Redis效能實際上還可以進一步的提高。雖然上一節介紹的非事務型流水線可以儘可能地減少應用程式和Redis之間的通訊往返次數，但是對於一個已

全國計算機等級考試二級教程--python語言程式設計（2018年版）第四章：程式的控制結構

宣告：本篇文章只是個人知識盲區、知識弱點、重點部分的歸納總結，望各位大佬不喜勿噴。梳理順序是按照書籍的實際順序梳理，轉載請註明出處。 作者：sumjess   一、程式的三種控制結構： 1、程式流程圖：       因為本身很

Python寶典第四章：可複用的函式與模組

模組是一組函式的集合。 def <函式名> (引數列表)：       <函式語句>       return <返回值> def ListSum(l): result=0 for i in l: resu

python第三章：循環語句--小白博客

code 一個數 less elif img ron 增量 開始 style Python條件語句 Python條件語句是通過一條或多條語句的執行結果（True或者False）來決定執行的代碼塊。 可以通過下圖來簡單了解條件語句的執行過程: Python程序語

python第五章：三大利器（裝飾器，叠代器，生成器）--小白博客

博客 單點 comment ron () urn tro sequence 要求 　　叠代器是訪問集合元素的一種方式。叠代器對象從集合的第一個元素開始訪問，直到所有的元素被訪問完結束。叠代器只能往前不會後退。 延遲計算或惰性求值 (Lazy evaluation) 　　

python第七章：常用模塊--小白博客

eve cep rt thread pre 動作 oot sso current 博客 yagmail模塊 python標準庫中發送電子郵件的模塊比較復雜，因此，有許多開原的庫提供了更加易用的接口來發送電子郵件，其中yagmail是一個使用比較廣泛的開原項目，yagmai

Python自學:第三章 使用函數sort( )對列表進行臨時排序

class 排序 輸出 sort 改變 使用 yota print 進行 # -*- coding: GBK -*- cars = ["bmw", "audi", "toyota", "subaru"] print("這是以前的列表：") print(ca

Netty In Action中文版 - 第四章：Transports(傳輸)

duplicate pipeline 客戶 下列表 bytes 線程安全 get 工具 jsb 本章內容 Transports(傳輸)NIO(non-blocking IO,New IO), OIO(Old IO,blocking IO), Local(本地),

讀構建之法 第四章：兩人合作

應用 結對編程 使用 一對一 測試 一個 比較 以及 領域 程序員寫的代碼最終是人在看，所以代碼規範很重要，原則是：簡明，易讀，無二義性。 不光是程序書寫的格式問題，還牽涉到程序設計、模塊之間的關系、設計模式等方方面面。 代碼復審的正確定義看代碼是否在代碼規範的框架內正確的