Python fr:Plus

[edit] Introduction

Nous avons vu jusqu'ici les principaux aspects de Python que vous utiliserez. Dans ce chapitre, nous verrons quelques autres points qui complèteront notre connaissance de Python.

[edit] Passer Des Tuples

Vous avez déjà voulu renvoyer deux valeurs d'une fonction ? C'est possible, il vous faut pour cela utiliser un tuple.

>>> def get_error_details():
...     return (2, 'second error details')
...
>>> errnum, errstr = get_error_details()
>>> errnum
2
>>> errstr
'second error details'

Notez que l'usage de a, b = <some expression> interprète le résultat de l'expression en tant que tuple avec deux valeurs.

Si vous voulez interpréter les résultats en tant que (a, <everything else>), alors vous avez juste besoin d'ajouter une étoile, comme vous le feriez avec les paramètres d'une fonction :

>>> a, *b = [1, 2, 3, 4]
>>> a
1
>>> b
[2, 3, 4]

cela veut aussi dire que la manière la plus rapide d'échanger deux variables en Python est :

>>> a = 5; b = 8
>>> a, b = b, a
>>> a, b
(8, 5)

[edit] Méthodes Speciales

Certaines méthodes comme __init__ et __del__ ont une signification spéciale dans les classes.

Les méthodes spéciales sont utilisées pour imiter certains comportements de built-in types. Par exemple, si vous voulez utiliser l'opération d'indexation x[key] pour votre classe (comme vous l'avez fait pour les listes et les tuples), alors il vous faut juste implémenter la méthode __getitem__() et c'est fait. Si vous y réfléchissez, c'est ce que fait Python pour la classe list elle-même !

Quelques utiles méthodes spéciales sont listées dans la table suivante. Si vous voulez tout savoir sur les méthodes spéciales, voyez le manuel.

[edit] Blocks D'Instructions A Une Ligne

Nous avons vu que chaque bloc d'instructions se démarque des autres par son niveau d'indentation. Il y a une mise en garde. Si votre block d'instructions contient seulement une instruction, alors vous pouvez l'indiquer sur la même ligne que, disons, une instruction de condition ou de boucle. L'exemple suivant devrait clarifier cela :

>>> flag = True
>>> if flag: print 'Yes'
...
Yes

Notez que l'unique instruction est utilisée sur place et pas en tant que bloc séparé. Bien qu'il soit possible d'utiliser cela pour raccourcir votre programme, je recommande fortement d'éviter cette méthode, à part pour rechercher des erreurs, principalement parce qu'il sera beaucoup plus facile d'ajouter une instruction supplémentaire si vous utilisez une indentation correcte.

[edit] Les Lambdas

Une instruction lambda est utilisée pour créer des nouveaux objets d'une fonction et les retourner à l'exécution.

#!/usr/bin/python
# Nom de fichier : lambda.py
 
def fais_répéter(n):
    return lambda s: s * n
 
deuxfois = fais_répéter(2)
 
print(deuxfois('mot'))
print(deuxfois(5))

Résultat :

   $ python lambda.py
   motmot
   10

Comment cela fonctionne :

Ici, nous utilisons une fonction fais_répéter pour créer des nouveaux objets d'une fonction à l'exécution et les retourner. Une instruction lambda est utilisée pour créer l'objet de la fonction. Fondamentalement, le lambda prend un paramètre suivi par une seule expression qui devient le corps de la fonction et la valeur de cette expression est renvoyée par la nouvelle fonction. Notez que même une fonction print ne peut pas être utilisée à l'intérieur d'une fonction lambda, seulement des expressions.

A FAIRE

Pouvons-nous faire un list.sort() en fournissant une fonction de comparaison créée avec lambda ?

points = [ { 'x' : 2, 'y' : 3 }, { 'x' : 4, 'y' : 1 } ]
# points.sort(lambda a, b : cmp(a['x'], b['x']))

[edit] Les List Comprehension

Les list comprehensions sont utilisées pour créer une nouvelle liste à partir d'une liste existante. Supposons, vous avez une liste de nombres et vous voulez obtenir une liste correspondante avec tous les nombres multipliés par 2 seulement si le nombre est supérieur à 2. Les List comprehensions sont idéales dans ce cas.

#!/usr/bin/python
# Nom de fichier : list_comprehension.py
 
listeun = [2, 3, 4]
listedeux = [2*i for i in listeun if i > 2]
print(listedeux)

Résultat :

   $ python list_comprehension.py
   [6, 8]

Comment cela fonctionne :

Ici, nous créons une nouvelle liste en indiquant la manipulation à effectuer (2*i) quand une condition est satisfaite (if i > 2). Notez que la liste originale n'est pas modifiée.

L'avantage des list comprehensions est que cela réduit la quantité de code passe-partout nécessaire quand on utilise une boucle pour traiter chaque élément d'une liste et le ranger dans une nouvelle liste.

[edit] Recevoir Des Tuples Et Des Dictionnaires Dans Des Fonctions

Il existe une façon spéciale de recevoir des paramètres pour une fonction en tant que tuple ou dictionnaire en utilisant respectivement le préfixe * ou ** . Cela est utile quand il y a un nombre variable d'arguments dans la fonction.

>>> def puissancesomme(puissance, *args):
...     '''Renvoie la somme de chaque argument elevé à la puissance indiquée.'''
...     total = 0
...     for i in args:
...         total += pow(i, puissance)
...     return total
 
...
>>> puissancesomme(2, 3, 4)
25
 
>>> puissancesomme(2, 10)
100

Comme nous avons un préfixe * sur la variable args , tous les arguments supplémentaires passés à la fonction sont stockés en tant que tuple dans args . Si un préfixe ** avait été utilisé à la place, les paramètres supplémentaires auraient été vus comme des paires clé/valeur d'un dictionnaire.

[edit] Exec Et Eval

La fonction exec est utilisée pour exécuter des instructions Python stockées dans une chaîne ou un fichier. Par exemple, nous pouvons générer une chaîne contenant du code Python et exécuter ces instructions avec exec :

>>> exec('print("Hello World")')
Hello World

De la même manière, la fonction eval est utilisée pour évaluer des expressions Python valides stockées dans une chaîne. Un exemple basique est montré ci-dessous.

>>> eval('2*3')
6

[edit] L'Instruction Assert

L'instruction assert est utilisée pour supposer que quelque chose est vrai. Par exemple, si vous êtes persuadé qu'une liste contient au moins un élément, et que vous voulez le vérifier et lever une erreur dans le cas contraire, alors l'instruction assert est idéale dans ce cas. Quand une instruction assert échoue, une AssertionError est levée.

>>> mylist = ['item']
>>> assert len(mylist) >= 1
>>> mylist.pop()
'item'
>>> mylist
[]
>>> assert len(mylist) >= 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

L'instruction assert doit être utilisée à bon escient. La plupart du temps, il vaut mieux attraper des exceptions, soit gérer le problème soit afficher un message d'erreur à l'utilisateur et ensuite sortir.

[edit] La Fonction Repr

La fonction repr est utilisée pour obtenir une représentation en chaîne de l'objet. Le côté intéressant est que vous aurez la plupart du temps eval(repr(object)) == object .

>>> i = []
>>> i.append('item')
>>> repr(i)
"['item']"
>>> eval(repr(i))
['item']
>>> eval(repr(i)) == i
True

Fondamentalement, la fonction repr est utilisée pour obtenir une représentation affichable de l'objet. Vous pouvez contrôler ce que vos classes renvoient pour la fonction repr en définissant la méthode __repr__ dans votre classe.

[edit] Récapitulatif

Nous avons vu quelques autres fonctionnalités de Python dans ce chapitre, et nous n'avons pas encore vu toutes les fonctionnalités de Python. Cependant, nous avons vu maintenant l'essentiel de ce que vous utiliserez en pratique. C'est suffisant pour vous permettre de démarrer avec les programmes que vous allez créer.

Nous allons ensuite approfondir Python.