Python基础学习（六）--函数，参数，递归

一、函数

函数就是组织好的，可以重复利用的，用来实现独立功能的代码段。
可以提高程序的代码重用率

（一）定义

1.格式

形如：

def 函数名():
    代码段

函数名实际上就是一个标识符，明明要求与变量命名要求完全相同，在此不再赘述。

2.尝试

floor=int(input('请输入楼层：'))
if floor==1:
    print('西单大悦城1层欢迎您')
    print('1楼、鞋类商品')
    print('2楼、女性服饰')
    print('3楼、男装')
    print('您现在在1层')
elif floor==2:
    print('西单大悦城2层欢迎您')
    print('1楼、鞋类商品')
    print('2楼、女性服饰')
    print('3楼、男装')
    print('您现在在2层')
elif floor==3:
    print('西单大悦城3层欢迎您')
    prt()print('1楼、鞋类商品')
    print('2楼、女性服饰')
    print('3楼、男装')
    print('您现在在3层')

可以看到上述代码有非常多重复的地方，如果用函数的话，可修改成：

def prt(f):    # 定义函数
    print('西单大悦城',f,'层欢迎您')
    print('1楼、鞋类商品')
    print('2楼、女性服饰')
    print('3楼、男装')
    print('您现在在',f,'层')
floor=int(input('请输入楼层：'))
if floor==1:
    prt(1)    # 调用函数
elif floor==2:
    prt(2)
elif floor==3:
    prt(3)

重点

1.只在调用的时候执行
2.函数必须先定义后调用

（二）参数

定义的时候，称为形参，因为没有实际的值
调用的时候，你给它什么值，它就是什么值

def qiuhe2(a,b):
    c=a+b
    print(c)
qiuhe2(2,3)    # 5
qiuhe2(5,6)    # 11

（三）函数调用的本质

函数调用的本质是函数名对应内存地址

def qiuhe3(a,b,c):
    s=a+b+c
    print(s)
qiuhe3(1,2,3)
print(qiuhe3)    # <function qiuhe3 at 0x000000000209D1E0>
qiuhe=qiuhe3    # 将qiuhe3的内存地址赋给qiuhe变量
# 同
print(id(qiuhe3))
print(id(qiuhe))
qiuhe(1,2,3)

面试题

def hs():
    print(i+1)
i=5
a=hs
b=hs
a()    # 6
i=7
a()    # 8
b()    # 8

二、参数的定义方式

（一）位置参数

前面用的那些就是位置参数，形参与实参一一对应传值。

（二）关键字参数

关键字参数无视参数顺序

def cha(a,b):    # a:3 b:1
    print(a-b)
cha(b=1,a=3)

当位置参数与关键字参数一起使用时，主要特别注意
关键字参数和位置参数同时使用时，关键字参数必须在位置参数后面

def hs(a,b,c):
    print(a,b,c)    # 2 3 7
hs(2,3,c=7)

若调用时用
hs(a=2,4,5)    # 报错

（三）默认参数

def dengji(name,age,sex='男'):
    print(name,age,sex)
dengji('张三',19)    # 张三 19 男
dengji('李四',20,'男')    # 李四 20 男
dengji('王五',21,'女')    # 王五 21 女

默认参数使用时要放在后面

def xiaozhu(a=3,b):     # 报错

def xiaozhu(b,a=3):
    print(a,b)
xiaozhu(1,2)

（四）可变参数

1.’*’

（1）’*'使参数变为了一个元组，所有传递的参数变为元组的元素

def kb(*a):
    print(a)
    # for x in a:
    #     print(x)
kb(1)    # (1,)
kb(1,2,3,4)    # (1,2,3,4)
kb()    # ()

def kb2(*a):
    print(a)
x=(1,2,3)
kb2(*x)    # (1, 2, 3)
kb2(x)    # ((1, 2, 3),)

（2）’*'具有打散序列的功能

def func(a,b,c):
    print(a,b,c)
tup=(1,2,3)
func(*tup)    # 1 2 3
lst=[1,2,3]
func(*lst)    # 1 2 3

2.’**’

（1）’**'使参数变成一个字典，所有传递的参数变为字典的键值对

!!!这里传参要求是键=值的形式

def kb(**kwargs):
    print(kwargs,type(kwargs))
kb(name='张三',age=18)    # {'name': '张三', 'age': 18} <class 'dict'>
kb(name='张三',age=18,sex='男')    # {'name': '张三', 'age': 18, 'sex': '男'} <class 'dict'>
kb()    # {} <class 'dict'>

（2）’**'有打散字典的功能，实参的key值必须与形参名相同，否则报错

def kb(name,age):
    print(name,age)
# 这里的key值必须与形参名相同，否则报错
a={'name':'张三','age':18}
kb(**a)    # 张三 18

（3）’**kwargs’必须放在’*args’后面

# 若写成def kb(**b,*a)，会报错
def kb(*a,**b):
    print(a,b)
a={'name':'张三','age':18}
kb(1,2,3,**a)    # (1, 2, 3) {'name': '张三', 'age': 18}
kb(1,2,3,*a)    # (1, 2, 3, 'name', 'age') {}

总结

定义函数时，参数的位置：位置参数，元组参数，默认参数，字典参数

def kb(a,*b,c=9,**d):
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)
kb(1,2,3,4,5)
结果：
a= 1
b= (2, 3, 4, 5)
c= 9
d= {}

kb(1,2,3,name='张三')
结果：
a= 1
b= (2, 3)
c= 9
d= {'name': '张三'}

三、返回值

没有return的函数，均返回空值None
python中可以返回多个值–元组类型
return的两个作用：1.返回内容；2.结束此方法

return返回内容：

def qiuhe(a,b):
    c=a+b
    return c
x=qiuhe(1,2)
print(x)    # 3
y=qiuhe(10,20)
print(y)    #30

注意！！！

a=[1,2,30,]
x=a.remove(30)
# a=[1,2]，x=None，说明remove()是一个有参数没有返回值的函数
print(x)    # None

返回值为多个值：

def hs(a,b):
    c=a+b
    d=a-b
    e=a*b
    return c,d,e
x=hs(5,6)
print(x)    # (11, -1, 30)
x,y,z=hs(5,6)
print(x,y,z)    # 11 -1 30

可以借助下面的两个代码段，好好体会什么叫做return的结束此方法的作用：

def hanshu(a,b):
    return
    c=a+b
    d=a-b
    return c,d
x=hanshu(5,6)
print(x)    # None

def hs():
    i=0
    while i<5:
        if i==2:
            return
        print(i)
        i+=1
x=hs()
print(x)
结果：
0
1
None

四、函数间的调用

def hs1(x,y):
    print(x*y)    # 6
def hs2(a,b,c):
    hs1(a,b)
    print(c)    # 4
hs2(2,3,4)

def total(price,num):
    return price*num
def pd():
    t=total(price,num)
    if t>300:
        return t*0.8
    else:
        return int(t)-int(t%10)
price = float(input('请输入西红柿单价：'))
num = float(input('请输入数量：'))
print('最终价格为：',pd())

五、递归函数

函数三大件：

1.递归前进

2.递归后退

3.递归边界

当递归边界成立的时候，递归后退，不成立的时候递归前进

（一）求阶乘

def jiecheng(n):
    if n==1:
        return 1
    else:
        return n*jiecheng(n-1)
x=jiecheng(6)
print(x)

（二）求第n个月的兔子数（斐波那契序列）

def tuzi(n):
    if n==1 or n==2:
        return 1
    else:
        return tuzi(n-1)+tuzi(n-2)
n=int(input('请输入月份：'))
# print(n,'的兔子数为：',tuzi(n))
for i in range(1,n+1):
    print('第',i,'个月的兔子数为：',tuzi(i))

# 使用循环的写法
def tuzi(n):
    a, b = 1, 1
    for i in range(1, n + 1):
        if i == 1 or i == 2:
            print(1, end='\t')
        else:
            a, b = b, a + b
            print(b, end='\t')
n=int(input('请输入月份：'))
tuzi(n)

（三）折半查找

只能用于有序的序列

def zbcz(a,start,end,key):
    if start>end:
        return -1
    middle=(start+end)//2
    if key<a[middle]:
        return zbcz(a,start,middle-1,key)
    elif key>a[middle]:
        return zbcz(a,middle+1,end,key)
    else:
        return middle
a=[1,2,3,4,5,6,7,8,9,10]
k=int(input('请输入想要查找的数：'))
x=zbcz(a,0,len(a)-1,k)
if x>=0:
    print(k, '的位置为：', x)
else:
    print('该序列中没有',k)

# 循环实现
def zbcz(a,start,end,k):
    while start<=end:
        middle=(start+end)//2
        if k>a[middle]:
            start=middle+1
        elif k<a[middle]:
            end=middle-1
        else:
            return middle
    return -1
a=[1,2,3,4,5,6,7,8,9,10]
k=int(input('请输入想要查找的数：'))
x=zbcz(a,0,len(a)-1,k)
if x>=0:
    print(k,'的位置为：',x)
else:
    print('该序列中没有',k)