版权声明：本文为博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/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