什么是函数
我们目前为止,已经可以完成一些软件的基本功能了,那么我们来完成这样一个功能:约x
|
1
2
3
4
5
|
pint(
"拿出手机"
)
print
(
"打开陌陌"
)
print
(
"找个漂亮的妹子"
)
print
(
"问她,约不约啊!"
)
print
(
"ok 走起"
)
|
ok so easy我们已经完成了对一个功能的描述,那么问题来了,我还想在约一次怎么搞,是不是就是在写一遍
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
# 约一次
pint(
"拿出手机"
)
print
(
"打开陌陌"
)
print
(
"找个漂亮的妹子"
)
print
(
"问她,约不约啊!"
)
print
(
"ok 走起"
)
# 再约一次
pint(
"拿出手机"
)
print
(
"打开陌陌"
)
print
(
"找个漂亮的妹子"
)
print
(
"问她,约不约啊!"
)
print
(
"ok 走起"
)
|
ok 非常简单搞定了,但是我还想约上个10次8次的,怎么搞,加个循环不就行了吗?
|
1
2
3
4
5
6
|
while
True
:
pint(
"拿出手机"
)
print
(
"打开陌陌"
)
print
(
"找个漂亮的妹子"
)
print
(
"问她,约不约啊!"
)
print
(
"ok 走起"
)
|
这样不就能实现不停的约了吗?但是呢 我一直约不是干不了别的了吗?.人要有节制,有需求了再约,这样比较好.所以呢这样写是不行的
最好是我想什么时候约就什么时候约. 好了说的这 我们就这样做,把约这个事,先计划好,然后按照安排好的流程.在需要约的时候 把这个约
的流程拿出来执行以下就好了.那么这里.我们可以先去定义一个事情或者是功能,等到需要的时候直接去用就好了.那么这里定义东西就是一个函数
函数:对代码块和功能的封装和定义
函数的定义
首先咱们认识一下要实现我们刚说的功能必备的知识点
|
1
2
|
def
函数名():
函数体
|
我们使用def关键字来定义函数,函数的定义语法,这里的函数名的命名规则和变量的命名规则一样.自己回顾一下变量的命名规则
函数体:就是函数被执行之后要执行的代码
我们现在就来实现刚刚我们说的定义一个约x功能:
|
1
2
3
4
5
6
|
def
make():
print
(
"拿出手机"
)
print
(
"打开陌陌"
)
print
(
"找一个漂亮的妹子"
)
print
(
"问她,约不约啊"
)
print
(
"ok 走起"
)
|
哦了,这就定义完了,但是这个时候我们去执行,会发生什么现象? 什么都没有发生.因为我只定义了一个函数.但是还没有执行过这个函数.
函数的调用
使用函数名加小括号就可以调用了 写法:函数名() 这个时候函数的函数体会被执行
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
# 调用yue函数
def
make():
print
(
"拿出手机"
)
print
(
"打开陌陌"
)
print
(
"找一个漂亮的妹子"
)
print
(
"问 约不约啊"
)
print
(
"ok 走起"
)
make()
# 这是make函数的调用
结果:
拿出⼿手机
打开陌陌
找个漂亮的妹⼦
问她, 约不约啊
ok. 走你
|
函数的执行流程
现在就实现了约一次,我想要约几次我就只需要
|
1
2
3
4
5
6
|
make()
make()
make()
make()
make()
make()
|
直接调用定义好的函数就可以了 咱们约完之后的得有个结果吧, 比如是约的萝莉,还是大妈啊总得有个结果,那么这个结果
怎么来描述和获得呢? 这就涉及到函数的返回值啦
函数的返回值
执行完函数之后,我们可以使用return来返回结果
|
1
2
3
4
5
6
7
8
|
def
make():
print
(
"约你"
)
print
(
"约我"
)
print
(
"约他"
)
return
print
(
"约谁呀"
)
# 这句话不会被执行
make()
|
函数中遇到return,此函数结束.不在继续执行
我们现在有return返回值,我们试试返回个东西
|
1
2
3
4
5
6
7
|
def
make():
print
(
"约你"
)
print
(
"约我"
)
print
(
"约他"
)
return
"美女一枚"
make()
|
我们现在返回了一个字符串,但是返回给谁了呢? 这个返回值返回给函数的调用者了,我们来看一下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
def
make():
print
(
"约你"
)
print
(
"约我"
)
print
(
"约他"
)
return
'美女一枚'
girl
=
make()
print
(girl)
结果:
约你
约我
约他
美女一枚
|
肯定好多朋友还是不明白上边怎么就打印美女一枚了,莫慌看下图:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
1.
定义了一个函数make
2.
调用函数
3.
执行函数里的约你
4.
执行函数里的约我
5.
执行函数里的约他
6.
返回给调用者一个字符串
'美女一枚'
,这个调用者就是make()
7.
将返回的字符串通过一个等号赋值给白变量girl
8.
打印变量girl的值
|
函数的返回值可以有多个结果:
|
1
2
3
4
5
6
7
|
def
make():
print
(
"约你"
)
print
(
"约我"
)
print
(
"约他"
)
return
"美女一枚"
,
"萝莉一枚"
girl
=
make()
print
(
type
(girl))
# tuple
|
总结一下:
1.遇到return,此函数结束,函数后面的东西将不会在执行
2.return 返回值
关于返回值:
如果return什么都不写或者干脆就没写return,返回的结果就是None
如果return后面写了一哥值,则调用者可以接受一个结果
如果return后面写了多个结果,则调用者可以接受一个tuple,调用者可以直接使用解构获取多个变量
OK,完美 可以得到结果了 但是我们约的方式是不是有点问题啊?陌陌现在还能约到吗?约不到了 我们换探探 那要是过几天探探也不行了
是不是会有一个替代品,那你们想有一个替代的,你就需要去改代码.是不是有点不合适了 最好的方式是想用什么约就用什么约 ok 我们也是可以实现的
我们可以在函数后边的括号里搞点事情
函数的参数
参数,也就是函数括号里的内容 函数在调用的时候指定一个具体的变量的值 就是参数.写法如下:
|
1
2
|
def
函数名(参数):
函数体
|
我们应该把代码改一下,能够实现我刚说的那种效果
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
def
make(chat):
print
(
"拿出⼿手机"
)
print
(
"打开"
+
chat)
print
(
"找个漂亮的妹⼦子"
)
print
(
"约不不约"
)
make(
"陌陌"
)
make(
"微信"
)
make(
"探探"
)
结果:
拿出手机
打开陌陌
找个漂亮的妹⼦
约不约
拿出⼿机
打开微信
找个漂亮的妹⼦
约不约
拿出手机
打开探探
找个漂亮的妹⼦
约不约
|
搞定了. 我们在调用make的时候给chat一个值. 然后再执行函数体.
参数
1.形参
写在函数声明的位置的变量叫形参,形式上的一个完整.表示这个函数需要xxx
2.实参
在函数调用的时候给函数传递的值.加实参,实际执行的时候给函数传递的信息.表示给函数xxx
3.传参
给函数传递信息的时候将实际参数交给形式参数的过程被称为传参.
|
1
2
3
4
5
6
7
8
9
|
def
make(chat):
# chat 形参
print
(
"拿出手机"
)
print
(
"打开"
+
chat)
print
(
"找个漂亮的妹子"
)
print
(
"约不约"
)
make(
"陌陌"
)
# 实参
len
(
"字符串"
)
# "字符串"在这⾥里里就是实参
print
(
"麻花藤"
)
# "麻花藤"就是实参
|
参数的分类
1.位置参数
约到现在,有没有想过这么一个问题,什么样的都约么? 哪里的都约么? 不一定吧.比如我现在在北京,我很寂寞,我喜欢小姐姐
alex在泰国,很寂寞 来一个就行了 .需要是不一样的 而我们现在的函数没没有这写功能 那怎么办呢? 很简单 多来几个参数就好了
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
def
make(chat,addr,age):
# chat 形参
print
(
"拿出手机"
)
print
(
"打开"
+
chat)
print
(
"找个"
+
addr
+
"附近漂亮的"
+
str
(age)
+
"岁妹子"
)
print
(
"约不约"
)
make(
"陌陌"
,
"北京"
,
18
)
# 实参
结果:
拿出手机
打开陌陌
找个北京附近漂亮的
18
岁妹子
约不约
|
上述代码分析: 在访问make()的时候,我们按照位置的顺序分别把"陌陌","北京",18赋值给了chat,addr,age,在传参过程中.系统会按照位置吧实参赋值到形参
练习
编写函数,给函数传递两个参数a,b a,b相加 返回a参数和b参数相加的和
def f(a,b):
c = a+b
return c
num_sum = f(5,8)
print(num_sum)
|
1
|
结果:
13
|
编写函数,给函数传递两个参数a,b 比较a,b的大小 返回a,b中最大的那个数
|
1
2
3
4
5
6
7
8
9
10
|
def
f(a,b):
if
a>b:
return
a
else
:
return
b
num_sum
=
f(
5
,
8
)
print
(num_sum)
结果:
8
|
比较大小的这个写法有点麻烦,我们在这里学一个三元运算符
|
1
2
3
4
5
6
7
8
|
def
f(a,b):
c
=
a
if
a > b
else
b
#当a>b就把a赋值给c,否则就把b赋值给c
return
c
msg
=
f(
5
,
7
)
print
(msg)
结果:
7
|
关键字参数
位置参数好不好呢? 如果是少量的参数还算OK, 没有问题. 但是如果函数在定义的时候参数非常多怎么办? 程序员必须记住, 我有哪些参数, 而且还有记住每个参数的位置, 否则函数就不能正常调用了. 那则么办呢? python提出了一种叫做关键字参数. 我们不需要记住每个参数的位置. 只要记住每个参数的名字就可以了
|
1
2
3
4
5
6
7
8
9
10
11
12
|
def
make(chat, address, age):
print
(
"拿出手机"
)
print
(
"打开"
+
chat)
print
(
"找个"
+
address
+
"附近漂亮的"
+
str
(age)
+
"岁妹子"
)
print
(
"约不约"
)
make(chat
=
"微信"
, age
=
18
, address
=
"北京"
)
# 关键字参数.
结果:
拿出手机
打开微信
找个北京附近漂亮的
18
岁妹子
约不约
|
搞定, 这样就不需要记住繁琐的参数位置了.
混合参数
可以把上面两种参数混合着使用. 也就是说在调用函数的时候即可以给出位置参数, 也可以指定关键字参数.
|
1
2
|
# 混合参数 <br>make("微信", age=18, address="上海")# 正确.第一个位置赋值给chat, 后面的参数开始指定关键字.
make(age
=
"18"
,
"微信"
, address
=
"广州"
)
# 错误, 最开始使用了关键字参数, 那么后面的 微信的位置就串了, 容易出现混乱
|
注意: 在使用混合参数的时候, 关键字参数必须在位置参数后面
综上: 在实参的⾓角度来看. 分为三种:
1. 位置参数
2. 关键字参数
3. 混合参数, 位置参数必须在关键字参数前面
位置参数:
位置参数,按照位置来赋值,到目前为止,我们编写的函数都是这种
|
1
2
3
4
5
|
def
make(chat, address, age):
print
(
"拿出手机"
)
print
(
"打开"
+
chat)
print
(
"找个"
+
address
+
"附近漂亮的"
+
str
(age)
+
"岁妹子"
)
print
(
"约不约"
)
|
默认值参数:
在函数声明的时候, 就可以给出函数参数的默认值. 在调用的时候可以 给出具体的值, 也可以不给值, 使⽤用默认值. 比如, 我们录入咱们班学生的基本信息. 通过调查发现. 我们班大部分学生都是男生. 这个时 候就可以给出⼀一个sex='男'的默认值.
|
1
2
3
4
5
6
|
def
stu_info(name, age, sex
=
'男'
):
print
(
"录入学生信息"
)
print
(name, age, sex)
print
(
"录入完毕"
)
stu_info(
"张强"
,
18
)
|
注意:必须先声明在位置参数,才能声明关键字参数
综上:在形参的角度来看
1. 位置参数
2. 默认值参数(大多数传进来的参数都是一样的, 一般用默认参数)
在实参的角度来看
1.位置参数 就是按照顺序传递
2.默认值参数(在填写参数的时候需要指定传递到形参中那个变量)