python 函數(function)、函數(def)、函數(return)

時間 2019-11-18

標籤 python 函數 function def return 欄目 Python 简体版

原文原文鏈接

函數 function

什麼是函數：
　　函數是能夠重複執行的語句塊，能夠重複使用
　　函數是面向過程編程的最小單位python

函數的做用：
　　1.用於封裝語句塊，提升代碼的重用性
　　2.定義用戶級別的函數編程

def 語句（把編碼打包） call（調用）

語法：
　　def函數名（形參列表）：
　　語句塊（代碼塊）
說明：
　　1.函數的名字就是語句塊的名稱
　　2.函數名的命名規則與變是一名相同（函數名必須爲標識符）
　　3.函數名是一個變量（不要輕易對其賦值）
　　4.函數有本身的名字空間，在函數外部不能夠訪問函數內部的變量（注意）在函數內部能夠訪問函數外部的變量，要讓函數處理外部的數據須要傳入一些數據
　　5.函數若是不須要傳入參數，則參數列表能夠爲空
　　6.語句部分不能爲空，若是爲空須要填充pass語句
做用：
　　用於建立函數，用函數名這個變量綁定這個函數app

# 示例見：
# 此示例示意用def語句定義一個沒有參數的函數
def say_hello():
    print("hello world!")
    print("hello china!")
    print("hello tarena!")

函數的調用表達式：
　　函數名（實際調用傳遞參數）

說明：
　　函數調用是一個表達式
　　若是沒有return語句，函數執行完畢後返回None對象函數

# 示例見：
# 此示例示意用def語句來定義帶有參數的函數
# 此函數名爲mymax，有兩個形式參數a，b 用於接收實參的傳遞
# 此函數計算兩個參數的最大值並打印
def mymax(a,b):
    print("a=",a)
    print
    ("b=",b)
    if a>b:
        print(a,"大於",b)
    else:
        print(a,"小於",b)
mymax(100,200)    #函數調用

練習：

# 3 寫一個函數myadd，此函數中的參數列表裏有兩個參數x，y此函數的功能是打印 x+y的和
# 如：
#    def myadd(...):
#        ...# ... 部分本身實現
#    myadd(100,200)   #打印300
#    myadd（"ABC","123"）  #打印 ABC123

def myadd(x,y):
    z = x +y
    print("和是",z)
myadd(100,200)   # 打印 300
myadd("ABC","123")   # 打印ABC123




# 寫一個函數print_event,傳入一個參數n表明終止的整數，打印0~n 之間全部的偶數
# 如：
#　　def print_event(n):
#　　　　....此處本身完成
#　　print_even(10)
#　　打印：
#　　0 2 4 6 8


# 方法1
def print_event(n):
for x in range(n):
　　if x % 2==0:
　　　　print(x)
print_event(10)

# 方法2
def print_event(n): 
for x in range(0,n+1,2):
　　print(x)
print_event(10)

return 語句：

語法：
　　return[表達式]
　　注：[]表明其中的內容可省略
做用：
　　用於函數中，結果當前函數的執行，返回到調用該函數的地方，同時返回
一個對象的引用關係
說明：
　　1.return 語句先執行右側的表達式，再將表達式的執行結果送回給當前函數的調用者
　　2.return 語句右側的表達式能夠省略，省略後至關於 return None
　　3.若是函數內沒有return語句，則函數執行完最後一條語句後返回None）
　　（至關於在最後加了一條return None語句）測試

# 示例見：
# 此示例示意return語句在函數中的應用
def say_hello2():
    print("hello aaa")
    print("hello bbb")
    #return 1+ 2  #等同於 return None
    return [1,2,3,4,5]
    print("hello ccc")
v = say_hello2()
print("v=",v)

v2 = say_hello2()
print("v2=",v2)

練習：

# 1.寫一個函數mymax，實現返回兩個數的最大值：
#    如：
#        def mymax(a,b):
#             ...
#    print(mymax(100,200))#200
#    print(mymax(100,200))#ABCD

# 方法1
def mymax(a,b):
    s = max(a,b)
    return s
print(mymax(100,200))
print(mymax("ABC","ABCD"))


# 方法2
def mymax(a,b):
    zuida = a
    if b > zuida:
        zuida = b
        return zuida
print(mymax(100,200))
print(mymax("ABC","ABCD"))


# 2.寫一個函數myadd，實現給出兩個數，返回這個兩個數的和
# 如：
#    def myadd(x,y):
        ....
#    a = int(input("請輸入第一個數："）
#    b = int(input("請輸入第二個數："）
#    print("你輸入的兩個數的和是：",myadd(a,b))


def myadd(x,y):
    return x+y
a = int(input("請輸入第一個數："))
b = int(input("請輸入第二個數："))
print("你輸入的兩個數的和是：",myadd(a,b))


# 3.寫一個函數，input_number
#    def input_number():
#    ...# 此處本身實現，此函數返回列表
#    此函數用來獲取用戶循環輸入往返整數，當用戶輸入負數時結束輸入
#    將用戶輸入的數字以列表的形式返回，再用內建函數max，min，sum
#    求出用戶輸入的最大值，最小值以及和

#   L = input_number()
#   print("用戶輸入的最大數是：",max(L))
#   print("用戶輸入的最小數是：",min(L))
#   print("用戶輸入的所有數的和是：",sum(L))

def input_number():
    # 1.建立空列表
    l = []
    # 2.循環讀取用戶輸入的正整數，存入在述列表
    while True:
        n = int(input("請輸入用戶數字："))
        if n<0:
            break# 此處本身實現，此函數返回列表
        l.append(n)
    # 3.返回上述列表的引用關係
    return l
L = input_number()
print("用戶輸入的最大數是：",max(L))
print("用戶輸入的最小數是：",min(L))
print("用戶輸入的所有數的和是：",sum(L))

python函數的參數傳遞（把數據給函數）

傳遞方式：
　　位置傳參
　　序列傳參
　　關鍵字傳參
　　字典關鍵字傳參ui

位置傳參：
　　實際參數（實參）的對應關係與形式參數（形參）的對應關係是按位置來依次對應的
示意：編碼

def mymin（a，b，c）
    pass
mymin（1,2,3）

說明：
　　實際參數和形式參數經過位置進行傳遞和匹配
　　實際參數的個數必須與形式參數的個數相同spa

# 示例：
# 此示例示意位置傳參
def myfunl(a,b,c):
    "這是一個函數的傳參的示例"
    print("a的值是：",a)
    print("b的值是：",b)
    print("c的值是：",c)

myfunl(1,2,3)  # 1 --- a  2 ----b  3----c
myfunl(4,5,6)

序列傳參
　　序列傳參是指在函數調用過程當中，用*將序列拆解後按位置進行傳遞的
傳參方式code

# 示例見：
# 此示例示意序列傳參
def myfunl(a,b,c):
    "這是一個函數的傳參的示例"
    print("a的值是：",a)
    print("b的值是：",b)
    print("c的值是：",c)

l1=[11,22,33]
t2=(100,200,300)
s3="ABC"
myfunl(l1[0],l1[1],l1[2])  # li[0](將11)---> a, L1[1]
myfunl(*l1) # 等同於myfunl(l1[0],l1[1],l1[2]) 
myfunl(*t2)
myfunl(s3[0],s3[1],s3[2])
myfunl(*s3)

# 說明：
　　# 序列傳參時，序列拆解的位置將與形參一一對應

關鍵字傳參：
　　關鍵字傳參是指傳參時，按着形參的名稱給形參賦值
　　實參和形參按名稱進行匹配對象

# 示例見；
# 此示例示意關鍵字傳參
def myfunl(a,b,c):
    "這是一個函數的傳參的示例"
    print("a的值是：",a)
    print("b的值是：",b)
    print("c的值是：",c)
myfunl(c=3,a=1,b=2)
myfunl(c=33,a=11,b=22+3)

# 說明：
#    實參和形參接形參名進行匹配，能夠不接位置進行匹配

字典關鍵字傳參：
　　是指實參爲字典，將字典用**拆解後進行關鍵字傳參的傳參方式

# 示例見；
def myfunl(a,b,c):
    "這是一個函數的傳參的示例"
    print("a的值是：",a)
    print("b的值是：",b)
    print("c的值是：",c)
d1 = {"c":33,"a":11,"b":22}
myfunl(c=d1["c"],a=d1["a"],b=d1["b"])   #33---->c,11---->a
myfunl(**d1)  #拆解字典，在按關鍵字傳參方式傳遞

# 說明：
#    字典的鍵名和形參名必須一致
#    字典的鍵名必須爲符合標識符命名規則的字符串
#    字典的鍵名要在形參中存在

練習：

# 已知有列表：
    L = [1,2,True,None,3.14]
    # 調用print函數，打印用「#」號分隔的文字信息到終端上
    print(...)  #打印  1#2#True#None#3.14
     
l = [1,2,True,None,3.14]
print(*l,sep="#")# 打印 1#2#True#None#3.14

函數的綜合傳參：
　　1.函數的傳參方式，在能肯定形參能惟一匹配到相應實參的狀況
下能夠任意組合
　　2.函數的位置傳參要先於關鍵字傳參

# 示例：
def myfun1(a,b,c)
    pass
myfun1(100,c=300,b=200) #正確
myfun1(c=300,b=200,100) #錯的
myfun1(100,*[200,300]) #正確
myfun1(*[100,200],300) #正確
myfun1(100,*[200],300) #正確
myfun1(100,**{"c":300,"b":200}) #正確
myfun1(**{"c":300,"b":200},a=100) #正確

# 可變 和 不可變的類型的容器做爲實參傳遞的區別：
    # 可變類型的實參做爲參數傳遞時，在函數內部能夠改變容器內的數據


# 示例見：
# 此示例示意，當函數的實參爲可變數據類型時，在函數內部能夠改成容器的內容
l = [1,2,3,4]
t = (1.1,2.2,3.3,4.4)
def append_5(x):
　　# x.append(5)
　　x += (5,)#新的x元組
append_5(l)
print(l)
append_5(t) #不存在 
print(t)

練習

# 寫一個函數，此函數讀取用戶輸入的數據，最後保存於全局變量的列表
# l中，當用戶輸入小於零的數時結束輸入
l=[]
def input_number(l1):
    while True:
        x = int(input("請輸入："))
        if x<0:
            break
        l1.append(x)
input_number(l)
print(l)
input_number(l)
print(l)

如下講函數的定義（建立函數的def語句的形參列表）

# 函數的缺省參數：
    # 語法：
# def 函數名（形參名1 = 默認實參1，形參2=默認實參2，...）：
    # 語句塊

# 示例見：
def info(name,age=1,address="不詳"):
    print(name,"今年",age,"歲.家庭住址",address)
info("路飛",35,"北京市朝陽區")
info("tarena",15)
info("小飛")

說明：
　　缺省參數必須自右至左依次存在，若是一個參數有缺省參數，則其
　　右側的全部參數都必須有缺省參數，如：
　　　　def test_fn(a,b=10,c): 是錯的
　　缺省參數能夠有0個，1個或多個，甚至所有都有缺省參數

# 示例：
def fn(a,b=10,c):# 錯誤
    pass
def fn（a=0,b=10,c=20） # 這是對的
    pass

練習：

# 寫一個函數myadd，此函數能夠計算兩個數，三個數及四個數的和
def myadd（...）：
....
    print(myadd(10,20))#30
    print(myadd(100,200,300))#600
    print(myadd(1,2,3,4))#10

def myadd(a,b,c=0,d=0):
    return a + b+ c +d 
print(myadd(10,20))
print(myadd(100,200,300))
print(myadd(1,2,3,4,))

函數形參的定義方式：

　　1.位置形參
　　2.型號的元組形參
　　3.命名關鍵字形參
　　4.雙星號字典形參

# 位置形參
    # 語法：
# def 函數名（形參名1，形參名2...）：
    # 語句塊
# 星號無組形參：
    # 語法：
# def 函數名（*元組形參名）：
    # 語句塊
# 做用：
    # 收集多餘的位置傳參
# 說明：
    # 在一個函數定義中元組形參名最多隻能有一個，通常命名爲"args"


# 示例見：
# 此示例示意星號元組形參的定義和使用
def func(*args):
    print("實參個數是",len(args))
    print("args=",args)
func(1,2,3,4)
func(5,6,7,8,"A","B","C","D")
func()

練習：

# 寫一個函數 mysun 能夠傳入任意個數字實參，返回全部實參的和
# def mysum(*args):
    # ...
# print(mysum(1,2,3,4))
# print(mysum(,1,3,5,7,9))

# 方法1
def mysum(*args):
    s = 0
    for x in args:
        s +=x
    return s
print(mysum(1,2,3,4))
print(mysum(1,3,5,7,9))

# 方法2
def mysum(*args):
    return sum(args)
print(mysum(1,2,3,4))
print(mysum(1,3,5,7,9))

命名關鍵字形參

# 語法：
   # def 函數名（*，命名關鍵字形參1，命名關鍵字形參2，...）：
       # 語句塊
   # 或
   # def 函數名（*args，命名關鍵字形參1，命名關鍵字形參2，..）
       # 語句塊
# 做用：
   # 強制全部的參數都必須用關鍵字傳參或字典關鍵了傳參
# 示例見：
   # named_keyword_args.py

# 此示例示意在函數形參中定義命名關鍵字形參，強制讓函數調用使用命名# 關鍵字傳參：
def funcl(a,b,*,c,d):
    print(a,b,c,d)
funcl(1,2,3,4)  # 報錯
funcl(1,2,c=30,d=40)
funcl(a=10,b=20,c=30,d=40)

def funcl(a,b,*args,c,d):
    print(a,b,args,c,d)
funcl(1,2,3,4)  # 報錯
funcl(1,2,c=30,d=40)
funcl(a=10,b=20,c=30,d=40)
funcl(1,2,3,4,d=400,c=300)
funcl(*"ABCDEFG",**{"c":999,"d":888})

雙星號字典形參

# 語法：
    # def 函數名（**字典形參名）
        # 語句塊
# 做用：
        # 收集多餘的關鍵字傳參
# 說明：
    # 字典形參名通常命名"kwargs"
    # 一個函數內字典形參最多隻能有一個

# 示例見：
# 此示例示意用雙星號字典形參接收多餘的關鍵字傳參
def func(**kwargs):
    print("關鍵字傳參的個數是：",len(kwargs))
    print("kwargs=",kwargs)
func(name="weimingze",age=35,address="北京時朝陽區")
func(a=1,b=2)

def func(a,b,**kwargs):
    print("關鍵字傳參的個數是：",len(kwargs))
    print("kwargs=",kwargs)
func(a=1,b=2,c=3)


# 函數的參數說明：
    # 位置形參，缺省參數，星號元組形參，雙星號字典形參能夠混合使用

函數參數自左自右的順序爲：

# 1.位置形參
# 2.星號元組形參
# 3.命名關鍵字形參
# 4.雙星號字典形參

# 示例：
def fn(a,b=20,*args,c=30,d=40,**kwargs):
    pass
fn(1)
fn(100,200,300,400,c="C",d="D",e="E")

練習：

# 已知內建函數max幫助文檔爲：
# max（...）
# max（iterable）  -> value
# max(arg1,arg2,*args) -> value
# 仿造 max寫一個mymax函數，功能與max徹底相同
   #（要求不容許調用max'）
# 測試程序以下：
# print(mymax([6,8,3,5]))  #8
# print(mymax(100,200))    #200
# print(mymax(1,3,5,7,9)） #9

# 方法1
def mymax(*args):
　　if len(args)==1: #判斷是不是一個可迭代參數的狀況
　　　　l = args[0] #必定綁定一個可迭代對象
　　　　zuida = l[0]
　　　　for x in l:
　　　　　　if x >zuida:
　　　　　　　　zuida = x
　　　　　　return zuida 
　　else: #不然有多個參數的狀況
　　　　zuida = args[0]
　　　　for x in args:
　　　　　　if x>zuida:
　　　　　　　　zuida = x
　　　　　　return zuida 
print(mymax([1,3,5,7,9]))
print(mymax(100,200))
print(mymax(6,8,3,5))

# 方法2
def mymax(a,*args):
　　if len(args)==0: #判斷是不是一個可迭代參數的狀況
　　　　l = a #必定綁定一個可迭代對象
　　　　zuida = l[0]
　　　　for x in l:
　　　　　　if x >zuida:
　　　　　　　　zuida = x
　　　　return zuida 
　　else: #不然有多個參數的狀況
　　　　zuida = a
　　　　for x in args:
　　　　　　if x>zuida:
　　　　　　　　zuida = x
　　　　return zuida

全局變量和局部變量

　　局部變量：local varible:
　　定義在函數內部的變量稱爲局部的變量（函數的形參也是局部變量）
　　局部變量只能在函數內部使用
　　局部變量在函數調用時纔可以被建立，在函數調用以後會自動銷燬
　　當有同名的全局變量和局部變量時，優先訪問局部變量

　　全局變量：global variable:
　　定義在函數外部，模塊內部的變量稱爲全局變量
　　全局變量，全部函數均可以直接訪問（但函數內不能將其直接賦值）

局部變量說明：
　　在函數內部賦值語句不會對全局變量形成影響
　　局部變量只能在其被聲明的函數內部訪問，而全局變量能夠在整數模塊範圍內訪問

# 示例見：
# global_local.py
# 此示例示意全局變量的定義和局部變量的定義
a = 100
b = 200
c = 999999
def fx(c):
    a = 1 # 建立局部變量，並無改變全局變量
    d = 400
    print(a,b,c,d)
fx(300)
print("a=",a)
print("b=",b)
print("c=",c) 


# globals 和 locals 函數：
    # globals()  返回當前全局做用域內變量的字典
    # locals（） 返回當前局部做用域內變量的字典



# 示例見：
# globals_and_locals.py
# 此示例示意全局變量的定義和局部變量的定義
a = 100
b = 200
c = 999999
def fx(c):
　　a = 1 # 建立局部變量，並無改變全局變量
　　d = 400
　　print(a,b,c,d)
fx(300)
print("a=",a)
print("b=",b)
print("c=",c) 
# 此示例示意globals 和 locals 函數的使用方法
a = 1
b = 2
c = 3
def fn(c,d):
　　e = 300
　　# 此處有多少個局部變量？
　　print("locals()返回：",locals())
　　# 此處有多少個全局變量？
　　print("locals()返回：",globals())
　　print(c)
　　print(globals()["c"])
fn (100,200)