Code de test
Lors de l'écriture de fonctions et de classes, vous pouvez également écrire des fonctions de test. Grâce aux tests, vous pouvez vous assurer que le code peut fonctionner normalement pour diverses entrées. Lorsque vous ajoutez du nouveau code à votre programme, vous pouvez également le tester pour vous assurer qu'il ne brise pas les routines existantes du programme. Testez fréquemment les modules.
Testez le code via les outils du module python unittest. Vous comprendrez à quoi cela ressemble de réussir un test, à quoi cela ressemble d'échouer, vous saurez comment améliorer le code si vous savez que le test échoue et vous saurez combien de tests écrire pour le projet. Savoir tester des fonctions et des classes.
Lors de l'exécution du programme, vous rencontrerez toujours diverses erreurs. Certaines erreurs sont causées par des problèmes d'écriture du programme. Par exemple, une chaîne doit être affichée au lieu d'un entier. Ce type d'erreur est généralement appelé un bug et les bugs doivent être corrigés.
Fonction de test
Test unitaire et cas de test
Le module unittest en Python fournit des outils de test de code Test unitaire est utilisé pour vérifier certains aspects de. la fonction. Pas de problème. Test case est un ensemble de tests unitaires pour garantir que la fonction n'a aucun problème dans tous les aspects.
Les cas de test à couverture complète incluent un ensemble complet de cas de test, couvrant diverses manières possibles d'utiliser les fonctions.
Peut réussir le test
Pour écrire une fonction de test pour une fonction, importez d'abord le module unittest et la fonction à tester, puis créez une classe qui hérite de unittest.TestCase, et écrivez un série de méthodes pour la fonction Différents aspects du comportement sont testés. Il est préférable de le nommer avec test.
name_function.py
|
def get_formatted_name(first, last):
"""获得全名."""
full_name = first + ' ' + last
return full_name.title()
|
def get_formatted_name(first, last): """Obtenir le nom complet.""" full_name = first + ' ' + last |
from name_function import get_formatted_name
print("Enter 'q' at any time to quit.")
while True:
first = input("nPlease give me a first name: ")
if first == 'q':
break
last = input("Please give me a last name: ")
if last == 'q':
break
formatted_name = get_formatted_name(first, last)
print("tNeatly formatted name: " + formatted_name + '.')
|
return full_name . title()
|
names.py
|
import unittest
from name_function import get_formatted_name
class NamesTestCase(unittest.TestCase):
"""测试name_function.py"""
def test_first_last_name(self):
"""能够正确地处理像Janis Joplin这样的姓名吗？"""
formatted_name = get_formatted_name('janis', 'joplin') self.assertEqual(formatted_name, 'Janis Joplin')
unittest.main()
|
| from name_function import get_formatted_nameprint("Entrez 'q' à tout moment pour quitter.") while True : first = input("nVeuillez me donner un prénom : ") if first == 'q' :
方法 |
用途 |
assertEqual(a, b) |
核实a == b |
assertNotEqual(a, b) |
核实 a != b |
assertTrue(x) |
核实 x 为True |
assertFalse(x) |
核实 x 为False |
assertIn(item, list) |
核实 item在list中 |
assertNotIn(item, list) |
核实 item不在list中 |
break last = input("Veuillez me donner un nom de famille : ") if last == 'q' : break formatted_name = get_formatted_name(first , dernier) print("tNom soigneusement formaté : " + formatted_name + '.') |
test_name_function . py
| import unittest from name_function import get_formatted_nameclass NamesTestCase(unittest.TestCase): """Test name_function.py""" def test_first_last_name(self): 🎜>" " " Pouvez-vous gérer correctement un nom comme Janis Joplin ? """ |
Une des fonctions les plus utiles de unittest : une méthode d'assertion, la méthode d'assertion assertEqual est utilisée pour vérifier si le résultat obtenu est le même que la valeur attendue. ne peut pas. Tests réussis Si le test échoue, ne modifiez pas le test. Corrigez plutôt le code qui a provoqué l'échec du test : vérifiez les modifications que vous venez d'apporter à la fonction pour trouver. les changements qui ont provoqué un comportement inattendu de la fonction Diverses méthodes d'assertion dans le module 6 assertions courantes
Méthode |
Objectif
|
| assertEqual(a, b) |
Vérifier a == b |
| assertNotEqual(a , b) |
Vérifier a != b |
| assertTrue(x) |
Vérifier x est vrai |
| assertFalse(x) |
Vérifiez que x est faux |
| assertIn(item, list) |
Vérifier que l'élément est dans la liste |
| assertNotIn(item , list) |
Vérifiez que l'élément n'est pas dans la liste |
Method setUp()
La classe Unittest.TestCase contient la méthode setUp(), qui nous permet de créer des objets une seule fois et de les utiliser dans chaque méthode de test.
Survey.py
|
class AnonymousSurvey():
"""收集匿名调查问卷的答案"""
def __init__(self, question):
"""存储一个问题，并为存储答案做准备"""
self.question = question
self.responses = []
def show_question(self):
"""显示调查问卷"""
print(question)
def store_response(self, new_response):
"""存储单份调查答卷"""
self.responses.append(new_response)
def show_results(self):
"""显示收集到的所有答卷"""
print("Survey results:")
for response in responses:
print('- ' + response)
|
class AnonymousSurvey() : Une question et se préparer à stocker la réponse""" > """Afficher le questionnaire""" """ self.responses.app fin (nouvelle_réponse) |
from survey import AnonymousSurvey
#定义一个问题，并创建一个表示调查的AnonymousSurvey对象
question = "What language did you first learn to speak?"
my_survey = AnonymousSurvey(question)
#显示问题并存储答案 my_survey.show_question()
print("Enter 'q' at any time to quit.n")
while True:
response = input("Language: ")
if response == 'q':
break
my_survey.store_response(response)
# 显示调查结果
print("nThank you to everyone who participated in the survey!")
my_survey.show_results()
|
def show_results (self): "" "Show toutes les réponses collectées" "" > table> Language_Survey.py | à partir de l'importation d'enquête AnonymousSurvey#Définir un question et créez un objet AnonymousSurvey représentant l'enquêtequestion = "Quelle langue avez-vous appris à parler en premier ?" my_survey = AnonymousSurvey(question)#Afficher les questions et stocker les réponses my_survey.show_question()print("Entrez 'q' à tout moment pour quitter.n")while True : response = input("Langue : ") if réponse == 'q' : pause my_survey .store_response(response) # Afficher les résultats de l'enquêteprint("nMerci à tous ceux qui ont participé à l'enquête !")my_survey.show_results() |
test_survey.py
|
import unittest
from survey import AnonymousSurvey
class TestAnonymousSurvey(unittest.TestCase):
"""针对AnonymousSurvey类的测试"""
def setUp(self):
"""创建一个调查对象和一组答案，供使用的测试方法使用"""
question = "What language did you first learn to speak?"
self.my_survey = AnonymousSurvey(question)
self.responses = ['English', 'Spanish', 'Mandarin']
def test_store_single_response(self):
"""测试单个答案会被妥善地存储""" self.my_survey.store_response(self.responses[0])
self.assertIn(self.responses[0], self.my_survey.responses)
def test_store_three_responses(self):
"""测试三个答案会被妥善地存储"""
for response in self.responses:
self.my_survey.store_response(response)
for response in self.responses:
self.assertIn(response, self.my_survey.responses)
unittest.main()
|
import unittest from Survey import AnonymousSurvey class TestAnonymousSurvey(unittest.TestCase): """Test pour la classe AnonymousSurvey""" def setUp (lui-même): " self.my_survey = AnonymousSurvey(question)
self.responses = [' Anglais', 'Espagnol', 'Mandarin']
def test_store_single_response (self):
"""Les réponses individuelles aux tests seront stockées correctement""" self.my_survey.store_response(self.responses[0])
self.assertIn(self.responses[ 0], self.my_survey.responses) réponses :
self.my_survey.store_response(response)
pour la réponse dans self.responses : self.assertIn(response, self.my_survey.res ponses) unittest.main()
|
Méthode setUp() fait deux choses : créer un sujet d'enquête ; crée une liste de réponses. Les noms de variables qui stockent ces deux éléments incluent le préfixe self (c'est-à-dire stocké dans les attributs), ils peuvent donc être utilisés n'importe où dans cette classe. Cela simplifie les deux méthodes de test, car elles ne créent ni des répondants ni des réponses. Utilisez int() pour saisir des nombres Étant donné que le type de données renvoyé par input() est str (chaîne), python convertira le nombre directement saisi en chaîne. str ne peut pas être directement comparé à un entier, str doit d'abord être converti en entier. Python fournit la fonction int() pour accomplir cela
height = input("Quelle est votre taille, en pouces ? ")
height = int( hauteur) #convertir en entier
opérateur modulo Lors du traitement numérique informations, l'opérateur modulo (%) est un outil très utile. Il divise deux nombres et renvoie le reste : >>> 4 % 31>>> 5 % 32>>> ; 7 % 3 1Si un nombre est divisible par un autre nombre, le reste est 0, donc l'opérateur modulo renverra 0. Vous pouvez l'utiliser pour déterminer si un nombre est pair ou impair. |
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
