【2023年】第44天 python中函数的定义和使用

一、函数的定义

1.前置内容

• 将一件事情的步骤封装在一起并得到最终结果。
• 函数名代表了整个函数要做的事情。
• 函数是实现函数功能的流程。
• 函数也可以称为方法和功能。
• 函数可以帮助我们重复使用，通过函数名我们可以知道函数的作用。
• 常见的内置函数有print，id，int，str，max，min，range
• 自定义函数，自己根据业务进行封装的函数。

2.函数书写的格式

def names(args...):
	todo something..
	返回值

函数名+小括号用来执行函数。

3.函数的返回值return

• 将函数结果返回的关键字
• return只能在函数体内使用。
• return支持返回所有的python类型。
• 有返回值的函数可以直接赋值给一个变量。

# coding:utf-8

def capitalize(data):
    index = 0
    temp = ''

    for item in data:
        if index == 0:
            temp = item.upper()
        else:
            temp += item
        index += 1
    
    return temp


# result = capitalize('hello xiao')
result = capitalize(data='hello xiao')
print(result)

• 实现一个首字母大写的函数capitalize(data)，带有一个参数。
• 因为要改变的是首字母，所以我们可以定义一个index=0的变量，然后再定义一个空的字符串，用于储存需要改变首字母的数据data。
• 然后对整个输入的data进行循环遍历。
• 在循环中，首先判断是否是首字母，如果是就是用upper函数对它进行大写，如果不是就使用temp加上循环的这一项。
• 最后设置跳出循环的条件index+=1，最后返回temp。
• 使用例子测试函数的功能是否可以实现，最后打印并输出。

def message(message, message_type):
    new_message = '[%s] %s' % (message_type, message)
    print(new_message)


message(message='今天下雨了', message_type='info')

• 没有返回值的函数。
• 首先传入两个参数message和message_type
• 然后进行格式化两个参数
• 最后对格式化的内容进行输出。
• 然后调用定义的函数，并且传入参数。

4.print()函数和return的区别

• print只是单纯的将对象进行打印，不支持赋值语句。
• return是对函数执行结果的返回，也支持赋值语句。

def test():
    for i in range(10):
        if i == 5:
            return i


print('test结果是：', test())

• 首先定义了一个没有参数的test函数
• 然后对i进行循环10次
• 判断如果i等于5的时候，就返回i，并且结束循环
• 最后调用test()函数。

二、函数的参数

1. 默认参数与必传参数

• 函数中定义的参数没有默认值，在调用函数时如果不传入则报错。
• 在定义函数的时候，参数后面没有符号于默认值。
• 错误的方式是：def add(a=3, b=4)，直接在定义函数时，情况是必传参数，直接赋值是不对的。
• 在定义函数的时候，没有默认值且必须在函数执行的时候传递进去的参数，且顺序与参数顺序相同，就是必传参数。
• 在定义函数的时候，定义的参数含有默认值，通过赋值语句给他是一个默认的值，比如def add(a, b=1)。
• 如果默认参数在调用函数的时候给予了新的值，函数将优先使用后传入的值进行工作。

# coding:utf-8
def add(a, b, c=3):
    return a + b + c

result = add(1, 2)  # 像a，b这样的参数都是必传参数，如果不传就会报错
print(result)

result = add(1, 2, 6)  # 这里第三个参数传入6之后，就会去替代原来的默认参数
print(result)

2. 不确定参数，可变参数

• 没有固定的参数名和数量(不知道要传的参数名具体是什么)

def add(*args, **kwargs):
...
add(1,2,3, name='dewei', age=33)

• *args代表：将无参数的值合并成元组
• **kwargs代表将有参数与默认值的赋值语句合并成字典。

def test_args(*args, **kwargs):
    print(args, type(args))
    print(kwargs, type(kwargs))


test_args(1, 2, 3, 4, 5, 6, name='xiao', age=33, top=165)

• 首先定义一个test_args的函数。
• 然后对args和args的类型进行打印。
• 最后对kwargs和kwargs的类型进行打印。
• 调用test_args函数，并且传入参数进行验证。
• 返回的结果是args是元组，kwargs是字典。

def test_args_super(*args, **kwargs):
    if len(args) >= 1:
        print(args[0])

    if 'name' in kwargs:
        print(kwargs['name'])
    else:
        print('no name')
    print(args, len(args))
    print(kwargs, len(kwargs))


test_args_super(1, name='xiao')
a = ('python', 'django')
b = {'name': 'xiao'}
test_args_super(*a, **b)

• 首先定义一个test_args_super的函数，传入了两个不定参数，*args和**kwargs。
• 对args参数的长度进行判断，如果长度大于1的话，打印出它的0索引。
• 如果’name’包含在kwargs中的话，则打印出name的值。如果不存在则打印出没有名字。
• 调用函数test_args_super函数，并且传入参数1和name， 运行后得到了我们传入的参数。
• 重写书写了a和b参数，分别表示args和kwargs，并进行调用函数test_args_super，这里必须要加上*号，如果不加就会导致调用失败，传入的参数不能正常的打印。

3. 参数规则

def add(a, b=1, *args, **kwargs)

• 参数的定义从左到右依次是必传参数，默认参数，可变元组参数，可变字典参数。
• 函数的参数传递非常的灵活。
• 必传参数与默认参数的传参多样化。

def add(a, b=1):
    print(a + b)


add(1, 2)
add(1)
add(a=1, b=2)
add(b=2, a=1)
# add(b=2)  # 会报错

• 调用函数传参时，一定要注意，如果是必传参数没有传参数进去，结果就会报错。

def test(a, b=1, *args):
    print(a, b, args)


s = (1, 2)
test(1, 2, *s)

• 首先定义了一个test函数，包含了必传参数，默认参数，和可变元组参数。
• 那我们传参数的时候就可以直接传入不需要再用赋值的形式了。

def test2(*args, a, b=1):
    print(a, b, args)


s = (1, 2)
test2(a=1, b=2, *s)

• 首先传入了test2函数，传入可变的元组参数，必传参数以及默认参数。
• 如果我们首先传入了可变元组参数，那我们就可以在调用函数的时候，使用赋值的形式实现参数部分。
• 但是这种方式不推荐使用。

def test3(a, b=1, **kwargs):
    print(a, b, kwargs)


test3(1, 2, name='xiao')
test3(a=1, b=2, name='xiao')
test3(name='xiao', age=33, a=1, b=2)

d = {'name': '小高'}
test3(a=1, b=2, **d)
test3(**d, a=1, b=2)
# test3(**d, 1, 2)  # 如果在调用函数时参数的位置(顺序)发生变化，一定要使用赋值语句的方式进行传参。

• 我们定义了一个test3函数，并且传入必传参数，默认参数，以及字典可变参数。
• 需要注意一点就是，如果在调用函数时参数的位置(顺序)发生变化，一定要使用赋值语句的方式进行传参。

4. 函数的参数类型的定义

def person(name:str, age:int=33):
	print(name, age)

• 参数名+冒号+类型
• 参数名+冒号+类型+等号+默认值
• 函数定义在python3.7之后可用
• 函数不会对参数类型进行验证

def add(a: int, b: int = 3):
    print(a + b)


add(1, 2)
add('hello', '小高')  # 虽然我们在定义函数的时候已经定义了参数类型，但是当我们调用函数并传入参数的时候并不会对它进行匹配验证

• 定义函数add，传入必传参数a，并且定义为int类型，传入默认参数b，不但定义类型为int，而且定义值为3
• 虽然我们在定义函数的时候已经定义了参数类型，但是当我们调用函数并传入参数的时候并不会对它进行匹配验证

def test(a: int, b: int = 3, *args: int, **kwargs: str):
    print(a, b, args, kwargs)


test(1, 2, 3, '4', name='小高')

• 定义了函数test，传入了a，b，*args，**kwargs参数，并且对每一部分都进行了类型的定义。

def test2(a: int, b, c=3):
    print(a, b, c)


test2(1, 3, 4)

• 定义了一个函数test2，传入a，b，c三个参数，并且对a的类型定义为int类型，b为必传参数，c为默认参数。