函数

一段可以被重复使用的代码片段

求数列的和, 不使用函数

# 1.求1-100的和
sum = 0
for i in range(1, 101):
    sum += i
print(f'sum = {sum}')

# 2.求300-400的和
sum = 0
for i in range(300, 401):
    sum += i
print(f'sum = {sum}')

# 3.求1-1000的和
sum = 0
for i in range(1, 1001):
    sum += i
print(f'sum = {sum}')

这几组代码基本是相似的, 只有一点点差异. 可以把重复代码提取出来, 做成一个函数

def calcSum(begin, end):
    sum = 0
    for i in range(begin, end + 1):
        sum += i
    return sum 

print(calcSum(1, 100))    # 5050
print(calcSum(300, 400))  # 35350
print(calcSum(1, 1000))   # 500500

语法格式

# 创建函数/定义函数
def 函数名(形参列表):
	函数体
	return 返回值

# 调用函数/使用函数
函数名(实参列表) // 不考虑返回值
返回值 = 函数名(实参列表) // 考虑返回值

函数必须先定义, 再使用

test3() # 还没有执行到定义, 就先执行调用了, 此时就会报错.

def test3():
	print('hello')

函数参数

在函数定义的时候, 可以在 ( ) 中指定形参,然后在调用的时候, 由调用者把实参传递进去.
这样就可以做到一份函数, 针对不同的数据进行计算处理

• 一个函数可以有一个形参, 也可以有多个形参, 也可以没有形参
• 一个函数的形参有几个, 那么传递实参的时候也得传几个. 保证个数要匹配

链式调用

把一个函数的返回值, 作为另一个函数的参数, 这种操作称为 链式调用

# 判定是否是奇数
def isOdd(num):
	if num % 2 == 0:
		return False
	else:
		return True
		
result = isOdd(10)
print(result)

# 也可以简化写作
print(isOdd(10))

嵌套调用

一个函数里面可以嵌套调用任意多个函数

def a():
	print("函数 a")
	
def b():
	print("函数 b")
	a()
	
def c():
	print("函数 c")
	b()
	
def d():
	print("函数 d")
	c()
	
d()

def a():
	print("函数 a")
	
def b():
	a()
	print("函数 b")
	
def c():
	b()
	print("函数 c")
	
def d():
	c()
	print("函数 d")
	
d()

函数递归

递归是 嵌套调用 中的一种特殊情况, 即一个函数嵌套调用自己

# 递归计算 5!
def factor(n):
	if n == 1:
		return 1
	return n * factor(n - 1)
	
result = factor(5)
print(result)

**注意: **

• 存在递归结束条件. 比如 if n == 1就是结束条件. 当 n 为 1 的时候, 递归就结束了
• 每次递归的时候, 要保证函数的实参是逐渐逼近结束条件的

变量作用域

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 = 20

def test():
	x = 10
	print(f'函数内部 x = {x}')
	
test()
print(f'函数外部 x = {x}')

如果函数内部尝试访问的变量在局部不存在, 就会尝试去全局作用域中查找

x = 20

def test():
	print(f'x = {x}')
	
test()