Partie 1 : Les bases du langage

Résumés Module 4 : Fonctions, tuples, dictionnaires, exceptions et

traitement des données

 La structuration du code et le concept de fonction ;

 Invocation de fonction et retour d'un résultat à partir d'une fonction ;
 Portées de nom et ombrage variable ;
 Les tuples et leur objectif, la construction et l'utilisation de tuples ;
 Les dictionnaires et leur objectif, la construction et l'utilisation de dictionnaires ;
 Exceptions - l'instruction try et la clause except, les exceptions Python intégrées, les tests de
code et le débogage.

4.1/ Les fonctions

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 (telles que la fonction print()). Vous
pouvez voir une liste complète des fonctions intégrées de Python sur
[Link]
 ceux qui proviennent des modules préinstallés (vous les découvrirez dans le cours Python
Essentials Partie 2)
 des fonctions définies par l'utilisateur qui sont écrites par des utilisateurs pour des
utilisateurs - vous pouvez écrire vos propres fonctions et les utiliser librement dans votre
code,
 les fonctions lambda (vous les découvrirez dans le cours Python Essentials Partie 2.)

3. Vous pouvez définir votre propre fonction à l'aide du mot clé def et de la syntaxe suivante :

 def your_function(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 définir une fonction qui prend également des arguments, tout comme la fonction à un
paramètre ci-dessous :

1/12
  def hello(name): # defining a function
 print("Hello,", name) # body of the function
 name = input("Enter your name: ")
 hello(name) # calling the function

4.2/ Comment les fonctions communiquent avec leur environnement ?

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.

Exemple de fonction à un paramètre :

 def hi(name):
 print("Hi,", name)
 hi("Greg")

Exemple de fonction à deux paramètres :

 def hi_all(name_1, name_2):

 print("Hi,", name_2)
 print("Hi,", name_1)
 hi_all("Sebastian", "Konrad")

Exemple de fonction à trois paramètres :

 def address(street, city, postal_code):

 print("Your address is:", street, "St.,", city, postal_code)
 s = input("Street: ")
 p_c = input("Postal Code: ")
 c = input("City: ")
 address(s, c, p_c)

2. Vous pouvez passer des arguments à une fonction en utilisant les techniques suivantes :

 passage d'argument positionnel dans lequel l'ordre des arguments passés importe
(Ex. 1),
 mot-clé (nommé) passage d'argument dans lequel l'ordre des arguments passés n'a
pas d'importance (Ex. 2),
 un mélange de passage d'arguments positionnels et de mots-clés (Ex. 3).

2/12
 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 de position ne doivent pas suivre les arguments de
mot-clé. C'est pourquoi si vous essayez d'exécuter l'extrait 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 une 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(first_name, last_name="Smith"):

 print(first_name, last_name)

 name("Andy") # outputs: Andy Smith
 name("Betty", "Johnson") # outputs: Betty Johnson (the keyword argument replaced by
"Johnson")

3/12
4.3/ Retourner un résultat d'une fonction

1. Vous pouvez utiliser le mot-clé return pour indiquer à une fonction de renvoyer une valeur.
L'instruction return 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

4/12
3. Vous pouvez utiliser une liste comme argument d'une fonction, par exemple :

 def hi_everybody(my_list):
 for name in my_list:
 print("Hi,", name)

 hi_everybody(["Adam", "John", "Lucy"])

4. Une liste peut également être un résultat de fonction, par exemple :

 def create_list(n):
 my_list = []
 for i in range(n):
 my_list.append(i)
 return my_list

 print(create_list(5))

4.4/ Portées en Python

1. Une variable qui existe en dehors d'une fonction a une portée à l'intérieur du corps de la
fonction (exemple 1) à moins que la fonction ne définisse une variable du même nom (exemple 2 et
exemple 3), par exemple :

Exemple 1:

 var = 2

 def mult_by_var(x):
 return x * var

 print(mult_by_var(7)) # outputs: 14

Exemple 2:

 def mult(x):
 var = 5
 return x * var
 print(mult(7)) # outputs: 35

5/12
Exemple 3:

 def mult(x):
 var = 7
 return x * var

 var = 3
 print(mult(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 :

 def adding(x):
 var = 7
 return x + var

 print(adding(4)) # outputs: 11
 print(var) # NameError

3. Vous pouvez utiliser le mot clé global suivi d'un nom de variable pour rendre la portée de la
variable globale, par exemple :

 var = 2
 print(var) # outputs: 2

 def return_var():
 global var
 var = 5
 return var

 print(return_var()) # outputs: 5
 print(var) # outputs: 5

4.5/ Récursivité
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 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
peut être facile de faire une erreur et de créer une fonction qui ne se termine jamais. Vous devez

6/12
é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 façon dont le concept de récursivité peut être
mis en pratique :

 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

4.6/ Tuples
1. Les tuples sont des collections de données ordonnées et non modifiables (immutable). Ils
peuvent être considérés comme des listes immutables. Ils sont écrits entre parenthèses :

 my_tuple = (1, 2, True, "a string", (3, 4), [5, 6], None)
 print(my_tuple)

 my_list = [1, 2, True, "a string", (3, 4), [5, 6], None]
 print(my_list)

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 :

 empty_tuple = ()
 print(type(empty_tuple)) # outputs: <class 'tuple'>

3. Un tuple à un élément peut être créé comme suit :

 one_elem_tuple_1 = ("one", ) # Brackets and a comma.

 one_elem_tuple_2 = "one", # No brackets, just a comma.

Si vous supprimez la virgule, vous direz à Python de créer une variable, pas un tuple :

 my_tuple_1 = 1,
 print(type(my_tuple_1)) # outputs: <class 'tuple'>

7/12
 
 my_tuple_2 = 1 # This is not a tuple.
 print(type(my_tuple_2)) # outputs: <class 'int'>

4. Vous pouvez accéder aux éléments de tuple en les indexant :

 my_tuple = (1, 2.0, "string", [3, 4], (5, ), True)

 print(my_tuple[3]) # outputs: [3, 4]

5. Les tuples sont immutables, ce qui signifie que vous ne pouvez pas modifier leurs éléments (vous
ne pouvez pas ajouter de tuples, ni modifier, ni supprimer des éléments de tuples). L'extrait de code
suivant provoquera une exception :

 my_tuple = (1, 2.0, "string", [3, 4], (5, ), True)

 my_tuple[2] = "guitar" # The TypeError exception will be raised.

Cependant, vous pouvez supprimer un tuple dans son ensemble :

 my_tuple = 1, 2, 3,
 del my_tuple
 print(my_tuple) # NameError: name 'my_tuple' is not defined

6. Vous pouvez parcourir les éléments d'un tuple (exemple 1), vérifier si un élément spécifique est
(pas) présent dans un tuple (exemple 2), utiliser la fonction len() 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
 tuple_1 = (1, 2, 3)
 for elem in tuple_1:
 print(elem)

# Example 2
 tuple_2 = (1, 2, 3, 4)
 print(5 in tuple_2)
 print(5 not in tuple_2)

# Example 3
 tuple_3 = (1, 2, 3, 5)
 print(len(tuple_3))

# Example 4
 tuple_4 = tuple_1 + tuple_2
 tuple_5 = tuple_3 * 2


8/12
  print(tuple_4)
 print(tuple_5)

Remarque :

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 :

 my_tuple = tuple((1, 2, "string"))

 print(my_tuple)

 my_list = [2, 4, 6]
 print(my_list) # outputs: [2, 4, 6]
 print(type(my_list)) # outputs: <class 'list'>
 tup = tuple(my_list)
 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,
 my_list = list(tup)
 print(type(my_list)) # outputs: <class 'list'>

4.7/ Dictionnaires
1. Les dictionnaires sont des collections de données non ordonnées*, modifiables (mutables) et
indexées. (*Dans 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 :

 my_dictionary = {
 key1: value1,
 key2: value2,
 key3: value3,
 }

9/12
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 méthode get() (ex. 2) :

 pol_eng_dictionary = {
 "kwiat": "flower",
 "woda": "water",
 "gleba": "soil"
 }

 item_1 = pol_eng_dictionary["gleba"] # ex. 1
 print(item_1) # outputs: soil

 item_2 = pol_eng_dictionary.get("woda")
 print(item_2) # 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 clé de l'élément de la manière suivante :

 pol_eng_dictionary = {
 "zamek": "castle",
 "woda": "water",
 "gleba": "soil"
 }

 pol_eng_dictionary["zamek"] = "lock"
 item = pol_eng_dictionary["zamek"]
 print(item) # outputs: lock

4. Pour ajouter ou supprimer une clé (et la valeur associée), utilisez la syntaxe suivante :

 phonebook = {} # an empty dictionary


 phonebook["Adam"] = 3456783958 # create/add a key-value pair
 print(phonebook) # outputs: {'Adam': 3456783958}

 del phonebook["Adam"]
 print(phonebook) # outputs: {}

Vous pouvez également insérer un élément dans un dictionnaire en utilisant la méthode update(), et
supprimer le dernier élément en utilisant la méthode popitem(), par exemple :

10/12
  pol_eng_dictionary = {"kwiat": "flower"}

 pol_eng_dictionary.update({"gleba": "soil"})
 print(pol_eng_dictionary) # outputs: {'kwiat': 'flower', 'gleba': 'soil'}

 pol_eng_dictionary.popitem()
 print(pol_eng_dictionary) # outputs: {'kwiat': 'flower'}

5. Vous pouvez utiliser la boucle for pour parcourir un dictionnaire, par exemple :

 pol_eng_dictionary = {
 "zamek": "castle",
 "woda": "water",
 "gleba": "soil"
 }

 for item in pol_eng_dictionary:
 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 :

 pol_eng_dictionary = {
 "zamek": "castle",
 "woda": "water",
 "gleba": "soil"
 }

 for key, value in pol_eng_dictionary.items():
 print("Pol/Eng ->", key, ":", value)

7. Pour vérifier si une clé donnée existe dans un dictionnaire, vous pouvez utiliser le mot clé in :

 pol_eng_dictionary = {
 "zamek": "castle",
 "woda": "water",
 "gleba": "soil"
 }

 if "zamek" in pol_eng_dictionary:
 print("Yes")

11/12
  else:
 print("No")

8. Vous pouvez utiliser le mot-clé del pour supprimer un élément spécifique ou supprimer un
dictionnaire. Pour supprimer tous les éléments du dictionnaire, vous devez utiliser la méthode
clear() :

 pol_eng_dictionary = {
 "zamek": "castle",
 "woda": "water",
 "gleba": "soil"
 }

 print(len(pol_eng_dictionary)) # outputs: 3
 del pol_eng_dictionary["zamek"] # remove an item
 print(len(pol_eng_dictionary)) # outputs: 2

 pol_eng_dictionary.clear() # removes all the items
 print(len(pol_eng_dictionary)) # outputs: 0

 del pol_eng_dictionary # removes the dictionary

9. Pour copier un dictionnaire, utilisez la méthode copy() :

 pol_eng_dictionary = {
 "zamek": "castle",
 "woda": "water",
 "gleba": "soil"
 }
 copy_dictionary = pol_eng_dictionary.copy()

12/12