函数介绍

1、什么是函数

函数就是盛放代码的容器，把实现某一功能的一组代码丢到一个函数中，就做成了一个小工具。
具备某一功能的工具就是函数。
事先准备工具的过程就是函数的定义。
遇到应用场景拿来就用就是函数的调用

2、为何要用函数

没用函数之前面临的问题：
1、代码冗余，程序组织结构不清晰、可读性差
2、扩展性差

3、如何用函数：

原则：先定义，后调用

3.1、定义函数的语法：

def 函数名(参数1，参数2，参数3...)：
	‘‘‘
	文档注释
	‘‘‘
    代码1
    代码2
    代码3
    return 返回值
1、def: 定义函数的关键字；
2、函数名：函数名指向函数内存地址，是对函数体代码的引用。函数的命名；
3、括号：括号内定义参数，参数根据个人需求可有可无；
4、冒号：括号后加冒号，然后在下一行开始缩进编写函数体的代码；
5、"""文档注释""": 描述函数功能，增强函数的可读性；
6、函数体：由语句和表达式组成；
7、return 值：定义函数的返回值，return是可有可无的。

3.2、如何调用函数：

函数名（）
函数的调用：函数名加括号
1、先找到名字
2、根据名字调用代码

def name():
    print(‘艾丽丝‘)
name()
# 艾丽丝

3.3、函数在定义阶段发生了什么事情：

定义函数不执行函数体代码，但是会检测函数语法，而代码的逻辑错误只有在执行时才会知道
def name():
    print(‘艾丽丝‘)
    # for
    x
name()
# 结果输出 爱丽丝 之后，报错 。
def name():
    print(‘艾丽丝‘)
    for
name()
# 语法错误，直接就报错

3.4、函数在调用阶段发生了什么事情：

1、先通过函数名找到函数的内存地址
2、然后函数的内存地址（）会触发函数体代码的运行

4、函数的返回值

用return控制函数的返回值

函数内可以有多个return，但只要执行一次，整个函数就立即结束，并且将return后的值当作本次调用的结果返回，具体来说，函数的返回值又分为三类：
1、return 值：返回的就是该值本身

def name():
    return ‘罗莉安‘
res = name()
print(res)
# 罗莉安

2、return 值1，值2，值3：返回的就是一个元组

def number():
    return 9,9,8
res = number()
print(res)
# (9, 9, 8)

3、函数内可以没有return，或就一个return后没有值，返回的就是None

def number():
    return
res = number()
print(res)
# None

5、定义函数和调用函数的三种方式

5.1、定义函数的三种形式

5.1.1、无参

def pr():
    print(‘你好‘)
    print(‘都好‘)
pr()

5.1.2、有参

def max(x,y):
    if x>y:
        print(x)
    else:
        print(y)
res = max(x,y)
print(res)

5.1.3、空函数

def func():
    pass

5.2、调用函数的三种方式

5.2.1、语句形式：单纯调用一个功能

foo()

5.2.2、表达式形式：

res = len(‘hello‘)
print(res)

5.2.3、可以把函数调用当作参数传给另一个函数：

res = len(‘hello‘)

for i in range(res):
    print(i,end=‘ ‘)
# 0 1 2 3 4 

6、函数的参数

6.1、函数分为两大类：

6.1.1、形参

在函数定义阶段括号内定义的变量名，称之为形式参数，简称形参
def func(x,y):
    pass

6.1.2、实参

在函数调用阶段括号内传入的值，称之为实际参数，简称实参
def func(x):
    pass
func(5)

形参与实参的关系：

在调用函数时，实参的值会绑定给形参名，然后可以在函数内使用，函数调用完毕后，解除绑定
def func(x):
    print(x)
func(5)
# 5

6.2、参数详解

6.1.1、位置形参：

在函数定义阶段按照从左到右的顺序依次定义的形参，称之为位置形参
特点：必须被传值，多一个少一个都不行
def func(x,y):
    print(x,y)

func(5,15)
# 5  15

6.1.2、默认形参：

在函数定义阶段已经为某个形参赋值了，称之为默认形参
特点：在函数定义阶段就已经赋值了，意味着在调用阶段可以不用为其赋值

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

func(5)    # 5 10
def func(x,y=10):
    print(x,y)

func(5,20) # 5 20

ps：可以混用位置形参与默认形参，但是位置形参必须在前

注意：
	1、默认形参的值只在函数定义阶段被赋值一次
    2、默认形参的值，通常应该是不可变类型
x=10

def foo(arg=x):
    print(arg)

x=20 #定义阶段arg已被赋值为10，此处的修改与默认参数arg无任何关系

foo()
# 10

a = 100

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

a = 200
func(10)
# 10 100

a = [1,2,3]

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

a = a.append(6)
func(10)
# 10 [1, 2, 3, 6]

def func(name,b,aihao=[]):
    aihao.append(b)
    print(name,b,aihao)
func(‘tom‘,‘种花‘)
func(‘jon‘,‘种树‘)
func(‘aili‘,‘看电视‘)

‘‘‘
tom 种花 [‘种花‘]
jon 种树 [‘种花‘, ‘种树‘]
aili 看电视 [‘种花‘, ‘种树‘, ‘看电视‘]
‘‘‘

6.1.3、位置实参

在函数调用阶段按照从左到右的顺序依次传入的值，称之为位置实参
特点：按照顺序与形参一一对应
def func(x,y):
    print(x,y)

func(15,5)
# 15 5

6.1.4、关键字实参

在函数调用阶段按照key = value 的格式传入的值，称之为关键字实参
特点：可以打乱顺序，但是仍然能够为指定的形参赋值
def func(x,y):
    print(x,y)

func(y = 5,x = 15)
# 15 5

PS：可以混用位置实参与关键字实参，但是

1、位置实参必须在关键字实参前
2、不能为一个形参多次赋值

6.3、*与**在形参与实参中的应用

可变长的参数：

可变长指的是函数调用阶段，实参的个数不固定，而实参是为了形参赋值的，所以对应着必须要有一种特殊格式的形参能用来接受溢出的实参

形参带*args：

* 会接受溢出的位置实参，然后将其存成元组，然后赋值给紧跟其后的变量名
def num(*args):
    print(args)
    res = 0
    for i in args:
        res += i
    print(res)
num(1,2,3) 
# (1, 2, 3)
#  6

形参带**kwargs：

** 会接收溢出的关键字实参，然后将其存为字典，然后赋值给紧跟其后的变量名
def num(**kwargs):
    print(kwargs)
    for i in kwargs:
        print(i,kwargs[i])
num(x=1,y=2,z=3)
# {‘x‘: 1, ‘y‘: 2, ‘z‘: 3}
#  x 1
#  y 2
#  z 3

实参中带*：

* 后跟的必须是一个可以被for循环遍历的类型
* 会将实参打散成位置实参
def f1(x,y):
    print(x,y)
f1(*(1,2))
#  1 2

实参中带**：

** 后跟的必须是一个字典
** 会将实参打散成关键字实参
def f1(x,y):
    print(x,y)
f1(**{"x":1,"y": 2})
#  1 2

函数传值模板：

def index(x,y,z):
    print(x,y,z)
def wrapper(*args,**kwargs):
    index(*args,**kwargs)
wrapper(1,2,3)
wrapper(1,y=2,z=3)
# 1 2 3
# 1 2 3

函数介绍 - 初识函数（定义，调用，参数介绍）

原文：https://www.cnblogs.com/BaiJiaZhengMing/p/14597951.html