Python函数详解-优快云博客

本文链接：https://blog.youkuaiyun.com/langdei/article/details/96832878

文章目录

一、函数定义:

一、函数定义:

	函数是组织好的，可重复使用的，用来实现独立功能的代码段。

作用:

函数能提高应用的模块性，和代码的重复利用率。
格式（不带参数）：

def 函数名(): # 定义函数名
代码
函数名() # 调用函数
实例：

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

运行结果：
在这里插入图片描述

格式（带参数）：

 def qiuhe(a,b,c):    # 形参：定义的时候，参数为形参，定义的时候没有实际值，只是占了一个位置，给他什么值，他就是什么值
 c = a + b + c
 print(c)

 qiuhe(1,2,3)  # 6  实参：调用的时候，参数为实参，里面有实际值

注意：

 调用的时候，这个函数定义时有几个参数，就需要传递几个参数  a,b,c  1,2,3  (一一对应)

默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。

形参

定义时小括号中的参数，用来接收参数用的，称为 “形参” a,b,c

实参

调用时小括号中的参数，用来传递给函数用的，称为 “实参” 1,2,3

 1.函数名称必须遵循 标识符规则：数字，字母，下划线，并且不能以数字开头，不能使用关键字
 2.函数先定义后调用
 3.函数不调用是不执行的
 4.函数可以多次调用

函数的调用

def area()
	代码
area()  # 调用函数

函数调用的本质

**本质是函数名对应的内存地址（）**

	def xiaogou():
   		 print("你好")

	print(xiaogou)
	print(id(xiaogou))
	d= xiaogou
	print(id(d))
	d()

在这里插入图片描述

二、函数的参数

1.位置参数（一一对应）
定义： 实参传递的顺序按照形参定义的顺序进行传递的顺序
举例：

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

2.关键字参数（跟顺序无关）
**定义：**以形参等于实参的形式忽略形参定义的顺序进行传参的传参方式
举例：

def dengji(name,age):
    print("我叫：",name)
    print("年龄：",age)
dengji(age=20,name="张杰")

在这里插入图片描述
注意：

	关键字参数和位置参数同时使用时，关键字参数必须放在位置参数后面定义

sum_num(30,num2=10)  # 正确格式
sum_num(num1=20,20)  # 会报错

3.默认参数 默认参数放在非默认参数的后面（否则异常）
**定义：**在定义参数的时候，给参数一个默认值，这样在调用参数的时候，如果不给有默认值的形参传参，会自动采用默认值，如果给有默认值的形参传参，会覆盖默认值
举例：

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

在这里插入图片描述
在代码中，形参和实参不一定要一致

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

在这里插入图片描述

4.可变参数（*args，kwargs）
定义： 函数中参数过多，定义起来非常麻烦，调用起来也非常麻烦，python给我们提供了可变参数类型，能处理比当初声明时更多的参数，会将传入的参数变成元组（*args）或字典（kwargs）
用途： 在定义函数需要，每个定义函数功能的都可以继续优化，所以我们需要用动态参数
如果把参数写死了，后期继续修改完善的功能的，修改该函数功能则会相当麻烦
*args 结果类型是元祖，传递值是任意**类型
**kwargs结果类型是字典，传递值是以key=value方式传入
*args

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

在这里插入图片描述
** * 星号打散序列功能**

def kb2(*args):
    print(args,type(args))
    # print(args[0])
    # print(args[0],args[1],args[2])
x = (1,2,3)
kb2(x) # 二维元组第一个数是元组  # ((1, 2, 3),) <class 'tuple'>
kb2(*x)  # 加星号打散

在这里插入图片描述

	a = [1,2,3]
	print(*a)  #（1,2,3）--->1 2 3

	b = [1,2,3]
	print(*b)  # 		1 2 3

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

**字典参数** **kwargs

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

在这里插入图片描述
**的打散功能

def kb(name,age):
    print(name,age) 
a = {'name':"张三","age":20}
kb(**a)

运行结果：
张三 20
注意

def kb(a,b):
    print(a,b)  # 张三 19

x = {"a":"张三","b":19}  #  **字典中key必须跟形参一样**
kb(**x)

对于元组和字典作为形参：

def kb(*a,**b):
    print(a,b)  # (1, 2, 3) {'name': '张三', 'age': 19}

a = {"name":"张三","age":19}
kb(1,2,3,**a)

def kb(**b,*a):  # **b得放后面不然报错
    print(a,b)

a = {"name":"张三","age":19}
kb(**a,1,2,3)  # 同上**a得放后面，不然报错

函数参数总结：
**定义函数参数时的顺序：**位置参数，元组参数，默认参数，字典参数

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 kb(a,b=9,*c,**d):
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)
kb(1,2,3,4)

在这里插入图片描述

def qiuhe(a,b):
    c = a+b  # 没写return返回None
    return c  # **谁调用返回给谁**,调用x，1,2就返回给x
x = qiuhe(1,2)
print(x)  # 3

y = qiuhe(10,20)  # 调用y10,20，返回给y
print(y)  # 30

三、练习：

a = [1,2,30]
x =a.remove(30)  # remove函数，参数30，（None）没有返回值
print(x)  # None 空

def hs(a,b):
    c=a+b
    d=a-b
    e=a*b
    return c,d,e  # **return可以返回多个值**
x=hs(5,6)
print(x)  # (11, -1, 30)  # 返回的是元组

这里要注意的是：return可以在函数内任意位置写多个，但return下面的语句将不执行

def hs(a,b):
    return  # **return可以写在函数内任意位置，可以写多个return**
    c=a+b
    d=a-b
    return c,d
x=hs(5,6)
print(x)  # None

实例（买西红柿）：

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)
print(money)

西红柿单价：4
西红柿数量：5
20

递归函数：

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

递归三大件：
递归前进
递归后退
递归边界
当递归边界成立的时候，递归后退，不成立的时候递归前进
通过以下两个案例来了解递归函数

def jiecheng(num):
    if num == 1:  # 递归边界  # 出口
        return 1
    else:
        return num*jiecheng(num-1)  # 调用自己
x = jiecheng(6)
print(x)  # 720

def p_n(n):
    print(n)
    if n == 1:
        return
    p_n(n-1)
    print("--heihei")
p_n(4)

4
3
2
1
--heihei
--heihei
--heihei

二分法查找：

def search(a,start,end,key):

    middle = (start+end)//2
    if key>a[middle]:
        return search(a,middle+1,end,key)
    elif key<a[middle]:
        return search(a,start,middle-1,key)
    else:
        return middle
a=[1,2,3,4,5,6,7,8,9,10]
key = int(input("请输入要查找的数："))
x = search(a,0,9,key)
print(key,"的位置是："

请输入要查找的数：9
9 的位置是： 8

修改后：

def search(a,start,end,key):

    middle = (start+end)//2
    if start > end or key>end or key<start:
        return -1
    elif key>a[middle]:
        return search(a,middle+1,end,key)
    elif key<a[middle]:
        return search(a,start,middle-1,key)
    else:
        return middle
a=[1,2,3,4,5,6,7,8,9,10]
key = int(input("请输入要查找的数："))
x = search(a,0,len(a)-1,key)
if x == -1:
    print("查无此数")
else:
    print(key,"的位置是：",x)
请输入要查找的数：15
查无此数

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]:
            return middle  # 出口
    return -1  # 出口
a=[1,2,3,4,5,6,7,8,9,10]
key = int(input("请输入要查找的数："))
x = zbcz(a,0,len(a)-1,key)
if x == -1:
    print("查无此数")
else:
    print(key, "的位置是：", x)
请输入要查找的数：19
查无此数

斐波那契数列求兔子

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))
运行结果：
		请输入月份：5
		5 月的兔子数是： 5