Python中的函数（10）

函数定义：

函数是组织好的，可重复使用的，用来实现独立功能的代码段。
函数可以提高程序代码的重用率。
def 函数名():
函数封装的代码

1.def是英文define（定义）的缩写
2.函数名称应该能够表达函数封装代码的功能，方便后续调用
3.函数名符合标识符命名规则
4.函数先定义，后调用
5.函数不调用，不执行
6.函数可以调用多次

函数调用：

通过 函数名()即可完成对函数的调用

#从上向下执行程序
def say():#定义函数
    print("1.嗯")
    print('2.哈')
    print("3.嘿")
#只有在程序中，主动调用函数，才会让函数执行
say()#函数的调用不能放在函数定义上方

运行结果：

函数调用的本质

#函数调用的本质：本质是函数名对应的内存地址()
def xiaogou():
    print('ni好')

print(id(xiaogou))
d=xiaogou#将xiaogou的内存地址赋值给d变量
print(id(d))
d()

运行结果：

def hs():
    print(i+1)

i=5
a=hs
b=hs
a()
i=7
b()
"""
运行结果：
6
8
"""

定义带有参数的函数

def qiuhe(a,b):#定义的时候，成为形参，因为它没有实际的的值，给它什么值，他就是什么值，没有数据，占了位置
    c=a+b
    print(c)
qiuhe(2,3)#5 实参：调用的时候，参数为实参有实际的值了
qiuhe(5,6)#11

函数的参数

位值参数

#位置参数
def hs(a,b):
    c=a+b
    print(c)
hs(2,3)
#hs(2,3,4)#不对，必须是一一对应着的参数
'''
运行结果：
5
'''

关键字参数

# 关键字参数，针对实参
def hs(a, b, c):
    print(a, b, c)
# 关键字参数和位置参数同时使用时，关键字参数必须在位置参数后面 定义
hs(c=1, a=2, b=3)
hs(2, 3, c=7)  # 关键字参数，针对实参，这里正确
# hs(a=2,3,4)#比如这里，报错
"""
运行结果：
2 3 1
2 3 7
"""

默认参数

#默认参数：写在形参里面
def dengji(name,age,sex='男'):
    print(name,age,sex)


dengji("张三",19)
dengji("李四",20,'男')
dengji('王五',21,'女')#女 会修改默认参数 男

"""
运行结果：
张三 19 男
李四 20 男
王五 21 女
"""

可变参数

元组参数 *args

#元组参数
def kb(*a):#通过给形参前面添加*号，使参数变成一个元组，所有传递的参数变成元组的元素
    print(a,type(a))#元组
kb(1)#(1,) <class 'tuple'>
kb(1,2,3,4)#(1, 2, 3, 4) <class 'tuple'>
kb()#() <class 'tuple'>

*具有打散序列的功能

print("第一个")
def kb2(*args):
    print(args,type(args))
x=(1, 2, 3)
kb2(x)#这里将一整个x看做了一个整体
kb2(*x)#一个个对应的传过去

print("第二个")
#*具有打散序列的功能
def kb2(*args):
    print(args,type(args))
    print(args[0],args[1],args[2])
x=(1, 2, 3)
kb2(*x)

运行结果：

a = [1, 2, 3]
print(*a)

b = (1, 2, 3)
print(*b)

c, *d = a
print(c, d)
"""
运行结果：
1 2 3
1 2 3
1 [2, 3]
"""

字典参数 **kwargs

def kb(**kwargs):
    print(kwargs,type(kwargs))
kb(name='张三',age=18)
kb(name='张三',age=20,sex='男')
kb()

运行结果：

打散字典

def kb(name,age):
    print(name,age)
a={"name":"张三","age":"20"}#这里的key值要和形参一样
kb(**a)
"""
运行结果：
张三 20
"""

注意： **kwargs 必须放在*args后面

def kb(*a,**b):
    print(a,b)
a={"name":"张三","age":"20"}
kb(1,2,3,**a)
"""
运行结果：
(1, 2, 3) {'name': '张三', 'age': '20'}

"""

四种函数参数的总结

#定义函数时参数的顺序：
# 位置参数、元组参数、默认参数、字典参数
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)


def kb2(a, *b, c=9, **d):
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)


kb2(1, 2, 3, name='张三')


def kb3(a, b=9, *c, **d):
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)


kb3(1, 2, 3, 4)

函数的返回值

return关键字的两个作用
return 关键字可以返回结果
return，表示返回，后续的代码都不会被执行

def hs(a, b):
    c = a + b
    d = a - b
    e = a * b
    return c, d, e  # python中可以有多个返回值


# 使用一个变量x接收多个值，返回多值就是返回一个tuple
x = hs(5, 6)
print(x)


def hs(a, b):
    c = a + b
    d = a - b
    e = a * b
    return c, d, e  # python中可以有多个返回值


# 使用等量变量来接收返回值
a, b, c = hs(5, 6)
print(a, b, c)

运行结果：

def hanshu():
    i = 0
    while i < 5:
        if i == 2:
            return  # return 没有返回值，返回值为空
        print(i)
        i += 1


x = hanshu()
print(x)

运行结果：

函数之间的调用

#函数之间的调用
def hs1(x,y):
    print(x*y)
def hs2(a,b,c):#在hs2()函数中调用hs1()
    hs1(a,b)
    print(c)
hs2(2,3,4)
"""
运行结果：
6
4
"""

def getMoney(price,numbers):

    return price*numbers

def zheKou(money):
    if money>300:
        return money*0.8
    else:
        d=int(money)-int(money)%10
        return d

price = float(input("价格"))
num = float(input("重量"))

# money=getMoney(price,num)
# money=zheKou(money)
#先运行函数里面的，由内而外
money=zheKou(getMoney(price,num))
print(money)

运行结果：

递归函数

递归：如果一个函数在内部调用自身本身，这个函数就是递归函数
使用递归函数的条件：
1.必须留出口
2.自己调用自己

递归三件：
1.递归前进
2.递归后退
3.递归边界
当递归边界成立的时候，递归后退，不成立的时候递归前进

1.求6的阶乘

#求6的阶乘
def jiecheng(n):
    if n == 1:  # 递归边界
        return 1
    else:
        return n * jiecheng(n - 1)


x = jiecheng(6)
print(x) # 720

2.斐波那契数列的规则

#斐波那契数列的规矩
#1 1 2 3 5 8 13 21
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))

运行结果：

用循环的形式写出来

n=int(input("月份") )
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")

3.先向里面的递归，再打印外面的heihei

#先向里面的递归，再打印外面的heihei
def p_n(n):
    print(n)
    if n==1:
        return
    p_n(n-1)
    print("--heihei")
p_n(4)

运行结果：

4.查找数字的所在位置

def zbcz(a, start, end, key):
    if start > end:
        return -1
    middle = (start + end) // 2
    if key > a[middle]:
        return zbcz(a, middle + 1, end, key)
    elif key < a[middle]:
        return zbcz(a, start, middle - 1, key)
    else:
        return middle


a = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]
k = int(input("请输入要查找的数："))
x = zbcz(a, 0, len(a) - 1, k)
print(k, "的位置是", x)

运行结果：

用循环的形式写出来

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  # 那么向左查找
        elif k == a[middle]:  # 如果相等，那么返回此时的middle值
            return middle
    return -1  # 如果循环结束没有找到，那么返回-1


a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
n = int(input('请输入要查找的数：'))
x = zbcz(a, 0, len(a) - 1, n)  # 调用二分查找（也叫折半查找）函数。位置下标从0开始到最后一个下标
if x == -1:
    print("查无此数")
else:
    print(n, "的位置是", x)