Tutoriel complet Python en pdf


Télécharger Tutoriel complet Python en pdf

★★★★★★★★★★2.3 étoiles sur 5 basé sur 3 votes.
Votez ce document:

Télécharger aussi :


Guide de formation complet Python pour réviser

...

2.1          Lancement de l’Interpréteur

L’interpréteur Python est habituellement installé  à  l’emplacement ‘/usr/local/bin/python’ sur les machines Unix sur lesquelles il est disponible ; placer ‘/usr/local/bin’ dans le path de votre shell UNIX permet de le lancer en tapant la commande python sous le shell. Puisque le choix du répertoire dans lequel est installé l’interpréteur est une option d’installation, d’autres endroits  sont  possibles ;  vérifiez  avec  votre  gourou  Python local  ou  votre  administrateur  système.  (Par  exemple, ‘/usr/local/python’ est un autre emplacement populaire.)

Tapez le caractère EOF (Control-D sur UNIX, Control-Z sur DOS ou Windows) à  l’invite (prompt) principale pour quitter l’interpréteur avec un code de retour de zéro. Si ça ne marche pas, vous pouvez quitter l’interpréteur en tapant les commandes suivantes : ‘import sys ; sys.exit()’.

Les fonctions d’édition de ligne de l’interpréteur ne sont habituellement pas très sophistiquées. Sur UNIX, celui qui a installé l’interpréteur peut avoir activé le support de la bibliothèque GNU Readline, qui ajoute une édition interactive plus élaborée et des fonctions d’historique. Peut-être la vérification la plus rapide pour savoir si l’édition de ligne de commande est supportée consiste à taper Control-P au premier prompt affiché par Python. Si ça fait un bip, vous disposez de l’édition de ligne de commande ; voir l’Annexe A pour une introduction aux touches. Si rien ne semble se passer, ou si ˆP est affiché, l’édition de ligne de commande n’est pas disponible ; vous pourrez seulement utiliser backspace pour enlever des caractères de la ligne courante.

L’interpréteur fonctionne en quelque sorte comme le shell UNIX : lorsqu’il est lancé avec l’entrée standard connectée à un périphérique tty, il lit et exécute les commandes interactivement ; lorsqu’il est lancé avec un nom de fichier en argument ou avec un fichier comme entrée standard, il lit et exécute un script depuis ce fichier.

Une troisième façon de lancer l’interpréteur est ‘python -c commande [arg] ...’, ce qui exécute les ins- tructions dans commande, de façon analogue à l’option -c du shell. Puisque les instructions en Python contiennent souvent des espaces ou d’autres caractères qui sont spéciaux pour le shell, il est conseillé de mettre entièrement entre guillemets (doubles quotes) la commande.

Notez qu’il y a une différence entre ‘python fichier’ et ‘python <fichier’. Dans le second cas, les requêtes en entrée du programme, comme les appels à input() et raw input(), sont effectuées depuis fichier. Puisque ce fichier a déjà été lu jusqu’à la fin par l’interpréteur avant que le programme ne commence à s’exécuter, le programme rencontrera immédiatement EOF. Dans le premier cas (qui est habituellement ce qu’on souhaite) les requêtes sont satisfaites par l’éventuel fichier ou périphérique qui est connecté à l’entrée standard de l’interpréteur Python.

Lorsqu’un fichier script est utilisé, il est parfois utile de pouvoir lancer le script et de passer ensuite en mode interactif. Ceci peut être fait en passant en paramètre -i avant le script. (Ceci ne marche pas si le script est lu depuis l’entrée standard, pour la même raison expliquée dans le paragraphe précédent.)

2.1.1      Passage de Paramètres

Lorsqu’ils sont connus de l’interpréteur, le nom du script et les paramètres supplémentaires sont passés au script dans la variable sys.argv, qui est une liste de chaˆınes. Sa longueur est d’au moins un ; quand aucun script ou arguments n’est  donné, sys.argv[0] est  une chaˆıne vide. Lorsque le  nom  du  script  donné  est  ’-’ (c’est à  dire l’entrée standard), sys.argv[0] est positionné à ’-’. Quand -c commande est utilisé, sys.argv[0] est positionné à ’-c’. Les options trouvées après -c commande ne sont pas retirées par le traitement des options de l’interpréteur Python mais laissées dans sys.argv pour être traitées par la commande.

2.1.2      Mode Interactif

Quand  les  commandes sont  lues  depuis un  terminal,  l’interpréteur fonctionne en  mode  interactif.  Dans  ce  mode, il demande la commande suivante avec le  prompt principal, habituellement trois signes supérieur (‘>>> ’) ; pour les lignes de continuation, il questionne avec le prompt secondaire, par défaut trois points (‘... ’). L’interpréteur imprime un message de bienvenue spécifiant son numéro de version et une notice de copyright avant d’afficher le prompt principal, par ex. :

python

Python 1.5.2b2 (#1, Feb 28 1999, 00:02:06)         [GCC 2.8.1] on sunos5

Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam

>>> 

Les lignes de continuation sont nécessaires lorsqu’on saisit une construction sur plusieurs lignes. Comme exemple, voici une instruction if :

>>> le_monde_est_plat = 1

>>> if le_monde_est_plat:

...            print "Gaffe `a pas tomber par dessus bord!"

...

Gaffe `a pas tomber par dessus bord!

2.2          L’Interpréteur et Son Environnement

2.2.1      Gestion des Erreurs

Quand une erreur survient, l’interpréteur imprime un  message d’erreur et  une trace de l’état  de la  pile. En  mode interactif, il retourne alors au prompt principal ; lorsque l’entrée se fait depuis un fichier, il termine l’exécution avec un code de sortie différent de zéro après avoir imprimé la trace de pile. (Les exceptions gérées par une clause except dans une instruction try ne sont pas des erreurs dans ce contexte ; voir 8.2.) Certaines erreurs sont fatales dans tous les cas et causent une sortie avec un code différent de zéro ; ceci se produit pour les aberrations internes et certains cas de saturation mémoire. Tous les messages d’erreur sont écrits sur la sortie d’erreur standard ; l’affichage normal des commandes exécutées est effectué sur la sortie standard.

Taper le caractère d’interruption (habituellement Control-C ou DEL) au prompt principal ou secondaire annule la saisie et revient au prompt principal.1 Taper le caractère d’interruption pendant l’exécution d’une commande déclenche l’exception KeyboardInterrupt, qui peut être gérée par une instruction try

2.2.2      Scripts Python Exécutables

Sur les systèmes UNIX  à la BSD, les scripts Python peuvent être rendus directement exécutables, comme les shell- scripts, en plaçant la ligne

#! /usr/bin/env python

(en  supposant  que  l’interpréteur  est  dans  le  $PATH  de  l’utilisateur  au  lancement  du  script)  et  rendant  le  fichier exécutable. Le ‘# !’ doit correspondre aux deux premiers caractères du fichier.

2.2.3      Le Fichier de Démarrage Interactif

Quand vous utilisez Python de façon interactive, il est souvent pratique que certaines commandes standard soient exécutées à chaque fois que l’interpréteur est lancé. Vous pouvez faire ceci en donnant à la variable d’environnement

$PYTHONSTARTUP la valeur du nom d’un fichier contenant vos commandes de démarrage. Ceci est analogue à l’utilisation du ‘.profile’ pour les shells UNIX.

Ce fichier est seulement lu avant les sessions interactives, non pas lorsque Python lit ses commandes dans un script, ni lorsque ‘/dev/tty’ est fourni comme source explicite pour les commandes (ce qui pour le reste se comporte comme une session interactive). Il est exécuté  dans le même espace de noms que celui ou`  sont exécutées les commandes interactives, de sorte que les objets qu’il définit ou importe peuvent être utilisés directement dans la session interactive. Vous pouvez aussi changer les invites sys.ps1 et sys.ps2 dans ce fichier.

Si vous voulez lire un fichier de lancement additionnel depuis le répertoire courant, vous pouvez programmer cela dans le fichier de démarrage global, par ex.   ‘execfile(’.pythonrc’)’. Si vous voulez utiliser le fichier de démarrage dans un script, vous devez le faire explicitement dans le script :

import os

filename = os.environ.get(’PYTHONSTARTUP’) if filename and os.path.isfile(filename):

execfile(filename)

...

Premiers Pas Vers la Programmation

Bien sûr, nous pouvons utiliser Python pour des taˆches plus compliquées que d’ajouter deux et deux. Par exemple, nous pouvons écrire une sous-séquence de la suite de Fibonacci de la façon suivante :

>>> # Suite de Fibonacci

... # La somme de deux

... a, b = 0, 1

>>> while b < 10:

...            print b

 Cet exemple introduit plusieurs fonctionnalités nouvelles.

–             La première ligne contient une affectation multiple : les variables a et b prennent simultanément les nouvelles valeurs 0 et 1. Sur la dernière ligne l’affectation multiple est utilisée à  nouveau, montrant que les expressions en partie droite sont d’abord toutes évaluées avant qu’aucune affectation ne se fasse.

–             La boucle while s’exécute tant que la condition (ici : b < 10) reste vraie. En Python, comme en C, toute valeur entière différente de zéro est vraie ; zéro est faux. La condition pourrait aussi être une chaˆıne ou une valeur de type liste,  en  fait n’importe quelle séquence ;  n’importe quoi avec une longueur différente de  zéro est  vrai, les séquences vides correspondent à faux. Le test utilisé dans l’exemple est une simple comparaison. Les opérateurs de comparaison standard sont écrits de la même façon qu’en C : <, >, ==, <=, >= et !=.

–             Le corps de la boucle est indenté : l’indentation est le moyen par lequel Python regroupe les instructions. Python ne fournit pas (encore) une fonction d’édition de ligne intelligente, donc vous devez insérer une tabulation ou un espace pour chaque ligne indentée. En pratique vous préparerez les saisies plus compliquées avec un éditeur de texte ; la plupart des éditeurs de texte ont une fonction d’auto-indentation. Lorsqu’une instruction composée est entrée en mode interactif, elle doit être suivie d’une ligne vide pour indiquer qu’elle est terminée (car l’interpréteur ne peut pas deviner si vous avez tapé la dernière ligne).

–             L’instruction print écrit la valeur de la ou des expressions qui lui sont données. Elle diffère de la simple écriture de l’expression (comme tout-à-l’heure dans les exemples de la calculatrice) dans la mesure ou` elle accepte plusieurs expressions et chaˆınes. Les chaˆınes sont imprimées sans quotes, et un espace est inséré entre les éléments, ce qui vous permet de les afficher dans un format plus sympathique, comme ceci :

>>> i = 256*256

>>> print ’La valeur de i est’, i La valeur de i est 65536

Une virgule finale empêche le retour chariot après l’affichage :

>>> a, b = 0, 1

>>> while b < 1000:

...            print b,

...            a, b = b, a+b

...

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

Notez que l’interpréteur insère un retour chariot avant d’imprimer le prompt suivant si la ligne n’a pas été complétée.

CHAPITRE QUATRE

D’Autres Outils de Controˆle d’Exécution

A part l’instruction while que l’on vient de découvrir, Python comprend les instructions de controˆle d’exécution habituelles connues dans d’autres langages, avec quelques adaptations.



4.1          Instructions if

Peut-être l’instruction la plus connue est-elle l’instruction if. Par exemple :

>>> if x < 0:

...            x = 0

...            print ’Négatif changé en zéro’

... elif x == 0:

...            print ’Zéro’

... elif x == 1:

...            print ’Un seul’

... else:

...            print ’Plus’

...

Il peut y avoir aucune ou plusieurs sections elif, et la section else est optionnelle. Le mot-clé ‘elif’ est une abréviation de ‘else if’, et est utile pour éviter une indentation excessive. Une séquence if . . . elif . . . elif . . . est un substitut pour les instructions switch ou case qu’on trouve dans d’autres langages.

4.2          Instructions for

L’instruction for en Python diffère un petit peu de ce que vous avez pu utiliser en C ou en Pascal. Au lieu d’itérer toujours dans une progression arithmétique de nombres (comme en Pascal), ou de laisser l’utilisateur complètement libre  dans les  tests  et  les  pas  d’itération  (comme en  C),  l’instruction  for de Python  itère  parmi les  éléments  de n’importe quelle séquence (par ex., une liste ou une chaˆıne), dans l’ordre ou`  ils apparaissent dans la séquence. Par exemple (aucun jeu de mots volontaire) :

 >>> # Mesurer quelques chaˆınes:

... a = [’chat’, ’fenˆetre’, ’défenestrer’]

>>> for x in a:

...            print x, len(x)

...

chat 4

fenˆetre 7

défenestrer 11

Il n’est pas prudent de modifier la séquence sur laquelle on itère dans la boucle (ceci peut seulement arriver pour les types de séquences modifiables, par exemple, les listes). Si vous avez besoin de modifier la liste sur laquelle vous itérez, par exemple, pour dupliquer des éléments sélectionnés, vous devez itérer sur une copie. La notation de découpage rend ceci particulièrement pratique :

>>> for x in a[:]: # fait une copie de la liste entière par découpage

...            if len(x) > 8: a.insert(0, x)

...

>>> a

[’défenestrer’, ’chat’, ’fenˆetre’, ’défenestrer’]

4.3          La Fonction range()

Si vous avez besoin d’itérer sur une séquence de nombres, la fonction intégrée range() vient à point. Elle génère des listes contenant des progressions arithmétiques, par ex. :

>>> range(10)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Le nombre de fin qui lui est passé  n’est jamais dans la liste générée ; range(10) génère une liste de 10 valeurs, exactement les indices des éléments d’une séquence de longueur 10. Il est possible de faire commencer l’intervalle à un autre nombre, ou de spécifier un incrément différent (même négatif) :

>>>        range(5,              10)

[5,          6, 7, 8,   9]

>>>        range(0,              10, 3)

[0,          3, 6, 9] 

>>> range(-10, -100, -30)

[-10, -40, -70]

Pour parcourir les indices d’une séquence, combinez range() et len() comme ci-dessous :

 >>> a = [’Marie’, ’avait’, ’un’, ’petit’, ’mouton’]

>>> for i in range(len(a)):

...            print i, a[i]

...

0             Marie

1             avait

2             un

3             petit

4             mouton

4.4          Les Instructions break et continue, et les Clauses else dans les Boucles

L’instruction break, comme en C, sort de la plus petite boucle for ou while englobante. L’instruction continue, également empruntée au C, continue sur la prochaine itération de la boucle.

Les instructions de boucle ont une clause else ; elle est exécutée lorsque la boucle se termine par épuisement de la liste (avec for) ou quand la condition devient fausse (avec while), mais pas quand la boucle est interrompue par une instruction break. Ceci est expliqué dans la boucle suivante, qui recherche des nombres premiers :

>>> for n in range(2, 10):

...            for x in range(2, n):

...            if n % x == 0:

...            print n, ’égale’, x, ’*’, n/x

...            break

...            else:

...            print n, ’est un nombre premier’

...

2             est un nombre premier

3             est un nombre premier

4             égale 2 * 2

5             est un nombre premier

6             égale 2 * 3

7             est un nombre premier

8             égale 2 * 4

9             égale 3 * 3

4.5          L’Instruction pass

L’instruction pass ne fait rien. Elle peut être utilisée lorsqu’une instruction est requise syntaxiquement mais que le programme ne nécessite aucune action. Par exemple :

>>> while 1:

...            pass # Attente active d’une interruption au clavier

...

4.6          Définition de Fonctions

Nous pouvons créer une fonction qui écrit la série de Fibonacci jusqu’à une limite quelconque :

>>> def fib(n):  # écrit la série de Fibonacci jusqu’`a n

...            "Affiche une suite de Fibonacci jusqu’`a n"

...            a, b = 0, 1

...            while b < n:

...            print b,

...            a, b = b, a+b

...

>>> # Maintenant on appelle la fonction qui vient juste d’ˆetre définie

... fib(2000)

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Le mot-clé  def débute la définition d’une fonction. Il doit être suivi par le  nom de la fonction et une liste entre parenthèses de  paramètres formels. Les instructions qui forment le  corps de la  fonction commencent sur  la  ligne suivante, indentée par une tabulation. La première instruction du corps de la fonction peut éventuellement être un texte dans une chaˆıne de caractères ; cette chaˆıne est la chaˆıne de documentation de la fonction, ou docstring.

Il y a des outils qui utilisent les docstrings pour générer automatiquement de la documentation papier, ou pour per- mettre à l’utilisateur de naviguer interactivement dans le code ; c’est une bonne technique que d’inclure les docstrings dans le code que vous écrivez, donc essayez de vous y habituer.

L’exécution d’une fonction génère une nouvelle table de symboles, utilisée pour les variables locales de la fonction. Plus précisément, toutes les affectations de variables dans une fonction stockent la valeur dans la table de symboles locale ; alors que les références à  des variables regardent en premier dans la table de symboles locale, puis dans la table de symboles globale, et enfin dans la table des noms intégrés. Ainsi, on ne peut affecter directement une valeur aux variables globales à l’intérieur d’une fonction (à moins de les déclarer avec une instruction global), bien qu’on puisse y faire référence.

Les vrais paramètres (arguments) d’un appel de fonction sont introduits dans la table de symboles locale de la fonction appelée quand  elle  est  appelée ;  ainsi,  les  arguments sont  passés  en  utilisant  un  passage  par  valeur.1  Quand  une fonction appelée appelle à son tour une autre fonction, une nouvelle table de symboles locaux est créée pour cet appel.

La définition d’une fonction introduit le nom de la fonction dans la table de symboles courante. La valeur du nom de la fonction a un type qui est reconnu par l’interpréteur comme une fonction définie par l’utilisateur. Cette valeur peut être affectée à un autre nom qui peut alors être utilisé aussi comme une fonction. Ceci permet de disposer d’un mécanisme général de renommage :

>>> fib

 

>>> f = fib

>>> f(100)

1 1 2 3 5 8 13 21 34 55 89

Vous pourriez objecter que fib n’est pas une fonction mais une procédure. En Python, comme en C, les procédures sont juste des fonctions qui ne retournent pas de valeur. En fait, techniquement parlant, les procédures retournent bien une valeur, bien qu’elle soit plutoˆt décevante. Cette valeur est appelée None (c’est un nom intégré). La valeur None n’est normalement pas affichée par l’interpréteur si elle devait être la seule valeur écrite. Vous pouvez le vérifier si vous y tenez vraiment :



1 En réalité, passage par référence d’objet serait une meilleure description, puisque si un objet modifiable est passé, l’appelant verra tous les changements que l’appelé y effectue (par ex., des éléments insérés dans une liste).

 >>> print fib(0) None

Ecrire une fonction qui retourne une liste des nombres de la suite de Fibonacci, au lieu de les imprimer, est très simple :

>>> def fib2(n): # retourne la série de Fibonacci jusqu’`a n

...            "Retourne une liste contenant la série de Fibonacci jusqu’`a n"

...            resultat = []

...            a, b = 0, 1

...            while b < n:

...            resultat.append(b)        # voir ci-dessous

...            a, b = b, a+b

...            return resultat

...

>>> f100 = fib2(100)       # on l’appelle

>>> f100              # écrire le résultat [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Cet exemple, comme d’habitude, démontre quelques nouvelles caractéristiques de Python :

–             L’instruction return termine une fonction en renvoyant une valeur. return sans une expression en argument est utilisé pour retourner depuis le milieu d’une procédure (aboutir à la fin termine aussi la procédure), auquel cas la valeur None est retournée.

–             L’instruction result.append(b) appelle une méthode de l’objet result. Une méthode est une fonction qui ‘appartient’ à un objet et est nommée obj.nommethode, ou` obj est un objet (cela pourrait être une expression), et nommethode est le nom d’une méthode qui est définie d’après le type de l’objet. Différents types définissent différentes méthodes. Les méthodes de types différents peuvent avoir le même nom sans que cela soit source d’am- bigu¨ıtés. (Il est possible de définir vos propres types d’objets et méthodes, en utilisant des classes, de la façon décrite en 9.) La méthode append() montrée précédemment, est définie pour les objets listes ; elle ajoute un nou- vel élément à la fin de la liste. Dans cet exemple, c’est équivalent à ‘result = result + [b]’, mais en plus performant.

4.7          Encore Plus sur la Définition de Fonctions

Il est aussi possible de définir des fonctions à nombre d’arguments variable. Il y a trois façons de faire, qui peuvent être combinées.

4.7.1      Valeurs d’Argument par Défaut

La technique la plus utile consiste à  spécifier une valeur par défaut pour un ou plusieurs arguments. Ceci crée une fonction qui peut être appelée avec moins d’arguments qu’il n’en a été défini, par ex.

 def demande_ok(question, tentatives=4, plainte=’Oui ou non, svp!’): while 1:

ok = raw_input(question)

if ok in (’o’, ’ou’, ’oui’): return 1

if ok in (’n’, ’no’, ’non’, ’niet’): return 0 tentatives = tentatives - 1

if tentatives < 0: raise IOError, ’utilisateur refusenik’ print plainte

Cette   fonction   peut   être   appelée   soit   comme   ceci   :   demande ok(’Etes vous sˆur de vouloir

quitter ?’)2  ou comme ceci : demande ok(’OK pour écrasement du fichier ?’, 2).

Les valeurs par défaut sont évaluées au moment de la définition de la fonction dans la portée de définition, ainsi par ex.

i = 5

def f(arg = i): print arg i = 6

f()

affichera 5.

Avertissement important : La valeur par défaut est évaluée seulement une fois. Ceci est important lorsque la valeur par défaut est un objet modifiable comme une liste ou un dictionnaire. Par exemple, la fonction suivante accumule les arguments qui lui sont passés au fur et à mesure des appels :

def f(a, l = []): l.append(a) return l

print f(1) print f(2) print f(3)

Ceci affichera

[1]

[1, 2]

[1, 2, 3]

Si vous ne voulez pas que la valeur par défaut soit partagée entre des appels successifs, vous pouvez plutoˆt écrire la fonction comme ceci :

def f(a, l = None): if l is None:

l = []

l.append(a) return l

2 NDT : l’accent circomflexe sur le “u” de “sur” s’affiche assez mal chez nous. Désolé, mais notre compétence en LaTeX est limitée. Merci de nous signaler le correctif.

 4.7.2     Arguments à Mot-Clé

Les fonctions peuvent aussi être appelées en utilisant des arguments mots-clés de la forme ‘motcle  = valeur’. Par exemple, la fonction suivante :

def perroquet(voltage, etat=’c\’est du solide’, action=’voom’, type=’Bleu Norvégien’): print "-- Ce perroquet ne fera pas", action,

print "si vous le mettez sous", voltage, "Volts." print "-- Beau plumage, le", typeprint "-- Ca", etat, "!"

pourrait être appelée de l’une des façons suivantes :

perroquet(1000)

perroquet(action = ’VOOOOOM’, voltage = 1000000)

perroquet(’un millier’, etat = ’fait bouffer les pissenlits par la racine’) perroquet(’un milion’, ’vous dégoute de la vie’, ’de bonds’)

mais les appels suivants seraient tous invalides :

perroquet()       # manque un argument obligatoire perroquet(voltage=5.0, ’rend mort’)           # un argument non-mot-clé suit un mot-clé perroquet(110, voltage=220)   # doublon de valeurs pour un argument perroquet(acteur=’John Cleese’)           # mot-clé inconnu

En général, une liste d’arguments doit être constituée de tous les arguments de position, suivis de tous les arguments mots-clés, ou` ces mots-clés doivent être choisis parmi les noms des paramètres formels. Il n’est pas important qu’un paramètre formel ait une valeur par défaut ou non. Aucun argument ne peut recevoir une valeur plus d’une fois — les noms de paramètre formel correspondant aux arguments de position ne peuvent être utilisés comme mots-clés dans les mêmes appels.

>>> def function(a):

...            pass

...

>>> function(0, a=0) Traceback (innermost last):

File "", line 1, in ?

TypeError: keyword parameter redefined

Quand un paramètre formel de la forme **nom est présent en dernière position, il reçoit un dictionnaire contenant tous les arguments mots-clés dont les mots-clés ne correspondent pas à un paramètre formel. Ceci peut être combiné avec un paramètre formel de la forme *nom (décrit dans la sous-section suivante) qui reçoit un tuple contenant les arguments positionnels au-delà de la liste de paramètres formels. (*nom doit être placé avant **nom.) Par exemple, nous définissons une fonction comme ceci :

def fromagerie(type, *arguments, **motcles): print "-- Avez-vous du", type, ’?’

print "-- Je suis désolé, plus personne n’a de", type for arg in arguments: print arg

print ’-’*40

for mc in motcles.keys(): print mc, ’:’, motcles[mc]

Elle pourrait être appelée comme ceci :

fromagerie(’Camembert’, "Il est très coulant, monsieur.", "Il est vraiment très, TRES coulant, monsieur.", client=’John Cleese’,

proprietaire=’Michael Palin’, sketch=’Sketch de la Fromagerie’ )

et bien sûr, elle écrirait :

-- Avez-vous du Camembert ?

-- Je suis désolé, plus personne n’a de Camembert Il est très coulant, monsieur.

Il est vraiment très, TRES coulant, monsieur.

----------------------------------------

client : John Cleese proprietaire : Michael Palin sketch : Sketch de la Fromagerie

4.7.3      Listes d’Arguments Arbitraires

Finalement, l’option la moins fréquemment utilisée est de spécifier qu’une fonction peut être appelée avec un nombre d’arguments arbitraire. Ces arguments seront récupérés dans un tuple. Avant le nombre variable d’arguments, zéro ou plus arguments normaux pourraient être présents.

def fprintf(fichier, format, *args): fichier.write(format % args)

4.7.4      Les Formes Lambda

Suite à la demande populaire, quelques caractéristiques trouvées habituellement dans les langages de programmation fonctionnelle et dans Lisp ont été ajoutées à Python. Avec le mot-clé lambda, de petites fonctions anonymes peuvent être créées. Voici une fonction qui retourne la somme de ses deux arguments : ‘lambda a, b : a+b’. Les formes Lambda peuvent être utilisées chaque fois qu’un objet fonction est requis. Elles sont limitées syntaxiquement à une expression unique. Sémantiquement, elles sont juste de l’enrobage syntaxique pour une définition de fonction normale. Comme les définitions de fonctions imbriquées, les formes lambda ne peuvent pas faire référence à des variables de la portée qui les contient, mais ceci peut être surpassé en utilisant judicieusement les valeurs des arguments par défaut, par ex.

def fabrique_incrementeur(n): return lambda x, incr=n: x+incr



2386