函数的基础

什么是函数

函数就是程序中具备某一功能的工具。（事先将工具准备好就是函数的定义，遇到应用场景拿来就用就是函数的调用。）

为何用函数

1. 精简程序
2. 增加程序的扩展性
3. 程序的可读性变好

如何调用函数

先定义函数，后调用。

• 定义函数：定义函数阶段只识别语法，不运行代码；也就是说：在函数定义阶段，只要不是语法错误，就不会报错。

  def 函数名(param1,param2...):
      '''
      函数功能的描述信息
      :param1 #描述
      :param2 #描述
      :return #返回值
      '''
      code1 # 实现某一个具体的功能
      code2
      code3
      retrun 返回值

  函数名的定义：

  1. 函数名具有某种意义
  2. 函数名接收函数体返回的返回值
  3. 函数名由下划线、字母、数字 组成，且不能以数字开头（也不能以下划线开头）

• 调用函数 : 调用函数阶段才执行函数体代码。

  函数名()可以使用这个工具

  函数名(param1,param2....)

定义函数的三种形式

定义函数时‘参数’是函数体接收外部传值的一种媒介，其实就是一个变量名。

无参函数

• 什么是无参函数

  在函数定义阶段，括号内没有参数（变量名），称为无参函数。

• 需要注意的点

  1. 定义时无参（变量名），则调用函数时也无需传入参数。
  2. 如果函数体代码逻辑不需要依赖外部传入的值，就必须得定义成无参函数

  def func():
      print('hello world')
  func()  # hello world

有参函数

• 什么是有参函数

  在函数定义阶段括号内有参数（变量名），称为有参函数。

• 需要注意的点

  1. 定义时有参（变量名），则调用函数时也必须传入参数。
  2. 如果函数体代码逻辑需要依赖外部传入的值，必须得定义成有参函数；且有几个参数，就必须传入几个值。

  def sum_self(x,y):
      '''求和'''
      res = x+y
      print(res)
  sum_self(1,2)  #3

空函数

当你只知道你需要实现某个功能，但不知道该如何用代码实现时，你可以暂时写个空函数，然后先实现其他功能。

def func():
    pass

函数的返回值

什么是返回值

返回值：函数内部代码经过一系列逻辑处理获得的结果。类型于变量值

def func():
    name = 'rayn'
    return name
name = func()
print(name)  # rayn

为什么要有返回值

如果需要在程序中拿到函数的处理结果并做进一步的处理，则需要函数必须要有返回值。

def max_self(salary1,salary2):
    if salary1 > salary2:
        return salary1
    else:
        return salary2
max_salary = max_self(20000,30000)
print(max_salary*12)  # 360000

需要注意：

• return是一个函数结束的标志，函数内可以有多个return，只要执行到return，函数就会停止；
• return的返回值可以返回任意数据类型；
• return的返回值无个数限制，即可以使用逗号隔开返回多个值；
  • 0个：返回None
  • 1个：返回值还是该值本身
  • 多个：返回值是元祖

def func():
    name = 'rayn'
    age = 20
    hobby_list = ['run','rap']
    return name,age,hobby_list

name,age,hobby_list = func()
print(f'name,age,hobby_list:{name,age,hobby_list}')

name,age,hobby_list:('rayn', 20, ['run', 'rap'])

函数的调用

函数参数的应用

形参和实参

• 形参：在函数定义阶段，括号内定义的参数，被称之为形式参数，简称：形参，类似于变量名，不为具体的数据类型。

  def func(x,y): # x,y 就是形参
      print(x)
      print(y)
  

• 实参：在函数调用阶段，括号内传入的参数，被称之为实际参数，简称实参，类似于变量的值；实参必须是具体的数据类型。

  func(1,2) # 1,2 就是实参

位置参数

• 位置形参：在函数定义阶段，按照从左到右的顺序依次定义的形参，称之为位置形参。

  def func(x,y):
      print(x)
      print(y)

  特点：按照位置定义的形参，都必须被传值，多一个不行，少一个也不行。

• 位置实参:在函数调用阶段，按照从左到右的顺序依次定义的实参，被称之为位置实参。

  fun(1,2)

  特点：按照位置为对应的形参依次传值。

默认形参

在函数定义阶段，提前赋值给形参，当实参传值的时候，实参传的值会覆盖默认值。值不需要改变，并且经常使用，就用默认形参；默认形参必须在位置形参后面。

def guess_age(age=18):
    inp_age = int(input('请输入年龄：'))
    if inp_age == age:
        print('猜对了')
    else:
        print('猜错了')
guess_age()
请输入年龄：18
猜对了

guess_age(20) # 实参上传的值覆盖了默认值
请输入年龄：20
猜对了

关键字实参

在调用时，按照key = value 的形式为指定的参数传值，称之为关键字实参；形参名是什么，则关键字实参名也必须是什么。

def self_max(a,b):
    print(f'a:{a},b:{b}')
res1 = self_max(b=30,a=20)

a:20,b:30

特点：可以打破位置的限制，但仍能为指定的形参赋值。

注意：

1. 可以混用位置实参和关键字实参，但是位置实参必须在关键字实参的前面。
2. 可以混用位置实参和关键字实参，但不能对一个形参重复赋值。

def self_max(x,y,z,a,b):
    print(f'{x},{y},{z},a:{a},b:{b}')
res1 = self_max(10,11,12,b=30,a=20)

10,11,12,a:20,b:30

可变长参数

可变长参数：指的是在调用函数时，传入的参数个数可以不固定。

调用函数时，传值的方式无非两种，一种是位置实参，另一种试试关键字实参，因此形参额必须得有两种解决方法，以此来分别接收溢出的位置实参（*）与关键字实参（**）。

可变长形参之 *

形参中的 * 会将溢出的位置实参全部接收，以元祖的形式存储，再把元祖赋值给 * 后的参数。注意：* 后的参数名约定俗成为args。

def self_max(*args):
    print(args)
res1 = self_max(10,11,12,13,14)

10 11 12 13 14

可变长形参之 **

形参中的 ** 会将溢出的关键字实参全部接收，以字典的形式存储，再把字典赋值给 ** 后的参数。注意：** 的参数名约定俗称为kwargs。

def self_max(**kwargs):
    print(kwargs)
res1 = self_max(a=10,b=20,c=30,d=40)

{'a': 10, 'b': 20, 'c': 30, 'd': 40}

可变长实参之 *

实参中的 * ，会将 * 后参数的值循环取出，打散成位置实参。以后但凡碰到实参中带 * 的，它就是位置实参，应该马上打散成位置实参去看。

def self_max(*args):
    print(args)

a = [1,2,3] # 把这个列表内的元素一个一个取出来，然后一个一个传给这个函数
self_max(*a)


(1, 2, 3)  

可变长实参之 **

实参中的 ** ，会将 ** 后参数的值循环取出，打散成关键字实参。以后但凡碰到实参中带 ** 的，它就是关键字实参，应该马上打散成关键字实参去看。

def self_max(**kwargs):
    print(kwargs)

x = {'a':10,'b':20,'c':30,'d':40}
res1 = self_max(**x)

{'a': 10, 'b': 20, 'c': 30, 'd': 40}

*后面必须得写args, ** 后面必须得写kwargs,约定俗成的一种规范

python-函数基础、函数参数

原文：https://www.cnblogs.com/raynduan/p/10953518.html