ROMMY production : Tutoriel Python 3.0

Lorsque vous programmerez, vous coderez sûrement plusieurs fois une même partie de codes. Pour que le codage soit rapide, vous remplacerez ces bouts de codes qui se répètent par une ligne.
En apprennant donc à faire des fonctions, vous rendrez votre code plus lisible.

Les fonctions

Les fonctions, vous en avez déjà entendu parlé, sûrement en mathématique. Et bien en programmation, les fonctions sont identiques.
En mathématique, on a y = f(x) où f est une fonction. Par exemple, f(x) = x², pour x = 3, f(3) = 9 et donc y = 9.
En programmation, c'est la même chose.Vous allez le découvrir au fil de ce chapitre.

Pour commencer, voyons comment nous allons créer une fonction en python :

Définition de fonction.

En orange, on utilise le mot clé "def" pour définir une fonction.
Ensuite en bleu, on nomme la fonction pour pouvoir l'utiliser, puis on termine par "():"
Puis tout ce qui appartient à la fonction sera décalé avec une tabulation.
L'intérieur de la fonction est composée d'autant d'instructions que l'on veut et se termine par "return" + quelque chose (variable, fonction, etc...)

Voyons l'exemple mathématique de tout à l'heure.
En programmation, on va coder :

def carre(x):
x *= x
return x

print (carre(3))
print (carre(4))

La première partie (ligne 1 à 3) correspond à la création de la fonction. La deuxième partie correspond au programme.
Sachez que le programme lit les fonctions mais ne fait rien, il commence à agir selon vos ordres après avoir lu toutes les fonctions. Dans cet exemple, il agit à partir de la ligne 5.

Mettons nous à la place du programme. Il crée la fonction "carre" et la mémorise. Puis il l'utilise quand on lui demande. Ici, il l'utilise deux fois : la première pour le carré de 3 puis le carré de 4.
Le resultat du programme est donc "9" puis "16"

Peut être avez vous vu que dans la fonction, il y avait un mot-clé (en orange). Ce mot-clé est return.
A quoi sert-il ?
Et bien, à retourner (récupérer) le résultat. Dans cette fonction, elle retourne la valeur de x après l'avoir transformer en carré. Les fonctions s'utilisent comme une variable, on aurait aussi pu écrire ce code :

def carre(x):
x *= x
return x

variable_carre = carre(3)
print (variable_carre)
variable_carre = carre(4)
print (variable_carre)

Dans ce code, la variable "variable_carre" récupére le résultat de la fonction puis est affichée par le print. Alors que dans le premier code, on affiche directement le résultat sans utiliser de variable.
Donc si vous avez besoin de garder le résultat, vous devrez utiliser la deuxième façon. Si vous ne désirez pas le garder, utilisez la première.

Au début de ce chapitre, je vous ai dit qu'elles servaient à raccourcir votre code. Si vous n'avez pas besoin qu'elles retournent un résultat et que le seul but de votre fonction est de raccourcir votre code, vous n'allez pas utiliser les fonctions mais les procédures (fonctions particulières).

Les procédures (les méthodes)

Les procèdures sont des fonctions sans return, car elles n'ont pas besoin de renvoyer quelque chose. En fait, elles ne font que réaliser des actions.
Voici comment on crée et utilise une procédure :

def procedure():
...
instruction ...

procedure()

Et oui, presque rien n'a changé, à part le return qui a disparu.

Comme exemple d'utilisation, je vais prendre rommy sokoban :

Le jeu ROMMY Sokoban

Le but est de déplacer le personnage sur la croix tout en haut, on sait tourner le personnage vers la gauche et avancer d'une case. Le programme sera :

Code avec nos propres procédures	Code sans nos propres procédures
# permet de tourner le personnage vers la droite def tournerDroite(): tournerGauche() tournerGauche() tournerGauche() # permet d'avancer plus vite def courir(): avancer() avancer() tournerDroite() courir() tournerDroite() avancer() tournerGauche() courir() tournerDroite() courir() tournerDroite() courir() courir()	tournerGauche() tournerGauche() tournerGauche() avancer() avancer() tournerGauche() tournerGauche() tournerGauche() avancer() tournerGauche() avancer() avancer() tournerGauche() tournerGauche() tournerGauche() avancer() avancer() tournerGauche() tournerGauche() tournerGauche() avancer() avancer() avancer() avancer()

Vous voyez que le code avec procédures est plus court et plus lisible que si l'on n'utilisait pas les procédures.

Dans l'exemple des fonctions, vous pouvez remarquer qu'il y a un "x" entre les parenthèses. Ceci est appelé un paramétre.

Les variables locales et globales

Les fonctions et procédures peuvent posséder aucun ou une infinité de paramétres qui permettent de transmettre des variables de l'extérieur vers l'intérieur des fonctions.

def addition(variable_interne_1, variable_interne_2):
return variable_interne_1 + variable_interne_2

variable_externe_1 = 2
variable_externe_2 = 4
somme = addition(variable_externe_1,variable_externe_2)
print ("La somme ", variable_externe_1, "+" , variable_externe_2, "vaut : " , somme)

Explication: variable_interne_1 et variable_interne_2 entre parenthèses sont des paramétres. variable_interne_1 est une copie de variable_externe_1, de même pour les 2eme variables.
Ce sont donc de nouvelles variables qui ont été créée, elles récupèrent les informations contenues dans les "variable_externe" puis manipulent ces informations dans la fonction et sont ensuite supprimer quand on sort de la fonction.
Elles ne sont donc plus utilisables en dehors de la fonction.
Ces variables qui ne peuvent être utilisées qu'à l'intérieur des fonctions sont appelées des variables locales, ici variable_interne_1 est une variable locale à la fonction "addition".
Faites très attention à ceci : si vous voulez utiliser la variable "variable_interne_1" en dehors de la fonction, vous aurez une erreur. Vous aurez un message disant que la variable n'existe pas car c'est une variable locale à la fonction "addition".

Une variable en dehors d'une fonction est appelée "variable globale". Elle peut être utilisée à l'extérieur mais aussi à l'intérieur des fonctions. Mais vous ne pourrez pas la modifier si la modification se fait dans une fonction. Pour pouvoir modifier cette variable, il faut utiliser l'instruction global.

exemple 1 :	exemple 2 :
def procedure(): a = 4# a est une variable locale print (a, b) a, b = 2, 3# a et b sont deux variables globales print (a, b) procedure() print (a, b)	def procedure(): global a a = 4# a est une variable globale print (a, b) a, b = 2, 3# a et b sont deux variables globales print (a, b) procedure() print (a, b)
resultat 1 :	resultat 2 :
2 3 4 3 2 3	2 3 4 3 4 3

Vous voyez que dans le resultat de l'exemple 2 (avec global), la variable "a" a été modifiée.
En fait, dans l'exemple 1, la variable locale "a" (ligne 2) n'est pas la même que la variable globale "a" (ligne 4), c'est une troisième variable qui a été crée.
N'étant pas la même variable, il est normal que la modification soit impossible.
Dans l'exemple 2, grâce à "global", la variable "a"(ligne 3) n'est pas une nouvelle variable mais est celle de la ligne 5. Elle peut donc être modifiée de l'intérieur de la fonction.

Si vous faites plusieurs programmes, il peut arriver qu'une fonction créée dans l'un soit utile pour l'autre. Dans ce cas, vous allez utiliser un module.

Les modules (Importation de fonctions)

Les modules sont des regroupements de fonctions. On appelle ça aussi des bibliothèques.
Voyons comment on crée un module, par exemple "mathematique.py" :

def addition(x, y):
  return x + y

def soustraction(x, y):
  return x - y

def multiplication(x, y):
  return x * y

Vous devez maintenant le sauvegarder, on va utiliser le nom "mathematique.py".

Maintenant que vous avez créé votre module, on va utiliser ces fonctions dans notre programme.
Pour pouvoir utiliser les fonctions, il faut les importer selon 2 méthodes :

En mettant from nom_du_module import *. Avec cette méthode, les fonctions ont toutes été importées dans le programme et vous pouvez donc les utiliser normalement.
from mathematique import *

print (soustraction(5,2))
print (multiplication(4, 2))

Vous pouvez aussi utiliser comme ceci : from nom_du_module import nom_de_fonction1, nom_de_fonction2 .... Dans ce cas il n'importera que les fonctions ou procédures qui ont été précisées.
En mettant import nom_du_module et en utilisant les fonctions de cette manière : nom_du_module.fonction(). Avec cette méthode, vous importez seulement la fonction demandée.
import mathematique

print (mathematique.soustraction(5,2))
print (mathematique.multiplication(4, 2))

La deuxième méthode est préférable car elle permet de préciser à quel module appartient la fonction.
Le fait de préciser le module permet d'éviter les problèmes dû aux noms de fonctions identiques.
Prenons par exemple la fonction soustraction de notre module et imaginons que cette fonction existe aussi dans le module math.py
Si on a utilisé la première façon pour importer, il est impossible de distinguer de quel module elle appartient. Tandis qu'avec la deuxième façon, le module est indiqué. (Pour info, chaque module forme un espace de noms. Chaque fonctions dans un module, fais partis d'un espaces de noms. Comme on indique l'espace de noms, il n'y a pas de confusion faites)
Si le nom du module est trop long, on peut donner un raccourci avec 'as' : import nom_du_module as nom_raccourci et utiliser la fonction de la manière suivante : nom_raccourci.fonction().

Vous pourrez bien sûr utiliser de la même façon des modules que vous n'aurez pas créé vous-même.
Vous devez donc voir en fonction de votre utilisation qu'elle est la meilleure méthode pour importer :

la première si vous devez utiliser beaucoup de fois les fonctions, procédures et surtout que vous n'utiliser pas d'autre module ayant des fonctions du même nom.
la seconde si vous utilisez des modules ayant des noms de fonctions identiques sinon si vous utilisez peu de fonctions ou rendre votre code plus lisibles car on saura de quel module appartiennent les fonctions.

Vous savez que l'on peut additionner, soustraire, ... plusieurs variables ensembles. Et bien pour les fonctions, c'est la même chose.

Les opérateurs

Les fonctions s'utilisent comme des variables, vous pouvez donc utiliser les mêmes opérateurs que ceux pour les variables.
Voici les opérateurs pour ceux qui ne s'en souviennent plus :

OPERATEUR :	Utilité :
+	Addition
-	Soustraction
*	Multiplication
/	Division
%	Modulo (reste de division)
**	Puissance
+=	Rajouter à la variable
-=	Enlever à la variable
*=	Multiplication de la variable
/=	Division de la variable

Quelques exemples :

from mathematique import *

print (soustraction(5,2) + multiplication(4, 2))
print (multiplication(4, 2) / addition(1,1))
somme = addition(1,1)# somme vaut 2 (1+1)
somme += addition(1,1)# somme vaut 4 (2 + (1+1))
print (somme)

Résultats :

11
4
4

Les renvois multiples

Nous avons vu au début que les fonctions retournaient (renvoyaient) quelque chose. Le problème c'est qu'elle ne renvoie qu'une valeur.
Par exemple, nous voulons récupérer les coordonnées d'un personnage dans un jeu.
Nous aimerions créer une fonction position() qui renvoie ces coordonnées.

def position():
return x# comment on fait pour donner la coordonnée du Y ?

Et bien !!! Avec le début du cours, c'est impossible.
Mais comme ce n'est que le début, vous ne pouvez pas tout savoir mais ne vous en faites pas, la solution arrive tout de suite.

def position():
return x, y

Et oui!!! C'est tout simple.

Comment on l'utilise maintenant ?
C'est là aussi assez simple :

coordX, coordY = position()

coordX récupère la valeur retournée par x et coordY la valeur retournée par y.

Attention, ceci est impossible avec certains langages.

Conclusion

Les fonctions servent donc à améliorer la lisibilité de votre code en le segmentant et en réduisant son volume.

Dans le chapitre suivant, vous apprendrez avec les conditions, à faire des tests dans votre programme.