文章目录
- 函数入门
- 一、形参和实参
- 二、参数类型
- 三、从实参的角度看
-
- 1.位置参数(必需参数)
-
- 1.1 无返回值
- 1.2 有返回值
- 2.关键字参数
- 3.混合参数（位置参数+关键字参数）
- 四、从形参的角度看
-
- 1.位置参数
-
- 1.1 无返回值
- 1.2 有返回值
- 2.默认值参数(缺省参数)
- 3.动态参数(*args,**kwargs)
-
- 3.1 *args：元组
- 3.2 ** kwargs：字典
- 3.3 args,*args,**kwargs 的顺序
函数，通常是程序中的代码块或语句块，它使用户能够重用相同的代码，从而最终节省了过多的内存使用，节省了时间，更重要的是，提供了更好的代码可读性。基本上，函数是执行某些特定任务并将结果返回给调用者的语句的集合。函数也可以执行某些特定任务而不返回任何内容。
提示：以下是本篇文章正文内容，下面案例可供参考
函数入门
函数的作用：减少代码的重复性，增强代码的可读性。
例1：没有采用任何参数，且无返回值
def my_function(): # my_function为函数名，而且仅使用小写字母，并使用下划线分隔单词
print("Hello From My Function!")
my_function() # 调用函数：my_function
pass # 占位符
my_function() # 再调用函数：my_function
- 1
- 2
- 3
- 4
- 5
- 6
例2：没有采用任何参数，且有返回值
def my_func():
a = 0
for i in range(1, 11):
a = a + i
return a
res = my_func()
print(res)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
例3（错误案例）：函数定义应始终存在于函数调用之前。否则，我们将得到一个错误
# 函数调用
greet('Paul')
# 定义函数
def greet(name):
print("Hello, " + name + ". Good morning!")
# Erro: name 'greet' is not defined
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
一、形参和实参
def myFunction(a,b,c): # a,b,c 为形参
pass
myFunction(x,y,z) # x,y,z 为实参，其中x - a，y - b，z - c 一对一传参
- 1
- 2
- 3
- 4
形参：形参被调用时，才分配内存单元，调用结束，就释放内存；形参只在函数内部才有效。
实参：可以是常量、变量、表达式、函数。
二、参数类型
1、位置参数/必需参数，可用在实参和形参中；
2、关键字参数，只用在实参中；
3、默认参数，只用在形参中；
4、可变长度参数/动态参数/不定长参数，只用在形参中。
形参列表中参数顺序：位置参数、不定长参数（*args）、不定长参数（**args）、默认参数
三、从实参的角度看
1.位置参数(必需参数)
按照与函数定义中的参数对应的顺序传递参数。
1.1 无返回值
例1：
# a,b为形参，11，22为实参
def sumpro(a,b):
print(a+b) # 函数体，尽可能不要出现print,这里方便学习才print打印
# 调用函数，实参必须是确定的值
sumpro(11,22)
- 1
- 2
- 3
- 4
- 5
- 6
例2：日常打招呼案例
def greet(name):
print("Hello, " + name + ". Good morning!")
greet('Paul') # Hello, Paul. Good morning!
- 1
- 2
- 3
- 4
def greet(name, msg):
"""This function greets to the person with the provided message"""
print("Hello", name + ', ' + msg)
greet("Monica", "Good morning!") # Hello Monica, Good morning!
- 1
- 2
- 3
- 4
- 5
1.2 有返回值
def plus(a, b):
return a + b
sum = plus(10,15)
print(sum)
- 1
- 2
- 3
- 4
2.关键字参数
以任意顺序传递参数并按名称指定每个参数，同时参数的数量都必须与函数定义中的参数数量相匹配。
例1：
def student(firstname, lastname):
print(firstname, lastname)
# 关键字参数
student(firstname ='Geeks', lastname ='Practice')
student(lastname ='Practice', firstname ='Geeks')
- 1
- 2
- 3
- 4
- 5
- 6
例2：
以下调用函数时，参数的顺序可以改变，结果一样。
greet(name = “Bruce”,msg = “How do you do?”)
greet(msg = “How do you do?”,name = “Bruce”)
greet(“Bruce”, msg = “How do you do?”)
def greet(name, msg="Good morning!"):
"""
这个函数用所提供的信息向对方问好。msg参数，如果没有提供值，则默认为"Good morning!"
"""
print("Hello", name + ', ' + msg)
greet("Kate")
- 1
- 2
- 3
- 4
- 5
- 6
- 7
3.混合参数（位置参数+关键字参数）
def greet(name, msg="Good morning!"):
"""
这个函数用所提供的信息向对方问好。msg参数，如果没有提供值，则默认为"Good morning!"
"""
print("Hello", name + ', ' + msg)
greet("Bruce", msg = "How do you do?")
- 1
- 2
- 3
- 4
- 5
- 6
- 7
四、从形参的角度看
1.位置参数
1.1 无返回值
# a,b为形参，11，22为实参
def plus(a,b):
print(a+b) # 函数体，尽可能不要出现print,这里方便学习才print打印
# 调用函数，实参必须是确定的值
plus(11,22)
- 1
- 2
- 3
- 4
- 5
- 6
1.2 有返回值
def plus(a,b):
print(a+b)
sum = plus(11,22)
print(sum)
- 1
- 2
- 3
- 4
- 5
2.默认值参数(缺省参数)
如果在函数调用中，没有提供实参值给该参数，则使用默认值参数的值。
def myFun(x, y = 50):
print("x: ", x)
print("y: ", y)
myFun(10) # ('x: ', 10)
# ('y: ', 50)
- 1
- 2
- 3
- 4
- 5
- 6
3.动态参数(*args,**kwargs)
动态参数（或不定长参数）有两种定义方式：
1.元组：在形参前加一个*，接收不定数量、不定名字实参；
2.字典：在形参前加两个*，用于接受关键参数。
3.1 *args：元组
例1：
def greet(*names):
"""这个函数向名字元组中的所有人物问好。"""
# names是一个带有参数的元组
for name in names:
print("Hello", name)
greet("Monica", "Luke", "Steve", "John")
- 1
- 2
- 3
- 4
- 5
- 6
- 7
程序运行结果：
Hello Monica
Hello Luke
Hello Steve
Hello John
- 1
- 2
- 3
- 4
例2：
def adder(*num):
sum = 0
for n in num:
sum = sum + n
print("Sum:",sum)
adder(3,5)
adder(4,5,6,7)
adder(1,2,3,5,6)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
例3：
def plus(*args):
total = 0
for i in args:
total += i
return total
sum = plus(20, 30, 40, 50)
print(sum) # 140
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
例4：位置参数+动态参数(元组)
def mysum(a=0, b=0, *args):
print("传入的参数:", a, b, args)
sum = a + b
for n in args: # 遍历动态参数(元组)
sum += n
return sum
- 1
- 2
- 3
- 4
- 5
- 6
调用函数：
print(mysum(1, 2)) # 传入的参数: 1 2 ()
print(mysum(1, 2, 3)) # 传入的参数: 1 2 (3,)
print(mysum(1, 2, 3, 4)) # 传入的参数: 1 2 (3, 4)
- 1
- 2
- 3
- 4
- 5
3.2 ** kwargs：字典
例1：创建一个可以接受任意数量关键字参数的函数：
def myFunction(**kwargs):
for kw in kwargs:
print(kw, '-', kwargs[kw])
if __name__ == "__main__":
myFunction(a = 24, b = 87, c = 3, d = 46)
"""程序运行结果：
a - 24
b - 87
c - 3
d - 46
"""
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
例2：电脑售价的案例：
def myFunction(**computers):
for kw in computers:
print(kw, '-', computers[kw])
if __name__ == "__main__":
myFunction(dell = 1299.50, asus = 1870.00, hp = 1990.50)
"""程序运行结果：
dell - 1299.5
asus - 1870.0
hp - 1990.5
"""
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
例3：
def myFunction(x, y, **kwargs):
print(x)
print(y)
for key, value in kwargs.items():
print(key, '-', value)
if __name__ == "__main__":
myFunction("ABC", "MNO", a = 24, b = 87, c = 3, d = 46)
"""程序运行结果：
ABC
MNO
a - 24
b - 87
c - 3
d - 46
"""
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
例4：实发工资=基本工资-缴纳个税金额-缴纳社保费用
def pay(basic, **kvargs):
# 分别获取tax个人税与social社保费
tax = kvargs.get('tax')
social = kvargs.get('social')
# 实发工资=基本工资-缴纳个税金额-缴纳社保费用
pay = basic - tax - social
return pay
print('实发工资是{}'.format(pay(8000, tax=500, social=1500))) # 实发工资是6000
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
3.3 args,*args,**kwargs 的顺序
技巧：当有位置参数、*args、**kwargs、关键参数时，先看两侧（位置参数与**kwargs/关键参数）再考虑中间。
def myFunction(name,age,*args, **kwargs):
print(name,age)
print(args)
print(kwargs)
if __name__ == "__main__":
myFunction("Bruce",28,"hello", "mars", a = 24, b = 87, c = 3, d = 46)
"""
Bruce 28
('hello', 'mars')
{'a': 24, 'b': 87, 'c': 3, 'd': 46}
"""
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12