初识函数

初识函数

1.什么是函数

函数就类似于是日常生活中我们所使用的工具

2.函数是干什么的

例如锤子是在打造好以后，我们就能拿来使用的，而函数就是需要我们提前定义好之后可以反复拿来使用

3.函数的语法格式

"""
def 函数名(参数1,参数2):
    '''函数注释'''
    函数体代码
    return 返回值

1.def(必须的)
    是定义函数的关键字
2.函数名(必须的)
    是函数的名字 相当于变量名
    函数名的命名规范与风格遵循变量名的
3.参数1,参数2(可选的)
    参数可以没有也可以有多个
    表示在使用函数之前需要满足的一些条件
4.函数注释(可选的)
    类似于产品说明书
    主要用于介绍函数功能 参数使用 及其他情况
5.函数体代码(必须的)
    函数核心的代码逻辑(重要)
6.return返回值(可选的)
    使用函数之后反馈给使用者的结果 可以有也可以没有

4.函数的调用

1.函数必须先定义后调用(顺序不能乱)
2.函数在定义阶段只检测语法不执行代码
3.函数在调用阶段才会执行函数体代码
	如何调用函数
    	函数名加括号 如果函数在定义阶段有参数则在调用阶段也需要给参数
函数在定义与调用阶段底层原理
1.在内存空间中申请一块空间存储函数体代码
2.将函数体代码所在的空间地址绑定给函数名
3.函数名加括号则会执行函数体代码

5.函数的分类

# 1.
# 内置函数
# python解释器自带的(提前给你定义好了
# 你直接使用即可)
# 2.
# 自定义函数
# 程序员自己写的函数
# 2.1.无参函数
# 2.2.有参函数
# 2.3.空函数

# 无参函数:在函数定义阶段括号内没有写参数(变量名)
def my_func():
    print('这个函数很牛逼')
	# 有参函数:在函数定义阶段括号内写了参数(变量名)
def my_func(a,b):
    print('这个函数更牛逼')
my_func(1,2)

# 空函数:函数体代码为空(pass ...)
"""
虽然空函数本身没有含义 但是空函数可以提前规定好编写代码的思路
"""

6.函数参数两大类

# 1.函数参数两大类
# 形式参数
# 函数定义时括号内填写的参数，简称:形参
# def func('参数1，参数2'):
#     pass
# 实际参数
# 函数调用时需要写的函数，简称：实参
# func('参数1，参数2')
# 形式参数在函数定义时使用，实际参数在函数调用时使用
'''函数形式参数与实际参数的关系
        形参和实参的关系类似与变量名与变量值的关系
            形参在实参在函数体代码运行时临时绑定关系，函数运行结束解除绑定关系
        形参的表现形式只有一种，可以看成是变量名
        实参的表现形式有很多种，可以看作是实际的数据值
'''

7.位置参数

# 2.位置参数
# 按照顺序，从左到右依次填入括号内
# 位置形式参数、位置实际参数
# def fun(a,b):
#     print(a,b)
#
#
# fun(1,2)  # 1 2
'''在使用位置参数时，调用函数时形式参数和实际参数是一一对应的，
且形式参数和实际参数的数量必须一致，不能少一个也不能多一个
'''

8.关键字参数

# 2.2 关键字实际参数
# 关键字参数是在函数调用时，实参可以用形参名=数据值的形式
# def fun(a, b):
#     print(a, b)
#
#
# fun(b=1, a=2)  # 2 1
'''在使用关键字实参时，调用时可以打乱程序
且在填写实际参数时，要确保都有值，不然会出现参数重复的错误
'''

# 比大小函数
# def fun(a, b):
#     if a > b:
#         print(a)
#     else:
#         print(b)
#
#
# fun(a=10, b=20)  # 20

9.默认形式参数

# 2默认形式参数
# 默认形式参数是在函数定义时给参数一个默认值，函数调用时如果不写，就代表是默认值，
# 如果根据一一对应的关系填值，则使用填的值
def fun(name, age, sex='male'):
     print(f'{name}, {age}, {sex}')


fun('jenny', 18, 'female')  # jenny, 18, female


def fun(name, age, hobby=[]):
     hobby.append(age)
     print(f'{name},{age},{hobby}')


fun(name='jason', age=18)  # jason,18,[18]
fun(name='jason', age=28)  # jason,28,[18, 28]
fun(name='jason', age=38)  # jason,38,[18, 28, 38]
'''当默认形参是一个空列表时，在调用时如果使用默认形参，
实际上每次都是在对同一个列表进行操作，也可以说是指向的是固定的一个地址
'''
n = 200


def fun(a, b, c=n):
     print(a, b, c)


n = 400
fun(1, 2)  # 1 2 200
'''之所以会出现如上情况可以从两个角度考虑
角度1
    默认形参在函数定义阶段就已经固定死了，不会再因为后续的条件改变而改变
    
角度2
    第一步，n指向200这个值的内存地址，c通过n指向200这个变量值，
    第二步，当n又指向400时，c和200的绑定关系还在
    所以不会受影响
'''

10.可变长参数

# 3.可变长参数
# 3.1 可变长形参
# 函数无论传入多少位置参数都可以运行
def fun(*args):
    print(args)


fun(1, 2, 3, 4, 5, 6)  # (1, 2, 3, 4, 5, 6)


def fun(a, b, *args):
    print(a, b, args)


fun(1, 2, 3, 4, 5, 6)  # 1 2 (3, 4, 5, 6)
'''*号在形参中的使用
    接受多余的位置参数，并组成元组的形式赋值给*号后面的变量名
'''

# 函数无论传入多少关键字参数都可以运行
# def fun(a, b, **kwargs):
#     print(a, b, kwargs)
#
#
# fun(1, 2, c=3, d=4, e=5, f=6)  # 1 2 {'c': 3, 'd': 4, 'e': 5, 'f': 6}
'''**号在形参中的作用
    接受多余的关键字参数，并组成字典的形式赋值给**号后面的变量名
'''

# # 函数无论传入多少位置参数和关键字参数都能运行
def fun(*args, **kwargs):
    print(args, kwargs)


fun()  # () {}
fun(1, 2, 3)  # (1, 2, 3) {}
fun(c=3, d=4, e=5, f=6)  # () {'c': 3, 'd': 4, 'e': 5, 'f': 6}
fun(1, 2, 9, 10, c=3, d=4, e=5, f=6)  # (1, 2, 9, 10) {'c': 3, 'd': 4, 'e': 5, 'f': 6}
'''在可变长形参中，如果不传入值，就会生成一个空元组或者空字典'''

# 3.2 可变长实参
# 当遇到要传入的实参数据很大时，且要实现一一对应时采用可变长实参就可以完美解决该类问题
# 当实参是一个列表时，如果实现一一对应关系
def fun(*args):
    print(args)


lis = [1, 2, 3, 4, 5, 6]
fun(*lis)  # (1, 2, 3, 4, 5, 6)
'''*号在实参中的应用
先把原来列表或元组里的元素打散成未知参数的形式再组成元组的形式赋值给*号后面的形参
'''

# 当传入的数据是一个字典的形式的时候
def fun(**kwargs):
    print(kwargs)


dic = {'c': 3, 'd': 4, 'e': 5, 'f': 6}
fun(**dic)  # {'c': 3, 'd': 4, 'e': 5, 'f': 6}
'''**号在关键字实参中的应用
    先把字典里的元素打散成关键字参数的形式，再组织成字典的形式赋值给**号后面的变量名
'''

'''函数在形参和实参上都遵循一个原则
格式越简单的位置越靠前，越复杂的位置越靠后
'''