一、函数的定义
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为默认参数。