一、函數(shù)

1.函數(shù)概述

1.1認(rèn)識函數(shù)

需求:求圓的面積

s = π * r ** 2

c = math.sqrt(a**2 + b**2)

代碼演示：

r1 = 6.8
s1 = 3.14 * r1 ** 2

r2 = 10
s1 = 3.14 * r2 ** 2

r3 = 2
s1 = 3.14 * r3 ** 2

r4 = 30
s1 = 3.14 * r4 ** 2

#define
def test(r):
  s = 3.14 * r * 2
    
test(6.8)
test(10)
test(30)

問題:代碼重復(fù)

? 后期維護(hù)成本太高

? 代碼可讀性不高

解決問題：函數(shù)

在一個完整的項目中，某些功能會被反復(fù)使用，那么將這部分功能對應(yīng)的代碼提取出來，當(dāng)需要使用功能的時候直接使用

本質(zhì)：對一些特殊功能的封裝

優(yōu)點：

? a.簡化代碼結(jié)構(gòu)，提高應(yīng)用的效率

? b.提高代碼復(fù)用性

? c.提高代碼的可讀性和可維護(hù)性

建議：但凡涉及到功能，都盡量使用函數(shù)實現(xiàn)

1.2定義函數(shù)

語法：

def 函數(shù)名(參數(shù)1，參數(shù)2，參數(shù)3....):

? 函數(shù)體

? 返回值

說明：

a.函數(shù)由兩部分組成：聲明部分和實現(xiàn)部分

b.def,關(guān)鍵字，是define的縮寫，表示定義的意思

c.函數(shù)名：類似于變量名，遵循標(biāo)識符的命名規(guī)則，盡量做到顧名思義

d.（）：表示的參數(shù)列表的開始和結(jié)束

e.參數(shù)1，參數(shù)2，參數(shù)3.... ：參數(shù)列表【形式參數(shù)，簡稱為形參】，其實本質(zhì)上就是一個變量名，參數(shù)列表可以為空

f.函數(shù)體：封裝的功能的代碼

g.返回值：一般用于結(jié)束函數(shù)，可有可無，如果有返回值，則表示將相關(guān)的信息攜帶出去，攜帶給調(diào)用者，如果沒有返回值，則相當(dāng)于返回None

?

2.使用函數(shù)

2.1簡單函數(shù)

無參無返回值的函數(shù)

代碼演示：

#1.無參無返回值的函數(shù)
#函數(shù)的聲明部分
def test():
    #函數(shù)的實現(xiàn)部分
    #函數(shù)體
    print("hello")

2.2函數(shù)的調(diào)用

定義好函數(shù)之后，讓函數(shù)執(zhí)行

格式：函數(shù)名(參數(shù)列表)

代碼演示：

#print(num)
#test()

#1.無參無返回值的函數(shù)
#函數(shù)的聲明部分
def test():
    #函數(shù)的實現(xiàn)部分
    #函數(shù)體
    #print("hello")
    for i in range(10):
        print(i)

def test():
    print("~~~~~~")

#注意1：當(dāng)定義好一個函數(shù)之后，這個函數(shù)不會自動執(zhí)行函數(shù)體

#2.函數(shù)的調(diào)用
#格式：函數(shù)名(參數(shù)列表)
#注意2：當(dāng)調(diào)用函數(shù)的時候，參數(shù)列表需要和定義函數(shù)時候的參數(shù)列表保持一致
#注意3：一個函數(shù)可以被多次調(diào)用
test()
test()
test()
test()

#3.注意4：當(dāng)在同一個py文件中定義多個同名的函數(shù)，最終調(diào)用函數(shù)，調(diào)用的最后出現(xiàn)的函數(shù)【覆蓋：函數(shù)名類似于變量名，相當(dāng)于變量的重新賦值】
#4.注意5：自定義函數(shù)必須先定義，然后才調(diào)用，否則報NameError

函數(shù)的調(diào)用順序：

#函數(shù)調(diào)用
#1.在一個自定義的函數(shù)內(nèi)部也可以調(diào)用函數(shù)
#2.函數(shù)調(diào)用的順序
def test1():
    print("aaaa")
    test2()
    print("over")

def test2():
    print("bbbb")
    test3()
    test4()

def test3():
    print("cccc")

def test4():
    print("dddd")

test1()

#注意：函數(shù)在調(diào)用的過程中，相互之間的關(guān)系，以及代碼執(zhí)行的先后順序

2.3函數(shù)中的參數(shù)

參數(shù)列表：如果函數(shù)所實現(xiàn)的功能涉及到未知項參與運(yùn)算，此時就可以將未知項設(shè)置為參數(shù)

格式：參數(shù)1,參數(shù)2.....

分類：

? 形式參數(shù)：在函數(shù)的聲明部分，本質(zhì)就是一個變量，用于接收實際參數(shù)的值 【形參】

? 實際參數(shù)：在函數(shù)調(diào)用部分，實際參與運(yùn)算的值，用于給形式參數(shù)賦值 【實參】

? 傳參：實際參數(shù)給形式參數(shù)賦值的過程，形式參數(shù) = 實際參數(shù)

代碼演示：

#傳參：實際參數(shù)給形式參數(shù)賦值的過程，形式參數(shù) = 實際參數(shù)

#需求：給函數(shù)一個姓名和一個年齡，在函數(shù)內(nèi)部將內(nèi)容打印出來
def myPrint(name,age):
    print("姓名：%s,年齡：%d"%(name,age))

#調(diào)用函數(shù)
str = "zhangsan"
num = 19
myPrint(str,num)

"""
傳參：
實參給形參賦值
name = "zhangsan"
age = 19
"""

#需求：求兩個數(shù)的和
def add(num1,num2):
    sum = num1 + num2
    print(sum)

add(10,20)
add(33,2)

#TypeError: add() missing 2 required positional arguments: 'num1' and 'num2'   實參和形參不匹配

形參和實參之間的關(guān)系：

#需求：交換兩個變量的值
def exchange(num1,num2):
    temp = num1
    num1 = num2
    num2 = temp
    print("exchange函數(shù)內(nèi)部：num1=%d num2=%d"%(num1,num2))

num1 = 11
num2 = 22
exchange(num1,num2)
print("外面：num1=%d num2=%d" % (num1, num2))

#1.實參和形參重名對函數(shù)實現(xiàn)沒有影響
#2.進(jìn)行傳參之后，實際參與運(yùn)算的是形參，對實參沒有影響【將形參可以理解為實參的替代品】
#3.本質(zhì)原因：形參和實參在內(nèi)存中開辟的空間不同

2.4值傳遞和引用傳遞【面試題】

值傳遞：傳參的過程中傳遞的是值，一般指的是不可變的數(shù)據(jù)類型，number,tuple,string

引用傳遞：傳參的過程中傳遞的是引用，一般指的是可變的數(shù)據(jù)類型，list，dict,set

代碼演示：

#值傳遞
def func1(a):
    a = 10

temp = 20
#傳參：temp,但實際上傳的是20
func1(temp)
print(temp)   #20


#引用傳遞
def func2(list1):
    list1[0] = 100

l = [10,20,30,40]
func2(l)    #list1 = l
print(l[0])


"""
l = [10,20,30,40]
list1 = l
list1[0] = 100

"""

總結(jié)：

引用傳遞本質(zhì)上傳遞的是內(nèi)存地址

2.5參數(shù)的類型【掌握】

a.必需參數(shù)

? 調(diào)用函數(shù)的時候必須以正確的順序傳參，傳參的時候參數(shù)的數(shù)量和形參必須保持一致

代碼演示：

#1.必需參數(shù)
def show1(str1,num1):
    print(str)

show1("hello",10)
#show1()
#如果形參沒有任何限制，則默認(rèn)為必需參數(shù)，調(diào)用函數(shù)的時候則必需傳參，順序一致，數(shù)量一致

b.關(guān)鍵字參數(shù)

? 使用關(guān)鍵字參數(shù)允許函數(shù)調(diào)用的時候?qū)崊⒌捻樞蚝托螀⒌捻樞蚩梢圆灰恢?，可以使用關(guān)鍵字進(jìn)行自動的匹配

代碼演示：

#2.關(guān)鍵字參數(shù)
def show2(name,age):
    age += 1
    print(name,age)

#正常調(diào)用
show2("abc",10)
#show2(10,"abc")

#關(guān)鍵字參數(shù)調(diào)用函數(shù)
#注意1：關(guān)鍵字參數(shù)中的關(guān)鍵字其實就是形參的變量名，通過變量名進(jìn)行傳參
show2(age = 20,name = "lisi")
show2(name = "lisi",age = 20)

#注意2：關(guān)鍵字參數(shù)只有一個的情況下，只能出現(xiàn)在參數(shù)列表的最后
show2("lisi",age = 30)

#錯誤演示
#show2(40,name = "lisi")   TypeError: show2() got multiple values for argument 'name'
#show2(name = "lisi",40)

#系統(tǒng)的關(guān)鍵字參數(shù)
print("",end=" ")

c.默認(rèn)參數(shù)

? 調(diào)用函數(shù)的時候，如果沒有傳遞參數(shù)，則會使用默認(rèn)參數(shù)

代碼演示：

#3.默認(rèn)參數(shù)
#注意1：在形參設(shè)置默認(rèn)參數(shù)，如果傳參，則使用傳進(jìn)來的數(shù)據(jù)，如果不傳參，則使用默認(rèn)數(shù)據(jù)
def fun1(name,age=18):
    print(name,age)

fun1("zhangsan",20)
fun1("lisi")
fun1(name = "abc",age = 33)
fun1(name = "hello")

#注意2：在參數(shù)列表中，如果所有的形參都是默認(rèn)參數(shù)，正常使用；但是，如果默認(rèn)參數(shù)值只有一個，則只能出現(xiàn)在參數(shù)列表的最后面
def fun2(num1 = 10,num2 = 20):
    print(num1.num2)

d.不定長參數(shù)

? 可以處理比當(dāng)初聲明時候更多的參數(shù) * **

代碼演示：

#4.不定長參數(shù)【可變參數(shù)】
#4.1   *   ：被當(dāng)做tuple處理，變量名其實就是一個元組名
#注意1：傳參的時候，實參可以根據(jù)需求任意傳參,數(shù)量不確定
#注意2:定義不定長參數(shù)時，最好將不定長參數(shù)放到參數(shù)列表的最后面【如果不定長參數(shù)出現(xiàn)在參數(shù)列表的前面，則在實參列表中使用關(guān)鍵字參數(shù)】
def func1(name,*hobby):
    print(name)
    print(hobby)
    print(type(hobby))   #<class 'tuple'>

    #遍歷
    for element in hobby:
        print(element)

func1("aaa","anc","aaa","5435","tesrg","gtsrhesh",10,True)

# 4.2  **   :被當(dāng)做字典處理，變量名就相當(dāng)于字典名
def func2(**args):
    print(args)
    print(type(args))   #<class 'dict'>

    for k,v in args.items():
        print(k,v)

#注意1：使用**的時候，實參就必須按照key=value的方式進(jìn)行傳參
func2(x = 10,y = 20)

2.6函數(shù)的返回值

作用：表示一個函數(shù)執(zhí)行完畢之后得到的結(jié)果

使用:return,表示結(jié)束函數(shù)，將函數(shù)得到的結(jié)果返回給調(diào)用者

代碼演示：

#1.結(jié)束函數(shù)，返回數(shù)據(jù)
#需求：求兩個整數(shù)的和，并返回
def add(num1,num2):
    sum1 = num1 + num2
    #print(sum1)

    #將結(jié)果返回給調(diào)用者
    return sum1

    #注意：在同一個代碼塊中，如果在return后面出現(xiàn)語句，則永遠(yuǎn)不會被執(zhí)行
    #print("hello")


#注意：如果一個函數(shù)由返回值，要么采用變量將返回值接出來，要么將整個函數(shù)的調(diào)用直接參與運(yùn)算
r = add(10,20)
print(r)
print(add(10,20))   #30
#print("~~~~",sum1)

total = add(1,2) + 5
print(total)    #8


def func(num1,num2):
    sum2 = num1 + num2


#注意：如果一個函數(shù)沒有返回值，則整體計算的結(jié)果為None
#print(func(10,20))

#如果一個函數(shù)沒有返回值，則這個函數(shù)的調(diào)用不能直接參與運(yùn)算
total1 = func(1,2) + 5  #TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
print(total1)

在分支語句中使用return

#2.如果一個函數(shù)體中有分支，設(shè)置了返回值，最好每一個分支都有一個返回值
#需求：輸入兩個數(shù)，比較兩個數(shù)的大小，返回較大的一個
def compare(num1,num2):
    if num1 > num2:
        return num1
    elif num1 < num2:
        return num2
    else:
        return True,num1

result = compare(12,12)
print(result)

#注意1：在Python中，不同分支返回的數(shù)據(jù)類型可以是不相同的
#注意2;在Python中，一個return可以同時返回多個數(shù)據(jù)，被當(dāng)做元組處理

總結(jié)：

自定義一個函數(shù)
是否需要設(shè)置參數(shù)：是否有未知項參與運(yùn)算

是否需要設(shè)置返回值：是否需要在函數(shù)外面使用函數(shù)運(yùn)算之后的結(jié)果

函數(shù)使用練習(xí)：

#需求1：封裝函數(shù)功能，統(tǒng)計1~某個數(shù)范圍內(nèi)能被3整除的數(shù)的個數(shù)
"""
參數(shù)：某個數(shù)
返回值：可設(shè)置可不設(shè)置
"""
def getCount(num):
    count = 0
    for i in range(num + 1):
        if i % 3 == 0:
            count += 1

    #print(count)
    return count

r1 = getCount(1000)
print(r1)
r2 = getCount(100)
print(r2)


#需求2：封裝函數(shù)功能，判斷某年是否是閏年
"""
參數(shù)：某年
返回值：可設(shè)置可不設(shè)置
"""
def isLeapYear(year):
    if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
        #print("閏年")
        #return "閏年"
        return  True
    else:
        #print("平年")
        #return "平年"
        return False

result = isLeapYear(2020)
print(result)

3.匿名函數(shù)【掌握】

不再使用def這種的形式定義函數(shù)，使用lambda來創(chuàng)建匿名函數(shù)

特點：

? a.lambda只是一個表達(dá)式，比普通函數(shù)簡單

? b.lambda一般情況下只會書寫一行，包含參數(shù)，實現(xiàn)體，返回值

語法:lambda 參數(shù)列表 ： 實現(xiàn)部分

代碼演示：

#語法:lambda 參數(shù)列表 ： 實現(xiàn)部分

#1.
#需求：求兩個數(shù)的和
#普通函數(shù)
def add(num1,num2):
    sum = num1 + num2

add(num1 = 10,num2 = 20)

#匿名函數(shù)本身是沒有函數(shù)名，將整個lambda表達(dá)式賦值給一個變量，然后將這個變量當(dāng)做函數(shù)使用
sum1 = lambda n1,n2:n1 + n2
print(sum1(10,20))

#2.在匿名函數(shù)中也可以使用關(guān)鍵字參數(shù)
g = lambda  x,y:x ** 2 + y ** 2
print(g(3,4))
print(g(x = 3,y = 4))

#3.在匿名函數(shù)中也可以使用默認(rèn)參數(shù)
h = lambda  x=0,y=0 : x ** 2 + y ** 2
print(h())
print(h(10))
print(h(10,20))

4.空函數(shù)和主函數(shù)

4.1空函數(shù)

一個什么都沒有實現(xiàn)的函數(shù)

借助于pass語句

代碼演示：

def func():
    pass

4.2主函數(shù)

每一個程序都有一個入口：主函數(shù)【main函數(shù)】

在Python中，主函數(shù)是隱式的

代碼演示：

def show():
    print("hello")


#通過__name__   == "__main__"表示其中的代碼是在主函數(shù)中運(yùn)行的
if  __name__  == "__main__":
    show()