【Python】函数的定义和调用、形参和实参、函数的返回值、多元赋值、全局和局部变量

函数的定义

函数的定义：分配任务

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 中只有函数能影响作用域