文章目录
函数定义
封装函数的好处
1、方便维护，模块设计
2、减少代码冗余
函数的参数
1、形参：函数定义时指定的参数
2、实参：函数调用时传递的参数
def add(a, b): # a,b为形参
# print("exec add function")
return a+b
print(add(1,2)) # 3 传入的参数1,2为实参
result = add(3,4) # 3,4为实参
print(result) # 7
按形参来分：
1、必选参数
# 必选参数:name,age,sex
def stuinfo(name, age, sex):
print(f"myname is {name}, my age is {age}, my sex is {sex}")
# 位置参数："sc",4,'f'
stuinfo("sc",4,'f')
# myname is sc, my age is 4, my sex is f
2、默认参数
默认参数,传参时可传可不传
# 定义形参时默认参数必须放最后，否则会报错
# def stuinfo(name, sex='f', age) 报错
def stuinfo(name, age, sex='f'): # sex为默认参数
print(f"myname is {name}, my age is {age}, my sex is {sex}")
stuinfo("sc",4) # 不给默认参数传值就默认为定义的值
# myname is sc, my age is 4, my sex is f
stuinfo("sc",5,"m") # 传入就会修改
# myname is sc, my age is 5, my sex is m
3、可变长位置参数：默认将传入的参数默认打包成一个元组
定义 : *arg
# *num为可变长位置参数
def myyargs(name, *num):
print(f"{name}:{num}")
print(type(num), *num, num) # *num --> 1,2 num --> (1, 2)
myyargs("sc")
# sc:()
# <class 'tuple'> ()
myyargs("sc1", 1)
# sc1:(1,)
# <class 'tuple'> 1 (1,)
myyargs("sc2", 1, 2)
# sc2:(1, 2)
# <class 'tuple'> 1 2 (1, 2)
4、可变长关键字参数
def myargs2(**num):
print(num)
# print(**num) --> print(a=1, b=2) 会报错，print里面不能放关键字参数,value是可变长位置参数
# TypeError: 'a' is an invalid keyword argument for print()
myargs2(a=1, b=2)
# {'a': 1, 'b': 2}
myargs2(a=1)
# {'a': 1}
myargs2(a=1, b=2, c=3)
# {'a': 1, 'b': 2, 'c': 3}
实参来分：
1、位置参数：按照形参的位置顺序传入实参
2、关键字参数：传参时指定形参的值
def stuinfo(name, age, sex='f'):
print(f"myname is {name}, my age is {age}, my sex is {sex}")
stuinfo("sc",sex='m',age=6) # "sc"为位置参数，sex、age为关键字参数
# myname is sc, my age is 6, my sex is m
位置参数一定要放在关键字参数前面，否则会报错
# stuinfo(sex='m',age=6,"sc") "sc"是位置参数，必须放在关键字参数前面
# SyntaxError: positional argument follows keyword argument
# stuinfo(name="sc", age=6, 'f') 也会报错
多重赋值报错
# stuinfo("sc",'m',age=6)
# 多重赋值报错，没有定义关键字参数是就按位置传入实参，此时'm'传给age,
# 而后面又定义了关键字参数age，再一次给age赋值，造成多重赋值
# TypeError: stuinfo() got multiple values for argument 'age'
函数中形参定义的顺序
def func01(必选参数， 可变长位置参数， 默认参数， 可变长关键字参数)
实参：
func01(位置参数，关键字参数)
packing 和 unpacking
packing：组包
python组包的操作是自动完成的，将多个值同时赋给一个变量时，解释器会进行自动组包操作
a = 10, 20, 30
print(a)
# (10, 20, 30)
# 定义了可变长位置参数*num时
# 传入1, 2 ----->打包成一个元组，再赋值给num --> num就是一个元组(1, 2)
# 定义了可变长关键字参数**num时
# packing --> 将传入的实参打包成一个字典，再赋值给num --> a=1, b=2 --> {'a': 1, 'b': 2}
unpacking: 解包
函数被调用时，*可以用来解包可迭代对象：列表、元组、字符串、字典，但是用*来解包字典时只会解包出字典的key值，value值会被丢弃
**的作用对象是字典，会解包成关键字参数key=value的格式
# unpacking --> (1,2) --> 解包成1,2
# unpacking --> {'a': 1, 'b': 2} --> 解包成 a=1,b=2
t1 = ("a", "b", "c")
print(*t1) # a b c
l1 = ['a', 'b', 'c']
print(*l1) # a b c
s1 = "adgs"
print(*s1) # a d g s
d1 = {"a":1, "b":2}
print(*d1) # a b
d1 = {"a":1, "b":2}
print("{a}...{b}".format(**d1))
# 1...2
print("{a}...{b}".format(a=1, b=2))
# 1...2
练习
- 可变长位置参数（*args）
计算N个数的和（N数量不确定）
def add(*args):
N = 0
# args是元组，是可迭代对象
for i in args:
N += i
print(f"元组的和为：{sum(args)}") # sum可以直接对可迭代对象求和
# 元组的和为：42
return N
print(add(1, 2, 3, 4, 9, 23)) # 42
-
可变长关键字参数（**kwargs）
计算N个数的和
def add2(**kwargs):
N = 0
# kwargs是一个字典
for value in kwargs.values():
N += value
print(f"字典的和为：{sum(kwargs.values())}")
# 字典的和为：55
return N
print(add2(a=1, b=10, c=20, d=24)) # 55
函数的return语句
作用：退出函数，并且返回结果
- 一个函数一旦执行到return就退出，不会执行后面的语句。
def maxnum(x, y):
print("return 语句。。。。")
if x>y:
print("return x")
return x
elif x<y:
print("return y")
return y
return x,y
print("return end....") # return后面的语句不会执行
result = maxnum(3,5)
# return 语句。。。。
# return y
print(f"结果为{result}")
# 结果为5
- 如果函数没有return语句，默认返回None。
def maxnum(x, y):
print("return 语句。。。。")
if x>y:
print("return x")
elif x<y:
print("return y")
print("return end....") # 因为没有执行return语句，所以会打印输出这一行
result = maxnum(3,5)
# return 语句。。。。
# return y
# return end....
print(f"结果为{result}")
# 结果为None
- 如果return后面不接任何表达式，也是返回None。
def maxnum(x, y):
print("return 语句。。。。")
if x>y:
print("return x")
elif x<y:
print("return y")
return
print("return end....")
result = maxnum(3,5)
# return 语句。。。。
# return y
print(f"结果为{result}")
# 结果为None
- return可以有多个，return一次也可以返回多个值。
def maxnum(x, y):
print("return 语句。。。。")
if x>y:
print("return x")
return x
elif x<y:
print("return y")
return y
return x,y
print("return end....") # return后面的语句不会执行
result = maxnum(5, 5)
print(f"结果为{result}")
# 结果为(5, 5)
# return有两个可以用两个变量接收
i, j = maxnum(5, 5)
print(f"结果为{result},i为{i},j为{j}")
# 结果为(5, 5),i为5,j为5
