mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
483 lines
14 KiB
Markdown
483 lines
14 KiB
Markdown
---
|
|
filename: learnpythonlegacy-fr.py
|
|
contributors:
|
|
- ["Louie Dinh", "http://ldinh.ca"]
|
|
translators:
|
|
- ["Sylvain Zyssman", "https://github.com/sylzys"]
|
|
- ["Nami-Doc", "https://github.com/Nami-Doc"]
|
|
---
|
|
|
|
Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des langages de programmation les plus populaires.
|
|
Je suis tombé amoureux de Python de par la clarté de sa syntaxe. C'est pratiquement du pseudo-code exécutable.
|
|
|
|
N.B. : Cet article s'applique spécifiquement à Python 2.7, mais devrait s'appliquer pour toute version Python 2.x. Python 2.7 est en fin de vie et ne sera plus maintenu à partir de 2020, il est donc recommandé d'apprendre Python avec Python 3. Pour Python 3.x, il existe un autre [tutoriel pour Python 3](../python/).
|
|
|
|
```python
|
|
# Une ligne simple de commentaire commence par un dièse
|
|
""" Les lignes de commentaires multipes peuvent être écrites
|
|
en utilisant 3 guillemets ("), et sont souvent utilisées
|
|
pour les commentaires
|
|
"""
|
|
|
|
####################################################
|
|
## 1. Types Primaires et Opérateurs
|
|
####################################################
|
|
|
|
# Les nombres
|
|
3 #=> 3
|
|
|
|
# Les calculs produisent les résultats mathématiques escomptés
|
|
1 + 1 #=> 2
|
|
8 - 1 #=> 7
|
|
10 * 2 #=> 20
|
|
35 / 5 #=> 7
|
|
|
|
# La division est un peu spéciale. C'est une division d'entiers, et Python arrondi le résultat par défaut automatiquement.
|
|
5 / 2 #=> 2
|
|
|
|
# Pour corriger ce problème, on utilise les float.
|
|
2.0 # Voici un float
|
|
11.0 / 4.0 #=> 2.75 ahhh... beaucoup mieux
|
|
|
|
# Forcer la priorité avec les parenthèses
|
|
(1 + 3) * 2 #=> 8
|
|
|
|
# Les valeurs booléenes sont de type primitif
|
|
True
|
|
False
|
|
|
|
# Pour la négation, on utilise "not"
|
|
not True #=> False
|
|
not False #=> True
|
|
|
|
# Pour l'égalité, ==
|
|
1 == 1 #=> True
|
|
2 == 1 #=> False
|
|
|
|
# L'inégalité est symbolisée par !=
|
|
1 != 1 #=> False
|
|
2 != 1 #=> True
|
|
|
|
# D'autres comparateurs
|
|
1 < 10 #=> True
|
|
1 > 10 #=> False
|
|
2 <= 2 #=> True
|
|
2 >= 2 #=> True
|
|
|
|
# On peut enchaîner les comparateurs !
|
|
1 < 2 < 3 #=> True
|
|
2 < 3 < 2 #=> False
|
|
|
|
# Les chaînes de caractères sont créées avec " ou '
|
|
"C'est une chaîne."
|
|
'C\'est aussi une chaîne.'
|
|
|
|
# On peut aussi les "additioner" !
|
|
"Hello " + "world!" #=> "Hello world!"
|
|
|
|
# Une chaîne peut être traitée comme une liste de caractères
|
|
"C'est une chaîne"[0] #=> 'C'
|
|
|
|
# % peut être utilisé pour formatter des chaîne, comme ceci:
|
|
"%s can be %s" % ("strings", "interpolated")
|
|
|
|
# Une autre manière de formatter les chaînes de caractères est d'utiliser la méthode 'format'
|
|
# C'est la méthode à privilégier
|
|
"{0} peut être {1}".format("La chaîne", "formattée")
|
|
# On peut utiliser des mot-clés au lieu des chiffres.
|
|
"{name} veut manger des {food}".format(name="Bob", food="lasagnes")
|
|
|
|
# None est un objet
|
|
None #=> None
|
|
|
|
# Ne pas utiliser le symbole d'inégalité "==" pour comparer des objet à None
|
|
# Il faut utiliser "is"
|
|
"etc" is None #=> False
|
|
None is None #=> True
|
|
|
|
# L'opérateur 'is' teste l'identité de l'objet.
|
|
# Ce n'est pas très utilisé avec les types primitifs, mais cela peut être très utile
|
|
# lorsque l'on utilise des objets.
|
|
|
|
# None, 0, et les chaînes de caractères vides valent False.
|
|
# Toutes les autres valeurs valent True
|
|
0 == False #=> True
|
|
"" == False #=> True
|
|
|
|
|
|
####################################################
|
|
## 2. Variables et Collections
|
|
####################################################
|
|
|
|
# Afficher du texte, c'est facile
|
|
print "Je suis Python. Enchanté!"
|
|
|
|
|
|
# Il n'y a pas besoin de déclarer les variables avant de les assigner.
|
|
some_var = 5 # La convention veut que l'on utilise des minuscules_avec_underscores
|
|
some_var #=> 5
|
|
|
|
# Accéder à une variable non assignée lève une exception
|
|
# Voyez les structures de contrôle pour en apprendre plus sur la gestion des exceptions.
|
|
some_other_var # Lève une exception
|
|
|
|
# 'if' peut être utilisé comme expression
|
|
"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
|
|
|
|
# Listes
|
|
li = []
|
|
# On peut remplir liste dès l'instanciation
|
|
other_li = [4, 5, 6]
|
|
|
|
# On ajoute des éléments avec 'append'
|
|
li.append(1) #li contient [1]
|
|
li.append(2) #li contient [1, 2]
|
|
li.append(4) #li contient [1, 2, 4]
|
|
li.append(3) #li contient [1, 2, 4, 3]
|
|
|
|
# Et on les supprime avec 'pop'
|
|
li.pop() #=> 3 et li contient [1, 2, 4]
|
|
# Remettons-le dans la liste
|
|
li.append(3) # li contient [1, 2, 4, 3] de nouveau.
|
|
|
|
# On accède aux éléments d'une liste comme à ceux un tableau.
|
|
li[0] #=> 1
|
|
# Le dernier élément
|
|
li[-1] #=> 3
|
|
|
|
# Accèder aux indices hors limite lève une exception
|
|
li[4] # Lève un 'IndexError'
|
|
|
|
# On peut accèder à des rangs de valeurs avec la syntaxe "slice"
|
|
# (C'est un rang de type 'fermé/ouvert' pour les plus matheux)
|
|
li[1:3] #=> [2, 4]
|
|
# Sans spécifier de fin de rang, on "saute" le début de la liste
|
|
li[2:] #=> [4, 3]
|
|
# Sans spécifier de début de rang, on "saute" la fin de la liste
|
|
li[:3] #=> [1, 2, 4]
|
|
|
|
# Retirer un élément spécifique dee la liste avec "del"
|
|
del li[2] # li contient [1, 2, 3]
|
|
|
|
# On peut additionner des listes entre elles
|
|
li + other_li #=> [1, 2, 3, 4, 5, 6] - Note: li et other_li existent toujours à part entière
|
|
|
|
# Concaténer des listes avec "extend()"
|
|
li.extend(other_li) # li vaut maintenant [1, 2, 3, 4, 5, 6]
|
|
|
|
# Vérifier l'existence d'un élément dans une liste avec "in"
|
|
1 in li #=> True
|
|
|
|
# Récupérer la longueur avec "len()"
|
|
len(li) #=> 6
|
|
|
|
|
|
# Les "tuples" sont comme des listes, mais sont immuables.
|
|
tup = (1, 2, 3)
|
|
tup[0] #=> 1
|
|
tup[0] = 3 # Lève un 'TypeError'
|
|
|
|
# Mais vous pouvez faire tout ceci sur les tuples:
|
|
len(tup) #=> 3
|
|
tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
|
|
tup[:2] #=> (1, 2)
|
|
2 in tup #=> True
|
|
|
|
# Vous pouvez "dé-packager" les tuples (ou les listes) dans des variables
|
|
a, b, c = (1, 2, 3) # a vaut maintenant 1, b vaut maintenant 2 and c vaut maintenant 3
|
|
# Sans parenthèses, un tuple est créé par défaut
|
|
d, e, f = 4, 5, 6
|
|
# Voyez maintenant comme il est facile d'inverser 2 valeurs
|
|
e, d = d, e # d is now 5 and e is now 4
|
|
|
|
|
|
# Dictionnaires
|
|
empty_dict = {}
|
|
# Un dictionnaire pré-rempli
|
|
filled_dict = {"one": 1, "two": 2, "three": 3}
|
|
|
|
# Trouver des valeurs avec []
|
|
filled_dict["one"] #=> 1
|
|
|
|
# Récupérer toutes les clés sous forme de liste avec "keys()"
|
|
filled_dict.keys() #=> ["three", "two", "one"]
|
|
# Note - l'ordre des clés du dictionnaire n'est pas garanti.
|
|
# Vos résultats peuvent différer de ceux ci-dessus.
|
|
|
|
# Récupérer toutes les valeurs sous forme de liste avec "values()"
|
|
filled_dict.values() #=> [3, 2, 1]
|
|
# Note - Même remarque qu'au-dessus concernant l'ordre des valeurs.
|
|
|
|
# Vérifier l'existence d'une clé dans le dictionnaire avec "in"
|
|
"one" in filled_dict #=> True
|
|
1 in filled_dict #=> False
|
|
|
|
# Chercher une clé non existante lève une 'KeyError'
|
|
filled_dict["four"] # KeyError
|
|
|
|
# Utiliser la méthode "get()" pour éviter 'KeyError'
|
|
filled_dict.get("one") #=> 1
|
|
filled_dict.get("four") #=> None
|
|
# La méthode get() prend un argument par défaut quand la valeur est inexistante
|
|
filled_dict.get("one", 4) #=> 1
|
|
filled_dict.get("four", 4) #=> 4
|
|
|
|
# La méthode "setdefault()" permet d'ajouter de manière sécuris une paire clé-valeur dans le dictionnnaire
|
|
filled_dict.setdefault("five", 5) #filled_dict["five"] vaut 5
|
|
filled_dict.setdefault("five", 6) #filled_dict["five"] is toujours 5
|
|
|
|
|
|
# Les sets stockent ... des sets
|
|
empty_set = set()
|
|
# On initialise un "set()" avec tout un tas de valeurs
|
|
some_set = set([1,2,2,3,4]) # some_set vaut maintenant set([1, 2, 3, 4])
|
|
|
|
# Depuis Python 2.7, {} peut être utilisé pour déclarer un 'set'
|
|
filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4}
|
|
|
|
# Ajouter plus d'éléments au set
|
|
filled_set.add(5) # filled_set contient maintenant {1, 2, 3, 4, 5}
|
|
|
|
# Intersection de sets avec &
|
|
other_set = {3, 4, 5, 6}
|
|
filled_set & other_set #=> {3, 4, 5}
|
|
|
|
# Union de sets avec |
|
|
filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
|
|
|
|
# Différence de sets avec -
|
|
{1,2,3,4} - {2,3,5} #=> {1, 4}
|
|
|
|
# Vérifier l'existence d'une valeur dans un set avec "in"
|
|
2 in filled_set #=> True
|
|
10 in filled_set #=> False
|
|
|
|
|
|
####################################################
|
|
## 3. Structure de contrôle
|
|
####################################################
|
|
|
|
# Initialisons une variable
|
|
some_var = 5
|
|
|
|
# Voici une condition 'if'. L'indentation est significative en Python !
|
|
# Affiche "some_var est inférieur à 10"
|
|
if some_var > 10:
|
|
print "some_var est supérieur à 10."
|
|
elif some_var < 10: # La clause elif est optionnelle
|
|
print "some_var iinférieur à 10."
|
|
else: # La clause else également
|
|
print "some_var vaut 10."
|
|
|
|
|
|
"""
|
|
Les boucles "for" permettent d'itérer sur les listes
|
|
Affiche:
|
|
chien : mammifère
|
|
chat : mammifère
|
|
souris : mammifère
|
|
"""
|
|
for animal in ["chien", "chat", "souris"]:
|
|
# On peut utiliser % pour l'interpolation des chaînes formattées
|
|
print "%s : mammifère" % animal
|
|
|
|
"""
|
|
"range(number)" retourne une liste de nombres
|
|
de 0 au nombre donné
|
|
Affiche:
|
|
0
|
|
1
|
|
2
|
|
3
|
|
"""
|
|
for i in range(4):
|
|
print i
|
|
|
|
"""
|
|
Les boucles "while" boucle jusqu'à ce que leur condition ne soit plus vraie
|
|
Affiche:
|
|
0
|
|
1
|
|
2
|
|
3
|
|
"""
|
|
x = 0
|
|
while x < 4:
|
|
print x
|
|
x += 1 # Raccourci pour x = x + 1
|
|
|
|
# Gérer les exceptions avec un bloc try/except
|
|
|
|
# Fonctionne pour Python 2.6 et ultérieur:
|
|
try:
|
|
# Utiliser "raise" pour lever une exception
|
|
raise IndexError("This is an index error")
|
|
except IndexError as e:
|
|
pass # Pass ne prend pas d'arguments. Généralement, on gère l'erreur ici.
|
|
|
|
|
|
####################################################
|
|
## 4. Fonctions
|
|
####################################################
|
|
|
|
# Utiliser "def" pour créer une nouvelle fonction
|
|
def add(x, y):
|
|
print "x vaut %s et y vaur %s" % (x, y)
|
|
return x + y # Renvoi de valeur avec 'return'
|
|
|
|
# Appeller une fonction avec des paramètres
|
|
add(5, 6) #=> Affichet "x is 5 et y vaut 6" et renvoie 11
|
|
|
|
# Une autre manière d'appeller une fonction, avec les arguments
|
|
add(y=6, x=5) # Les arguments peuvent venir dans n'importe quel ordre.
|
|
|
|
# On peut définir une foncion qui prend un nombre variable de paramètres
|
|
def varargs(*args):
|
|
return args
|
|
|
|
varargs(1, 2, 3) #=> (1,2,3)
|
|
|
|
|
|
# On peut également définir une fonction qui prend un nombre
|
|
# variable d'arguments
|
|
def keyword_args(**kwargs):
|
|
return kwargs
|
|
|
|
# Appelons-là et voyons ce qu'il se passe
|
|
keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
|
|
|
|
# On peut faire les deux à la fois si on le souhaite
|
|
def all_the_args(*args, **kwargs):
|
|
print args
|
|
print kwargs
|
|
"""
|
|
all_the_args(1, 2, a=3, b=4) affiche:
|
|
(1, 2)
|
|
{"a": 3, "b": 4}
|
|
"""
|
|
|
|
# En appellant les fonctions, on peut faire l'inverse des paramètres / arguments !
|
|
# Utiliser * pour développer les paramètres, et ** pour développer les arguments
|
|
params = (1, 2, 3, 4)
|
|
args = {"a": 3, "b": 4}
|
|
all_the_args(*args) # equivaut à foo(1, 2, 3, 4)
|
|
all_the_args(**kwargs) # equivaut à foo(a=3, b=4)
|
|
all_the_args(*args, **kwargs) # equivaut à foo(1, 2, 3, 4, a=3, b=4)
|
|
|
|
# Python a des fonctions de première classe
|
|
def create_adder(x):
|
|
def adder(y):
|
|
return x + y
|
|
return adder
|
|
|
|
add_10 = create_adder(10)
|
|
add_10(3) #=> 13
|
|
|
|
# Mais également des fonctions anonymes
|
|
(lambda x: x > 2)(3) #=> True
|
|
|
|
# On trouve aussi des fonctions intégrées plus évoluées
|
|
map(add_10, [1,2,3]) #=> [11, 12, 13]
|
|
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
|
|
|
|
# On peut utiliser la syntaxe des liste pour construire les "maps" et les "filters"
|
|
[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13]
|
|
[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
|
|
|
|
####################################################
|
|
## 5. Classes
|
|
####################################################
|
|
|
|
# Une classe est un objet
|
|
class Human(object):
|
|
|
|
# Un attribut de classe. Il est partagé par toutes les instances de cette classe.
|
|
species = "H. sapiens"
|
|
|
|
# Initialiseur basique
|
|
def __init__(self, name):
|
|
# Assigne le paramètre à l'attribut de l'instance de classe.
|
|
self.name = name
|
|
|
|
# Une méthode de l'instance. Toutes les méthodes prennent "self" comme 1er paramètre.
|
|
def say(self, msg):
|
|
return "%s: %s" % (self.name, msg)
|
|
|
|
# Une méthode de classe est partagée par toutes les instances.
|
|
# On les appelle avec le nom de la classe en premier paramètre
|
|
@classmethod
|
|
def get_species(cls):
|
|
return cls.species
|
|
|
|
# Une méthode statique est appellée sans référence à une classe ou à une instance
|
|
@staticmethod
|
|
def grunt():
|
|
return "*grunt*"
|
|
|
|
|
|
# Instancier une classe
|
|
i = Human(name="Ian")
|
|
print i.say("hi") # Affiche "Ian: hi"
|
|
|
|
j = Human("Joel")
|
|
print j.say("hello") #Affiche "Joel: hello"
|
|
|
|
# Appeller notre méthode de classe
|
|
i.get_species() #=> "H. sapiens"
|
|
|
|
# Changer les attributs partagés
|
|
Human.species = "H. neanderthalensis"
|
|
i.get_species() #=> "H. neanderthalensis"
|
|
j.get_species() #=> "H. neanderthalensis"
|
|
|
|
# Appeller la méthode statique
|
|
Human.grunt() #=> "*grunt*"
|
|
|
|
|
|
####################################################
|
|
## 6. Modules
|
|
####################################################
|
|
|
|
# On peut importer des modules
|
|
import math
|
|
print math.sqrt(16) #=> 4.0
|
|
|
|
# Et récupérer des fonctions spécifiques d'un module
|
|
from math import ceil, floor
|
|
print ceil(3.7) #=> 4.0
|
|
print floor(3.7) #=> 3.0
|
|
|
|
# Récuperer toutes les fonctions d'un module
|
|
# Attention, ce n'est pas recommandé.
|
|
from math import *
|
|
|
|
# On peut raccourcir le nom d'un module
|
|
import math as m
|
|
math.sqrt(16) == m.sqrt(16) #=> True
|
|
|
|
# Les modules Python sont juste des fichiers Python ordinaires.
|
|
# On peut écrire ses propres modules et les importer.
|
|
# Le nom du module doit être le même que le nom du fichier.
|
|
|
|
# On peut trouver quelle fonction et attributs déterminent un module
|
|
import math
|
|
dir(math)
|
|
```
|
|
|
|
## Prêt à aller plus loin?
|
|
|
|
### En ligne gratuitement
|
|
|
|
* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
|
|
* [Dive Into Python](http://www.diveintopython.net/)
|
|
* [The Official Docs](http://docs.python.org/2.6/)
|
|
* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
|
|
* [Python Module of the Week](http://pymotw.com/2/)
|
|
|
|
### Format papier
|
|
|
|
* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
|
|
* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
|
|
* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
|
|
|