函数的由来

Python中函数的使用非常广泛，前面我们已经接触过多个函数，比如 input() 、print()、range()、len() 函数等等，这些都是 Python 的内置函数，可以直接使用。

除了可以直接使用的内置函数外，Python 还支持自定义函数，即将一段有规律的、可重复使用的代码定义成函数，从而达到一次编写、多次调用的目的。

综上如果开发中也有这样被反复使用的代码场景，怎么实现呢？所以 Python 提供了一个功能，即允许我们将常用的代码以固定的格式封装（包装）成一个独立的代码块，只要知道这个代码块的名字就可以重复使用它，这个代码块就叫做函数（Function）。

函数

什么是函数？

函数就是对实现某一特定功能的代码的封装（通俗的讲就是把实现某一功能的代码打包就是函数），这样做的好处是：函数能提高应用的模块性和代码的重复利用率。

从生活的角度来看，函数可以看成你非常喜欢吃的海底捞火锅，进去吃可能你要点菜，肉，调料等，但是海底捞火锅每次去都要排队，太难啦！

所以海底捞就推出了自煮火锅，这个自煮火锅把常吃的：菜，肉，调料都放进去了。想吃买这个火锅就行了。这就是封装。

定义函数：

def 函数名(参数列表): //实现特定功能的多行代码 [return [返回值]]

注意：

def关键字、函数名()和冒号是固定写法

函数名则是根据函数的功能来命名，一般要求做到见名知意

参数列表根据情况可以有一个、两个、多个，如果有两个或者以上，使用逗号隔开

函数体就是实现函数功能的代码段，函数体属于函数中的内容，前面需要一个缩进

[return [返回值]]表示可选，即返回值的内容可以有也可以没有取决于开发需求

比如有一个制作汉堡的步骤

print('准备面包坯子')
print('炸鸡块放上去')  
print('涂上番茄酱和沙拉酱')
print('放上生菜')
print('包装')

如果把上面的代码封装到函数中如何实现呢？

# 此处的n表示数量
def make_hamburger():
  print('准备面包坯子')
  print('炸鸡块放上去')  
  print('涂上番茄酱和沙拉酱')
  print('放上生菜')
  print('包装')

Ok！这样我们就定义好了一个函数(无参数无返回值的函数)，如果要制作汉堡，只要调用函数就可以了。

函数调用

调用函数也就是执行函数。即把刚才定义的函数当成是一个工具，那么调用函数就相当于使用该工具。

调用格式：

[返回值 =] 函数名([实参列表])

其中，函数名即指的是要调用的函数的名称，[实参列表]即参数定义时要传入的形参的值，是否要传递这些参数取决于函数定义时是否定义了参数，如果该函数有返回值，我们可以通过一个变量来接收该值。

比如上面make_hamburger函数的调用就是：

make_hamburger()

比如我们要定义一个函数用来实现用户的登录，并调用

def login():
  username = input('输入用户名：')
  password = input('输入密码:')
  if username =='admin' and password=='1234':
    print('用户登录成功！')
  else:
    print('用户登录失败！')
    
# 调用函数
login()

上面只是为了让大家能认识函数的定义和调用，下面我们更加深入的从参数和返回值两个方面来了解函数定义

函数的参数

函数分为有参数和无参数函数。通常情况下，定义函数时都会选择有参数的函数形式，函数参数的作用是传递数据给函数体，函数体则使用传递进来的参数做一些相应的处理。

格式(强调括号中没有内容)

def 函数名():

函数体

调用的时候也不用传内容

函数名()

而有参数的则不同：

def 函数名(形参列表):

函数体

注：参数的个数是不确定的，可以是1，2个或者多个

调用的时候：

函数名(实参列表) 定义的时候有多少个参数我们就需要传递几个实参

那参数的作用是什么呢？那什么是形参和实参呢？

• 形参即在定义函数时，函数名后面括号中的参数就是形式参数，
• 实参即在调用函数时，函数名后面括号中的参数也称为实际参数，也就是函数的调用者给函数的参数。例如:

我们多做几个汉堡r，定义一个带参数n的函数make_hamburger来做汉堡，其中定义时候的n就是形参，调用make_hamburger中的5就是实参。

def make_hamburger(n):
  for i in range(1,n+1):
    print('准备面包坯子')
     print('炸鸡块放上去')  
    print('涂上番茄酱和沙拉酱')
    print('放上生菜')
    print('包装')
    print(f'做好了第{i}个汉堡！')
# 调用函数
make_hamburger(5)

通过上例我们观察下图：

假设有一个密不透风的黑盒子，而这个盒子就是我们的函数，盒子里面装的就是函数体的代码。

没有参数的函数就相当于盒子里面的内容是固定的，不变的。

有参数的函数则相当于在盒子上挖了一个洞，通过这个洞可以将外界的内容送进去。

外界送进去的是1，则里面使用的就是1. 外界送进去的是2，则盒子里面使用的就是2。以此类推

参数种类

函数的参数可以分为：位置参数、默认值参数、关键字参数、可变参数。

位置参数，有时也称必备参数，指的是必须按照正确的顺序将实际参数传到函数中。为了让大家更加清楚了解位置参数

我们来看如下代码：

# 有参数的汉堡函数
def make_hamburger(n,kind):
 '''
    汉堡函数，可以用来指定个数和汉堡类型
    @param n: 指定需要几个汉堡
    @param kind: 指定汉堡类型，比如鸡腿堡、双层牛肉堡等
    @return: None
 '''
    for i in range(1,n+1):
       print(f'正在制作第{i}个{kind}汉堡...')  
       print('准备面包坯子')
     print(f'{kind}放上去')  
    print('涂上番茄酱和沙拉酱')
    print('放上生菜')
    print('包装')
    print(f'做好了第{i}个汉堡！')

# 调用函数
make_hamburger(1,'鸡腿')
make_hamburger(5,'双层牛肉')

# 如果参数位置发生了改变则报错:TypeError: can only concatenate str (not "int") to str
# make_hamburger('藤椒鸡肉',5)

# 如果少传递一个参数: TypeError: make_hamburger() missing 1 required positional argument: 'kind'
make_hamburger(5)

错误的原因就是：

1. 将【藤椒鸡肉】传到形参n的位置了，而n被用于range函数中了，所以报错。
2. 第二个错误就是缺少了参数kind

因此调用函数时传入的实参的数量和位置都必须和定义函数时保持一致

默认值参数

上面我们看到如果kind参数不给出就会报错，Python为了能让开发者更加灵活的使用有参数函数，还制定了一个默认值参数。

格式：

def 函数名(普通参数,形参名=默认值):

函数体

注意：如果有默认值参数必须放到普通参数的后面

默认值参数在使用的时候有如下特点：

1. 默认值是指在定义的时候就给定值
2. 定义的时候默认值参数必须在普通参数的后面
3. 调用的时候默认值参数的实参值可以给也可以不给，如果不给就使用默认值的值，给了则使用新值。

比如鸡腿堡卖的非常好招牌，我们可以将种类kind设置成默认鸡腿堡。

# 有参数的奶茶函数
def make_hamburger(n,kind='鸡腿'):
  '''
    汉堡函数，可以用来指定个数和汉堡类型
    @param n: 指定需要几个汉堡
    @param kind: 指定汉堡类型，比如鸡腿堡、双层牛肉堡等
    @return: None
  '''
  for i in range(1,n+1):
       print(f'正在制作第{i}个{kind}汉堡...')  
        print('准备面包坯子')
     print(f'{kind}放上去')  
    print('涂上番茄酱和沙拉酱')
    print('放上生菜')
    print('包装')
    print(f'做好了第{i}个汉堡！')
        
# 调用函数，此时kind位置的参数没有传递，因为设置了默认值参数。
make_hamburger(1)        
        
# 调用函数
make_hamburger(2,'双层牛肉')

有什么区别呢？虽然make_hamburger定义的时候有两个参数，但是调用的时候只传递了一个参数也没有报错，这是因为定义了默认值参数，不传递的情况下则使用默认值。

最后再次强调，当定义一个有默认值参数的函数时，有默认值的参数必须位于所有没默认值参数的后面。

关键字参数

关键字参数是指函数的参数比较多，在调用的时候容易混乱，为了能在调用的时候更加明确参数值是给谁的，而产生的关键字参数。

通过此方式指定函数实参时，不再需要与形参的位置完全一致，只要将参数名写正确即可。

make_hamburger(3,kind = '藤椒鸡腿')

我们在上面的函数基础上再多加一个参数price：

def make_hamburger(n,kind='鸡腿',price=13):
   '''
    汉堡函数，可以用来指定个数和汉堡类型
    @param n: 指定需要几个汉堡
    @param kind: 指定汉堡类型，比如鸡腿堡、双层牛肉堡等
    @return: None
  '''
  print(f'本次共购买{n}个{kind}汉堡，共计{n*price}元')
  for i in range(1,n+1):
       print(f'正在制作第{i}个{kind}汉堡...')  
        print('准备面包坯子')
     print(f'{kind}放上去')  
    print('涂上番茄酱和沙拉酱')
    print('放上生菜')
    print('包装')
    print(f'做好了第{i}个汉堡！')
 

# 为了方便大家测试结果，可以注释其他的函数调用保留一个即可        
# 调用函数，
make_hamburger(1) # 位置数必须赋值传参，其他的使用默认值

# 改变汉堡类型和价格
milk_tea(2,price=16,kind='双层牛肉')

# 甚至如果大家担心第一个参数意思不明确，也可以使用关键字参数
milk_tea(n=3,kind='藤椒鸡腿',price=15)

大家发现在调用的时候使用关键字参数，使函数的调用也变得更加方便和灵活了。

练习一个随机验证码的游戏吧，验证码这个在网站经常见到，因为经常使用所以我们就封装成函数使用。

import random

# 其中n表示的是几位的验证码，我们常见的是4位，所以设置成默认值参数
def validate_code(n=4):
  # 验证码一般是字母和数字的组合
  s = 'QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm1234567890'
  code = ''
  for i in range(n):
    r = random.choice(s)
    code += r
  print('验证码是：{}'.format(code))

# 打印
validate_code(5)
validate_code()

可变参数

什么是可变参数呢？就是在定义或者调用的时候都不能明确参数的个数。比如Python内置函数中有个max函数，用来求最大值的。但是我们会求几个数的最大值呢？有可能是2个数中最大的，也可能是5个数中最大的，或者10个数中最大的。

看一下代码：

max(1,2,3)
max(2,4,6,8,9,10)
max(5,8,0)

那max函数如何定义才可以使参数个数更加灵活？使用：*args或者**kwargs

我们来定义一个可以计算多位数字和的函数add

def add(*args):  #  args即arguments的简写   *args 在函数中使用的时候就是一个()
 print(type(args))  # 是个元组类型

 if len(args)>1:
  sum =0
  for i in args:
   sum+=i

  print('和是:',sum)
 else:
  print('参数至少2个')

# 
add()

add(1)

add(1,2)

add(1,2,3)

如果在调用的时候传入关键字参数，我们此时就要使用**kwargs即 key word arguments

定义一个简单的函数

def func(**kwargs):   # kwargs 即  key word  arguments  ，而**kwargs 就是一个字典类型的
 print(kwargs)   # 即字典保存关键字参数 {'a':1,'b':2,'c':3}
 
func(a=1,b=2,c=3)

返回值

用 def 语句创建函数时，可以用 return 语句指定应该返回的值，该返回值可以是任意类型。需要注意的是，return 语句在同一函数中可以出现多次，但只要有一个得到执行，就会直接结束函数的执行。

函数返回值就是你所调用的函数返回给你的值。返回值可指定，如果不指定默认返回None。

一个函数可以有返回值，也可以没有返回值。

（1）没有返回值的函数：功能只是完成一个操作，函数体内可没有return语句。调用会返回None

（2）有返回值的函数：函数的最后会有一个返回值return，将函数执行的结果返出。

简而言之就是，如果没有返回值不需要在函数中添加关键字return，否则必须有return关键字。

看一个没有方法返回值的案例：

def make_hamburger():
  print('准备面包坯子')
   print('炸鸡块放上去')  
  print('涂上番茄酱和沙拉酱')
  print('放上生菜')
  print('包装')
# 所谓返回值就是在调用函数的时候获取返回结果
# 通过变量result获取返回值结果
result = milk_tea(2)
# 打印获取的返回值结果
print("返回值结果是：{}".format(result))

大家可以观察到返回值结果是：None. 因为没有return关键字

再看一下这段代码：

def make_hamburger():
  print('准备面包坯子')
   print('炸鸡块放上去')  
  print('涂上番茄酱和沙拉酱')
  print('放上生菜')
  print('包装')
    # 通过关键字return向外返出结果    
    return '不好意思久等了，您要的汉堡已经制作完成！欢迎下次光临！'

# 通过变量result获取返回值结果
result = milk_tea(2)

# 打印获取的返回值结果
print("返回值结果是：{}".format(result))

这段代码打印的返回值结果是：不好意思久等了，您要的汉堡已经制作完成！欢迎下次光临！

比如前面提到过的1-10的累加和，要求最后将累加的结果返回，如何实现呢？

# 1. 定义函数
def get_sum():
 # 请补全里面的内容
 total = 0 
 for i in range(1,11):
  total+=i
 return total
 
# 2. 调用函数
get_sum()

当然Python的返回值也可以返回多个值。

def func():
  return 'hello',666
  
# 调用函数并获取返回值
result = func()
print(result) # 大家可以看到结果是：('hello',666)

所以我们知道，如果return后面有多个返回值则将多个返回值保存在元组中，最后以元组的形式整体返回。

下次给大家带来匿名函数、递归函数、变量作用域等内容。