Plongez au coeur de Python

[mapping-expression for element in source-list if filter-expression]

C’est une extension des list comprehensions que vous connaissez et appréciez. Les deux premiers tiers sont identiques, la dernière partie, commençant par le if, est l’expression de filtrage. Une expression de filtrage peut être n’importe quelle expression qui s’évalue en vrai ou faux (ce qui en Python peut être presque tout). Tout élément pour lequel l’expression de filtrage s’évalue à vrai sera inclu dans la liste à transformer. Tous les autres éléments seront ignorés, il ne passeront jamais par l’expression de mutation et ne seront pas inclus dans la liste retournée.

Exemple 4.14. Présentation du filtrage de liste

>>> li = ["a", "mpilgrim", "foo", "b", "c", "b", "d", "d"]
>>> [elem for elem in li if len(elem) > 1]       
['mpilgrim', 'foo']
>>> [elem for elem in li if elem != "b"]         
['a', 'mpilgrim', 'foo', 'c', 'd', 'd']
>>> [elem for elem in li if li.count(elem) == 1] 
['a', 'mpilgrim', 'foo', 'c']

	L’expression de mutation est ici très simple (elle retourne juste la valeur de chaque élément), observez plutôt attentivement l’expression de filtrage. Au fur et à mesure que Python parcours la liste, il soumet chaque élément à l’expression de filtrage, si l’expression s’évalue à vrai, l’élément passe par l’expression de mutation et le résultat est inclu dans la liste de résultat. Ici, on filtre toutes les chaînes d’un seul caractère, il ne reste donc que les chaînes plus longues.
	Ici, on filtre une valeur spécifique : b. Notez que cela filtre toutes les occurences de b, puisqu’à chaque fois qu’il apparaît, l’expression de filtrage s’évaluera à faux.
	count est une méthode de listes qui retourne le nombre d’occurences d’une valeur dans la liste. On pourrait penser que ce filtre élimine les doublons de la liste, retournant une liste contenant seulement un exemplaire de chaque valeur. Mais en fait, les valeurs qui apparaissent deux fois dans la liste initiale (ici b et d) sont totalement éliminées. Il y a des moyens de supprimer les doublons d’une liste mais le filtrage n’est pas la solution.

    methodList = [method for method in dir(object) if callable(getattr(object, method))]

Cela à l’air complexe et ça l’est, mais la structure de base est la même. L’expression complète renvoie une liste qui est assignée à la variable methodList. La première moitié de l’expression est la mutation de liste. L’expression de mutation est une expression d’identité, elle retourne la valeur de chaque élément. dir(object) retourne une liste des attributs et méthodes de object, c’est à cette liste que vous appliquez la mutation. La seule nouveauté est l’expression après le if.

L’expression de filtrage à l’air impressionant, mais elle n’est pas si terrible. Vous connaissez déjà callable, getattr et in. Comme vous l’avez vu dans la section précédente, l’expression getattr(object, method) retourne un objet fonction si object est un module et si method est le nom d’une fonction de ce module.

Donc, cette expression prend un objet, appelé object, obtient une liste des noms de ses attributs, méthodes, fonctions et quelques autres choses, puis filtre cette liste pour éliminer ce qui ne nous intéresse pas. Cette élimination se fait en prenant le nom de chaque attribut/méthode/fonction et en obtenant une référence vers l’objet véritable, grâce à la fonction getattr. On vérifie alors si cet objet est appelable, ce qui sera le cas pour toutes les méthodes et fonctions prédéfinies (comme la méthode pop d’une liste) ou définies par l’utilisateur ( comme la fonction buildConnectionString du module odbchelper). Nous ne nous intéressons pas aux autres attributs, comme l’attribut __name__ qui existe pour tout module.