I. Introducción
Hoy en día, el autor todavía quiere hablar sobre los conceptos básicos de Python, explicando principalmente la introducción, captura y procesamiento de excepciones en Python. Solo aprendiéndolos podemos allanar el camino para la posterior construcción del marco de prueba automatizado y el mantenimiento diario . Directo a ello sin decir tonterías.
Dos, colección de manejo de excepciones
2.1 Explicación del manejo de excepciones
Antes de introducir oficialmente el manejo de excepciones, debemos dejar que todos comprendan un concepto: es imposible que la programación sea perfecta, y siempre hay situaciones que no se pueden considerar, porque nadie es perfecto y los seres humanos tienen defectos, sin mencionar que la programación viene. de seres humanos. Manos, en un proyecto real, no le crean a nadie que diga: Mi código es perfecto, no habrá problemas con esto, y de igual manera, en el mundo de la programación, no hay confiabilidad absoluta.
Todos también deben tener claro que siempre que el programa sea escrito por una persona, debe haber problemas. Si el programa no se ejecuta de acuerdo con el proceso normal, lo llamamos una excepción. Como su nombre lo indica, el manejo de excepciones es para resolver esta situación anormal y hacer que el programa siga normalmente la lógica y la ejecución del proceso.
2.2 Captura de excepciones
Cuando un programa se ejecuta y reporta un error, dejará de ejecutarse. Si lo ejecutamos nuevamente después del manejo de excepciones, no habrá más informes de errores. Este informe de errores se puede capturar para que el programa se ejecute sin problemas. Este proceso de manejo de excepciones es llamado captura de excepción. Veamos primero un ejemplo:
print("------------------- 欢迎来到报名注册系统 -------------------")
age = (input("请输入您的年龄:"))
age = int(age)
if age < 18:
print("很遗憾，您暂时不满足注册条件")
else:
print("恭喜您符合注册条件")
Como se muestra en el código anterior, cuando los datos de entrada son 18, el cálculo lógico del programa se puede realizar normalmente, de modo que el código se puede ejecutar normalmente hasta el final, pero ¿realmente no hay ningún problema con dicho código? Veamos este ejemplo nuevamente: cuando la entrada son letras inglesas abc, se produce un error ValueError , que literalmente nos dice que hay un error numérico y la cadena no se puede convertir a un número entero:
print("------------------- 欢迎来到报名注册系统 -------------------")
age = (input("请输入您的年龄:"))
age = int(age)
if age < 18:
print("很遗憾，您暂时不满足注册条件")
else:
print("恭喜您符合注册条件")
Como se muestra en la figura anterior, cuando ocurre un ValueError, podemos manejarlo mediante la captura de excepciones. El código procesado es:
print("------------------- 欢迎来到报名注册系统 -------------------")
age = (input("请输入您的年龄:"))
try:
age = int(age)
except:
print("您的年龄输入非法，请重新运行本程序")
if age < 18:
print("很遗憾，您暂时不满足注册条件")
else:
print("恭喜您符合注册条件") 
Como se muestra en la figura anterior, ejecutamos el programa nuevamente e ingresamos abc, el programa aún no se puede ejecutar, no es ValueError en este momento, sino TypeError ahora.
2.3 Principio de captura de excepciones
Para resolver el error TypeError anterior, primero comprendamos el principio de captura de excepciones. Cuando se inicia oficialmente una declaración de prueba, Python la marcará en el contexto del programa actual. Cuando ocurre una excepción, volverá a la marca y el La cláusula try se ejecutará primero. , los siguientes escenarios posibles:
Escenario 1: si ocurre una excepción durante la ejecución de la declaración try, Python regresa a try y ejecuta la primera cláusula excepto que coincide con la excepción. Una vez manejada la excepción, el código continúa ejecutándose.
Escenario 2: si ocurre una excepción durante la ejecución de la declaración try y no hay ninguna cláusula excepto coincidente, la excepción se enviará al try superior o a la capa superior del programa, y el programa finalizará aquí y se producirá el error. Se imprimirá el mensaje.
Escenario 3: si no se produce ninguna excepción durante la ejecución de la cláusula try, Python continuará ejecutando la declaración del código.
Después de comprender el principio de captura de excepciones, veamos cómo resolver el error TypeError anterior. El significado literal es incorrecto y el número entero no se puede comparar con la cadena, pero de hecho ya hemos procesado la variable edad antes de eso. Pero porque se detecta la excepción del intento, se ejecuta el primer intento que coincida con la cláusula excepto y la cláusula reemplaza la declaración de excepción, por lo que la conversión de tipo aquí no es válida y se producirá un error de tipo cuando el programa se ejecute nuevamente. Este método también es muy simple, simplemente ponga la declaración de juicio en el intento.
Cuando la declaración de juicio se coloca en el intento, cambia un poco. Si no se detecta ninguna excepción, el programa se ejecutará como de costumbre y el juicio tendrá efecto. Si se detecta una excepción, saltará directamente a la ejecución excepto. salida, indicando que su edad es ilegal, por lo que no habrá lógica de juicio, por lo que no habrá errores TypeError. Por cierto, este es nuestro error de desarrollo común "compre uno y obtenga otro gratis". El código para el segundo modificación es la siguiente:
# 程序仍然有可优化的地方，仅展示try.. except语句的使用方式
print("------------------- 欢迎来到报名注册系统 -------------------")
age = (input("请输入您的年龄:"))
try:
age = int(age)
if age < 18:
print("很遗憾，您暂时不满足注册条件")
else:
print("恭喜您符合注册条件")
except:
print("您的年龄输入非法，请重新运行本程序") 
2.4 Captura de excepciones específicas
La captura de excepción específica, como su nombre lo indica, es capturar una excepción específica que ocurre, como el ValueError que encontramos. Si captura otros tipos de excepción, cuando encuentre ValueError durante la ejecución del código, aún se informará un error:
print("------------------- 欢迎来到报名注册系统 -------------------")
age = (input("请输入您的年龄:"))
try:
age = int(age)
if age < 18:
print("很遗憾，您暂时不满足注册条件")
else:
print("恭喜您符合注册条件")
# 这里进行捕获的异常类型是IndexError，非ValueError，最后的结果仍然会报错，因为没有成功捕获
except IndexError:
print("您的年龄输入非法，请重新运行本程序")
Cuando el tipo capturado es incorrecto, aún aparecerá un mensaje de error para finalizar el programa. Por ejemplo, si una persona conduce ebrio, entonces debería ser manejado por la policía de tránsito en lugar de la Oficina de Asuntos Civiles, porque ese no es su cometido. responsabilidad La captura de excepción también debe prestar atención a la contraparte, como se muestra en el siguiente código Como se muestra, si se establece en ValueError, se puede capturar con éxito, al igual que la policía de tránsito se ocupó de conducir en estado de ebriedad, solución perfecta:
print("------------------- 欢迎来到报名注册系统 -------------------")
age = (input("请输入您的年龄:"))
try:
age = int(age)
if age < 18:
print("很遗憾，您暂时不满足注册条件")
else:
print("恭喜您符合注册条件")
except ValueError:
print("您的年龄输入非法，请重新运行本程序") 
2.5 Manejo de captura de excepciones
Acabamos de dar un ejemplo. Cuando la excepción se captura como IndexError, el error de ValueError seguirá apareciendo después de ejecutar el programa, pero podemos capturarlo directamente cuando no lo configuramos excepto para usarlo directamente. Entonces, ¿qué necesitamos? configurarlo para? Es de suponer que algunos estudiantes ya han tenido esas dudas en mente.
excepto puede entenderse como un policía universal, un receptor universal, que puede detectar todos los tipos de excepciones (muy pocas no pueden detectarse directamente), y la captura de excepciones específicas solo puede detectar excepciones específicas que ocurren. La razón por la que todavía lo usamos es porque Se especializa en captar un tipo, por ejemplo, si una persona tiene problemas de piel, entonces debe ser más profesional acudir a la clínica de dermatología que al médico de urgencias, como dice el refrán, hay especialización en cirugía.
Excepto que es un receptor universal, lo tratará de la misma manera después de detectar una excepción. Por ejemplo, obviamente no es razonable tratar los síntomas de un resfriado y un ataque cardíaco de la misma manera. Entonces, en este momento, un "Doctor" específico (captura específica) para el procesamiento correspondiente.
En la actualidad, algunos errores comunes son: ValueError, TypeError, IndexError, etc., por lo que en todo el proceso de prueba automatizada inevitablemente encontraremos muchos otros errores ¿Cómo capturar excepciones cuando no tenemos claros otros errores? Hay dos formas, la primera es recordar una vez que te lo pierdes, al igual que los amiguitos que comenzaron a programar, nadie sabe que se encontrarán con ValueError, después de encontrarlo una vez, le prestarán especial atención la próxima vez. una captura por adelantado, comúnmente conocida como pisar el foso. La otra forma es continuar agregando excepto al final, y también mantenemos el receptor universal, de modo que cuando la captura específica no detecte una excepción pero el programa tenga una excepción, excepto la detectará:
print("------------------- 欢迎来到报名注册系统 -------------------")
age = (input("请输入您的年龄:"))
try:
age = int(age)
if age < 18:
print("很遗憾，您暂时不满足注册条件")
else:
print("恭喜您符合注册条件")
# 这里会报错ValueError，因为捕获的类型是IndexError，很明显无法进行ValueError异常捕获，那么我们可以在添加一个万能捕手except来进行捕获
except IndexError:
print("您的年龄输入非法，请重新运行本程序")
# 在下面可以在进行一个except的添加：
except:
print("万能捕手在此，束手就擒吧！") 
2.6 excepto、Excepción与BaseException
Sabemos que except es un receptor universal, pero en realidad su identidad es Exception, y Python lo omite por defecto para nosotros. De hecho, se ve así:
except Exception:
print("万能捕手在此，束手就擒吧！")excepto y excepto excepción son completamente equivalentes y se pueden agregar o no en la escritura diaria, según los hábitos y preferencias personales. BaseException es la clase principal de Exception, y Exception como subclase no puede interceptar errores del tipo BaseException de la clase principal.
BaseException: contiene todas las excepciones integradas
Excepción: no contiene todas las excepciones integradas, solo incluye excepciones integradas que no salen del sistema; excepciones como SystemExit no están incluidas. Todos los errores en Python se derivan de la clase BaseException
2.7 uso de finalmente
La función de finalmente es ejecutar el código finalmente independientemente de si excepto captura con éxito la excepción correspondiente:
"""
参考如下代码：打开了love.txt这个文件，进行了阅读，又想写入一点东西，但现在是只读的模式，无法进行内容写入，故此会报错io.UnsupportedOperation
虽然没有写入成功，但是这个文件是成功读取了的，那么在文件的章节中提到过，如果打开了一个文件要记得关闭，否则其他人无法使用
所以在finally这里我们就可以加上f.close()，代表着无论是否有捕捉到异常，最后我都要关闭这个文件，以确保其他人能够正常使用该文件
"""
import io
try:
f = open("love.txt", encoding="utf-8", mode="r")
f.read()
f.write("随便写点~")
except io.UnsupportedOperation:
print("抓的就是你这个io.UnsupportedOperation报错")
finally:
# finally的作用是无论except是否成功捕获到了对应的异常，均需要执行finally下的代码
f.close()2.8 Impresión de información de excepción
Aunque podemos detectar la excepción, debemos saber cuál es la excepción. Cuando detectamos una excepción, podemos imprimir la información de la excepción:
print("------------------- 欢迎来到报名注册系统 -------------------")
age = (input("请输入您的年龄:"))
try:
age = int(age)
if age < 18:
print("很遗憾，您暂时不满足注册条件")
else:
print("恭喜您符合注册条件")
# 这里会报错ValueError，捕获的是IndexError，很明显无法进行异常捕获，那么我们可以在添加一个万能捕手except来进行捕获
except IndexError as error:
print("您的年龄输入非法，请重新运行本程序")
# 在这里加一个as，后面接一个变量，然后进行变量打印即可，当出现对应的异常时就会打印对应异常的信息
except Exception as error:
print("万能捕手在此，束手就擒吧！", f"已捕获异常:{error}")
Se acaba de mencionar que excepto y excepción Exception son equivalentes, pero si quieres usar as, debes usar este último, esta es la regla gramatical:
# 正确用法，在捕获类型后加as 变量
except Exception as error:
print("万能捕手在此，束手就擒吧！", f"已捕获异常:{error}")
# 错误的用法，不符合语法规则
except as error:
print("万能捕手在此，束手就擒吧！", f"已捕获异常:{error}")Finalmente me gustaría agradecer a todos los que han leído atentamente mi artículo, la reciprocidad siempre es necesaria, aunque no es algo muy valioso, puedes quitártelo si lo necesitas:
Subprograma de entrevista de prueba de software
¡El banco de preguntas de pruebas de software superado por millones de personas! ! ! ¡Quién es quién lo sabe! ! ! El miniprograma de cuestionarios más completo de toda la red, puedes usar tu teléfono móvil para hacer los cuestionarios, en el metro o en el autobús, ¡enróllalo!
Se cubren las siguientes secciones de preguntas de la entrevista:
1. Teoría básica de pruebas de software, 2. web, aplicaciones, pruebas de función de interfaz, 3. red, 4. base de datos, 5. linux
6. web, aplicación, automatización de interfaz, 7. pruebas de rendimiento, 8. conceptos básicos de programación, 9. preguntas de la entrevista de horas, 10. preguntas de prueba abiertas, 11. pruebas de seguridad, 12. conceptos básicos de informática
Estos materiales deberían ser el almacén de preparación más completo y completo para los amigos [de pruebas de software]. Este almacén también ha acompañado a decenas de miles de ingenieros de pruebas en el viaje más difícil. ¡Espero que pueda ayudarlo a usted también!