函数
1、函数的概念
a.函数所解决的问题：
复杂度增大、组织结构不清晰、可读性差、代码冗余、可扩展性差
函数就是具备某一种功能的物件
实现准备工具的过程称为函数的定义
遇到特定的场景拿来就用称为函数的调用
b.函数的分类:
内置函数
自定义函数
2、函数的使用：
1 先定义
2 再调用
a.函数的定义语法：
def 函数名(arg1,arg2,arg3):
“注释”
函数体
return 返回值
注意：
函数名一般是动词
b. retrun的使用：
return 返回值没有类型限制
在函数内部可以有多个return，但只能执行一次，函数就结束调用，并且会把return后的值作为函数执行的结果返回
没有return：返回None，等同于return None
return 一个值：返回该值
return 多个值：返回多个值组成的一个元组
c.定义的三种形式：
无参：应用场景仅仅只是执行一些操作，比如与用户交互、打印等
有参：需要根据外部传进来的参数，才能执行相应的逻辑操作，比如统计长度，求最大值
空函数：设计代码结构
3、函数的调用：
函数调用的三种形式：
a.语句形式
b.表达式形式
c.当做另外一个函数的参数
def
my_max
(x
,
y):
if
x > y:
return
x
else
:
return
y
my_max(
1
,
2
)
#
语句形式
res=my_max(
1
,
2
)*
10
#
表达式形式
# res1=my_max(1,2) #如果不使用第三种形式要写这两行
# res2=my_max(res1,3)
res2=my_max(my_max(
1
,
2
)
,
3
)
#
函数调用可以当做另外一个函数的参数
print
(res2)
练习：
#
定义阶段
def
foo
():
print
(
‘from foo‘
)
bar()
# print(foo)
def
bar
():
print
(
‘from bar‘
)
#
调用阶段
foo()
注意：
函数在定义阶段只检测语法，不执行代码
4、函数参数
a.参数的形式
1 形参
2 实参
#
形参：在定义函数时，括号内的参数成为形参
#特点：形参就是变量名
# def foo(x,y): #x=1,y=2
# print(x)
# print(y)
#实参：在调用函数时，括号内的参数成为实参
#特点：实参就是变量值
# foo(1,2)
#在调用阶段实参（变量值）才会绑定形参（变量名）
#调用结束后，解除绑定
b.参数的分类：
1 位置参数：按照从左到右的顺序依次定义的参数
位置形参：必须被传值，并且多一个不行，少一个也不行
位置实参：与形参按照位置一一对应
位置参数：按照从左到右的顺序依次定义的参数
位置形参：必须被传值，并且多一个不行，少一个也不行
位置实参：与形参按照位置一一对应
def
foo
(x
,
y):
print
(x)
print
(y)
foo(
‘egon‘
,
1
,
2
)
2 关键字实参：指的是按照name=value的形式，指名道姓地给name传值
注意问题：
问题一: 语法规定位置实参必须在关键字实参的前面
问题二: 一定不要对同一个形参传多次值
关键字实参：指的是按照name=value的形式，指名道姓地给name传值
def
foo
(name
,
age):
print
(name)
print
(age)
foo(
‘egon‘
,
18
)
foo(
age
=
18
,
name
=
‘egon‘
)
关键字实参需要注意的问题是：
def
foo
(name
,
age
,
sex):
print
(name)
print
(age)
print
(sex)
foo(
‘egon‘
,
18
,
‘male‘
)
print
(
‘======>‘
)
foo(
sex
=
‘male‘
,
age
=
18
,
name
=
‘egon‘
)
foo(
‘egon‘
,
sex
=
‘male‘
,
age
=
18
)
问题一:语法规定位置实参必须在关键字实参的前面
foo(
‘egon‘
,
sex
=
‘male‘
,
age
=
18
)
问题二:一定不要对同一个形参传多次值
foo(
‘egon‘
,
sex
=
‘male‘
,
age
=
18
,
name
=
‘egon1‘
)
foo(
‘male‘
,
age
=
18
,
name
=
‘egon1‘
)
3默认形参：在定义阶段，就已经为形参赋值，意味在调用阶段可以不用传值
默认参数需要注意的问题：
问题一：默认参数必须放在位置参数之后
问题二：默认参数只在定义阶段赋值一次，而且仅一次
问题三：默认参数的值应该定义成不可变类型
默认形参：在定义阶段，就已经为形参赋值，意味在调用阶段可以不用传值
def
foo
(x
,
y=
1111111
):
print
(x)
print
(y)
foo(
1
,
‘a‘
)
def
register
(name
,
age
,
sex=
‘male‘
):
print
(name
,
age
,
sex)
register(
‘asb‘
,
73
)
register(
‘wsb‘
,
38
)
register(
‘ysb‘
,
84
)
register(
‘yaya‘
,
28
,
‘female‘
)
默认参数需要注意的问题
问题一:默认参数必须放在位置参数之后
def
foo
(y=
1
,
x):
print
(x
,
y)
问题二：默认参数只在定义阶段赋值一次，而且仅一次
x=
100
def
foo
(a
,
b=x):
print
(a
,
b)
x=
111111111111111111111111111111
foo(
‘egon‘
)
问题三：默认参数的值应该定义成不可变类型
4可变长参数：指的是实参的个数不固定
形参必须要两种机制来分别处理实参：
按照位置定义的实参溢出的情况：*
跟按照关键字定义的实参溢出的情况：**
处理位置实参：*会把溢出的位置实参保存成元组
def
foo
(x
,
y
,
*args):
#nums=(3,4,5,6,7)
print
(x)
print
(y)
print
(args)
foo(
1
,
2
,
3
,
4
,
5
,
6
,
7
)
#*
foo(
1
,
2
)
#*
输出结果：
1
2
(3, 4, 5, 6, 7)
1
2
()
处理关键字实参：**会把溢出的关键字实参保存成字典
def
foo
(x
,
y
,
**kwargs):
#kwargs={‘z‘:3,‘b‘:2,‘a‘:1}
print
(x)
print
(y)
print
(kwargs)
foo(
1
,
2
,
z
=
3
,
a
=
1
,
b
=
2
)
#**
输出结果：
1
2
{‘z‘: 3, ‘a‘: 1, ‘b‘: 2}
*、**结合使用
def
wrapper
(*args
,
**kwargs):
#args=(1,2,3) kwargs={‘a‘:1,‘b‘:2}
print
(args)
print
(kwargs)
wrapper(1,2,3,a=1,b=2)
命名关键字参数：在*后面定义的形参称为命名关键字参数，必须是以关键字实参的形式传值
def
foo
(name
,
age
,
*args
,
sex=
‘male‘
,
group):
print
(name)
print
(age)
print
(args)
print
(sex)
print
(group)
foo(
‘alex‘
,
18
,
19
,
20
,
300
,
group
=
‘group1‘
)
5、函数对象
函数是第一类的对象：指的是函数可以被当做数据传递
a.被赋值
b.可以当做参数传入
c.可以当做函数的返回
d.可以当做容器类型的元素
def
foo
():
print
(
‘from foo‘
)
f=foo #
把函数名赋值给变量
print
(f)
f() #
使用变量名可以调用函数
def
wrapper
(func):
# print(func)
func()
wrapper(foo) #
把函数名foo当做参数传递给func
def
wrapper
(func): #
把函数名foo当做参数传递给func，func当做return
return
func #
的返回值
res=wrapper(foo)
print
(res)
cmd_dic={
‘func‘
:foo #把函数名以value的形式传入字典中
}
print
(cmd_dic)
cmd_dic[
‘func‘
]()
本文出自 “lyndon” 博客，请务必保留此出处http://lyndon.blog.51cto.com/11474010/1948661
原文：http://lyndon.blog.51cto.com/11474010/1948661
【说明】：本文章由站长整理发布，文章内容不代表本站观点，如文中有侵权行为，请与本站客服联系(QQ:254677821)！