脚本之家,脚本语言编程技术及教程分享平台!
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Python - 详解Python的函数与异常

详解Python的函数与异常

2022-03-10 00:26盼小辉丶 Python

这篇文章主要为大家介绍了Python的函数与异常,具有一定的参考价值,感兴趣的小伙伴们可以参考一下,希望能够给你带来帮助

1. 函数

抽象是程序能够被人理解的关键所在。程序应非常抽象,如获取用户输入构造列表,查找列表中最大的值,并进行打印:

list_a = get_input()
max_value = max(list_a)
print(max_value)

看到这些代码,可以很容易这个程序是做什么的,至于这些操作的具体细节,将在独立的函数中给出。

虽然我们并没有具体讲解过函数定义,但是我们已经使用过Python 的内置函数 print,input 等。函数可用于减少代码重复,并使程序更易于理解和维护。可以将函数理解为一个“子程序”:函数本质上是一个命名语句序列,可以通过引用函数名称,在程序中的任何位置执行这些指令。创建函数的代码称为“函数定义”,当函数在程序中使用时,称为函数被“调用”。

1.1 自定义函数

通过定义函数可以隐藏计算细节,函数定义需要一个函数名、一系列参数(也可以不使用参数)以及一个函数体,函数也可以显式地返回一个值,函数定义的一般形式如下所示:

def name_of_function(paramters):
  body_of_function

例如编写一个求圆面积的函数:

def area_of_circle(radius):
  area = 3.14 * radius ** 2
  return area

在这个函数定义中,def 是告诉 Python 要定义一个函数,函数名(这里为 area_of_circle )用于函数后续的调用,函数名后的括号里是函数的形式参数列表。在这个函数中,radius 是唯一的形式参数,函数体可以是任何一段 Python 代码,return 语句用于调用函数时返回一个值,只能用于函数体中,执行 return 语句会结束对函数的调用。如果要调用 area_of_circle 函数,需要为其提供一个实际参数值,函数调用是一个表达式,表达式的值就是调用函数返回的值:

>>> area_of_circle(10)
314.0
>>> area = area_of_circle(10)
>>> print(area)
314.0

函数被调用时,将执行以下过程:

1.调用程序在函数调用点暂停执行

2.函数形参获得实参提供的值

3.执行函数体中的代码,直至遇到 return 语句,return 后面的表达式的值作为函数调用的值;或者直到函数体中没有语句可以继续执行,这时函数返回的值为 None;

4.如果 return 后面没有表达式,返回的值也为 None返回到函数被调用的点执行之后的代码

详解Python的函数与异常

我们已经知道,函数也可以不包含参数或返回值,例如以下简单的函数示例:

def hello_world():
  for i in range(3):
      print('Hello World!')

调用此函数,将打印三行 ‘Hello World!',且函数的返回值为 None:

>>> value = hello_world()
Hello World!
Hello World!
Hello World!
>>> print(value)
None

1.2 函数与参数

编写函数时,常常需要多个参数,那么不同参数是如何赋值的呢?在 Python 中,有两种方法可以将形参绑定到实参。最常用的方法是使用位置参数,即第一个形参绑定到第一个实参,第二个形参绑定到第二个实参,以此类推;第二种方法是关键字参数,即形参根据名称绑定到实参:

def inforname(name, sex, address):
  print("My name is {}, my gender is {}, and my home address is {}.".format(name, sex, address))

以下几种函数调用方式是等价的,其中第一种方式为位置参数,其他方法为关键字参数

inforname('panxiaohui', 'male', 'henan')
inforname('panxiaohui', address = 'henan', sex = 'male')
inforname('panxiaohui', 'male', address = 'henan')
inforname(address = 'henan', sex = 'male', name = 'panxiaohui')

关键字参数可以放在位置参数后,但位置参数不能放在关键字参数后:

>>> inforname('panxiaohui', sex = 'male', 'henan')
File "<stdin>", line 1
  inforname('panxiaohui', sex = 'male', 'henan')
                                               ^
SyntaxError: positional argument follows keyword argument

前面我们在介绍 print 函数时,提到过可以使用可选参数 end 来改变 print 函数默认换行的行为,可选参数是带有默认值的参数,通常和关键字参数结合使用,在函数调用时可以不为其赋值(此时将使用默认值),而不带有默认值的参数,在函数调用时则必须为其指定参数值。

首先编写以下函数:

def special_number(start, end, step=1):
  list_value = []
  for i in range(start, end, step):
      list_value.append(i)
  return list_value

执行函数调用:

>>> special_number(2,10)
[2, 3, 4, 5, 6, 7, 8, 9]
>>> special_number(2,10, step=2)
[2, 4, 6, 8]
>>> special_number(2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: special_number() missing 1 required positional argument: 'end'

1.3 函数与返回值

返回值是从函数发送信息到调用函数的程序部分的主要方式,函数还可以通过更改函数参数来与调用程序通信,这需要理解函数调用中使用的实参和形参之间的关系。

在函数中,尽管实参和形参的名称是一样的,但它们并不是同一个变量。每个函数都定义了一个命名空间,也称为作用域,每次函数调用都将创建一个新的作用域:

def exponentiation(number, power):
  power = power * 2
  result = number ** power
  number = result
def test_exponentiation():
  n = 2
  power = 5
  exponentiation(n, power)
  print(n, power)

调用函数,可以直观的看出作用域的含义:

>>> test_exponentiation()
2 5

在函数内使用的变量称为局部变量(与之相对的是全局变量)。test_exponentiation() 函数的前两行创建了名为 original 和 power 的两个局部变量,它们的值分别为 2 和 5。 然后调用了 exponentiation() 函数。形参 number 和 power 被赋值为来自实参 original 和 power 的值。需要牢记一点,即使实参和形参的名称都为 power,它们也是两个独立的变量,参数的赋值使 test_exponentiation() 函数中的变量 original 和 power 引用了实参的“值”:

详解Python的函数与异常

执行 exponentiation() 首先为其局部变量 power 赋一个新值,并创建一个新变量 result。然后,exponentiation() 为 number 赋值,让它具有与 result 相同的值。虽然,现在 number 与 result 指向相同的值、并且修改了 exponentiation()函数中 power 变量,但这对 test_exponentiation() 函数中的变量 original 和 power 没有影响:

详解Python的函数与异常

exponentiation() 执行完成后,控制返回到 test_exponentiation(),exponentiation() 中的局部变量被回收,test_exponentiation() 函数中的 original 和 power 仍分别指初始值。

综上,Python 中函数的形参只接收实参的“值”,函数不能访问保存实参的变量。因此,为形参分配新值对实参变量没有影响,这是由于 Python “按值”传递所有参数。一些编程语言(如 C++ )允许变量本身作为参数传递给函数,这种机制称为“按引用”传递参数。当变量按引用传递时,向形参分配新值实际上会更改调用程序中的参数变量的值。

由于 Python 不允许按引用传递参数,因此需要使用 return 语句返回修改后的值:

def exponentiation(number, power):
  power = power * 2
  result = number ** power
  number = result
  return number, power
def test_exponentiation():
  original = 2
  power = 5
  original, power = exponentiation(original, power)
  print(original, power)

执行函数,查看输出:

>>> test_exponentiation()
1024 10

 

2. 异常处理

程序编写过程中,有两种常见的错误:第一种时语法错误,例如编写程序时缩进出现问题、第二种问题是算法的逻辑错误,例如访问不存在的变量、列表越界访问等。后者通常称为异常,为了处理这种情况,Python 提供了异常处理机制:

>>> x = []
>>> x[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range

在 Python 中,异常状态使用异常对象来表示,在遇到错误时引发异常。如果未处理异常对象,程序将会终止并显示错误消息 (Traceback)。每种异常也都是不同异常类的实例(上一示例中异常是类 IndexError 的实例),可以使用不同方式引发并捕获这些实例,而不至于导致整个程序运行失败。

2.1 raise 语句

可以使用 raise 语句来引发异常,并将类或实例作为参数。将类作为参数时,将自动创建一个实例,同时也可以添加错误消息提示:

>>> raise OSError
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
OSError
>>> raise OSError("can't open this file")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
OSError: can't open this file

2.2 异常捕获

当程序发生异常时,也称程序“抛出”异常。对异常进行处理,通常称为异常捕获。为此,可使用 try/except 语句。例如,进行除法运算时,如果用户输入了一个非零的除数,那么运算结果就会被打印出来。但是,如果用户输入了一个零作为除数,那么就会引发 ZeroDivisionError 异常:

>>> number_a = float(input('Please enter a number: '))
Please enter a number: 10.2
>>> number_b = float(input('Please enter another number: '))
Please enter another number: 0
>>> print(number_a / number_b)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: float division by zero

使用 except 语句块则可以“捕捉”这个异常,并且打印提示消息,然后通过对除数加一个很小的值确保其不为零,这意味着程序并不会终止,而是继续执行后续语句:

>>> try:
...     print(number_a / number_b)
... except:
...     print('Divisor cannot be zero!')
...     print('Add a small number to the divisor.')
...     print(number_a / (number_b + 1e-8))
Divisor cannot be zero
Add a small number to the divisor
1019999999.9999999

如果需要捕获多个异常,可以使用多个 except 子句,或者在一个元组中指定这些异常:

# 使用多个 except 子句
try:
  number_a = input('Please enter a number:')
  number_b = input('Please enter another number:')
  print(float(number_a) / float(number_b))
except TypeError:
  print("That wasn't a number!")
except ZeroDivisionError:
  print('Divisor cannot be zero!')
# 使用元组指定异常
try:
  number_a = input('Please enter a number:')
  number_b = input('Please enter another number:')
  print(float(number_a) / float(number_b))
except (ZeroDivisionError, TypeError):
  print("You entered the wrong number!")

try/except 语句还有一个可选的 else 子句,如果使用这个子句,那么必须放在所有的 except 子句之后,else 子句在 try 子句没有发生任何异常时执行,例如在 try 语句中执行除法运算,如果正确运算没有发生异常,则执行 else 部分,打印结果:

try:
  number_a = input('Please enter a number:')
  number_b = input('Please enter another number:')
  result = float(number_a) / float(number_b)
except (ZeroDivisionError, TypeError):
  print("You entered the wrong number!")
else:
  print(result)

不把所有语句都放在 try 子句,而使用 else 子句,可以避免一些意料之外,而 except 又无法捕获的异常。

2.3 finally 子句

finally 子句可以与 try 语句配套使用,可以在发生异常时执行清理工作,不管 try 子句中是否发生异常,都将执行 finally 子句:

result = None
try:
  number_a = input('Please enter a number:')
  number_b = input('Please enter another number:')
  result = float(number_a) / float(number_b)
except (ZeroDivisionError, TypeError):
  print("You entered the wrong number!")
else:
  print(result)
finally:
  del result

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注服务器之家的更多内容!

原文链接:https://blog.csdn.net/LOVEmy134611/article/details/121602192

延伸 · 阅读

精彩推荐