函数的定义及参数

函数 可以对重复使用的功能代码进行封装，提高代码的复用性，提高工作效率，降低代码的耦合性。
关键字def 其基本形式如下：

 

def 函数名字():    # 函数命名规范同变量（内置函数，官方库，第三方库的名字统统不能用）
    函数的功能代码
函数名字()       #  定义好的函数不会直接执行其中的功能代码，需要调用才能执行函数内部代码
函数可以调用其他函数，也可以在函数内部调用自己，但是最好不要这样操作一般运行993次（[Previous line repeated 993 more times]）后报错RecursionError: maximum recursion depth exceeded while calling a Python object

def xingxing(n):    # 定义函数并封装
    for i in range(1,n+1):
        for j in range(1,i+1):
            print('*',end='')
        print()
xingxing(5)   # 调用封装好的函数，debug调试在调用函数处打断点，运行到调用函数代码行可使用step into快捷键F7进入函数内部，如下图
*
**
***
****
*****

内置函数常见的有：
bool(),dict(),float(),id(),input(),int(),list(),print(),set(),str(),tuple()

函数的参数 定义函数的时候，可以在后面的括号中定义参数

def xingxing(n):     # 定义一个可以自定义打印三角形大小的函数 n
    for i in range(1,n+1):
        for j in range(1,i+1):
            print('*',end='')
        print()
xingxing(5)

参数类型：
形参：定义的参数（顾名思义形式参数），又分三种定义形式：
1、必需参数（必备参数）：定义了就一定（必须）要传，不能多也不能少
2、默认参数（缺省参数）：定义的时候可以设置默认值，调用的时候可传可不传，不传就使用默认值
3、不定长参数：（可变/动态参数）可以接收0个或多个参数
    *args：只能接收位置传参，以元组的形式保存，args名字可以修改，主要是前面的*号赋于的特性，但最好不要修改
        如果*用在实参前面是进行元组拆包（可以拆列表），并按位置参数传参
    **kwargs：只能接收关键字传参，以字典的形式保存，kwargs名字可以修改，主要是前面的**号赋于的特性，但最好不要修改
        如果**用在实参前面是进行字典拆包（只能拆字典），并按关键字参数传参，注意此时形参名字和字典的key必须一致

def add(a,b,c=33,d=44):    # 默认参数在最后位置，如果后面还有形参的话必须也是默认参数
    print('a:',a)
    print('b:',b)
    print('c:',c)
    print('d:',d)
add(11,12,d=55)    # 默认参数c不传参时默认33
a: 11
b: 12
c: 33
d: 55

def func(*args):    # 不定长参数，可以传任何长度的数据存在元组中
    print(args)     # 不带*号，带*号时(*args)正常打印，如func(11)就打印11，一般不这样用
func()          ()    # 空元组
func(11)        (11,) # 元组
func('str','11',22,[1,2])    ('str', '11', 22, [1, 2])   #元组

def func(**kwargs):    # 以字典的形式保存
    print(kwargs)      # 不带*号，带*号只能带一个再多报错，(*kwargs)正常打印，如func(func(a=11,b=22))就打印a b，一般不这样用
func()    {}
func(a=11,b=22)    {'a': 11, 'b': 22}

def func(*args,**kwargs):    # 两种不定长混合使用，形参*args要在**kwargs之前
    print(args,kwargs)    # 打印时无顺序要求
func(11,22,a=33,d=44)    # 由于形参*args要在**kwargs之前，所以实参传参时也要遵循位置传参在前，关键字传参在后的原则

def func(a,b,c):
    print(a,b,c)
tu = (1,2,3)
func(*tu)    1 2 3    # 如果*用在实参前面是进行元组拆包（可以拆列表），并按位置参数传参

def func(a, b, c):
    print(a, b, c)
dict = {'a': 1, 'b': 2, 'c': 3}
func(**dict)    1 2 3    # 如果**用在实参前面是进行字典拆包（只能拆字典），并按关键字参数传参，注意此时形参名字和字典的key必须一致

def add(a):
    print(a)

first = (2,3,4)
add(first)    (2, 3, 4)

def add(*a):
    print(a)

first = (2,3,4)
add(first, 6)    ((2, 3, 4), 6)

def add(*a):
    print(a)

first = (2,3,4)
add(*first)    (2, 3, 4)

def add(**a):
    print(a)


first = {"name": "daxigua", "age": 18}
add(**first)    {'name': 'daxigua', 'age': 18}
add(name='daxigua', age=18)    {'name': 'daxigua', 'age': 18}

def run(a,b,c):
    print(a)
    print(b)
    print(c)

x = 'dxg'
run(*x)
d
x
g

实参：调用函数实际传递的参数（顾名思义实际参数），又分两种形式：
1、位置传参（位置参数）：按照参数定义的位置进行传递
2、关键字传参（关键字参数）：通过参数名字指定传递
注意：可以使用两种形式混合传递参数，但是必须先写完位置参数，再写关键字参数，否则报错SyntaxError: positional argument follows keyword argument

def add(a,b):    # 必需参数，定义了两个参数，调用的时候必须传2个参数，不能多也不能少，否则报错 形参多与实参报TypeError: add() missing 1 required positional argument: 'c'  形参少于实参报TypeError: add() takes 2 positional arguments but 3 were given
    print(f'a={a}')
    print(f'b={b}')
    print(a+b)
add(11,22)    # 位置传参，a接收11，b接收12
a=11
b=22
33

def add(a,b):
    print('a:',a)
    print('b:',b)
    print(a+b)
add(b=11,a=22)    # 关键字传参，a接收22，b接收11
a: 22
b: 11
33

def add(a,b,c,d):
    print('a:',a)
    print('b:',b)
    print('c:',c)
    print('d:',d)
    print(a+b+c+d)
add(11,22,d=33,c=44)    # 两种形式混合传参，必须先写完位置参数，再写关键字参数，而且例如从第三个位置开始按照关键字参数传参，则形参也必须从第三位开始，之后所有的参数都按关键字参数传参