Éléments Essentiels de La Programmation en Python: Module 4: Dans Ce Module, Vous Découvrirez

Éléments essentiels de la programmation en Python: Module 4
Dans ce module, vous découvrirez :
• Définir et utiliser des fonctions ;

• Différentes façons de passer des arguments ;
• Portées de nom ;
• Tuples et dictionnaires ;
• Traitement de l'information.
Pourquoi a-t-on des fonctions ?

Jusqu'à présent, vous avez rencontré des fonctions à plusieurs reprises, mais l'opinion sur leurs mérites que nous vous avons
donnée est plutôt unilatérale. Vous avez uniquement invoqué les fonctions en les utilisant comme des outils pour vous
faciliter la vie et pour simplifier les tâches longues et fastidieuses.
Lorsque vous souhaitez que certaines données soient imprimées sur la console, vous utilisez print () . Lorsque vous
souhaitez lire la valeur d'une variable, vous utilisez input () , couplé à int () ou float () .
Vous avez également utilisé certaines méthodes, qui sont en fait des fonctions, mais déclarées de manière très spécifique.
Vous allez maintenant apprendre à écrire vos propres fonctions et à les utiliser. Nous allons écrire plusieurs fonctions
ensemble, du très simple au plutôt complexe, ce qui nécessitera votre concentration et votre attention.
Il arrive souvent qu'un morceau de code particulier soit répété plusieurs fois dans votre programme. Il est répété soit
littéralement, soit avec seulement quelques modifications mineures, consistant en l'utilisation d'autres variables dans le
même algorithme. Il arrive également qu'un programmeur ne puisse pas résister à la simplification du travail et commence à
cloner de tels morceaux de code à l'aide des opérations de presse-papiers et de copier-coller.
Cela pourrait devenir très frustrant quand il s'avère soudainement qu'il y avait une erreur dans le code cloné. Le
programmeur aura beaucoup de corvée pour trouver tous les endroits qui nécessitent des corrections. Il existe également un
risque élevé que les corrections provoquent des erreurs.
Nous pouvons maintenant définir la première condition qui peut vous aider à décider quand commencer à écrire vos propres
fonctions : si un fragment particulier du code commence à apparaître à plusieurs endroits, envisagez la possibilité de
l'isoler sous la forme d'une fonction invoquée depuis les points où le code d'origine a été placé auparavant.
Il peut arriver que l'algorithme que vous allez implémenter soit si complexe que votre code commence à se développer de
manière incontrôlée, et soudain vous remarquez que vous n'êtes plus en mesure de le parcourir si facilement.
Vous pouvez essayer de résoudre le problème en commentant le code en détail, mais vous constaterez rapidement que cela
aggrave considérablement votre situation - trop de commentaires rendent le code plus volumineux et plus difficile à
lire. Certains disent qu'une fonction bien écrite doit être considérée d'un seul coup d'œil.
Un bon développeur attentif divise le code (ou plus précisément : le problème) en morceaux bien isolés et les code chacun
sous la forme d'une fonction.
Cela simplifie considérablement le travail du programme, car chaque morceau de code peut être codé séparément et testé
séparément. Le processus décrit ici est souvent appelé décomposition.
Nous pouvons maintenant énoncer la deuxième condition : si un morceau de code devient si volumineux que sa lecture
et sa sous-estimation peuvent causer un problème, envisagez de le diviser en problèmes distincts et plus petits et
implémentez chacun d'eux sous la forme d'une fonction distincte.
Cette décomposition se poursuit jusqu'à ce que vous obteniez un ensemble de fonctions courtes, faciles à comprendre et à
tester.
Décomposition
Il arrive souvent que le problème soit si important et complexe qu'il ne puisse pas être attribué à un seul développeur, et
qu'une équipe de développeurs doit y travailler. Le problème doit être réparti entre plusieurs développeurs de manière à
garantir leur coopération efficace et transparente.
Il semble inconcevable que plus d'un programmeur écrive le même morceau de code en même temps, donc le travail
doit être réparti entre tous les membres de l'équipe.
Ce type de décomposition a un objectif différent de celui décrit précédemment - il ne s'agit pas seulement de partager le
travail, mais aussi de partager la responsabilité entre de nombreux développeurs.
Chacun d'eux écrit un ensemble de fonctions clairement définies et décrites, qui une fois combinées dans le module
(nous vous en parlerons un peu plus tard) donnera le produit final.
Cela nous amène directement à la troisième condition : si vous allez diviser le travail entre plusieurs programmeurs,
décomposez le problème pour permettre au produit d'être implémenté sous la forme d'un ensemble de
fonctions écrites séparément regroupées dans différents modules.
D'où viennent les fonctions ?

En général, les fonctions proviennent d'au moins trois endroits :
• à partir de Python lui-même - de nombreuses fonctions (comme print () ) font partie intégrante de Python et sont
toujours disponibles sans effort supplémentaire de la part du programmeur ; nous appelons ces fonctions des fonctions
intégrées ;
• à partir des modules préinstallés de Python - de nombreuses fonctions, très utiles, mais utilisées beaucoup moins souvent
que celles intégrées, sont disponibles dans un certain nombre de modules installés avec Python ; l'utilisation de ces fonctions
nécessite quelques étapes supplémentaires de la part du programmeur afin de les rendre entièrement accessibles (nous vous
en parlerons dans un moment);
• directement à partir de votre code - vous pouvez écrire vos propres fonctions, les placer dans votre code et les utiliser
librement ;
• il existe une autre possibilité, mais elle est liée aux classes, nous allons donc l'omettre pour l'instant.
Votre première fonction

Jetez un œil à l'extrait dans l'éditeur.
print("Enter a value: ")
a = int(input())
b = int(input())
c = int(input())
C'est assez simple, mais nous voulons seulement que ce soit un exemple de transformation d'une partie répétitive
d'un code en fonction.
Les messages envoyés à la console par la fonction print() sont toujours les mêmes. Bien sûr, il n'y a rien de vraiment
mauvais dans un tel code, mais essayez d'imaginer ce que vous auriez à faire si votre patron vous demandait de
changer le message pour le rendre plus poli, par exemple, pour le commencer par la phrase "Please," .
Il semble que vous deviez passer du temps à changer toutes les occurrences du message (vous utiliseriez un presse-
papiers, bien sûr, mais cela ne vous faciliterait pas la vie). Il est évident que vous commettriez probablement des erreurs
pendant le processus de modification, et vous (et votre patron) seriez un peu frustré.
Est-il possible de séparer une partie aussi reproductible du code, de la nommer et de la rendre réutilisable ? Cela
signifierait qu'un changement effectué une fois au même endroit serait propagé à tous les endroits où il est
utilisé.
Bien sûr, un tel code ne devrait fonctionner que lorsqu'il est explicitement lancé.
Oui c'est possible. C'est exactement à cela que servent les fonctions.
Votre première fonction

Comment faites-vous une telle fonction ?
Vous devez le définir. Le mot définir est significatif ici.
Voici à quoi ressemble la définition de fonction la plus simple :
def functionName():
functionBody
• Il commence toujours par le mot-clé def (pour définir)

• Ensuite def le nom de la fonction (les règles pour nommer les fonctions sont exactement les mêmes que pour
nommer les variables)
• Après le nom de la fonction, il y a une place pour une paire de parenthèses (elles ne contiennent rien ici, mais
cela changera bientôt)
• La ligne doit être terminée par deux points ;
• La ligne directement après def commence le corps de la fonction - un couple (au moins un)
d’instructions nécessairement imbriquées, qui seront exécutées chaque fois que la fonction est invoquée
; remarque : la fonction se termine là où se termine l’imbrication, vous devez donc être prudent.
Nous sommes prêts à définir notre fonction d’invite . Nous allons le nommer message - le voici :
def message():
La fonction est extrêmement simple, mais entièrement utilisable. Nous l'avons nommé message , mais vous pouvez
l'étiqueter selon votre goût. Utilisons-le.
Notre code contient maintenant la définition de la fonction :
def message():
print("We start here.")

print("We end here.")
Remarque : nous n'utilisons pas du tout la fonction - il n'y a aucune invocation à l'intérieur du code.
Lorsque vous l'exécutez, vous voyez la sortie suivante :
We start here.
We end here.
Cela signifie que Python lit les définitions de la fonction et s'en souvient, mais ne lancera aucune d'entre elles sans votre
permission.
Nous avons modifié le code maintenant - nous avons inséré l’invocation de la fonction entre les messages de début et
de fin :
def message():

message()
La sortie semble différente maintenant :
We start here.
Enter a value:
We end here.
Testez le code, modifiez-le, expérimentez-le.
Fonctionnement des fonctions

Regardez l'image ci-dessous :
Il essaie de vous montrer tout le processus :
• Lorsque vous appelez une fonction, Python se souvient de l'endroit où cela s'est produit et saute dans la fonction
invoquée ;
• Le corps de la fonction est alors exécuté ;
• Atteindre la fin de la fonction force Python à retourner à l'endroit directement après le point d'invocation.
Il y a deux captures très importantes. Voici le premier d'entre eux :

Vous ne devez pas invoquer une fonction qui n'est pas connue au moment de l'invocation.
N'oubliez pas - Python lit votre code de haut en bas. Il ne va pas regarder de l'avant pour trouver une fonction que vous avez
oublié de mettre au bon endroit ("droit" signifie "avant l'invocation".)
Nous avons inséré une erreur dans ce code - voyez-vous la différence ?

message()
def message():
Nous avons déplacé la fonction à la fin du code. Python est-il capable de le trouver lorsque l'exécution atteint l’invocation ?
Non, ça ne l'est pas. Le message d'erreur indiquera :
NameError: name 'message' is not defined
N'essayez pas de forcer Python à rechercher des fonctions que vous n'avez pas fournies au bon moment.
La deuxième prise semble un peu plus simple :
Vous ne devez pas avoir une fonction et une variable du même nom.
L'extrait suivant est erroné :
def message():
message = 1
L'attribution d'une valeur au message de nom fait que Python oublie son rôle précédent. La fonction nommée message
devient indisponible.
Heureusement, vous êtes libre de mélanger votre code avec des fonctions - vous n'êtes pas obligé de mettre toutes vos
fonctions en haut de votre fichier source.
Regardez l'extrait de code :
def message():
message()
Cela peut sembler étrange, mais c'est tout à fait correct et fonctionne comme prévu.
Revenons à notre exemple principal et utilisons la fonction pour le bon travail, comme ici:
def message():
message()
a = int(input())
message()
b = int(input())
message()
c = int(input())
La modification du message d'invite est maintenant facile et claire - vous pouvez le faire en changeant le code en un seul
endroit - à l'intérieur du corps de la fonction.
Ouvrez le bac à sable et essayez de le faire vous-même.
Points clés à retenir

1. Une fonction est un bloc de code qui exécute une tâche spécifique lorsque la fonction est appelée (invoquée). Vous pouvez
utiliser des fonctions pour rendre votre code réutilisable, mieux organisé et plus lisible. Les fonctions peuvent avoir des
paramètres et des valeurs de retour.
2. Il existe au moins quatre types de fonctions de base en Python :
• Fonctions intégrées qui font partie intégrante de Python (comme la fonction print() ). Vous pouvez voir une liste
complète des fonctions intégrées de Python sur https://docs.python.org/3/library/functions.html .
• Ceux qui proviennent de modules préinstallés (vous en apprendrez plus à leur sujet dans le module 5 de ce cours)
• Fonctions définies par l'utilisateur qui sont écrites par les utilisateurs pour les utilisateurs - vous pouvez écrire vos
propres fonctions et les utiliser librement dans votre code,
• Les fonctions lambda (vous les découvrirez dans le module 6 de ce cours.)
3. Vous pouvez définir votre propre fonction à l'aide du mot - clé def et de la syntaxe suivante:
def yourFunction(optional parameters):

# the body of the function
Vous pouvez définir une fonction qui ne prend aucun argument, par exemple :
def message(): # defining a function

print("Hello") # body of the function
message() # calling the function
Vous pouvez également définir une fonction qui accepte des arguments, tout comme la fonction à un paramètre ci-dessous :
def hello(name): # defining a function

print("Hello,", name) # body of the function
name = input("Enter your name: ")
hello(name) # calling the function
Nous vous en dirons plus sur les fonctions paramétrées dans la section suivante. Ne t'inquiète pas.
Exercice 1
La fonction input() est un exemple de:
a) fonction définie par l'utilisateur

b) fonction intégrée
Vérifier
Exercice 2
Que se passe-t-il lorsque vous essayez d'appeler une fonction avant de la définir ? Exemple :
hi ()
def hi():
print("hi!")
Vérifier
Exercice 3
Que se passera-t-il lorsque vous exécuterez le code ci-dessous ?
def hi():
print("hi")
hi(5)
Vérifier
Fonctions paramètrées
La pleine puissance de la fonction se révèle lorsqu'elle peut être équipée d'une interface capable d'accepter les données
fournies par l'invocateur. Ces données peuvent modifier le comportement de la fonction, la rendant plus flexible et adaptable
aux conditions changeantes.
Un paramètre est en fait une variable, mais deux facteurs importants rendent les paramètres différents et spéciaux:
• les paramètres n'existent qu'à l'intérieur des fonctions dans lesquelles ils ont été définis, et le seul endroit où le
paramètre peut être défini est un espace entre une paire de parenthèses dans l'instruction def ;
• l'attribution d'une valeur au paramètre se fait au moment de l'appel de la fonction, en spécifiant l'argument
correspondant.
def function(parameter):
###
N'oubliez pas:
• les paramètres vivent à l'intérieur des fonctions (c'est leur environnement naturel)
• les arguments existent en dehors des fonctions et sont porteurs de valeurs passées aux paramètres
correspondants.
Il existe une frontière claire et sans ambiguïté entre ces deux mondes.
Enrichissons la fonction ci-dessus avec un seul paramètre - nous allons l'utiliser pour montrer à l'utilisateur le numéro d'une
valeur demandée par la fonction.
Nous devons reconstruire la déclaration def - voici à quoi cela ressemble maintenant:
def message(number):
###
La définition spécifie que notre fonction fonctionne sur un seul paramètre nommé number. Vous pouvez l'utiliser comme
variable ordinaire, mais uniquement à l'intérieur de la fonction - elle n'est visible nulle part ailleurs.
Améliorons maintenant le corps de la fonction:
print("Enter a number:", number)
Nous avons utilisé le paramètre. Remarque: nous n'avons attribué aucune valeur au paramètre. Est-ce correct?
Oui, ça l'est.
Une valeur pour le paramètre arrivera de l'environnement de la fonction.
N'oubliez pas: la spécification d'un ou plusieurs paramètres dans la définition d'une fonction est également une
exigence, et vous devez la remplir lors de l'appel. Vous devez fournir autant d'arguments qu'il y a de paramètres définis.
Ne pas le faire entraînera une erreur.
Essayez d'exécuter le code dans l'éditeur.

Voici ce que vous verrez dans la console:
TypeError: message() missing 1 required positional argument: 'number'
Cela semble mieux, bien sûr:

message(1)
De plus, il se comporte mieux. Le code produira la sortie suivante:

Enter a number: 1
Pouvez-vous voir comment cela fonctionne? La valeur de l'argument utilisé lors de l'appel (1) a été transmise à la
fonction, définissant la valeur initiale du paramètre nommé number .
Nous devons vous sensibiliser à une circonstance importante.
Il est légal et possible d'avoir une variable nommée de la même manière qu'un paramètre de fonction.
L'extrait illustre le phénomène:
number = 1234
message(1)
print(number)
Une situation comme celle-ci active un mécanisme appelé shadowing:
• le paramètre x masque toute variable du même nom, mais ...
• ... uniquement à l'intérieur de la fonction définissant le paramètre.
Le paramètre nommé number est une entité complètement différente de la variable nommée number .
Cela signifie que l'extrait ci-dessus produira la sortie suivante:

Enter a number: 1
1234
Une fonction peut avoir autant de paramètres que vous le souhaitez, mais plus vous en avez, plus il est difficile de
mémoriser leurs rôles et leurs objectifs.
Modifions la fonction - elle a maintenant deux paramètres:

def message(what, number):
print("Enter", what, "number", number)
Cela signifie également que l'invocation de la fonction nécessitera deux arguments.
Le premier nouveau paramètre est destiné à porter le nom de la valeur souhaitée.
C'est ici:
def message(what, number):
print("Enter", what, "number", number)
message("telephone", 11)
message("price", 5)
message("number", "number")
Voici la sortie que vous allez voir:
Enter telephone number 11
Enter price number 5
Enter number number number
Exécutez le code, modifiez-le, ajoutez plus de paramètres et voyez comment cela affecte la sortie.
Passage de paramètre positionnel

Une technique qui attribue le ième (premier, deuxième, etc.) argument au paramètre de la fonction iième (premier,
deuxième et ainsi de suite) est appelée passage de paramètre positionnel, tandis que les arguments passés de cette
manière sont appelés arguments positionnels.
Vous l'avez déjà utilisé, mais Python peut offrir beaucoup plus. Nous allons vous en parler maintenant.
def myFunction(a, b, c):
print(a, b, c)
myFunction(1, 2, 3)
Remarque: le passage de paramètres positionnels est intuitivement utilisé par les gens dans de nombreuses occasions
sociales. Par exemple, il peut être généralement admis que lorsque nous nous présentons, nous mentionnons nos
prénoms avant notre nom de famille, par exemple, "Mon nom est John Doe".
Soit dit en passant, les Hongrois le font dans l'ordre inverse.
Implémentons cette coutume sociale en Python. La fonction suivante sera chargée de présenter quelqu'un:
def introduction(firstName, lastName):
print("Hello, my name is", firstName, lastName)
introduction("Luke", "Skywalker")
introduction("Jesse", "Quick")
introduction("Clark", "Kent")
Pouvez-vous deviner la sortie? Exécutez le code et découvrez si vous aviez raison.
Imaginez maintenant que la même fonction soit utilisée en Hongrie. Dans ce cas, le code ressemblerait à ceci:
introduction("Skywalker", "Luke")
introduction("Quick", "Jesse")
introduction("Kent", "Clark")
La sortie sera différente. Peux-tu le deviner?
Exécutez le code pour voir si vous étiez ici aussi. Êtes-vous surpris?
Pouvez-vous rendre la fonction plus indépendante de la culture?
Argument de mot-clé passant

Python propose une autre convention pour le passage d'arguments, où la signification de l'argument est dictée par son
nom, et non par sa position - c'est ce qu'on appelle le passage d'argument par mot clé.
Jetez un œil à l'extrait:
introduction(firstName = "James", lastName = "Bond")
introduction(lastName = "Skywalker", firstName = "Luke")
Le concept est clair - les valeurs transmises aux paramètres sont précédées du nom des paramètres cibles, suivi du
signe =.
La position n'a pas d'importance ici - la valeur de chaque argument connaît sa destination sur la base du nom utilisé.
Vous devriez pouvoir prédire la sortie. Exécutez le code pour vérifier si vous aviez raison.
Bien sûr, vous ne devez pas utiliser un nom de paramètre inexistant.
L'extrait de code suivant provoquera une erreur d'exécution :
introduction(surname="Skywalker", firstName="Luke")
C'est ce que Python vous dira:
TypeError: introduction() got an unexpected keyword argument 'surname'
Essayez-le vous-même.
Mélanger les arguments de position et de mot-clé

Vous pouvez mélanger les deux modes si vous le souhaitez - il n'y a qu'une seule règle incassable: vous devez mettre
les arguments positionnels avant les arguments mot-clé.
Si vous réfléchissez un instant, vous devinerez certainement pourquoi.

Pour vous montrer comment cela fonctionne, nous utiliserons la fonction simple à trois paramètres suivants :
def adding(a, b, c):

print(a, "+", b, "+", c, "=", a + b + c)
Son but est d'évaluer et de présenter la somme de tous ses arguments.
La fonction, lorsqu'elle est invoquée de la manière suivante :
adding(1, 2, 3)
affichera :
1 + 2 + 3 = 6
C'était - comme vous pouvez le soupçonner - un pur exemple de passage d'arguments positionnels.
Bien sûr, vous pouvez remplacer une telle invocation par une variante purement mot-clé, comme celle-ci :
adding(c = 1, a = 2, b = 3)
Notre programme affichera une ligne comme celle-ci :
2 + 3 + 1 = 6
Notez l'ordre des valeurs.
Essayons maintenant de mélanger les deux styles.
Regardez l'invocation de fonction ci-dessous :
adding(3, c = 1, b = 2)
Analysons-le:
• l'argument (3) pour le paramètre a est passé en utilisant la manière positionnelle ;
• les arguments pour c et b sont spécifiés comme mots-clés.
Voici ce que vous verrez dans la console :
3 + 2 + 1 = 6
Soyez prudent et méfiez-vous des erreurs. Si vous essayez de passer plusieurs valeurs à un seul argument, vous
n'obtiendrez qu'une erreur d'exécution.
Regardez l'invocation ci-dessous - il semble que nous ayons essayé de définir a deux fois :
adding(3, a = 1, b = 2)
Réponse de Python :
TypeError: adding() got multiple values for argument 'a'
Regardez le snipet ci-dessous. Un code comme celui-ci est tout à fait correct, mais cela n'a pas beaucoup de sens :
adding(4, 3, c = 2)
Tout va bien, mais laisser dans un seul mot-clé semble un peu bizarre - qu'en pensez-vous?
Fonctions paramétrées - plus de details

Il arrive parfois que les valeurs d'un paramètre particulier soient utilisées plus souvent que d'autres. Ces arguments
peuvent avoir leurs valeurs par défaut (prédéfinies) prises en considération lorsque leurs arguments correspondants
ont été omis.
Ils disent que le nom de famille anglais le plus populaire est Smith. Essayons de prendre cela en compte.
La valeur du paramètre par défaut est définie à l'aide d'une syntaxe claire et illustrée :
def introduction(firstName, lastName="Smith"):
print("Hello, my name is", fistName, lastName)
Vous n'avez qu'à étendre le nom du paramètre avec le signe =, suivi de la valeur par défaut.
Appelons la fonction comme d'habitude :
introduction("James", "Doe")
Pouvez-vous deviner la sortie du programme ? Exécutez-le et vérifiez si vous aviez raison.
Et ? Tout se ressemble, mais lorsque vous invoquez la fonction d'une manière qui semble un peu suspecte à première
vue, comme ceci :
introduction("Henry")
ou ceci:
introduction(firstName="William")
il n'y aura pas d'erreur et les deux appels réussiront, tandis que la console affichera la sortie suivante :
Hello, my name is Henry Smith
Hello, my name is William Smith

Essaye-le.
Vous pouvez aller plus loin si c'est utile. Les deux paramètres ont maintenant leurs valeurs par défaut, regardez le code
ci-dessous:
def introduction(firstName="John", lastName="Smith"):
Cela rend l'invocation suivante absolument valide :
introduction()
Et c'est la sortie attendue :
Hello, my name is John Smith
Si vous utilisez un argument de mot-clé, le reste prendra la valeur par défaut :
introduction(lastName="Hopkins")
La sortie est :
Hello, my name is John Hopkins
Testez le.
Félicitations - vous venez d'apprendre les moyens de base de communiquer avec les fonctions.

1. Vous pouvez transmettre des informations aux fonctions à l'aide de paramètres. Vos fonctions peuvent avoir autant de
paramètres que vous le souhaitez.
Un exemple de fonction à un paramètre:
def hi(name):
print("Hi,", name)
hi("Greg")
Un exemple de fonction à deux paramètres:
def hiAll(name1, name2):

print("Hi,", name2)
print("Hi,", name1)
hiAll("Sebastian", "Konrad")
Un exemple de fonction à trois paramètres:
def address(street, city, postalCode):

print("Your address is:", street, "St.,", city, postalCode)
s = input("Street: ")
pC = input("Postal Code: ")
c = input("City: ")
address(s, c, pC)
2. Vous pouvez passer des arguments à une fonction en utilisant les techniques suivantes:
• passage de l'argument positionnel dans lequel l'ordre des arguments a réussi (Ex. 1),
• passage d'un mot clé (nommé) dans lequel l'ordre des arguments transmis n'a pas d'importance (Ex.2),
• un mélange d'arguments positionnels et de mots-clés passant (Ex. 3).
Ex. 1
def subtra(a, b):
print(a - b)
subtra(5, 2) # outputs: 3
subtra(2, 5) # outputs: -3
Ex. 2
def subtra(a, b):
print(a - b)
subtra(a=5, b=2) # outputs: 3

subtra(b=2, a=5) # outputs: 3
Ex. 3
def subtra(a, b):
print(a - b)
subtra(5, b=2) # outputs: 3

subtra(5, 2) # outputs: 3
Il est important de se rappeler que les arguments positionnels ne doivent pas suivre les arguments des mots clés . C'est
pourquoi si vous essayez d'exécuter l'extrait de code suivant:
def subtra(a, b):
print(a - b)
subtra(5, b=2) # outputs: 3

subtra(a=5, 2) # Syntax Error
Python ne vous laissera pas le faire en signalant a SyntaxError .
3. Vous pouvez utiliser la technique de passage d'argument par mot clé pour prédéfinir une valeur pour un argument donné:
def name(firstN, lastN="Smith"):

print(firstN, lastN)
name("Andy") # outputs: Andy Smith

name("Betty", "Johnson") # outputs: Betty Johnson (the keyword argument replaced by
"Johnson")
Exercice 1
Quelle est la sortie de l'extrait de code suivant?
def intro(a="James Bond", b="Bond"):

print("My name is", b + ".", a + ".")
intro()
Exercice 2
def intro(a="James Bond", b="Bond"):

intro(b="Sean Connery")
Exercice 3

def intro(a, b="Bond"):
intro("Susan")
Exercice 4
def sum(a, b=2, c):

print(a + b + c)
sum(a=1, c=3)
Effets et résultats: l' instruction de retour

Toutes les fonctions présentées précédemment ont une sorte d'effet - elles produisent du texte et l'envoient à la console.
Bien sûr, les fonctions - comme leurs frères et sœurs mathématiques - peuvent avoir des résultats.
Pour que les fonctions renvoient une valeur (mais pas uniquement à cette fin), vous utilisez l' return instruction.
Ce mot vous donne une image complète de ses capacités. Remarque: c'est un mot-clé Python .
L' return instruction a deux variantes différentes - considérons-les séparément.
revenir sans expression

Le premier se compose du mot-clé lui-même, sans que rien ne le suive.
Lorsqu'il est utilisé à l'intérieur d'une fonction, il provoque l' arrêt immédiat de l'exécution de la fonction et un retour
instantané (d'où le nom) au point d'invocation .
Remarque: si une fonction n'est pas destinée à produire un résultat, l' utilisation de l' return instruction n'est pas
obligatoire - elle sera exécutée implicitement à la fin de la fonction.
Quoi qu'il en soit, vous pouvez l'utiliser pour terminer les activités d'une fonction à la demande , avant que le contrôle
n'atteigne la dernière ligne de la fonction.
Considérons la fonction suivante:
def happy_new_year(wishes = True):
print("Three...")
print("Two...")
print("One...")
if not wishes:
return
print("Happy New Year!")

Lorsqu'il est invoqué sans aucun argument:
happy_new_year()
La fonction provoque un peu de bruit - la sortie ressemblera à ceci:

Three...
Two...
One...
Happy New Year!
Fournir False comme argument:
happy_new_year(False)
modifiera le comportement de la fonction - l' return instruction provoquera sa fin juste avant les souhaits - c'est la sortie
mise à jour:
Three...
Two...
One...
revenir avec une expression

La deuxième return variante est complétée par une expression :
def function():
return expression
Il y a deux conséquences à l'utiliser:
• il provoque l' arrêt immédiat de l'exécution de la fonction (rien de nouveau par rapport à la première variante)
• de plus, la fonction évaluera la valeur de l'expression et la renverra (d'où le nom une fois de plus) comme
résultat de la fonction .
Oui, nous le savons déjà - cet exemple n'est pas vraiment sophistiqué:
def boring_function():
return 123
x = boring_function()
print("The boring_function has returned its result. It's:", x)
L'extrait de code écrit le texte suivant dans la console:
The boring_function has returned its result. It's: 123
Examinons-le pendant un certain temps.

Analysez la figure ci-
dessous:
L'instruction return , enrichie de l'expression (l'expression est très simple ici), "transporte" la valeur de l'expression à
l'endroit où la fonction a été invoquée.
Le résultat peut être librement utilisé ici, par exemple, pour être affecté à une variable.
Il peut également être complètement ignoré et perdu sans laisser de trace.
Remarque, nous ne sommes pas trop polis ici - la fonction renvoie une valeur, et nous l'ignorons (nous ne l'utilisons en
aucune façon):
def boring_function():
print("'Boredom Mode' ON.")
return 123
print("This lesson is interesting!)
boring_function()
print("This lesson is boring...")
Le programme produit la sortie suivante:
This lesson is interesting!
'Boredom Mode' ON.
This lesson is boring...
Est-ce punissable? Pas du tout.
Le seul inconvénient est que le résultat a été irrémédiablement perdu.
N'oubliez pas:
• vous êtes toujours autorisé à ignorer le résultat de la fonction et à être satisfait de l'effet de la fonction (si la
fonction en a)
• si une fonction est destinée à renvoyer un résultat utile, elle doit contenir la deuxième variante de
l' return instruction.
Attendez une minute - cela signifie-t-il qu'il y a aussi des résultats inutiles? Oui - dans un certain sens.
Quelques mots sur None
Laissez-nous vous présenter une valeur très curieuse (pour être honnête, une valeur nulle) nommée None .
Ses données ne représentent aucune valeur raisonnable - en fait, ce n'est pas du tout une valeur; par conséquent, il ne
doit participer à aucune expression .
Par exemple, un extrait comme celui-ci:
print(None + 2)
provoquera une erreur d'exécution, décrite par le message de diagnostic suivant:
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
Remarque: None est un mot - clé .
Il n'y a que deux types de circonstances qui None peuvent être utilisées en toute sécurité:
• lorsque vous l' affectez à une variable (ou le retournez comme résultat d'une fonction )
• lorsque vous le comparez à une variable pour diagnostiquer son état interne.
Comme ici:
value = None
if value is None:
print("Sorry, you don't carry any value")
N'oubliez pas ceci: si une fonction ne retourne pas une certaine valeur en utilisant une return clause d'expression, on
suppose qu'elle renvoie implicitement None .
Testons-le.
Quelques mots sur None : suite

Jetez un œil au code dans l'éditeur.
def strangeFunction(n):
if(n % 2 == 0):
return True
Il est évident que la strangeFunction fonction retourne True lorsque son argument est pair.
Que retourne-t-il autrement?
Nous pouvons utiliser le code suivant pour le vérifier:
print(strangeFunction(2))
print(strangeFunction(1))
Voici ce que nous voyons dans la console:

True
None
Ne soyez pas surpris la prochaine fois que vous voyez None un résultat de fonction - cela peut être le symptôme d'une
erreur subtile à l'intérieur de la fonction.
Effets et résultats: listes et fonctions

Il y a deux questions supplémentaires auxquelles il faut répondre ici.
La première est: une liste peut-elle être envoyée à une fonction comme argument?
Bien sûr que oui! Toute entité reconnaissable par Python peut jouer le rôle d'un argument de fonction, bien qu'il doive
être assuré que la fonction est capable d'y faire face.
Donc, si vous passez une liste à une fonction, la fonction doit la gérer comme une liste.
Une fonction comme celle-ci ici:
def list_sum(lst):
s = 0
for elem in lst:
s += elem
return s
et invoqué comme ceci:
print(list_sum([5, 4, 3]))
reviendra 12 en conséquence, mais vous devriez vous attendre à des problèmes si vous l'invoquez de cette manière
risquée:
print(list_sum(5))
La réponse de Python sera sans équivoque:
TypeError: 'int' object is not iterable
Cela est dû au fait qu'une seule valeur entière ne doit pas être itérée par la for boucle .
Effets et résultats: listes et fonctions - suite

La deuxième question est: une liste peut-elle être un résultat de fonction?
Oui bien sûr! Toute entité reconnaissable par Python peut être un résultat de fonction.
Regardez le code dans l'éditeur.
def strangeListFunction(n):
strangeList = []
for i in range(0, n):
strangeList.insert(0, i)
return strangeList
print(strangeListFunction(5))
La sortie du programme sera comme ceci:
[4, 3, 2, 1, 0]
Vous pouvez maintenant écrire des fonctions avec et sans résultats.
Plongeons un peu plus profondément dans les problèmes liés aux variables dans les fonctions. Ceci est essentiel pour
créer des fonctions efficaces et sûres.
LABORATOIR
Temps éstimé
10-15 minutes
Niveau de difficulté
Facile
Objectifs
Familiariser l’apprenant avec:
• • projeter et écrire des fonctions paramétrées;

• • utiliser la déclaration de retour;
• • tester les fonctions.
Scénario
Votre tâche consiste à écrire et tester une fonction qui prend un argument (un an) et renvoie True si l'année est une
année bissextile, ou False sinon.
La graine de la fonction est déjà semée dans le code squelette de l'éditeur.
def isYearLeap(year):
# put your code here

#
testData = [1900, 2000, 2016, 1987]
testResults = [False, True, True, False]
for i in range(len(testData)):
yr = testData[i]
print(yr,"->",end="")
result = isYearLeap(yr)
if result == testResults[i]:
print("OK")
else:
print("Failed")
Remarque : nous avons également préparé un court code de test, que vous pouvez utiliser pour tester votre fonction.
Le code utilise deux listes - l'une avec les données de test et l'autre contenant les résultats attendus. Le code vous
indiquera si l'un de vos résultats n'est pas valide.
LABORATOIRE
Temps estimé
15-20 minutes
Moyen
Conditions préalables
LAB 4.1.3.6
Objectifs
Familiarisez l'étudiant avec:
• projeter et écrire des fonctions paramétrées;

• utiliser la déclaration de retour ;
• utiliser les propres fonctions de l'élève.
Scénario
Votre tâche consiste à écrire et tester une fonction qui prend deux arguments (un an et un mois) et renvoie le nombre de
jours pour la paire mois / année donnée (alors que seul février est sensible à la year valeur, votre fonction doit être
universelle).
La première partie de la fonction est prête. Maintenant, convainquez la fonction de revenir None si ses arguments n'ont
pas de sens.
Bien sûr, vous pouvez (et devez) utiliser la fonction précédemment écrite et testée (LAB 4.1.3.6). Cela peut être très
utile. Nous vous encourageons à utiliser une liste remplie des durées des mois. Vous pouvez le créer à l'intérieur de la
fonction - cette astuce raccourcira considérablement le code.
Nous avons préparé un code de test. Développez-le pour inclure plus de cas de test.
# your code from LAB 4.1.3.6
def daysInMonth(year, month):
# put your new code here
testYears = [1900, 2000, 2016, 1987]
testMonths = [2, 2, 1, 11]
testResults = [28, 29, 31, 30]
for i in range(len(testYears)):
yr = testYears[i]
mo = testMonths[i]
print(yr, mo, "->", end="")
result = daysInMonth(yr, mo)
if result == testResults[i]:
print("OK")
else:
print("Failed")
LABORATOIRE
Temps estimé
20-30 minutes
Moyen
Conditions préalables
LAB 4.1.3.6
LAB 4.1.3.7
Objectifs
Familiarisez l'étudiant avec:
• projeter et écrire des fonctions paramétrées;

• utiliser la déclaration de retour ;
• construire un ensemble de fonctions utilitaires;
• utiliser les propres fonctions de l'élève.
Scénario
Votre tâche consiste à écrire et tester une fonction qui prend trois arguments (une année, un mois et un jour du mois) et
retourne le jour correspondant de l'année, ou retourne None si l'un des arguments n'est pas valide.
Utilisez les fonctions précédemment écrites et testées. Ajoutez des cas de test au code. Ce test n'est qu'un début.
def daysInMonth(year, month):
def dayOfYear(year, month, day):
# put your new code here
print(dayOfYear(2000, 12, 31))
LABORATOIRE
Temps estimé
15-20 minutes
Moyen
Objectifs
• familiariser l'étudiant avec les notions et algorithmes classiques;
• améliorer les compétences de l'étudiant dans la définition et l'utilisation des fonctions.
Scénario
Un nombre naturel est premier s'il est supérieur à 1 et n'a pas de diviseurs autres que 1 et lui-même.
Compliqué? Pas du tout. Par exemple, 8 n'est pas un nombre premier, car vous pouvez le diviser par 2 et 4 (nous ne
pouvons pas utiliser des diviseurs égaux à 1 et 8, car la définition l'interdit).
En revanche, 7 est un nombre premier, car nous ne pouvons pas trouver de diviseurs légaux pour lui.
Votre tâche consiste à écrire une fonction vérifiant si un nombre est premier ou non.
La fonction:
• est appelé isPrime ;

• prend un argument (la valeur à vérifier)
• renvoie True si l'argument est un nombre premier, et False sinon.
Astuce: essayez de diviser l'argument par toutes les valeurs suivantes (à partir de 2) et vérifiez le reste - s'il est nul,
votre nombre ne peut pas être un nombre premier; réfléchissez bien au moment où vous devez arrêter le processus.
Si vous avez besoin de connaître la racine carrée d'une valeur, vous pouvez utiliser l' ** opérateur. Rappelez-vous: la
racine carrée de x est la même que x 0,5
Complétez le code dans l'éditeur.
def isPrime(num):
for i in range(1, 20):
if isPrime(i + 1):
print(i + 1, end=" ")
print()
Exécutez votre code et vérifiez si votre sortie est la même que la nôtre.
Données de test
Production attendue:
2 3 5 7 11 13 17 19
LABORATOIRE
Temps estimé
10-15 minutes
Facile
Objectifs
• améliorer les compétences de l'étudiant dans la définition, l'utilisation et le test des fonctions.
Scénario
La consommation de carburant d'une voiture peut s'exprimer de différentes manières. Par exemple, en Europe, il est
indiqué comme la quantité de carburant consommée pour 100 kilomètres.
Aux États-Unis, il est indiqué comme le nombre de kilomètres parcourus par une voiture utilisant un gallon de carburant.
Votre tâche consiste à écrire une paire de fonctions convertissant l / 100 km en mpg, et vice versa.
Les fonctions:
• sont nommés l100kmtompg et mpgtol100km respectivement;

• prendre un argument (la valeur correspondant à leurs noms)
Complétez le code dans l'éditeur.
def l100kmtompg(liters):
def mpgtol100km(miles):
print(l100kmtompg(3.9))
print(l100kmtompg(7.5))
print(l100kmtompg(10.))
print(mpgtol100km(60.3))
Exécutez votre code et vérifiez si votre sortie est la même que la nôtre.
Voici quelques informations pour vous aider:

• 1 mille américain = 1609,344 mètres;
• 1 gallon américain = 3,785411784 litres.
Données de test
Production attendue:
60.31143162393162
31.36194444444444
23.52145833333333
3.9007393587617467
7.490910297239916
10.009131205673757
1. Vous pouvez utiliser le return mot - clé pour indiquer à une fonction de renvoyer une valeur. L' return instruction quitte
la fonction, par exemple:
def multiply(a, b):
return a * b
print(multiply(3, 4)) # outputs: 12
def multiply(a, b):
return
print(multiply(3, 4)) # outputs: None
2. Le résultat d'une fonction peut être facilement affecté à une variable, par exemple:
def wishes():
return "Happy Birthday!"
w = wishes()
print(w) # outputs: Happy Birthday!
Regardez la différence de sortie dans les deux exemples suivants:
# Example 1
def wishes():
print("My Wishes")
return "Happy Birthday"
wishes() # outputs: My Wishes
# Example 2
def wishes():
print("My Wishes")
return "Happy Birthday"
print(wishes()) # outputs: My Wishes
# Happy Birthday
3. Vous pouvez utiliser une liste comme argument d'une fonction, par exemple:
def hiEverybody(myList):
for name in myList:
print("Hi,", name)
hiEverybody(["Adam", "John", "Lucy"])
4. Une liste peut également être un résultat de fonction, par exemple:
def createList(n):
myList = []
for i in range(n):
myList.append(i)
return myList
print(createList(5))
Exercice 1
def hi():
return
print("Hi!")
hi()
Exercice 2

def isInt(data):
if type(data) == int:
return True
elif type(data) == float:
return False
print(isInt(5))
print(isInt(5.0))
print(isInt("5"))
Exercice 3
def evenNumLst(ran):
lst = []
for num in range(ran):
if num % 2 == 0:
lst.append(num)
return lst
print(evenNumLst(11))
Exercice 4
def listUpdater(lst):
updList = []
for elem in lst:
elem **= 2
updList.append(elem)
return updList
l = [1, 2, 3, 4, 5]
print(listUpdater(l))
Fonctions et champs d'application

Commençons par une définition:
La portée d'un nom (par exemple, un nom de variable) est la partie d'un code où le nom est correctement
reconnaissable.
Par exemple, la portée du paramètre d'une fonction est la fonction elle-même. Le paramètre est inaccessible en dehors
de la fonction.
Vérifions-le. Regardez le code dans l'éditeur.
def scopeTest():
x = 123
scopeTest()
print(x)
Que se passera-t-il lorsque vous l'exécuterez?
Le programme échouera lors de son exécution. Le message d'erreur indiquera:
NameError: name 'x' is not defined
C'est à prévoir.
Nous allons mener quelques expériences avec vous pour vous montrer comment Python construit des étendues et
comment vous pouvez utiliser ses habitudes à votre avantage.
Fonctions et champs d'application: suite

Commençons par vérifier si une variable créée à l'extérieur d'une fonction est visible à l'intérieur des fonctions. En
d'autres termes, le nom d'une variable se propage-t-il dans le corps d'une fonction?
Regardez le code dans l'éditeur. Notre cochon d'Inde est là.
def myFunction():
print("Do I know that variable?", var)
var = 1
myFunction()
print(var)
Le résultat du test est positif - le code affiche:
Do I know that variable? 1

1
La réponse est: une variable existant en dehors d'une fonction a une portée à l'intérieur des corps des
fonctions .
Cette règle comporte une exception très importante. Essayons de le trouver.
Faisons un petit changement au code:
def myFunction():
var = 2
var = 1
myFunction()
print(var)
Le résultat a également changé - le code produit maintenant une sortie légèrement différente:

1
Que s'est il passé?
• la var variable créée à l'intérieur de la fonction n'est pas la même que lorsqu'elle est définie à l'extérieur - il
semble qu'il y ait deux variables différentes du même nom;
• de plus, la variable de la fonction masque la variable provenant du monde extérieur.
Nous pouvons rendre la règle précédente plus précise et adéquate:
Une variable existant en dehors d'une fonction a une portée à l'intérieur des corps des fonctions, à l'exclusion
de celles d'entre elles qui définissent une variable du même nom.
Cela signifie également que la portée d'une variable existante en dehors d'une fonction n'est prise en charge que
lors de l'obtention de sa valeur (lecture). L'attribution d'une valeur force la création de la propre variable de la fonction.
Assurez-vous de bien comprendre cela et effectuez vos propres expériences.
Fonctions et étendues: le mot-clé global

J'espère que vous devriez maintenant être parvenu à la question suivante: cela signifie-t-il qu'une fonction n'est pas en
mesure de modifier une variable définie en dehors d'elle? Cela créerait beaucoup d'inconfort.
Heureusement, la réponse est non .
Il existe une méthode Python spéciale qui peut étendre la portée d'une variable d'une manière qui inclut les corps
des fonctions (même si vous voulez non seulement lire les valeurs, mais aussi les modifier).
Un tel effet est provoqué par un mot-clé nommé global :
global name
global name1, name2, ...
L'utilisation de ce mot-clé dans une fonction avec le nom (ou les noms séparés par des virgules) d'une ou de plusieurs
variables, force Python à s'abstenir de créer une nouvelle variable à l'intérieur de la fonction - celle accessible de
l'extérieur sera utilisée à la place.
En d'autres termes, ce nom devient global (il a une portée globale et peu importe qu'il fasse l'objet d'une lecture ou
d'une affectation).
def myFunction():
global var
var = 2
var = 1
myFunction()
print(var)
Nous avons ajouté global à la fonction.
Le code génère désormais:
Cela devrait être une preuve suffisante pour montrer que le mot clé global fait ce qu'il promet.
Comment la fonction interagit avec ses arguments

Voyons maintenant comment la fonction interagit avec ses arguments.
Le code dans l'éditeur devrait vous apprendre quelque chose. Comme vous pouvez le voir, la fonction modifie la valeur
de son paramètre. Le changement affecte-t-il l'argument?
Exécutez le programme et vérifiez.
def myFunction(n):
print("I got", n)
n += 1
print("I have", n)
var = 1
myFunction(var)
print(var)
La sortie du code est:
I got 1
I have 2
1
La conclusion est évidente - la modification de la valeur du paramètre ne se propage pas en dehors de la

fonction (en tout cas, pas lorsque la variable est un scalaire, comme dans l'exemple).
Cela signifie également qu'une fonction reçoit la valeur de l'argument, pas l'argument lui-même. Cela est vrai pour les
scalaires.
Vaut-il la peine de vérifier comment cela fonctionne avec les listes (vous souvenez-vous des particularités de l'attribution
de tranches de liste par rapport à l'attribution de listes dans leur ensemble?).
L'exemple suivant éclairera le problème:
def myFunction(myList1):
print(myList1)
myList1 = [0, 1]
myList2 = [2, 3]
myFunction(myList2)
print(myList2)
La sortie du code est:
[2, 3]
[2, 3]
Il semble que l'ancienne règle fonctionne toujours.
Enfin, pouvez-vous voir la différence dans l'exemple ci-dessous:
def myFunction(myList1):
print(myList1)
del myList1[0]
myList2 = [2, 3]
myFunction(myList2)
print(myList2)
Nous ne changeons pas la valeur du paramètre myList1 (nous savons déjà que cela n'affectera pas l'argument), mais
modifions plutôt la liste identifiée par lui.
La sortie peut être surprenante. Exécutez le code et vérifiez:
[2, 3]
[3]
Pouvez-vous l'expliquer?
Essayons:
• si l'argument est une liste, la modification de la valeur du paramètre correspondant n'affecte pas la liste
(rappelez-vous: les variables contenant des listes sont stockées différemment des scalaires)
• mais si vous modifiez une liste identifiée par le paramètre (remarque: la liste, pas le paramètre!), la liste reflétera
le changement.
Il est temps d'écrire quelques exemples de fonctions. Vous le ferez dans la section suivante.
1. Une variable qui existe en dehors d'une fonction a une portée à l'intérieur du corps de la fonction (exemple 1) sauf si la
fonction définit une variable du même nom (exemple 2 et exemple 3), par exemple:
Exemple 1:
var = 2
def multByVar(x):
return x * var
print(multByVar(7)) # outputs: 14
Exemple 2:
def mult(x):
var = 5
return x * var
print(mult(7)) # outputs: 35
Exemple 3:
def multip(x):
var = 7
return x * var
var = 3
print(multip(7)) # outputs: 49
2. Une variable qui existe à l'intérieur d'une fonction a une portée à l'intérieur du corps de la fonction (exemple 4), par
exemple:
Exemple 4:
def adding(x):
var = 7
return x + var
print(adding(4)) # outputs: 11
print(var) # NameError
3. Vous pouvez utiliser le global mot - clé suivi d'un nom de variable pour rendre la portée de la variable globale, par
exemple:
var = 2
print(var) # outputs: 2
def retVar():
global var
var = 5
return var
print(retVar()) # outputs: 5
print(var) # outputs: 5
Exercice 1
Que se passe-t-il lorsque vous essayez d'exécuter le code suivant?
def message():
alt = 1
print("Hello, World!")
print(alt)
Exercice 2
a = 1
def fun():
a = 2
print(a)
fun()
print(a)
Exercice 3
a = 1
def fun():
global a
a = 2
print(a)
fun()
a = 3
print(a)
Exercice 4
a = 1
def fun():
global a
a = 2
print(a)
a = 3
fun()
print(a)
Quelques fonctions simples: évaluer l'IMC

Commençons par une fonction pour évaluer l'indice de masse corporelle (IMC).
Comme vous pouvez le voir, la formule obtient deux valeurs:
• poids (à l'origine en kilogrammes)
• hauteur (à l'origine en mètres)
Il semble que cette nouvelle fonction aura deux paramètres. Son nom sera bmi, mais si vous préférez un autre nom,
utilisez-le à la place.
Codons la fonction.
La fonction est complète ci-dessous (et dans la fenêtre de l'éditeur):
def bmi(weight, height):

return weight / height ** 2
print(bmi(52.5, 1.65))
Le résultat produit par l'exemple d'invocation se présente comme suit :
19.283746556473833
La fonction répond à nos attentes, mais c'est un peu simple - elle suppose que les valeurs des deux paramètres sont
toujours significatives. Cela vaut vraiment la peine de vérifier s'ils sont dignes de confiance.
Vérifions-les tous les deux et renvoyons None si l'un d'eux semble suspect.
Quelques fonctions simples: évaluer l'IMC et convertir les unités

impériales en unités métriques
Regardez le code dans l'éditeur. Il y a deux choses auxquelles nous devons prêter attention.
Tout d'abord, l'invocation du test garantit que la protection fonctionne correctement - la sortie est :
None
Deuxièmement, jetez un œil à la façon dont le symbole backslash ( \ ) est utilisé. Si vous l'utilisez dans du code Python
et terminez une ligne avec lui, il indiquera à Python de continuer la ligne de code dans la ligne de code suivante.
Cela peut être particulièrement utile lorsque vous devez gérer de longues lignes de code et que vous souhaitez
améliorer la lisibilité du code.
D'accord, mais il y a quelque chose que nous avons omis trop facilement - les mesures impériales. Cette fonction n'est
pas trop utile pour les personnes habituées aux livres, pieds et pouces.
Que peut-on faire pour eux?
Nous pouvons écrire deux fonctions simples pour convertir des unités impériales en unités métriques. Commençons
par les livres.
C'est un fait bien connu que 1 lb = 0.45359237 kg . Nous allons utiliser cela dans notre nouvelle fonction.
Ceci est notre fonction d'aide, nommée lbtokg :
def lbtokg(lb):
return lb * 0.45359237
print(lbtokg(1))
Le résultat de l'invocation du test semble bon :
0.45359237
Et maintenant il est temps pour les pieds et les pouces : 1 ft = 0.3048 m , and 1 in = 2.54 cm = 0.0254 m .
La fonction que nous avons écrite est nommée ftintom :
def ftintom(ft, inch):
return ft * 0.3048 + inch * 0.0254
print(ftintom(1, 1))
Le résultat d'un test rapide est:
0.3302
Il semble comme prévu.
Remarque: nous voulions nommer le deuxième paramètre uniquement in et pas inch, mais nous ne pouvions pas.
Est-ce que tu sais pourquoi?
in est un mot-clé Python - il ne peut pas être utilisé comme nom.
Convertissons six pieds en mètres:
print(ftintom(6, 0))
Et c'est la sortie :
1.8288000000000002
Il est tout à fait possible que vous souhaitiez parfois utiliser uniquement des pieds sans pouces. Python vous aidera-t-il?
Bien sur.
Nous avons un peu modifié le code:
def ftintom(ft, inch = 0.0):
return ft * 0.3048 + inch * 0.0254
print(ftintom(6))
Le paramètre inch a maintenant sa valeur par défaut égale à 0.0 .
Le code produit la sortie suivante - c'est ce qui est attendu:
1.8288000000000002
Enfin, le code est capable de répondre à la question : quel est l'IMC d'une personne de 5'7 "de haut et pesant 176 lbs ?
C'est le code que nous avons construit :
def ftintom(ft, inch = 0.0):
return ft * 0.3048 + inch * 0.0254
def lbstokg(lb):
return lb * 0.45359237
def bmi(weight, height):
if height < 1.0 or height > 2.5 or \
weight < 20 or weight > 200:
return None
return weight / height ** 2
print(bmi(weight = lbstokg(176), height = ftintom(5, 7)))

Et la réponse est :
27.565214082533313
Exécutez le code et testez-le.

Quelques fonctions simples : suite
Jouons maintenant avec les triangles. Nous allons commencer par une fonction pour vérifier si trois côtés de longueurs
données peuvent construire un triangle.
Nous savons depuis l'école que la somme de deux côtés arbitraires doit être plus longue que le troisième côté.
Ce ne sera pas un défi difficile. La fonction aura trois paramètres - un pour chaque côté.
Il renverra True si les côtés peuvent construire un triangle et False sinon. Dans ce cas, isItATriangle est un bon
nom pour une telle fonction.
def isItATriangle(a, b, c):
if a + b <= c:
return False
if b + c <= a:
return False
if c + a <= b:
return False
return True
print(isItATriangle(1, 1, 1))
Vous pouvez y trouver notre fonction. Exécutez le programme.
Il semble que cela fonctionne bien - ce sont les résultats :

True
False
Pouvons-nous le rendre plus compact ? Ça a l'air un peu verbeux.
Ceci est une version plus compacte :
if a + b <= c or b + c <= a or \
c + a <= b:
return False
return True
Pouvons-nous le compacter encore plus?
Oui, nous pouvons – regardez :

return a + b > c and b + c > a and c + a > b
Nous avons annulé la condition (inversé les opérateurs relationnels et remplacé les or par des et , recevant une
expression universelle pour tester les triangles).
Installons la fonction dans un programme plus grand. Il demandera à l'utilisateur trois valeurs et utilisera la fonction.
Quelques fonctions simples: les triangles et le théorème de Pythagore

Regardez le code dans l'éditeur. Il demande à l'utilisateur trois valeurs. Ensuite, il utilise la isItATriangle fonction. Le
code est prêt à fonctionner.
a = float(input("Enter the first side's length: "))
b = float(input("Enter the second side's length: "))
c = float(input("Enter the third side's length: "))
if isItATriangle(a, b, c):
print("Congratulations - it can be a triangle.")
else:
print("Sorry, it won't be a triangle.")
Dans la deuxième étape, nous essaierons de nous assurer qu'un certain triangle est un triangle à angle droit .
Nous devrons utiliser le théorème de Pythagore :
c2=a2+b2
Comment reconnaît-on lequel des trois côtés est l'hypoténuse?
L'hypoténuse est le côté le plus long .
Voici le code:
def isItRightTriangle(a, b, c):
if not isItATriangle(a, b, c):
return False
if c > a and c > b:
return c ** 2 == a ** 2 + b ** 2
if a > b and a > c:
return a ** 2 == b ** 2 + c ** 2
print(isItRightTriangle(5, 3, 4))
print(isItRightTriangle(1, 3, 4))
Regardez comment nous testons la relation entre l'hypoténuse et les côtés restants - nous choisissons le côté le plus
long et appliquons le théorème de Pythagore pour vérifier si tout va bien. Cela nécessite trois contrôles au total.
Quelques fonctions simples: évaluer le champ d'un triangle

Nous pouvons également évaluer le champ d'un triangle. La formule de Heron sera utile ici:
Nous allons utiliser l'opérateur d'exponentiation pour trouver la racine carrée - cela peut sembler étrange, mais cela
fonctionne:
Ceci est le code resultant :

def heron(a, b, c):
p = (a + b + c) / 2
return (p * (p - a) * (p - b) * (p - c)) ** 0.5
def fieldOfTriangle(a, b, c):
if not isItATriangle(a, b, c):
return None
return heron(a, b, c)
print(fieldOfTriangle(1., 1., 2. ** .5))

a = float(input("Enter the first side's length: "))

b = float(input("Enter the second side's length: "))
c = float(input("Enter the third side's length: "))
if isItATriangle(a, b, c):
print("Congratulations - it can be a triangle.")
else:
print("Sorry, it won't be a triangle.")
Nous l'essayons avec un triangle à angle droit comme un demi-carré avec un côté égal à 1. Cela signifie que son champ
doit être égal à 0,5.
C'est étrange - le code produit la sortie suivante :
0.49999999999999983
C'est très proche de 0,5, mais ce n'est pas exactement 0,5. Qu'est-ce que ça veut dire ? Est-ce une erreur ?
Non, ça ne l'est pas. Ce sont les spécificités des calculs à virgule flottante. Nous vous en dirons bientôt plus.
Quelques fonctions simples: factorielles

Une autre fonction que nous allons écrire est la factorielle . Vous souvenez-vous de la définition d'une factorielle?
0! = 1 (yes! it's true)
1! = 1
2! = 1 * 2
3! = 1 * 2 * 3
4! = 1 * 2 * 3 * 4
:
:
n! = 1 * 2 ** 3 * 4 * ... * n-1 * n
Il est marqué d'un point d' exclamation et est égal au produit de tous les nombres naturels de un à son argument.
Écrivons notre code. Nous allons créer une fonction et l'appeler factorialFun . Voici le code:
def factorialFun(n):
if n < 0:
return None
if n < 2:
return 1
product = 1
for i in range(2, n + 1):
product *= i
return product
for n in range(1, 6): # testing
print(n, factorialFun(n))
Remarquez comment nous reflétons pas à pas la définition mathématique et comment nous utilisons la for boucle
pour trouver le produit .
Nous ajoutons un code de test simple, et voici les résultats que nous obtenons:
1 1
2 2
3 6
4 24
5 120
Quelques fonctions simples: les nombres de Fibonacci

Connaissez-vous les chiffres de Fibonacci ?
Il s'agit d'une séquence de nombres entiers construite à l'aide d'une règle très simple:
• le premier élément de la séquence est égal à un ( Fib 1 = 1 )

• le second est également égal à un ( Fib 2 = 1 )
• chaque nombre suivant est la somme des deux nombres précédents ( Fib i = Fib i-1 + Fib i-2 )
Voici quelques-uns des premiers numéros de Fibonacci:
fib1 = 1
fib2 = 1
fib3 = 1 + 1 = 2
fib4 = 1 + 2 = 3
fib5 = 2 + 3 = 5
fib6 = 3 + 5 = 8
fib7 = 5 + 8 = 13
Que pensez-vous de l' implémenter en tant que fonction ?
Créons notre fib fonction et testons-la. C'est ici:
def fib(n):
if n < 1:
return None
if n < 3:
return 1
elem1 = elem2 = 1
sum = 0
sum = elem1 + elem2
elem1, elem2 = elem2, sum
return sum
for n in range(1, 10): # testing

print(n, "->", fib(n))
Analysez for soigneusement le corps de la boucle et découvrez comment nous déplaçons

les variables elem1 et elem2 à travers les nombres de Fibonacci suivants .
La partie test du code produit la sortie suivante:
1 -> 1
2 -> 1
3 -> 2
4 -> 3
5 -> 5
6 -> 8
7 -> 13
8 -> 21
9 -> 34
Quelques fonctions simples: récursivité

Il y a encore une chose que nous voulons vous montrer pour que tout soit complet - c'est la récursivité .
Ce terme peut décrire de nombreux concepts différents, mais l'un d'eux est particulièrement intéressant - celui se
référant à la programmation informatique.
Dans ce domaine, la récursivité est une technique où une fonction s'invoque .
Ces deux cas semblent être les meilleurs pour illustrer le phénomène - factoriels et nombres de Fibonacci. Surtout ce
dernier.
La définition des nombres de Fibonacci est un exemple clair de récursivité . Nous vous avons déjà dit que:
Fib i = Fib i-1 + Fib i-2
La définition du i ème nombre fait référence au numéro i-1, et ainsi de suite, jusqu'à ce que vous atteigniez les deux
premiers.
Peut-il être utilisé dans le code? Oui il peut. Cela peut également rendre le code plus court et plus clair.
La deuxième version de notre fib() fonction utilise directement cette définition:
def fib(n):
if n < 1:
return None
if n < 3:
return 1
return fib(n - 1) + fib(n - 2)
Le code est beaucoup plus clair maintenant.
Mais est-ce vraiment sûr? Est-ce que cela comporte un risque?
Oui, il y a effectivement un petit risque. Si vous oubliez de considérer les conditions qui peuvent arrêter la chaîne
des invocations récursives, le programme peut entrer dans une boucle infinie . Tu dois être prudent.
La factorielle a aussi un second côté récursif . Regardez:
n! = 1 × 2 × 3 × ... × n-1 × n
Il est évident que:
1 × 2 × 3 × ... × n-1 = (n-1)!
Donc, finalement, le résultat est:
n! = (n-1)! × n
Il s'agit en fait d'une recette prête pour notre nouvelle solution.
C'est ici:
def factorialFun(n):
if n < 0:
return None
if n < 2:
return 1
return n * factorialFun(n - 1)
Est-ce que ça marche? Oui. Essayez-le par vous-même.
def fib(n):
if n < 1:
return None
if n < 3:
return 1
elem1 = elem2 = 1
sum = 0
sum = elem1 + elem2
elem1, elem2 = elem2, sum
return sum
for n in range(1, 10):
print(n, "->", fib(n))
Notre court voyage fonctionnel est presque terminé. La section suivante traitera de deux types de données Python
curieux: les tuples et les dictionnaires.

1. Une fonction peut appeler d'autres fonctions ou même elle-même. Lorsqu'une fonction s'appelle elle-même, cette situation
est connue sous le nom de récursivité , et la fonction qui s'appelle elle-même et contient une condition de terminaison
spécifiée (c'est-à-dire le cas de base - une condition qui ne dit pas à la fonction de faire d'autres appels à cette fonction) est
appelée fonction récursive .
2. Vous pouvez utiliser des fonctions récursives en Python pour écrire du code propre et élégant et le diviser en
morceaux plus petits et organisés . D'un autre côté, vous devez être très prudent car il pourrait être facile de faire une
erreur et de créer une fonction qui ne se termine jamais . Vous devez également vous rappeler que les appels récursifs
consomment beaucoup de mémoire et peuvent donc parfois être inefficaces.
Lorsque vous utilisez la récursivité, vous devez prendre en compte tous ses avantages et inconvénients.
La fonction factorielle est un exemple classique de la mise en pratique du concept de récursivité:
# Recursive implementation of the factorial function
def factorial(n):
if n == 1: # the base case (termination condition)
return 1
else:
return n * factorial(n - 1)
print(factorial(4)) # 4 * 3 * 2 * 1 = 24
Exercice 1
Que se passera-t-il lorsque vous tenterez d'exécuter l'extrait de code suivant et pourquoi?
def factorial(n):
return n * factorial(n - 1)
print(factorial(4))
Exercice 2
def fun(a):
if a > 30:
return 3
else:
return a + fun(a + 3)
print(fun(25))
Types de séquences et mutabilité

Avant de commencer à parler de tuples et de dictionnaires , nous devons introduire deux concepts importants: les types de
séquence et la mutabilité .
Un type de séquence est un type de données en Python qui est capable de stocker plus d'une valeur (ou moins d'une,
car une séquence peut être vide), et ces valeurs peuvent être parcourues séquentiellement (d'où le nom) , élément
par élément.
La for boucle étant un outil spécialement conçu pour parcourir les séquences, nous pouvons exprimer la définition comme
suit: une séquence est une donnée qui peut être scannée par la for boucle .
Vous avez rencontré jusqu'à présent une séquence Python - la liste. La liste est un exemple classique d'une séquence Python,
bien qu'il existe d'autres séquences qui méritent d'être mentionnées, et nous allons vous les présenter maintenant.
La deuxième notion - la mutabilité - est une propriété de n'importe quelle donnée de Python qui décrit sa disponibilité à
être librement modifiée pendant l'exécution du programme. Il existe deux types de données
Python: mutables et immuables .
Les données mutables peuvent être mises à jour librement à tout moment - nous appelons une telle opération in situ.
In situ est une phrase latine qui se traduit littéralement par sa position . Par exemple, l'instruction suivante modifie les
données in situ:
list.append(1)
Les données immuables ne peuvent pas être modifiées de cette manière .
Imaginez qu'une liste ne peut être attribuée et relue. Vous ne pourrez ni lui ajouter un élément, ni en supprimer aucun
élément. Cela signifie que l'ajout d'un élément à la fin de la liste nécessiterait la recréation de la liste à partir de zéro.
Vous devrez créer une liste complètement nouvelle, composée de tous les éléments de la liste déjà existante, plus le nouvel
élément.
Le type de données dont nous voulons vous parler maintenant est un tuple . Un tuple est un type de séquence
immuable . Il peut se comporter comme une liste, mais il ne doit pas être modifié in situ.
Qu'est-ce qu'un tuple?

La première et la distinction la plus claire entre les listes et les tuples est la syntaxe utilisée pour les créer - les tuples
préfèrent utiliser des parenthèses , tandis que les listes aiment voir les crochets, bien qu'il soit également possible de
créer un tuple uniquement à partir d'un ensemble de valeurs séparées par des virgules .
Regardez l'exemple:
tuple1 = (1, 2, 4, 8)
tuple2 = 1., .5, .25, .125
Il y a deux tuples, contenant chacun quatre éléments .
Imprimons-les:
print(tuple1)
print(tuple2)
Voici ce que vous devriez voir dans la console:

(1, 2, 4, 8)
(1.0, 0.5, 0.25, 0.125)
Remarque: chaque élément de tuple peut être d'un type différent (virgule flottante, entier ou tout autre type de données
non encore introduit).
Comment créer un tuple?

Il est possible de créer un tuple vide - des parenthèses sont alors nécessaires:
emptyTuple = ()
Si vous souhaitez créer un tuple à un élément , vous devez prendre en considération le fait que, pour des raisons de syntaxe
(un tuple doit être distingué d'une valeur simple ordinaire), vous devez terminer la valeur par une virgule:
oneElementTuple1 = (1, )
oneElementTuple2 = 1.,
La suppression des virgules ne gâchera pas le programme dans un sens syntaxique, mais vous obtiendrez à la place deux
variables simples, pas des tuples.
Comment utiliser un tuple?

Si vous souhaitez obtenir les éléments d'un tuple afin de les relire, vous pouvez utiliser les mêmes conventions
auxquelles vous êtes habitué lors de l'utilisation des listes.
Jetez un œil au code dans l'éditeur.
myTuple = (1, 10, 100, 1000)
print(myTuple[0])
print(myTuple[-1])
print(myTuple[1:])
print(myTuple[:-2])
for elem in myTuple:

print(elem)
Le programme devrait produire la sortie suivante - exécutez-le et vérifiez:
1000
(10, 100, 1000)
(1, 10)
10
100
1000
Les similitudes peuvent être trompeuses - n'essayez pas de modifier le contenu d'un tuple ! Ce n'est pas une liste!
Toutes ces instructions (sauf la plus haute) provoqueront une erreur d'exécution:
myTuple = (1, 10, 100, 1000)
myTuple.append(10000)
del myTuple[0]
myTuple[1] = -10
Voici le message que Python vous donnera dans la fenêtre de la console:
AttributeError: 'tuple' object has no attribute 'append'
Comment utiliser un tuple: suite

Qu'est-ce que les tuples peuvent faire d'autre pour vous?
• la len() fonction accepte les tuples et retourne le nombre d'éléments contenus à l'intérieur;
• l' + opérateur peut joindre des tuples ensemble (nous vous l'avons déjà montré)
• l' * opérateur peut multiplier les tuples, tout comme les listes;
• les opérateurs in et not in fonctionnent de la même manière que dans les listes.
L'extrait dans l'éditeur les présente tous.
myTuple = (1, 10, 100)
t1 = myTuple + (1000, 10000)
t2 = myTuple * 3
print(len(t2))
print(t1)
print(t2)
print(10 in myTuple)
print(-10 not in myTuple)
La sortie doit ressembler à ceci:
9
(1, 10, 100, 1000, 10000)
(1, 10, 100, 1, 10, 100, 1, 10, 100)
True
True
L'une des propriétés de tuple les plus utiles est leur capacité à apparaître sur le côté gauche de l'opérateur
d'affectation . Vous avez vu ce phénomène il y a quelque temps, quand il fallait trouver un outil élégant pour échanger
les valeurs de deux variables.
Jetez un œil à l'extrait ci-dessous:
var = 123
t1 = (1, )
t2 = (2, )
t3 = (3, var)
t1, t2, t3 = t2, t3, t1
print(t1, t2, t3)
Il montre trois tuples en interaction - en effet, les valeurs qui y sont stockées "circulent"
- t1 devient t2 , t2 devient t3 et t3 devient t1 .
Remarque: l'exemple présente un fait plus important: les éléments d' un tuple peuvent être des variables , pas
seulement des littéraux. De plus, elles peuvent être des expressions si elles se trouvent du côté droit de l'opérateur
d'affectation.
Qu'est-ce qu'un dictionnaire?

Le dictionnaire est une autre structure de données Python. Ce n'est pas un type de séquence (mais peut être facilement
adapté au traitement de séquence) et il est modifiable .
Pour expliquer ce qu'est réellement le dictionnaire Python, il est important de comprendre qu'il s'agit littéralement d'un
dictionnaire.
Le dictionnaire Python fonctionne de la même manière qu'un dictionnaire bilingue . Par exemple, vous avez un mot anglais
(par exemple, chat) et avez besoin de son équivalent français. Vous parcourez le dictionnaire afin de trouver le mot (vous
pouvez utiliser différentes techniques pour le faire - cela n'a pas d'importance) et finalement vous l'obtenez. Ensuite, vous
vérifiez l'homologue français et c'est (très probablement) le mot "chat".
Dans le monde de Python, le mot que vous recherchez est nommé a key . Le mot que vous obtenez du dictionnaire est appelé
a value .
Cela signifie qu'un dictionnaire est un ensemble de paires clé-valeur . Remarque:
• chaque clé doit être unique - il n'est pas possible d'avoir plus d'une clé de la même valeur;
• une clé peut être des données de tout type (sauf liste): elle peut être un nombre (entier ou flottant), voire une
chaîne;
• un dictionnaire n'est pas une liste - une liste contient un ensemble de valeurs numérotées, tandis qu'un dictionnaire
contient des paires de valeurs ;
• la len() fonction fonctionne également pour les dictionnaires - elle renvoie le nombre d'éléments de valeur-clé dans
le dictionnaire;
• un dictionnaire est un outil à sens unique - si vous avez un dictionnaire anglais-français, vous pouvez rechercher
des équivalents français de termes anglais, mais pas l'inverse.
Nous pouvons maintenant vous montrer quelques exemples pratiques.
Comment faire un dictionnaire?

Si vous souhaitez affecter des paires initiales à un dictionnaire, vous devez utiliser la syntaxe suivante:
dictionary = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"}
phone_numbers = {'boss' : 5551234567, 'Suzy' : 22657854310}
empty_dictionary = {}
print(dictionary)
print(phone_numbers)
print(empty_dictionary)
Dans le premier exemple, le dictionnaire utilise des clés et des valeurs qui sont toutes deux des chaînes. Dans le second, les
clés sont des chaînes, mais les valeurs sont des entiers. La disposition inverse (touches → nombres, valeurs → chaînes) est
également possible, ainsi que la combinaison nombre-nombre.
La liste des paires est entourée d'accolades , tandis que les paires elles-mêmes sont séparées par des virgules et les clés
et valeurs par des deux-points .
Le premier de nos dictionnaires est un dictionnaire anglais-français très simple. Le second - un très petit annuaire
téléphonique.
Les dictionnaires vides sont construits par une paire d'appareils orthopédiques vides - rien d'inhabituel.
Le dictionnaire dans son ensemble peut être imprimé avec une seule print() invocation. L'extrait peut produire la sortie
suivante:
{'dog': 'chien', 'horse': 'cheval', 'cat': 'chat'}
{'Suzy': 5557654321, 'boss': 5551234567}
{}
Avez-vous remarqué quelque chose de surprenant? L'ordre des paires imprimées est différent de celui de l'affectation
initiale. Qu'est-ce que ça veut dire?
Tout d'abord, c'est une confirmation que les dictionnaires ne sont pas des listes - ils ne préservent pas l'ordre de leurs
données, car l'ordre n'a aucun sens (contrairement aux vrais dictionnaires papier). L'ordre dans lequel un
dictionnaire stocke ses données est complètement hors de votre contrôle et de vos attentes. C'est normal. (*)
REMARQUE
(*) En Python 3.6x, les dictionnaires sont devenus des collections ordonnées par défaut. Vos résultats peuvent varier en
fonction de la version de Python que vous utilisez.
Comment utiliser un dictionnaire?

Si vous souhaitez obtenir l'une des valeurs, vous devez fournir une valeur de clé valide:
print(dictionary['cat'])
print(phone_numbers['Suzy'])
Obtenir la valeur d'un dictionnaire ressemble à l'indexation, en particulier grâce aux crochets entourant la valeur de la
clé.
Remarque:
• si la clé est une chaîne, vous devez la spécifier comme une chaîne;
• les touches sont sensibles à la casse : 'Suzy' est quelque chose de différent de 'suzy' .
L'extrait produit deux lignes de texte:
chat
5557654321
Et maintenant, la nouvelle la plus importante: vous ne devez pas utiliser de clé inexistante . Essayer quelque chose
comme ça:
print(phone_numbers['president'])
provoquera une erreur d'exécution. Essaye de le faire.
Heureusement, il existe un moyen simple d'éviter une telle situation. L' in opérateur, avec son compagnon not in ,
peut sauver cette situation.
Le code suivant recherche en toute sécurité certains mots français:

words = ['cat', 'lion', 'horse']
for word in words:

if word in dictionary:
print(word, "->", dictionary[word])
else:
print(word, "is not in dictionary")
La sortie du code se présente comme suit:
cat -> chat

lion is not in dictionary
horse -> cheval
Comment utiliser un dictionnaire: les touches ()

Les dictionnaires peuvent-ils être parcourus en utilisant la for boucle, comme les listes ou les tuples?
Non et oui.
Non, car un dictionnaire n'est pas un type de séquence - la for boucle est inutile avec lui.
Oui, car il existe des outils simples et très efficaces qui peuvent adapter n'importe quel dictionnaire
aux for exigences de la boucle (en d'autres termes, créer un lien intermédiaire entre le dictionnaire et une entité de
séquence temporaire).
Le premier d'entre eux est une méthode nommée keys() , possédée par chaque dictionnaire. La méthode renvoie un
objet itérable composé de toutes les clés rassemblées dans le dictionnaire . Avoir un groupe de clés vous permet
d'accéder à l'ensemble du dictionnaire de manière simple et pratique.
Comme ici:
for key in dictionary.keys():
print(key, "->", dictionary[key]
La sortie du code se présente comme suit:
horse -> cheval
dog -> chien
cat -> chat
Le trié () fonction
Voulez-vous que ce soit trié ? Il suffit d'enrichir la boucle for pour obtenir une telle forme:
for key in sorted(dictionary.keys()):
La fonction sorted() fera de son mieux - la sortie ressemblera à ceci:
cat -> chat
dog -> chien
horse -> cheval
Comment utiliser un dictionnaire: les méthodes items () et values ()

Une autre façon est basée sur l'utilisation d'une méthode de dictionnaire nommée items() . La méthode renvoie des
tuples (c'est le premier exemple où les tuples sont plus qu'un simple exemple d'eux-mêmes) où chaque tuple est une
paire clé-valeur .
Voilà comment cela fonctionne:
for english, french in dictionary.items():

print(english, "->", french)
Notez la manière dont le tuple a été utilisé comme for variable de boucle.
L'exemple imprime:
cat -> chat
dog -> chien
horse -> cheval
Il existe également une méthode nommée values() , qui fonctionne de manière similaire à keys() , mais renvoie des
valeurs .
Voici un exemple simple:
for french in dictionary.values():
print(french)
Le dictionnaire n'étant pas en mesure de trouver automatiquement une clé pour une valeur donnée, le rôle de cette
méthode est plutôt limité.
Voici la sortie attendue:
cheval
chien
chat
Comment utiliser un dictionnaire: modifier et ajouter des valeurs

Attribuer une nouvelle valeur à une clé existante est simple - comme les dictionnaires sont entièrement modifiables , il
n'y a aucun obstacle à les modifier.
Nous allons remplacer la valeur "chat" par "minou" , qui n'est pas très précise, mais cela fonctionnera bien avec notre
exemple.
Regardez:
dictionary['cat'] = 'minou'
print(dictionary)
La sortie est:
{'dog': 'chien', 'horse': 'cheval', 'cat': 'minou'}

Ajout d'une nouvelle clé
L'ajout d'une nouvelle paire clé-valeur à un dictionnaire est aussi simple que de changer une valeur - vous n'avez qu'à
affecter une valeur à une nouvelle clé , auparavant inexistante .
Remarque: il s'agit d'un comportement très différent des listes, qui ne vous permettent pas d'attribuer des valeurs à des
indices non existants.
Ajoutons une nouvelle paire de mots au dictionnaire - un peu bizarre, mais toujours valide:
dictionary['swan'] = 'cygne'
print(dictionary)
L'exemple affiche:
{'swan': 'cygne', 'horse': 'cheval', 'dog': 'chien', 'cat': 'chat'}
SUPPLÉMENTAIRE
Vous pouvez également insérer un élément dans un dictionnaire en utilisant la méthode update() , par exemple:
dictionary.update({"duck" : "canard"})
print(dictionary)
Retrait d'une clé

Pouvez-vous deviner comment supprimer une clé d'un dictionnaire?
Remarque: la suppression d'une clé entraînera toujours la suppression de la valeur associée . Les valeurs ne
peuvent exister sans leurs clés .
Cela se fait avec l'instruction del .
Voici l'exemple:
del dictionary['dog']
print(dictionary)
Remarque: la suppression d'une clé non existante provoque une erreur .
L'exemple affiche:
{'cat': 'chat', 'horse': 'cheval'}

SUPPLÉMENTAIRE
Pour supprimer le dernier élément d'un dictionnaire, vous pouvez utiliser la popitem() méthode:
dictionary.popitem()
print(dictionary) # outputs: {'cat' : 'chat', 'dog' : 'chien'}

Dans les anciennes versions de Python, c'est-à-dire avant 3.6.7, la popitem() méthode supprime un élément aléatoire
d'un dictionnaire.
Tuples et dictionnaires peuvent fonctionner ensemble

Nous avons préparé un exemple simple, montrant comment les tuples et les dictionnaires peuvent fonctionner
ensemble.
Imaginons le problème suivant:
• vous avez besoin d'un programme pour évaluer les notes moyennes des élèves;
• le programme doit demander le nom de l'élève, suivi de son score unique;
• les noms peuvent être entrés dans n'importe quel ordre;
• la saisie d'un nom vide termine la saisie des données;
• une liste de tous les noms, ainsi que le score moyen évalué, doivent ensuite être émis.
Regardez le code dans l'éditeur. Voilà comment le faire.
school_class = {}
while True:
name = input("Enter the student's name (or type exit to stop): ")
if name == 'exit':
break
score = int(input("Enter the student's score (0-10): "))
if name in school_class:
school_class[name] += (score,)
else:
school_class[name] = (score,)
for name in sorted(school_class.keys()):

adding = 0
counter = 0
for score in school_class[name]:
adding += score
counter += 1
print(name, ":", adding / counter)
Maintenant, analysons-le ligne par ligne:
• ligne 1 : créez un dictionnaire vide pour les données d'entrée; le nom de l'élève est utilisé comme clé, tandis
que tous les scores associés sont stockés dans un tuple (le tuple peut être une valeur de dictionnaire - ce n'est
pas un problème du tout)
• ligne 3 : entrez dans une boucle "infinie" (ne vous inquiétez pas, elle se cassera au bon moment)
• ligne 4 : lisez le nom de l'élève ici;
• ligne 5-6 : si le nom est exit , quittez la boucle;
• ligne 8 : demandez l'un des scores de l'élève (un entier compris entre 1 et 10)
• ligne 10-11 : si le nom de l'élève est déjà dans le dictionnaire, allongez le tuple associé avec le nouveau score
(notez l'opérateur + =)
• ligne 12-13 : s'il s'agit d'un nouvel élève (inconnu du dictionnaire), créez une nouvelle entrée - sa valeur est un
tuple à un élément contenant le score entré;
• ligne 15 : parcourir les noms des élèves triés;
• ligne 16-17 : initialiser les données nécessaires pour évaluer la moyenne (somme et compteur)
• ligne 18-20 : nous parcourons le tuple, en prenant tous les scores suivants et en mettant à jour la somme, avec
le compteur;
• ligne 21 : évaluer et imprimer le nom et la note moyenne de l'élève.
Voici un enregistrement d'une conversation que nous avons eue avec notre programme:
Enter the student's name and press Enter to stop: Bob

Enter the student's score (0-10): 7
Enter the student's name (or type exit to stop): Andy
Enter the student's name (or type exit to stop): Bob
Enter the student's name (or type exit to stop): Bob
Enter the student's name (or type exit to stop):
Andy : 5.333333333333333
Bob : 6.0
Points clés à retenir: tuples

1. Les tuples sont des collections de données ordonnées et immuables (immuables). Ils peuvent être considérés comme des
listes immuables. Ils sont écrits entre parenthèses:
myTuple = (1, 2, True, "a string", (3, 4), [5, 6], None)
print(myTuple)
myList = [1, 2, True, "a string", (3, 4), [5, 6], None]
print(myList)
Chaque élément de tuple peut être d'un type différent (c'est-à-dire des entiers, des chaînes, des booléens, etc.). De plus, les
tuples peuvent contenir d'autres tuples ou listes (et inversement).
2. Vous pouvez créer un tuple vide comme ceci:
emptyTuple = ()
print(type(emptyTuple)) # outputs: <class 'tuple'>

3. Un tuple à un élément peut être créé comme suit:
oneElemTup1 = ("one", ) # brackets and a comma
oneElemTup2 = "one", # no brackets, just a comma

Si vous supprimez la virgule, vous direz à Python de créer une variable, pas un tuple:
myTup1 = 1,
print(type(myTup1)) # outputs: <class 'tuple'>
myTup2 = 1
print(type(myTup2)) # outputs: <class 'int'>

4. Vous pouvez accéder aux éléments de tuple en les indexant:
myTuple = (1, 2.0, "string", [3, 4], (5, ), True)
print(myTuple[3]) # outputs: [3, 4]

5. Les tuples sont immuables, ce qui signifie que vous ne pouvez pas modifier leurs éléments (vous ne pouvez pas ajouter de
tuples, ni modifier ou supprimer des éléments de tuple). L'extrait de code suivant provoquera une exception:
myTuple = (1, 2.0, "string", [3, 4], (5, ), True)
myTuple[2] = "guitar" # a TypeError exception will be raised

Cependant, vous pouvez supprimer un tuple dans son ensemble:
myTuple = 1, 2, 3,
del myTuple
print(myTuple) # NameError: name 'myTuple' is not defined
6. Vous pouvez parcourir un élément d'un tuple (exemple 1), vérifier si un élément spécifique est (pas) présent dans un tuple
(exemple 2), utiliser la len() fonction pour vérifier combien d'éléments il y a dans un tuple (exemple 3), ou même joindre /
multiplier des tuples (exemple 4):
# Example 1
t1 = (1, 2, 3)
for elem in t1:
print(elem)
# Example 2
t2 = (1, 2, 3, 4)
print(5 in t2)
print(5 not in t2)
# Example 3
t3 = (1, 2, 3, 5)
print(len(t3))
# Example 4
t4 = t1 + t2
t5 = t3 * 2
print(t4)
print(t5)
SUPPLÉMENTAIRE
Vous pouvez également créer un tuple à l'aide d'une fonction intégrée Python appelée tuple() . Ceci est particulièrement
utile lorsque vous souhaitez convertir un certain itérable (par exemple, une liste, une plage, une chaîne, etc.) en un tuple:
myTup = tuple((1, 2, "string"))
print(myTup)
lst = [2, 4, 6]
print(lst) # outputs: [2, 4, 6]
print(type(lst)) # outputs: <class 'list'>
tup = tuple(lst)
print(tup) # outputs: (2, 4, 6)
print(type(tup)) # outputs: <class 'tuple'>

De la même manière, lorsque vous souhaitez convertir un itérable en liste, vous pouvez utiliser une fonction intégrée Python
appelée list() :
tup = 1, 2, 3,
lst = list(tup)
print(type(lst)) # outputs: <class 'list'>
Points clés à retenir: dictionnaires

1. Les dictionnaires sont des collections de données non ordonnées * , modifiables (modifiables) et indexées. ( * En Python
3.6x, les dictionnaires sont classés par défaut.
Chaque dictionnaire est un ensemble de paires clé: valeur . Vous pouvez le créer en utilisant la syntaxe suivante:
myDictionary = {
key1 : value1,
key2 : value2,
key3 : value3,
}
2. Si vous souhaitez accéder à un élément du dictionnaire, vous pouvez le faire en faisant référence à sa clé à l'intérieur d'une
paire de crochets (ex. 1) ou en utilisant la get() méthode (ex. 2):
polEngDict = {
"kwiat" : "flower",
"woda" : "water",
"gleba" : "soil"
item1 = polEngDict["gleba"] # ex. 1
print(item1) # outputs: soil
item2 = polEngDict.get("woda")
print(item2) # outputs: water

3. Si vous souhaitez modifier la valeur associée à une clé spécifique, vous pouvez le faire en vous référant au nom de la clé de
l'élément de la manière suivante:
polEngDict = {
"zamek" : "castle",
"woda" : "water",
"gleba" : "soil"
polEngDict["zamek"] = "lock"
item = polEngDict["zamek"] # outputs: lock

4. Pour ajouter ou supprimer une clé (et la valeur associée), utilisez la syntaxe suivante:
myPhonebook = {} # an empty dictionary
myPhonebook["Adam"] = 3456783958 # create/add a key-value pair
print(myPhonebook) # outputs: {'Adam': 3456783958}
del myPhonebook["Adam"]
print(myPhonebook) # outputs: {}
Vous pouvez également insérer un élément dans un dictionnaire à l'aide de la update() méthode et supprimer le dernier
élément à l'aide de la popitem() méthode, par exemple:
polEngDict = {"kwiat" : "flower"}
polEngDict = update("gleba" : "soil")
print(polEngDict) # outputs: {'kwiat' : 'flower', 'gleba' : 'soil'}
polEngDict.popitem()
print(polEngDict) # outputs: {'kwiat' : 'flower'}
5. Vous pouvez utiliser la for boucle pour parcourir un dictionnaire, par exemple:
polEngDict = {
"zamek" : "castle",
"woda" : "water",
"gleba" : "soil"
for item in polEngDict:
print(item) # outputs: zamek
# woda
# gleba
6. Si vous souhaitez parcourir les clés et les valeurs d'un dictionnaire, vous pouvez utiliser la méthode items() , par
exemple:
polEngDict = {
"zamek" : "castle",
"woda" : "water",
"gleba" : "soil"
for key, value in polEngDict.items():
print("Pol/Eng ->", key, ":", value)

7. Pour vérifier si une clé donnée existe dans un dictionnaire, vous pouvez utiliser le in mot - clé:
polEngDict = {
"zamek" : "castle",
"woda" : "water",
"gleba" : "soil"
}
if "zamek" in polEngDict:
print("Yes")
else:
print("No")
8. Vous pouvez utiliser le del mot - clé pour supprimer un élément spécifique ou supprimer un dictionnaire. Pour supprimer
tous les éléments du dictionnaire, vous devez utiliser la clear() méthode:
polEngDict = {
"zamek" : "castle",
"woda" : "water",
"gleba" : "soil"
print(len(polEngDict)) # outputs: 3
del polEngDict["zamek"] # remove an item
polEngDict.clear() # removes all the items
del polEngDict # removes the dictionary
9. Pour copier un dictionnaire, utilisez la copy() méthode:
polEngDict = {
"zamek" : "castle",
"woda" : "water",
"gleba" : "soil"
copyDict = polEngDict.copy()
Points clés à retenir: tuples et dictionnaires

Exercice 1
Que se passe-t-il lorsque vous essayez d'exécuter l'extrait de code suivant?
myTup = (1, 2, 3)
print(myTup[2])
Exercice 2
tup = 1, 2, 3
a, b, c = tup
print(a * b * c)
Exercice 3
Complétez le code pour utiliser correctement la count() méthode pour trouver le nombre de doublons 2 dans le tuple
suivant.
tup = 1, 2, 3, 2, 4, 5, 6, 2, 7, 2, 8, 9
duplicates = # your code
print(duplicates) # outputs: 4
Exercice 4
Écrivez un programme qui "collera" les deux dictionnaires ( d1 et d2 ) ensemble et en créera un nouveau ( d3 ).
d1 = {'Adam Smith':'A', 'Judy Paxton':'B+'}
d2 = {'Mary Louis':'A', 'Patrick White':'C'}
d3 = {}
for item in (d1, d2):
# your code
print(d3)
Exercice 5
Écrivez un programme qui convertira la l liste en tuple.
l = ["car", "Ford", "flower", "Tulip"]
t = # your code
print(t)
Exercice 6
Écrivez un programme qui convertira le colors tuple en dictionnaire.
colors = (("green", "#008000"), ("blue", "#0000FF"))
# your code
print(colDict)
Exercice 7
Que se passera-t-il lorsque vous exécuterez le code suivant?
myDict = {"A":1, "B":2}
copyMyDict = myDict.copy()
myDict.clear()
print(copyMyDict)
Exercice 8
Quelle est la sortie du programme suivant?
colors = {
"white" : (255, 255, 255),
"grey" : (128, 128, 128),
"red" : (255, 0, 0),
"green" : (0, 128, 0)
for col, rgb in colors.items():
print(col, ":", rgb)
PROJET
Temps estimé
30-60 minutes
Moyen / dur
Objectifs
• Perfectionner les compétences de l'élève dans l'utilisation de Python pour résoudre des problèmes complexes,
• Intégration de techniques de programmation dans un programme composé de nombreuses parties différentes.
Scénario
Votre tâche consiste à écrire un programme simple qui prétend jouer au tic-tac-toe avec l’utilisateur. Pour vous
faciliter la tâche, nous avons décidé de simplifier le jeu. Voici nos hypothèses :
• L’ordinateur (c'est-à-dire votre programme) devrait jouer au jeu en utilisant des 'X’ ;
• L’utilisateur (par exemple, vous) devrait jouer au jeu en utilisant des 'O’ ;
• Le premier mouvement appartient à l'ordinateur - il place toujours son premier 'X' au milieu du plateau ;
• Tous les carrés sont numérotés ligne par ligne en commençant par 1 (voir l'exemple de session ci-dessous pour
référence)
• L’utilisateur entre son mouvement en entrant le numéro du carré qu'il choisit - le nombre doit être valide, c'est-à-
dire qu'il doit être un entier, il doit être supérieur 0 et inférieur à 10 , et il ne peut pas pointer vers un champ qui
est déjà occupé ;
• Le programme vérifie si le jeu est terminé - il y a quatre verdicts possibles : le jeu doit continuer, ou le jeu se
termine par une égalité, votre victoire ou la victoire de l’ordinateur ;
• L’ordinateur répond avec son mouvement et le contrôle est répété ;
• N’implémentez aucune forme d'intelligence artificielle - un choix de champ aléatoire fait par l'ordinateur est
assez bon pour le jeu.
L'exemple de session avec le programme peut ressembler à ceci :
+-------+-------+-------+
| | | |
| 1 | 2 | 3 |
| | | |
+-------+-------+-------+
| | | |
| 4 | X | 6 |
| | | |
+-------+-------+-------+
| | | |
| 7 | 8 | 9 |
| | | |
+-------+-------+-------+
Enter your move : 1
+-------+-------+-------+
| | | |
| O | 2 | 3 |
| | | |
+-------+-------+-------+
| | | |
| 4 | X | 6 |
| | | |
+-------+-------+-------+
| | | |
| 7 | 8 | 9 |
| | | |
+-------+-------+-------+
+-------+-------+-------+
| | | |
| O | X | 3 |
| | | |
+-------+-------+-------+
| | | |
| 4 | X | 6 |
| | | |
+-------+-------+-------+
| | | |
| 7 | 8 | 9 |
| | | |
+-------+-------+-------+
Enter your move : 8
+-------+-------+-------+
| | | |
| O | X | 3 |
| | | |
+-------+-------+-------+
| | | |
| 4 | X | 6 |
| | | |
+-------+-------+-------+
| | | |
| 7 | O | 9 |
| | | |
+-------+-------+-------+
+-------+-------+-------+
| | | |
| O | X | 3 |
| | | |
+-------+-------+-------+
| | | |
| 4 | X | X |
| | | |
+-------+-------+-------+
| | | |
| 7 | O | 9 |
| | | |
+-------+-------+-------+
Enter your move : 4
+-------+-------+-------+
| | | |
| O | X | 3 |
| | | |
+-------+-------+-------+
| | | |
| O | X | X |
| | | |
+-------+-------+-------+
| | | |
| 7 | O | 9 |
| | | |
+-------+-------+-------+
+-------+-------+-------+
| | | |
| O | X | X |
| | | |
+-------+-------+-------+
| | | |
| O | X | X |
| | | |
+-------+-------+-------+
| | | |
| 7 | O | 9 |
| | | |
+-------+-------+-------+
Enter your move : 7
+-------+-------+-------+
| | | |
| O | X | X |
| | | |
+-------+-------+-------+
| | | |
| O | X | X |
| | | |
+-------+-------+-------+
| | | |
| O | O | 9 |
| | | |
+-------+-------+-------+
You won !
Exigences
Implémentez les fonctionnalités suivantes :
• Le tableau doit être stocké sous forme de liste à trois éléments, tandis que chaque élément est une autre liste à
trois éléments (les listes internes représentent des lignes) afin que tous les carrés soient accessibles en utilisant
la syntaxe suivante:
board[row][column]
• Chacun des éléments de la liste des internes peut contenir 'O' , 'X' ou un chiffre qui représente le numéro de
la place (place un tel est considéré comme libre)
• L’apparence du tableau doit être exactement la même que celle présentée dans l'exemple.
• Implémentez les fonctions définies pour vous dans l'éditeur.
def DisplayBoard(board):
#
# the function accepts one parameter containing the board's current status
# and prints it out to the console
#
def EnterMove(board):
#
# the function accepts the board current status, asks the user about their move,
# checks the input and updates the board according to the user's decision
#
def MakeListOfFreeFields(board):
#
# the function browses the board and builds a list of all the free squares;
# the list consists of tuples, while each tuple is a pair of row and column numbers
#
def VictoryFor(board, sign):

#
# the function analyzes the board status in order to check if
# the player using 'O's or 'X's has won the game
#
def DrawMove(board):
#
# the function draws the computer's move and updates the board
#
Le dessin d'un nombre entier aléatoire peut être fait en utilisant une fonction Python appelée randrange() . L'exemple
de programme ci-dessous montre comment l'utiliser (le programme imprime dix nombres aléatoires de 0 à 8).
Remarque: l'instruction from-import fournit un accès à la fonction randrange définie dans un module Python externe
appelé random .
from random import randrange
for i in range(10):
print(randrange(8))
Toutes nos félicitations ! Vous avez terminé le module 4.

Bien joué ! Vous avez atteint la fin du module 4 et franchi une étape importante dans votre formation en programmation
Python. Voici un bref résumé des objectifs que vous avez couverts et que vous vous êtes familiarisés avec le module 4 :
• La définition et l'utilisation des fonctions - leur raison d'être, leur objectif, leurs conventions et leurs pièges ;
• Le concept de passer des arguments de différentes manières et de définir leurs valeurs par défaut, ainsi que les
mécanismes de retour des résultats de la fonction ;
• Problèmes de portée de nom ;
• Nouveaux agrégats de données : tuples et dictionnaires, et leur rôle dans le traitement des données.
Vous êtes maintenant prêt à répondre au questionnaire du module et à tenter le dernier défi: le module 4 Test, qui vous
aidera à évaluer ce que vous avez appris jusqu'à présent.

Éléments Essentiels de La Programmation en Python: Module 4: Dans Ce Module, Vous Découvrirez

Transféré par

Droits d'auteur :

Formats disponibles

Éléments Essentiels de La Programmation en Python: Module 4: Dans Ce Module, Vous Découvrirez

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Éléments Essentiels de La Programmation en Python: Module 4: Dans Ce Module, Vous Découvrirez

Transféré par

Droits d'auteur :

Formats disponibles

Éléments essentiels de la programmation en Python: Module 4

Dans ce module, vous découvrirez :

• Définir et utiliser des fonctions ;

Pourquoi a-t-on des fonctions ?

D'où viennent les fonctions ?

Votre première fonction

print("Enter a value: ")

print("Enter a value: ")

print("Enter a value: ")

Votre première fonction

Vous devez le définir. Le mot définir est significatif ici.

Voici à quoi ressemble la définition de fonction la plus simple :

• Il commence toujours par le mot-clé def (pour définir)

Notre code contient maintenant la définition de la fonction :

print("We start here.")

Lorsque vous l'exécutez, vous voyez la sortie suivante :

print("We start here.")

La sortie semble différente maintenant :

Testez le code, modifiez-le, expérimentez-le.

Fonctionnement des fonctions

Il essaie de vous montrer tout le processus :

Il y a deux captures très importantes. Voici le premier d'entre eux :

Nous avons inséré une erreur dans ce code - voyez-vous la différence ?

print("We start here.")

Non, ça ne l'est pas. Le message d'erreur indiquera :

NameError: name 'message' is not defined

La deuxième prise semble un peu plus simple :

L'extrait suivant est erroné :

Regardez l'extrait de code :

print("We start here.")

print("We end here.")

Ouvrez le bac à sable et essayez de le faire vous-même.

Points clés à retenir

2. Il existe au moins quatre types de fonctions de base en Python :

def yourFunction(optional parameters):

def message(): # defining a function

message() # calling the function

def hello(name): # defining a function

name = input("Enter your name: ")

hello(name) # calling the function

La fonction input() est un exemple de:

a) fonction définie par l'utilisateur

Que se passera-t-il lorsque vous exécuterez le code ci-dessous ?

Une valeur pour le paramètre arrivera de l'environnement de la fonction.

Ne pas le faire entraînera une erreur.

Essayez d'exécuter le code dans l'éditeur.

Cela semble mieux, bien sûr:

De plus, il se comporte mieux. Le code produira la sortie suivante:

Nous devons vous sensibiliser à une circonstance importante.

L'extrait illustre le phénomène:

Une situation comme celle-ci active un mécanisme appelé shadowing:

• le paramètre x masque toute variable du même nom, mais ...

• ... uniquement à l'intérieur de la fonction définissant le paramètre.

Cela signifie que l'extrait ci-dessus produira la sortie suivante:

Modifions la fonction - elle a maintenant deux paramètres:

print("Enter", what, "number", number)

Cela signifie également que l'invocation de la fonction nécessitera deux arguments.

Le premier nouveau paramètre est destiné à porter le nom de la valeur souhaitée.

def message(what, number):