函数的定义
函数的定义:分配任务
def 函数名(形参列表):
函数体
return 返回值
def
:define
,定义- 形参列表中,可以有多个形参,它们之间使用逗号分隔
- 函数体要带一级缩进,带有缩进的代码,才能算是函数的内部语句
- 函数执行到
return
就代表执行完了,后面跟的值就是函数的返回值。return
语句不是必须得,可有可无
函数的调用
函数的调用:开始完成任务
函数名(实参列表)
- 实参列表,简称实参,此处写的实参的个数要和形参的个数匹配
def test():
print('hello')
print('hello')
print('hello')
# 调用函数
test()
"""
运行结果
hello
hello
hello
"""
- 函数调用才会真正执行函数体里面的代码
- 函数经过一次定义之后,可以被调用多次
Python
中要求,函数定义写在前面,调用在后面,“先定义,再使用”
形参和实参
举一个例子:
我有一个朋友
高中的时候,是一个学霸
通过是一个非常漂亮的女生
他们的关系非常好,
但是因为一些原因,最终没能在一起
这个朋友,其实 就是我
- 在这里面,“我有一个朋友“ 就是形参,“我” 就是实参
- 函数的调用是可以有多次的,每次调用的实参,也是可以不同的
- 函数的实参,就是在函数调用的时候,要赋值给形参
def calcSum(beg, end):
theSum = 0
for i in range(beg, end + 1):
theSum += i
print(theSum)
# 求 1-100 的和
calcSum(1,100)
# 求 300-400 的和
calcSum(300,400)
"""
运行结果
5050
35350
"""
在 C++/Java
里面,不光要求实参和形参的个数要匹配,还要求类型也匹配。但是在 Python
里面,只要求个数,对类型没有要求(动态类型)
def test(x, y):
return x + y
test(10, 20)
test(12.4, 11.5)
test('hello', 'world')
"""
运行结果
30
23.9
helloworld
"""
- 也不是说传入什么类型都可以,只要保证传入的参数类型,在函数体里面能够支持对应的运算操作即可(字符串和数字就不能一起)
函数的返回值
函数的参数可以视为是函数的 “输入”, 则函数的返回值, 就可以视为是函数的 “输出” .
此处的 “输入”, “输出” 是更广义的输入输出, 不是单纯指通过控制台输入输出.
我们可以把函数想象成一个 “工厂”. 工厂需要买入原材料, 进行加工, 并生产出产品.
函数的参数就是原材料, 函数的返回值就是生产出的产品.
一个 return
求 beg-end
之间的数的和:
def calcSum(beg, end):
theSum = 0
for i in range(beg, end + 1):
theSum += i
return theSum
result = calcSum(1,100)
print(result)
- 此处的求和代码,在
calcSum
内部只进行了计算,而把打印的逻辑放到了函数的外面,calcSum
把计算结果当做返回值,返回给“函数的调用者”- 这里把函数里面算好的
5050
赋值给了result
变量 - 在实际开发中,一般更倾向于这种写法。
- 一个通用的编程原则:一个函数只做一件事
- 这里把函数里面算好的
解耦合
- 在一个稍微复杂一点的程序中,经常会涉及到很多个模块,模块之间可能要进行交互
- 交互就会带来耦合,我们希望通过良好的设计让耦合尽量低
- 你和你的女朋友,耦合就比较强,一方产生变动,对另一方影响就非常大
- 比如你的女朋友生病了,你就要去照顾她,去陪她
- 你和你的其他普通女性朋友之间的耦合就几乎为 0,一方产生变动,对另一方几乎没啥影响
- 如果这个朋友生病了,你肯定不会去照顾她,你甚至都不会知道
多个 return
一般多个 return
语句是搭配:分支语句/循环语句
def isOdd(num):
if num % 2 == 0:
return False
else:
return True
print(isOdd(10))
print(isOdd(19))
"""
运行结果
False
True
"""
isOdd
是在判断输入的数字是不是奇数- 是,返回真
- 不是,返回假
def Odd(num):
if num % 2 == 0:
return False
return True
- 这个代码逻辑和上面的逻辑是等价的
- 当函数执行到
return
的时候就不再继续向下执行了,而是回到了调用位置(函数结束了) - 把
return True
写到if
外面,意味着不管条件是否满足,都会执行return True
,但是仔细观察,就会发现当条件满足之后,if 里面有一个return
了, 所以一旦条件满足,就会执行if
里面的 return,函数就结束了,就没有机会执行到外面的return
了
Python
中的一个函数可以返回多个值,是非常香的特征,C++/Java
都馋哭了
C++/Java
中调用一个函数一次只能返回一个值C++
要想返回多个值,可以通过输出型参数(指针/引用)Java
要想返回多个值,需要把多个值给包装成一个对象,然后再返回这个对象
多元赋值
def getPoint():
x = 10
y = 20
return x, y
a, b = getPoint()
- 这里就将
x
赋值给了a
,将y
赋值给了b
Golang 在设计的时候也把这个机制给引用进去了
虽然现在返回了多个值,但是我只想用其中一部分,不关注其他的
- 可以使用
_
来进行占位
def getPoint():
x = 10
y = 20
return x, y
_, b = getPoint()
- 不要
x
了,只要y
,把y
赋值给b
即可
变量作用域
def getPoint():
x = 10
y = 20
return x, y
x, y = getPoint()
- 在这个代码中, 函数内部存在
x
,y
, 函数外部也有x
,y
. - 但是这两组
x
,y
不是相同的变量, 而只是恰好有一样的名字.
- 比如说,你喊你的女朋友“宝贝”,你的朋友喊他女朋友也是“宝贝”
- 但是这两个“宝贝”是不同的,这是在各自不同的范围
- 你喊你的女朋友“宝贝”,是在你俩的圈子里
- 你朋友喊你的女朋友“宝贝”,是在他俩的圈子里
- 你们俩在各自圈子里互不影响
函数内的变量
一个变量的有效范围是一定的,只在一个固定的区域内生效
函数内部的变量只在函数内部生效,出了函数就失效了
def getPoint():
x = 10
y = 20
return x, y
getPoint()
print(x,y)
全局变量和局部变量
虽然名字相同,实际上是不同的变量.
x = 10
def test():
x = 20
print(f'函数内部 x = {x}')
test()
print(f'函数外部 x = {x}')
"""
运行结果
函数内部 x = 20
函数外部 x = 10
"""
- 外面的
x
是全局变量,是在整个程序中都有效的 - 函数里面的
x
是局部变量,只在函数内部有效
x = 10
def test():
print(f'x = {x}')
test()
"""
运行结果
x = 10
"""
- 在函数里读取全局变量是可以的
- 当函数中尝试访问某个变量的时候,会先尝在局部变量中查找,如果找到,就直接访问
- 如果没有找到,就向上一级作用域中进行查找,
test
再往上一级,就是全局了
- 如果没有找到,就向上一级作用域中进行查找,
修改全局变量
如果是想在函数内部修改全局变量的值,需要使用 global
关键字声明
x = 10
def test():
global x
x = 20
test()
print(f'x = {x}')
"""
运行结果
x = 20
"""
- 如果没有
global
,此时就会把x = 10
当做是在函数内部创建了一个局部变量x
,但实际上是要修改全局变量x
- 为了让函数里面知道这里的
x
是一个全局变量,就是用 global 关键字先声明一下
if
,else,while
,for
这些关键字也会引入“代码块”,但是这些代码块不会对变量的作用域产生影响,上述语句中的代码块内部定义的变量,可以在外面被访问
for i in range(1, 3):
print(i)
print('---------------')
print(i)
"""
1
2
---------------
2
"""
- 在
C++/Java
中只要是{ }
就会影响到作用域,而Python
不会,Python
中只有函数能影响作用域