Voir la source de Python 2

{{Menu_Python_2}}{{Pythonline3}}
{{#widget:Iframe|url=https://tarentino.fr/images/e/e4/Menu1.svg|width=850|height=200|border=0}}
__NOTOC__
<font size=6 color=red>'''PYTHON programmation objet'''</font>
= Python =
== Les bases ==
<div style="width:52%; height:600px; overflow:auto; border:solid 1px black;">
<center>
<table>
<tr>
<td >{{Video_3}}</td>
<td >{{#widget:YouTube|id=HPM2ZAxKVlU}}</td>
</tr>
</table>
</center>
=== Les variables par l'exemple ===
* Affectons une valeur à la variable age 
<syntaxhighlight lang="python" line='line'>
>>> age = 30
>>> age
30
</syntaxhighlight>
* On va ensuite ajouter 10 à la valeur de cette variable
<syntaxhighlight lang="python" line='line'>
>>> age = 30
>>> age = age + 10
>>> age
40
</syntaxhighlight>
* Il est possible de mettre une variable dans une autre variable.
<syntaxhighlight lang="python" line='line'>
>>> age = 30
>>> age2 = age
>>> age2
30
</syntaxhighlight>
* On peut mettre à peu près tout ce qu'on veut dans la variable, y compris du texte:
<syntaxhighlight lang="python" line='line'>
>>> age = "J'ai 30 ans"
>>> age
"J'ai 30 ans"
</syntaxhighlight>
* Il est possible de concaténer, c'est à dire d'ajouter du texte à du texte:
<syntaxhighlight lang="python" line='line'>
>>> age = age + " et je suis encore jeune!"
>>> age
"J'ai 30 ans et je suis encore jeune!"
</syntaxhighlight>
*  On peut même multiplier une chaine de caractères.
<syntaxhighlight lang="python" line='line'>
>>> age = "jeune"
>>> age * 3
'jeunejeunejeune'
</syntaxhighlight>
* Evidemment, si on essaie de faire des additions avec des variables qui sont des chiffres et d'autres qui sont du texte, l'interpréteur va hurler
<syntaxhighlight lang="python" line='line'>
>>> age = "J'ai 30 ans"
>>> age
"J'ai 30 ans"
>>> age + 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
</syntaxhighlight>
* On remarquera que l'interpréteur est sympa puisqu'il dit ce qui ne va pas: Il ne peut pas concaténer str et int .
</div>

== Les listes ==
<div style="width:52%; height:600px; overflow:auto; border:solid 1px black;">
<center>
<table>
<tr>
<td >{{Video_4}}</td>
<td >{{#widget:YouTube|id=J3RJE8516MU}}</td>
</tr>
</table>
</center>
* Les listes (ou list / array ) en python sont une variable dans laquelle on peut mettre plusieurs variables.
=== Créer une liste en python ===
 <syntaxhighlight lang="python" line='line'>
 >>> liste = []
 </syntaxhighlight>
=== Voir le contenu de la liste en l'appelant ===
 <syntaxhighlight lang="python" line='line'>
 >>> liste
 <type 'list'>
 </syntaxhighlight>
===  Ajouter une valeur à une liste python ===
 <syntaxhighlight lang="python" line='line'>
 >>> liste = [1,2,3]
 >>> liste
 [1, 2, 3]
 </syntaxhighlight>
=== Ajouter après la création de la liste ===
<font color=green size=4>méthode append</font>
 <syntaxhighlight lang="python" line='line'>
 >>> liste = []
 >>> liste
 []
 >>> liste.append(1)
 >>> liste
 [1]
 >>> liste.append("ok")
 >>> liste
 [1, 'ok']
 </syntaxhighlight>
* Il est possible de mélanger dans une même liste des variables de type différent. On peut d'ailleurs mettre une liste dans une liste.
=== Afficher un item d'une liste ===
 <syntaxhighlight lang="python" line='line'>
 >>> liste = ["a","d","m"]
 >>> liste[0]
 'a'
 >>> liste[2]
 'm'
 </syntaxhighlight>
=== Modifier une valeur avec son index ===
 <syntaxhighlight lang="python" line='line'>
 >>> liste = ["a","d","m"]
 >>> liste[0]
 'a'
 >>> liste[2]
 'm'
 >>> liste[2] = "z"
 >>> liste
 ['a', 'd', 'z']
 </syntaxhighlight>
===  Supprimer une entrée avec un index ===
<font color=red size=4>Fonction del</font>
 <syntaxhighlight lang="python" line='line'>
 >>> liste = ["a", "b", "c"]
 >>> del liste[1]
 >>> liste
 ['a', 'c']
 </syntaxhighlight>
===  Supprimer une entrée avec sa valeur ===
<font color=green size=4>Méthode remove</font>
 <syntaxhighlight lang="python" line='line'>
 >>> liste = ["a", "b", "c"]
 >>> liste.remove("a")
 >>> liste
 ['b', 'c']
 </syntaxhighlight>
===  Inverser les valeurs d'une liste ===
* Inverser les items d'une liste
<font color=green size=4>méthode reverse</font>
 <syntaxhighlight lang="python" line='line'>
 >>> liste = ["a", "b", "c"]
 >>> liste.reverse()
 >>> liste
 ['c', 'b', 'a']
 </syntaxhighlight>
===  Compter le nombre d'items d'une liste ===
* Il est possible de compter le nombre d'items d'une liste avec la fonction len .
 <syntaxhighlight lang="python" line='line'>
 >>> liste = [1,2,3,5,10]
 >>> len(liste)
 5
 </syntaxhighlight>
=== Compter le nombre d'occurences d'une valeur ===
<font color=green size=4>Méthode count</font>
 <syntaxhighlight lang="python" line='line'>
 >>> liste = ["a","a","a","b","c","c"]
 >>> liste.count("a")
 3
 >>> liste.count("c")
 2
 </syntaxhighlight>
=== Trouver l'index d'une valeur ===
<font color=green size=4>méthode index</font>
 <syntaxhighlight lang="python" line='line'>
 >>> liste = ["a","a","a","b","c","c"]
 >>> liste.index("b")
 3
 </syntaxhighlight>
=== Manipuler une liste ===
 <syntaxhighlight lang="python" line='line'>
 >>> liste = [1, 10, 100, 250, 500]
 >>> liste[0]
 1
 >>> liste[-1] # Cherche la dernière occurence
 500
 >>> liste[-4:] # Affiche les 4 dernières occurrences
 [500, 250, 100, 10]
 >>> liste[:] # Affiche toutes les occurences
 [1, 10, 100, 250, 500]
 >>> liste[2:4] = [69, 70]
 [1, 10, 69, 70, 500]
 >>> liste[:] = [] # vide la liste
 []
 </syntaxhighlight>
=== Boucler sur une liste ===
* Pour afficher les valeurs d'une liste, on peut utiliser une boucle:
 <syntaxhighlight lang="python" line='line'>
 >>> liste = ["a","d","m"]
 >>> for lettre in liste:
 ...     print lettre
 ... 
 a
 d
 m
 </syntaxhighlight>
* Pour récupérer l'index, utiliser la fonction enumerate .
 <syntaxhighlight lang="python" line='line'>
 >>> for lettre in enumerate(liste):
 ...     print lettre
 ... 
 (0, 'a')
 (1, 'd')
 (2, 'm')
 </syntaxhighlight>
'''Les valeurs retournées par la boucle sont des tuples.'''
=== Copier une liste ===
* Beaucoup de débutants font l'erreur de copier une liste de cette manière:
 <syntaxhighlight lang="python" line='line'>
 >>> x = [1,2,3]
 >>> y = x
 </syntaxhighlight>
* Or si on change une valeur de la liste y , la liste x sera elle aussi affectée par cette modification:
 <syntaxhighlight lang="python" line='line'>
 >>> x = [1,2,3]
 >>> y = x
 >>> y[0] = 4
 >>> x
 [4, 2, 3]
 </syntaxhighlight>
* En fait cette syntaxe permet de travailler sur un même élément nommé différemment
* Alors comment copier une liste qui sera indépendante?
 <syntaxhighlight lang="python" line='line'>
 >>> x = [1,2,3]
 >>> y = x[:]
 >>> y[0] = 9
 >>> x
 [1, 2, 3]
 >>> y
 [9, 2, 3]
 </syntaxhighlight>
* Pour des données plus complexes, utiliser la <font color=red size=4>fonction deepcopy</font> du module copy
 <syntaxhighlight lang="python" line='line'>
 >>> import copy
 >>> x = [[1,2], 2]
 >>> y = copy.deepcopy(x)
 >>> y[1] = [1,2,3]
 >>> x
 [[1, 2], 2]
 >>> y
 [[1, 2], [1, 2, 3]]
 </syntaxhighlight>
=== Transformer une string en liste ===
* Transformer une chaine de caractère en liste. 
<font color=green size=4>Méthode split</font>
 <syntaxhighlight lang="python" line='line'>
 >>> ma_chaine = "Olivier:ENGEL:Strasbourg"
 >>> ma_chaine.split(":")
 ['Olivier', 'ENGEL', 'Strasbourg']
 </syntaxhighlight>
=== Transformer une liste en string ===
<font color=green size=4>Méthode " join "</font>
 <syntaxhighlight lang="python" line='line'>
 >>> liste = ["Olivier","ENGEL","Strasbourg"]
 >>> ":".join(liste)
 'Olivier:ENGEL:Strasbourg'
 </syntaxhighlight>
=== Trouver un item dans une liste ===
* Pour savoir si un élément est dans une liste, utiliser le mot clé in de cette manière:
 <syntaxhighlight lang="python" line='line'>
 >>> liste = [1,2,3,5,10]
 >>> 3 in liste
 True
 >>> 11 in liste
 False
 </syntaxhighlight>
=== La fonction range ===
* La <font color=red size=4>fonction range</font> génère une liste composée d'une simple suite arithmétique.
 <syntaxhighlight lang="python" line='line'>
 >>> range(10)
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 </syntaxhighlight>
=== Agrandir une liste par une liste ===
* Pour mettre bout à bout deux listes, utiliser la <font color=green size=4>méthode extend</font>
 <syntaxhighlight lang="python" line='line'>
 >>> x = [1, 2, 3, 4]
 >>> y = [4, 5, 1, 0]
 >>> x.extend(y)
 >>> print x
 [1, 2, 3, 4, 4, 5, 1, 0]
 </syntaxhighlight>
=== Permutations ===
* La permutation d'un ensemble d'éléments est une liste de tous les cas possibles. 
* Si on besoin de cette fonctionnalité, inutile de réinventer la roue, itertools 
 <syntaxhighlight lang="python" line='line'>
 >>> from itertools import permutations
 >>> list(permutations(['a', 'b', 'c']))
 [('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]
 </syntaxhighlight>
=== Permutation d'une liste de liste ===
* Afficher tous les cas possibles d'une liste elle-même composée de liste? 
* Outil product de itertools :
 <syntaxhighlight lang="python" line='line'>
 >>> from itertools import product
 >>> list(product(['a', 'b'], ['c', 'd']))
 [('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd')]
 </syntaxhighlight>
=== Astuces ===
* Afficher les 2 premiers éléments d'une liste
 <syntaxhighlight lang="python" line='line'>
 >>> liste = [1,2,3,4,5]
 >>> liste[:2]
 [1, 2]
 </syntaxhighlight>
* Afficher le dernier item d'une liste:
 <syntaxhighlight lang="python" line='line'>
 >>> liste = [1, 2, 3, 4, 5, 6]
 >>> liste[-1]
 6
 </syntaxhighlight>
* Afficher le 3ème élément en partant de la fin:
 <syntaxhighlight lang="python" line='line'>
 >>> liste = [1, 2, 3, 4, 5, 6]
 >>> liste[-3]
 4
 </syntaxhighlight>
* Afficher les 3 derniers éléments d'une liste:
 <syntaxhighlight lang="python" line='line'>
 >>> liste = [1, 2, 3, 4, 5, 6]
 >>> liste[-3:]
 [4, 5, 6]
 </syntaxhighlight>
* Additionner deux listes pour les combiner ensemble en utilisant l'opérateur + :
 <syntaxhighlight lang="python" line='line'>
 >>> x = [1, 2, 3]
 >>> y = [4, 5, 6]
 >>> x + y
 [1, 2, 3, 4, 5, 6]
 </syntaxhighlight>
* Mutiplier une liste:
 <syntaxhighlight lang="python" line='line'>
 >>> x = [1, 2]
 >>> x*5
 [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
 </syntaxhighlight>
* Utile pour initialiser une liste:
 <syntaxhighlight lang="python" line='line'>
 >>> [0] * 5
 [0, 0, 0, 0, 0]
 </syntaxhighlight>

== Méthodes de manipulation de listes ==
<div style="width:80%; height:600px; overflow:auto; border:solid 1px black;">
=== Ajouter, Supprimer, trier ===
<center>
<table>
<tr>
<td >{{Video_6}}</td>
<td >{{#widget:YouTube|id=h_s6ctXNPJ0}}</td>
</tr>
</table>
</center>
</div>

</div>

== Les Tuples ==
<div style="width:52%; height:600px; overflow:auto; border:solid 1px black;">
* Un tuple est une liste qui ne peut plus être modifiée.
=== Créer un tuple ===
 <syntaxhighlight lang="python" line='line'>
 >>> mon_tuple = ()
 </syntaxhighlight>
=== Ajouter une valeur à un tuple ===
* Créer un tuple avec des valeurs
 <syntaxhighlight lang="python" line='line'>
 >>> mon_tuple = (1, "ok", "olivier")
 </syntaxhighlight>
* Les parenthèses ne sont pas obligatoires mais facilite la lisibilité du code (rappelons que la force de python est sa simplicité de lecture):
 <syntaxhighlight lang="python" line='line'>
 >>> mon_tuple = 1, 2, 3
 >>> type(mon_tuple)
 <type 'tuple'>
 </syntaxhighlight>
* Lorsqu'on créé un tuple avec une seule valeur, ne pas oublier d'y ajouter une virgule, sinon ce n'est pas un tuple.
 <syntaxhighlight lang="python" line='line'>
 >>> mon_tuple = ("ok")
 >>> type(mon_tuple)
 <type 'str'>
 >>> mon_tuple = ("ok",)
 >>> type(mon_tuple)
 <type 'tuple'>
 </syntaxhighlight>
=== Afficher une valeur d'un tuple ===
* Le tuple est une sorte de liste, on peut donc utiliser la même syntaxe pour lire les données du tuple.
 <syntaxhighlight lang="python" line='line'>
 >>> mon_tuple[0]
 1
 </syntaxhighlight>
* Et évidemment si on essaie de changer la valeur d'un index, l'interpreteur nous insulte copieusement:
 <syntaxhighlight lang="python" line='line'>
 >>> mon_tuple[1] = "ok"
 Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
 TypeError: 'tuple' object does not support item assignment
 </syntaxhighlight>
=== A quoi sert un tuple alors? ===
* Le tuple permet une affectation multiple:
 <syntaxhighlight lang="python" line='line'>
 >>> v1, v2 = 11, 22
 >>> v1
 11
 >>> v2
 22
 </syntaxhighlight>
* Il permet également de renvoyer plusieurs valeurs lors d'un appel d'une fonction:
 <syntaxhighlight lang="python" line='line'>
 >>> def donne_moi_ton_nom():
 ...     return "olivier", "engel"
 ... 
 >>> donne_moi_ton_nom()
 ('olivier', 'engel')
 </syntaxhighlight>
* On utilisera un tuple pour définir des sortes de constantes qui n'ont donc pas vocation à changer.
</div>

== Les Dictionnaires ==
<div style="width:50%; height:600px; overflow:auto; border:solid 1px black;">
* Un dictionnaire en python est une sorte de liste mais au lieu d'utiliser des index , on utilise des clés alphanumériques.
=== Créer un dictionnaire python ===
* Initialiser un dictionnaire:
 <syntaxhighlight lang="python" line='line'>
 >>> a = {}
 </syntaxhighlight>
* ou
 <syntaxhighlight lang="python" line='line'>
 >>> a = dict()
 </syntaxhighlight>
=== Ajouter des valeurs dans un dictionnaire python ===
* Il faut indiquer une clé ainsi qu'une valeur:
 <syntaxhighlight lang="python" line='line'>
 >>> a = {}
 >>> a["nom"] = "Wayne"
 >>> a["prenom"] = "Bruce"
 >>> a
 {'nom': 'Wayne', 'prenom': 'Bruce'}
 </syntaxhighlight>
* On peut utiliser des clés numériques comme dans la logique des listes .
* Comment récupérer une valeur dans un dictionnaire python?
* La <font color=green size=4>méthode get</font>  permet de récupérer une valeur dans un dictionnaire et si la clé est introuvable, on peut donner une valeur à retourner par défaut:
 <syntaxhighlight lang="python" line='line'>
 >>> data = {"name": "Wayne", "age": 45}
 >>> data.get("name")
 'Wayne'
 >>> data.get("adresse", "Adresse inconnue")
 'Adresse inconnue'
 </syntaxhighlight>

=== Vérifier la présence d'une clé dans un dictionnaire python ===
* Utiliser la <font color=green size=4>méthode haskey</font> pour vérifier la présence d'une clé
 <syntaxhighlight lang="python" line='line'>
 >>> a.has_key("nom")
 True
 </syntaxhighlight>
=== Supprimer une entrée dans un dictionnaire python ===
* Il est possible de supprimer une entrée en indiquant sa clé, comme pour les listes:
 <syntaxhighlight lang="python" line='line'>
 >>> del a["nom"]
 >>> a
 {'prenom': 'Bruce'}
 </syntaxhighlight>
=== Récupérer les clés d'un dictionnaire python par une boucle ===
* Pour récupérer les clés on utilise la <font color=green size=4>méthode keys</font> .
 <syntaxhighlight lang="python" line='line'>
 >>> fiche = {"nom":"Wayne", "prenom":"Bruce"}
 >>> for cle in fiche.keys():
 ...     print cle
 ... 
 nom
 prenom
 </syntaxhighlight>
=== Récupérer les valeurs d'un dictionnaire python par une boucle ===
* <font color=green size=4>Méthode values</font>
 <syntaxhighlight lang="python" line='line'>
 >>> fiche = {"nom":"Wayne", "prenom":"Bruce"}
 >>> for valeur in fiche.values():
 ...     print valeur
 ... 
 Wayne
 Bruce
 </syntaxhighlight>
=== Récupérer les clés et les valeurs d'un dictionnaire python par une boucle ===
* Pour récupérer les clés et les valeurs en même temps, on utilise la <font color=green size=4>méthode items</font> qui retourne un tuple .
 <syntaxhighlight lang="python" line='line'>
 >>> fiche = {"nom":"Wayne","prenom":"Bruce"}
 >>> for cle,valeur in fiche.items():
 ...     print cle, valeur
 ... 
 nom Wayne
 prenom Bruce
 </syntaxhighlight>
=== Utiliser des tuples comme clé dans un dictionnaire python ===
* Une des forces de python est la combinaison tuple/dictionnaire qui fait des merveilles dans certains cas comme lors de l'utilisation de coordonnées.
 <syntaxhighlight lang="python" line='line'>
 >>> b = {}
 >>> b[(32)]=12
 >>> b[(45)]=13
 >>> b
 {(4, 5): 13, (3, 2): 12}
 </syntaxhighlight>
=== Créer une copie indépendante d'un dictionnaire python ===
* Comme pour toute variable, on ne peut pas copier un dictionnaire en faisant dic1 = dic2 
 <syntaxhighlight lang="python" line='line'>
 >>> d = {"k1":"Bruce", "k2":"Wayne"}
 >>> e = d
 >>> d["k1"] = "XXX"
 >>> e
 {'k2': 'Wayne', 'k1': 'XXX'}
 </syntaxhighlight>
* Pour créer une copie indépendante, on peut utiliser la <font color=green size=4>méthode copy</font>
 <syntaxhighlight lang="python" line='line'>
 >>> d = {"k1":"Bruce", "k2":"Wayne"}
 >>> e = d.copy()
 >>> d["k1"] = "XXX"
 >>> e
 {'k2': 'Wayne', 'k1': 'Bruce'}
 </syntaxhighlight>
=== Fusionner des dictionnaires python ===
* La <font color=green size=4>méthode update</font> permet de fusionner deux dictionaires .
 <syntaxhighlight lang="python" line='line'>
 >>> a = {'nom': 'Wayne'}
 >>> b = {'prenom': 'bruce'}
 >>> a.update(b)
 >>> print(a)
 {'nom': 'Wayne', 'prenom': 'Bruce'}
 </syntaxhighlight>
</div>

== Fonctions et Méthodes ==
<div style="width:50%; height:600px; overflow:auto; border:solid 1px black;">
<center>
<table>
<tr>
<td >{{Video_5}}</td>
<td >{{#widget:YouTube|id=u3u0BxbzLFw}}</td>
</tr>
</table>
</center>
=== Les fonctions ===
* Une fonction (ou function ) est une suite d'instructions que l'on peut appeler avec un nom.
==== Première fonction ====
* Créons une fonction qui nous retournera un âge:
 <syntaxhighlight lang="python" line='line'>
 >>> def indique_mon_age():
 ...     return 30;
 ... 
 >>> indique_mon_age()
 30
 </syntaxhighlight>
* On ne peut pas copier coller ce code, on doit entrer chaque ligne à la main et appuyer sur entrée pour retourner à la ligne. Les 3 chevrons et les 3 points sont affichés par l'interpréteur python.
* Tout d'abord pour indiquer à l'interpréteur qu'on veut créer une fonction , on utilisera le mot clé def suivi d'un nom puis de parenthèses et ensuite d'un double point.
* On remarque également qu'il y a un espace entre les 3 points et le mot clé "return", il s'agit d'une indentation , c'est à dire un espace qui améliore non seulement la lecture de la fonction mais qui indique que nous sommes toujours dans la fonction. Lorsque l'action demandée n'est plus dans la fonction, il ne faut plus indenter le texte. Pour indenter du texte, on doit appuyer sur la touche TAB du clavier -ou dans d'autres cas créer 4 espaces manuellement-.
==== Les paramètres ====
* Créons une autre fonction:
<syntaxhighlight lang="python" line='line'>
>>> def augmente_moi(a):
...     return augmente_moi + 2
... 
>>> augmente_moi(1)
3
 </syntaxhighlight>
* Cette fonction incrémente de 2 une valeur que l'on passe en paramètre.
* Il est d'ailleurs possible d'utiliser plusieurs paramètres:
 <syntaxhighlight lang="python" line='line'>
 >>> def augmente_moi(a, b):
 ...     return 30 + a + b
 ... 
 >>> augmente_moi(1, 2)
 33
 </syntaxhighlight>
* Un paramètre est obligatoire
* Lorsqu'on indique des paramètres à une fonction, ces derniers doivent impérativement être renseignés sans quoi une erreur apparaîtra.
 <syntaxhighlight lang="python" line='line'>
 >>> def augmente_moi(a, b):
 ...     return 30 + a + b
 ...
 >>> augmente_moi(1)
 Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
 TypeError: augmente_moi() takes exactly 2 arguments (1 given)
 </syntaxhighlight>
* <font color=Magenta size=4>L'opérateur splat</font> : * est très souvent utilisé en python.
 def ma_function(*var)
 def ma_function(**var)
 ma_function(*var)
 ma_function(**var)
* Une liste en paramètre
* On peut récupérer les valeurs renseignées via une liste:
<syntaxhighlight lang="python" line='line'>
>>> def augmente_moi(*param):
...     return param[0] + param[1] + param[2]
... 
>>> augmente_moi(1, 2, 3)
6
>>> augmente_moi(10, 20, 30)
60
</syntaxhighlight>
* Rendre obligatoire uniquement certains paramètres avec une liste.
* Si on désire rendre obligatoire uniquement certains paramètres, utiliser la syntaxe suivante:
<syntaxhighlight lang="python" line='line'>
>>> def ma_fiche(prenom, nom, *reste):
...     return prenom + " " + nom 
... 
>>> ma_fiche("olivier","engel")
'olivier engel'
</syntaxhighlight>
* On remarque que le paramètre " reste " est précédé d'une étoile * .
* Utiliser un dictionnaire pour les paramètres
* On peut utiliser un dictionnaire en paramètres pour cela on doit ajouter une double étoile: **
<syntaxhighlight lang="python" line='line'>
>>> def ma_fiche(**parametres):
...     return parametres["prenom"]
...
>>> ma_fiche(prenom="olivier")
'olivier'
</syntaxhighlight>

==== Utilisation de splat liste au niveau des appels de fonctions ====
* Reprenons l'exemple de la fonction augmente_moi :
<syntaxhighlight lang="python" line='line'>
>>> def augmente_moi(*param):
...     return param[0] + param[1] + param[2]
... 
</syntaxhighlight>
* Nous avons vu qu'il était possible de faire ceci:
<syntaxhighlight lang="python" line='line'>
>>> augmente_moi(1, 2, 3)
6
</syntaxhighlight>
* L'utilisation de l'étoile permet de passer par une liste:
<syntaxhighlight lang="python" line='line'>
>>> data = [1, 2, 3]
>>> augmente_moi(*data)
6
</syntaxhighlight>
* Utilisation de splat dictionnaire au niveau des appels de fonctions.
* Prenons l'exemple de cette fonction:
<syntaxhighlight lang="python" line='line'>
>>> def test(firstname="", lastname=""):
...     return "{} {}" .format(firstname, lastname)
</syntaxhighlight>
* Créons notre dictionnaire:
<syntaxhighlight lang="python" line='line'>
>>> data = {'firstname':'olivier', 'lastname':'engel'}
</syntaxhighlight>
* Et envoyons notre variable avec une étoile *
<syntaxhighlight lang="python" line='line'>
>>> test(*data)
'lastname firstname'
</syntaxhighlight>
* Puis avec deux étoiles **
<syntaxhighlight lang="python" line='line'>
>>> test(**data)
'olivier engel'
</syntaxhighlight>

=== Portée des variables (variable globale et variable locale) ===
Une variable déclarée à la racine d'un module est visible dans tout ce module. On parle alors de variable globale .
<syntaxhighlight lang="python" line='line'>
>>> x = "hello"
>>> def test():
...     print x
... 
>>> test()
hello
</syntaxhighlight>
Et une variable déclarée dans une fonction ne sera visible que dans cette fonction. On parle alors de variable locale .
<syntaxhighlight lang="python" line='line'>
>>> x = False
>>> def test():
...     x = "hello"
... 
>>> test()
>>> x
False
</syntaxhighlight>

== Les fonctions natives ==
<center>
{{Python_natif}}
</center>

== Procédure et fonctions ==
* Une fonction n'est pas obligée de renvoyer une valeur, on parlera alors dans ce cas plutôt de procédure . 
</div>