Salut,

J'utilise actuellement les assertions pour vérifier le type des arguments dans le constructeur d'une classe (par exemple) mais je ne suis pas sûr de la véritable utilisation des assertions.

AZ.

http://fr.openclassrooms.com/forum/sujet/python-assert-46119
http://www.tutorialspoint.com/python/assertions_in_python.htm

Un en francais et un anglais 

-
Edité par Anonyme 14 septembre 2014 à 16:17:53

Ah ouais d'acc . Mais est-ce que l'utilisation que j'en fait est pertinente ?:

class Patate:	
    def __init__(self, name, map_, pos, repr_='O'):
		try:
			assert isinstance(name, str)
			assert isinstance(pos, tuple)
			assert isinstance(repr_, str)

			self.name = name
			self.pos = pos
			self.repr = repr_
		except AssertionError:
			raise TypeError('Invalid Patate constructor arguments')

-
Edité par Anonyme 14 septembre 2014 à 16:24:40

Et bien je pense que oui si tu veux être sûr que name et repr sont des chaines (str) et que pos est un tuple.

Mais si tu veux juste faire un bloc pour catcher les erreurs, c'est inutile.

-
Edité par Anonyme 14 septembre 2014 à 16:26:46

Bonjour.

La vérification des types des variables ne fait pas parti de la philosophie de Python.
Mais cela n'est pas choquant de le faire avec des techniques propres, tant que cela ne vient pas alourdir le code.

Penche toi plutôt vers les décorateurs, qui sera bien plus propre qu'utiliser des assert en début de méthode.
Un exemple parmi tant d'autres : http://www.pythoncentral.io/validate-python-function-parameters-and-return-types-with-decorators/

@Pinguet62: Merci pour cette solution, j'avais pas pensé aux décorateurs ! Je passe le sujet en résolu du coup.

Même si le sujet est résolu, j'ajoute une précision : les assertions sont en général utilisées dans la programmation dirigée par les tests : au fur et à mesure qu'on améliore un programme, on met au niveau global des assertions pour vérifier si les les fonctionnalités précédentes marchent encore. Ainsi, si une "amélioration" du programme empêche le bon déroulement d'une fonction qui marchait précédemment, on le sait tout de suite par une `AssertionError`. Dans ton cas, il serait plus logique de lever des `TypeError`. En plus, les `AssertionError` ne sont pas levées quand le script est lancé en mode optimisé.

Mais est-ce que l'utilisation que j'en fait est pertinente ?

Je dirais que non, les assertions sont là pour tester dans une fonction main par exemple que tes fonctions renvoient bien le résultat attendu.

Imaginons une fonction somme,

def somme(*values):
    s = 0
    for n in values:
        s += n
    return s

On testera dans le programme principal que cette fonction est correcte

assert somme(12, 5) == 17
assert somme(8, -5) == 3
# etc... batterie de tests

Si un de ces tests unitaires n'est pas fonctionnel, nous avons à faire à un use case, qu'il faudra prendre en compte pour modifier le code en conséquence, c'est comme un patch sur un bug.

L'objectif de ces tests est de prendre tous les cas sensibles afin d'éviter au maximum des bugs pouvant touché le côté productif du programme.

Pour des tests plus complexes, on s'invente des scénarios, des productions et on vérifie que le résultat correspond aux attentes...

EDIT: Pour aller plus loin, voir programmation par contrat

EDIT2 : Le module qui devrait t'intéresser, pyContracts

-
Edité par Anonyme 14 septembre 2014 à 23:11:51