【Python】基础语法 3 (函数)

函数详解

  • 1. 函数是什么
  • 2. 语法格式
  • 3. 函数参数
  • 4. 函数返回值
  • 5. 变量作用域
  • 6. 函数执行过程
  • 7. 链式调用
  • 8. 嵌套调用
  • 9. 函数递归
  • 10. 参数默认值
  • 11. 关键字参数

1. 函数是什么

编程中的函数和数学中的函数有一定的相似之处。
数学上的函数,比如 y = sinx,x 取不同的值 y 就会得到不同的结果
在编程中的函数,是一段可以被重复使用的代码片段

代码示例:求数列的和,不使用函数

# 1.求 1-100 的和
theSum = 0
for i in range(1, 101):
    theSum += i
print(theSum)

# 2.求 300-400 的和
theSum = 0
for i in range(300, 401):
    theSum += i
print(theSum)

# 3.求 1-1000 的和
theSum = 0
for i in range(1, 1001):
    theSum += i
print(theSum)

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

代码示例:求数列的和,使用函数

# 定义函数
def calcSum(beg, end):
    theSum = 0
    for i in range(beg, end + 1):
        theSum += i
    print(theSum)
   

# 调用函数
calcSum(1, 100)
calcSum(300, 400)
calcSum(1, 1000)

可以明显的看到,重复的代码已经被消除了。

2. 语法格式

  • 创建函数/定义函数
def 函数名(形参列表):
   函数体
   return 返回值
  1. 形参列表中,可以有多个形参,多个形参(形式参数)之间使用逗号分隔。
  2. 函数体的部分要带有一级缩进(带有缩进的代码,才是函数体内部的语句)
  3. return 返回值 指得是函数的返回值,函数执行到 return 就意味着执行完了,return 后面的值 就是函数的返回值。return 语句并不是必须的,可以有也可以没有。
  • 调用函数/使用函数
函数名(实参列表)             # 不考虑返回值
返回值 = 函数名(实参列表)    # 考虑返回值

实际参数,简称实参。函数名(实参列表),这里的实参列表写实参的个数要和形参的个数匹配。

注意:

  • 函数必须先定义,后使用
test()

def test():
    print('hello')

还没有执行到定义,就先执行调用了,此时就会报错。
在这里插入图片描述

  • 函数定义并不会执行函数体内容,必须要调用才会执行,调用几次就会执行几次
def test():
    print('hello')

如果光是定义函数,而不调用,则不会执行。
【Python】基础语法 3 (函数)_第1张图片

3. 函数参数

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

考虑到前面的代码:

def calcSum(beg, end):
    theSum = 0
    for i in range(beg, end + 1):
        theSum += i
    print(theSum)
   

calcSum(1, 100)
calcSum(300, 400)
calcSum(1, 1000)

上面的代码中,beg,end 就是函数的形参。1, 100 / 300, 400 就是函数的参数。
在执行 sum(1, 100) 的时候, 就相当于 beg = 1, end = 100 , 然后在函数内部就可以针对 1-100 进行运算。

注意:

  • 一个函数可以有一个形参,也可以有多个形参,也可以没有新参。
  • 一个函数的形参有几个,那么传递实参的时候也得传几个,保证个数要匹配。
def test(a, b, c):
    print(a, b, c)

test(10)

在这里插入图片描述

  • 和 C++ / Java 不同, Python 是动态类型的编程语言, 函数的形参不必指定参数类型。换句话说, 一个函数可以支持多种不同类型的参数。
def test(a):
    print(a)


test(10)
test('hello')
test(True)

【Python】基础语法 3 (函数)_第2张图片

4. 函数返回值

函数的参数可以视为是函数的“输入”,则函数的返回值,就可以视为是函数的“输出”。

还是前面的求和代码

def calcSum(beg, end):
    theSum = 0
    for i in range(beg, end + 1):
        theSum += i
    print(theSum)
   

calcSum(1, 100)

可以转换成

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 把计算将结果当作返回值,返回给“函数调用者”— result。

我们一般更倾向于第二种写法

  • 一个通用的编程原则:一个函数只做一件事。
  • 第一种写法,函数即做了计算,又做了打印(和用户交互)。
  • 第二种写法,函数只是做了计算,不关心如何和用户交互。
    一旦后续需要改变和用户交互方式,第二种写法就更有优势(不必修改函数代码),当前是通过控制台和用户交互的。
  • 一个函数可以有多个 return 语句
    示例:判定是否是奇数
# 判定是否是奇数
def isOdd(num):
   if num % 2 == 0:
       return False
   else:
       return True
   
   
result = isOdd(10)
print(result)
  • 执行到 return 语句,函数就会立即执行结束,回到调用位置。
# 判定是否是奇数
def isOdd(num):
   if num % 2 == 0:
       return False
   return True


result = isOdd(10)
print(result)

把 return True 写到 if 外面意味着条件是否满足都会执行 return True,但是再仔细观察,就会发现条件满足之后,if 里面有一个 retrun 了。一旦条件满足,是没有机会执行到 return True。
如果 if 里面没有 return 语句,就不能这么写了。

  • 一个函数可以一次返回多个返回值。使用 , 来分割多个返回值
def getPoint():
   x = 10
   y = 20
   return x, y


a, b = getPoint()
  • 如果只想关注其中的部分返回值,可以使用 _ 来忽略不想要的返回值。
def getPoint():
   x = 10
   y = 20
   return x, y


_, b = getPoint()

5. 变量作用域

观察一下代码

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, b)

在这里插入图片描述

  • 在不同的作用域中,允许存在同名的变量
    虽然名字相同,但实际是不同的变量
x = 20


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


test()
print(f'函数外部 x = {x}')

【Python】基础语法 3 (函数)_第3张图片
注意:

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


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


test()

在这里插入图片描述

  • 如果是想在函数内部,修改全局变量的值,需要使用 global 关键字声明
x = 20


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


test()
print(f'函数外部 x = {x}')

【Python】基础语法 3 (函数)_第4张图片
如果此处没有 global , 则函数内部的 x = 10 就会被视为是创建一个局部变量 x, 这样就和全局变量 x 不相关了。

  • if / while / for 等语句块不会影响到变量作用域
for i in range(1, 10):
   print(f'函数内部 i = {i}')

print(f'函数外部 i = {i}')

6. 函数执行过程

  • 调用函数才会执行函数体代码. 不调用则不会执行。
  • 函数体执行结束(或者遇到 return 语句), 则回到函数调用位置, 继续往下执行。
def test():
    print("执行函数内部代码")
    print("执行函数内部代码")


print("1111")
test()
print("2222")
test()
print("3333")

这个过程还可以使用 PyCharm 自带的调试器来观察.

  • 点击行号右侧的空白, 可以在代码中插入 断点
  • 右键, Debug, 可以按照调试模式执行代码. 每次执行到断点, 程序都会暂停下来。
  • 使用 Step Into (F7) 功能可以逐行执行代码。

7. 链式调用

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

代码示例:

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

我们前面很多代码都是这样写的,但实际上可以简化的写作

print(isOdd(10))

这就是函数的链式调用,这是一种比较常见的写法。

8. 嵌套调用

内部函数还可以调用其他函数,这个动作称为嵌套调用

def test():
    print("执行函数内部代码")
    print("执行函数内部代码")
    print("执行函数内部代码")

test 函数内部调用了 print 函数,这里就属于嵌套调用。

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

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

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

【Python】基础语法 3 (函数)_第5张图片

图解:
【Python】基础语法 3 (函数)_第6张图片

函数之间的调用关系,在 Python中会使用一个特定的数据结构来表示,称为 函数调用栈。每次函数调用,都会在调用栈里新增一个元素,称为 栈帧

可以通过 PyCharm 调试器看到函数调用栈和栈帧。
在调试状态下, PyCharm 左下角一般就会显示出函数调用栈。
【Python】基础语法 3 (函数)_第7张图片

每个函数的局部变量,都包含在自己的栈帧中

def a():
   num = 10
   print("函数 a")


def b():
   num = 20
   print("函数 b")
   a()


def c():
   num = 30
   print("函数 c")
   b()


def d():
   num = 40
   print("函数 d")
   c()


d()

选择不同的栈帧,就可以看到各自栈帧中的局部变量
【Python】基础语法 3 (函数)_第8张图片

9. 函数递归

函数递归 就是一个函数自己调用自己。

函数递归的两个必要条件:
(1) 存在限制条件,当满足这个限制条件的时候,递归便不再继续。
(2) 每次递归调用之后越来越接近这个限制条件。

示例:递归计算 5的阶乘
【Python】基础语法 3 (函数)_第9张图片

def Fac(n):
    if n <= 1:
        return 1
    else:
        return n * Fac(n - 1)


result = Fac(5)
print(result)

图解:
【Python】基础语法 3 (函数)_第10张图片

递归的优点

  • 递归类似于 “数学归纳法” , 明确初始条件, 和递推公式, 就可以解决一系列的问题。
  • 递归代码往往代码量非常少。

递归的缺点

  • 递归代码往往难以理解, 很容易超出掌控范围。
  • 递归代码容易出现栈溢出的情况。
  • 递归代码往往可以转换成等价的循环代码. 并且通常来说循环版本的代码执行效率要略高于递归版本。

10. 参数默认值

Python 中的函数,可以给形参指定默认值
带有默认值的参数,可以在调用的时候不传参

代码示例:计算两个数的和

def add(x, y, debug=False):
    if debug:
        print(f'x = {x}, y = {y}')
    return x + y


print(add(10, 20))
print(add(10, 20, True))

此处 debug=False 即为参数默认值. 当我们不指定第三个参数的时候, 默认 debug 的取值即为 False.
【Python】基础语法 3 (函数)_第11张图片

带有默认值的参数需要放到没有默认值的参数的后面

def add(x, debug=False, y):
   if debug:
       print(f'x = {x}, y = {y}')
   return x + y


print(add(10, 20))

在这里插入图片描述

11. 关键字参数

在调用函数的时候, 需要给函数指定实参. 一般默认情况下是按照形参的顺序, 来依次传递实参的。
但是我们也可以通过 关键字参数, 来调整这里的传参顺序, 显式指定当前实参传递给哪个形参。
关键字传参就是按照形参的名字来进行传参。

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


test(x=10, y=20)
test(x=100, y=200)

【Python】基础语法 3 (函数)_第12张图片
形如上述 test(x=10, y=20) 这样的操作, 即为 关键字参数。

位置参数可以和关键字参数还能混着用,只不过混着用的时候要求位置参数在前,关键参数在后。
关键字参数,一般是搭配默认参数来使用的。

本章到这里就结束啦,如果有哪里写的不好的地方,请指正。
如果觉得不错并且对你有帮助的话请给个三连支持一下吧!
Fighting!!!✊

你可能感兴趣的:(Python,python,开发语言,学习)