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

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('艾丽丝')
    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