From d22029e0d0e300c5fb4538748e5ed696eeb0241f Mon Sep 17 00:00:00 2001
From: Syl Zys <sylzys@gmail.com>
Date: Sun, 8 Sep 2013 14:53:33 +0200
Subject: Added Python French translation

---
 fr-fr/python-fr.html.markdown | 491 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 491 insertions(+)
 create mode 100644 fr-fr/python-fr.html.markdown

(limited to 'fr-fr/python-fr.html.markdown')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
new file mode 100644
index 00000000..84831772
--- /dev/null
+++ b/fr-fr/python-fr.html.markdown
@@ -0,0 +1,491 @@
+---
+langage: python
+
+contributeurs:
+    - ["Louie Dinh", "http://ldinh.ca"]
+    
+traducteurs:
+  - ["Sylvain Zyssman", "https://github.com/sylzys"]
+
+fichier: learnpython.py
+
+---
+
+Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des langages de promgrammation les plus populaires.
+Je suis tombé amoureux de Python de par la clarité de sa syntaxe. C'est pratiquement du pseudo-code exécutable.
+
+Vos retours sont grandement appréciés. Vous pouvez me contacter sur Twitter [@louiedinh](http://twitter.com/louiedinh) ou par e-mail: louiedinh [at] [google's email service]
+
+NB: Cet artice s'applique spécifiquement à Python 2.7, mais devrait s'appliquer pour toute version Python 2.x
+Vous pourrez bientôt trouver un article pour Python 3!
+
+```python
+# Une ligne simple de commentaire commence par un dièse
+""" Les lignes de commenatires multipes peut être écrite
+    en utilisant 3 '"', et sont souvent utilisées
+    pour commenter
+"""
+
+####################################################
+## 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' "int", 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 traiter 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 nouvelle 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' test l'identité de l'objet.
+# Ce n'est pas très utilse avec les types primitifs, mais cela peut être très util
+# 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, 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 utiliser une liste pré-remplie.
+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 pour un tableau.
+li[0] #=> 1
+# Le dernier élément
+li[-1] #=> 3
+
+# Accèder aux indes 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]
+# Ne pas spécifier de début de rang
+li[2:] #=> [4, 3]
+# Ne pas spécifier de fin de rang
+li[:3] #=> [1, 2, 4]
+
+# Retirer un élément spécifique dee la lsite 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
+
+# Concatener 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 tupels (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'inverse 2 valeurs
+e, d = d, e     # d is now 5 and e is now 4
+
+
+# Dictionaires
+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'odre des clés du dictionnaire n'est pas garanti.
+# Vos résultats peuvent différer de ceux ci-dessous.
+
+# 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 existence 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'existene 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:           # Optionnel également
+    print "some_var vaut 10."
+
+
+"""
+Les boucles "for" font des itérations 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 qu'une 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)
+
+
+# Ont peut également définir une fonction qui prend un nombrenumber of
+# 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 hérite d'un objet
+class Human(object):
+
+    # L'attribut d'une 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
+
+# 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)
+
-- 
cgit v1.2.3


From b466a86d9d293c0ddab7db089c31158a065b4cf1 Mon Sep 17 00:00:00 2001
From: Syl Zys <sylzys@gmail.com>
Date: Sun, 8 Sep 2013 16:27:38 +0200
Subject: typo corrections, thanks to Nami-Doc for re-reading

---
 fr-fr/python-fr.html.markdown | 66 +++++++++++++++++++++----------------------
 1 file changed, 33 insertions(+), 33 deletions(-)

(limited to 'fr-fr/python-fr.html.markdown')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index 84831772..2f10e410 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -11,8 +11,8 @@ fichier: learnpython.py
 
 ---
 
-Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des langages de promgrammation les plus populaires.
-Je suis tombé amoureux de Python de par la clarité de sa syntaxe. C'est pratiquement du pseudo-code exécutable.
+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.
 
 Vos retours sont grandement appréciés. Vous pouvez me contacter sur Twitter [@louiedinh](http://twitter.com/louiedinh) ou par e-mail: louiedinh [at] [google's email service]
 
@@ -21,9 +21,9 @@ Vous pourrez bientôt trouver un article pour Python 3!
 
 ```python
 # Une ligne simple de commentaire commence par un dièse
-""" Les lignes de commenatires multipes peut être écrite
-    en utilisant 3 '"', et sont souvent utilisées
-    pour commenter
+""" Les lignes de commenatires multipes peuvent être écrites
+    en utilisant 3 guillemets ("), et sont souvent utilisées
+    pour les commentaires
 """
 
 ####################################################
@@ -39,12 +39,12 @@ Vous pourrez bientôt trouver un article pour Python 3!
 10 * 2 #=> 20
 35 / 5 #=> 7
 
-# La division est un peu spéciale. C'est une division d' "int", et Python arrondi le résultat par défaut automatiquement.
+# 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
+11.0 / 4.0 #=> 2.75 ahhh... beaucoup mieux
 
 # Forcer la priorité avec les parenthèses
 (1 + 3) * 2 #=> 8
@@ -82,13 +82,13 @@ not False #=> True
 # On peut aussi les "additioner" !
 "Hello " + "world!" #=> "Hello world!"
 
-# Une chaîne peut être traiter comme une liste de caractères
+# 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 nouvelle manière de formatter les chaînes de caractères est d'utiliser la méthode 'format'
+# 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.
@@ -102,8 +102,8 @@ None #=> None
 "etc" is None #=> False
 None is None  #=> True
 
-# L'opérateur 'is' test l'identité de l'objet.
-# Ce n'est pas très utilse avec les types primitifs, mais cela peut être très util
+# 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.
@@ -116,7 +116,7 @@ None is None  #=> True
 ## 2. Variables et Collections
 ####################################################
 
-# Afficher, c'est facile
+# Afficher du texte, c'est facile
 print "Je suis Python. Enchanté!"
 
 
@@ -133,7 +133,7 @@ some_other_var  # Lève une exception
 
 # Listes
 li = []
-# On peut utiliser une liste pré-remplie.
+# On peut remplir liste dès l'instanciation
 other_li = [4, 5, 6]
 
 # On ajoute des éléments avec 'append'
@@ -147,29 +147,29 @@ 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 pour un tableau.
+# 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 indes hors limite lève une exception
+# 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]
-# Ne pas spécifier de début de rang
+# Sans spécifier de début de rang
 li[2:] #=> [4, 3]
-# Ne pas spécifier de fin de rang
+# Sans spécifier de fin de rang
 li[:3] #=> [1, 2, 4]
 
-# Retirer un élément spécifique dee la lsite avec "del"
+# 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
 
-# Concatener des listes avec "extend()"
+# 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"
@@ -179,7 +179,7 @@ li.extend(other_li) # li vaut maintenant [1, 2, 3, 4, 5, 6]
 len(li) #=> 6
 
 
-# Les "tuples", sont comme des listes, mais sont immuables.
+# Les "tuples" sont comme des listes, mais sont immuables.
 tup = (1, 2, 3)
 tup[0] #=> 1
 tup[0] = 3  # Lève un 'TypeError'
@@ -190,15 +190,15 @@ tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
 tup[:2] #=> (1, 2)
 2 in tup #=> True
 
-# Vous pouvez "dé-packager" les tupels (ou les listes) dans des variables
+# 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'inverse 2 valeurs
+# Voyez maintenant comme il est facile d'inverser 2 valeurs
 e, d = d, e     # d is now 5 and e is now 4
 
 
-# Dictionaires
+# Dictionnaires
 empty_dict = {}
 # Un dictionnaire pré-rempli
 filled_dict = {"one": 1, "two": 2, "three": 3}
@@ -208,8 +208,8 @@ 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'odre des clés du dictionnaire n'est pas garanti.
-# Vos résultats peuvent différer de ceux ci-dessous.
+# 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]
@@ -219,7 +219,7 @@ filled_dict.values() #=> [3, 2, 1]
 "one" in filled_dict #=> True
 1 in filled_dict #=> False
 
-# Chercher une clé non existence lève une 'KeyError'
+# Chercher une clé non existante lève une 'KeyError'
 filled_dict["four"] # KeyError
 
 # Utiliser la méthode "get()" pour éviter 'KeyError'
@@ -255,7 +255,7 @@ 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'existene d'une valeur dans un set avec "in"
+# Vérifier l'existence d'une valeur dans un set avec "in"
 2 in filled_set #=> True
 10 in filled_set #=> False
 
@@ -273,12 +273,12 @@ 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:           # Optionnel également
+else:           # La clause else également
     print "some_var vaut 10."
 
 
 """
-Les boucles "for" font des itérations sur les listes
+Les boucles "for" permettent d'itérer sur les listes
 Affiche:
     chien : mammifère
     chat : mammifère
@@ -301,7 +301,7 @@ for i in range(4):
     print i
 
 """
-Les boucles "while" boucle jusqu'à ce qu'une condition ne soit plus vraie
+Les boucles "while" boucle jusqu'à ce que leur condition ne soit plus vraie
 Affiche:
     0
     1
@@ -345,7 +345,7 @@ def varargs(*args):
 varargs(1, 2, 3) #=> (1,2,3)
 
 
-# Ont peut également définir une fonction qui prend un nombrenumber of
+# On peut également définir une fonction qui prend un nombre
 # variable d'arguments
 def keyword_args(**kwargs):
     return kwargs
@@ -395,10 +395,10 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
 ## 5. Classes
 ####################################################
 
-# Une classe hérite d'un objet
+# Une classe est un objet
 class Human(object):
 
-    # L'attribut d'une classe. Il est partagé par toutes les instances de cette classe.
+    # Un attribut de classe. Il est partagé par toutes les instances de cette classe.
     species = "H. sapiens"
 
     # Initialiseur basique
-- 
cgit v1.2.3


From 3cf89d514689ca8610c30171424b2ce1908c0465 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Sun, 8 Sep 2013 22:05:15 -0700
Subject: Updated new contributions

---
 fr-fr/python-fr.html.markdown | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

(limited to 'fr-fr/python-fr.html.markdown')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index 2f10e410..f9b98d41 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -1,14 +1,10 @@
 ---
 langage: python
-
-contributeurs:
+contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
-    
-traducteurs:
+translators:
   - ["Sylvain Zyssman", "https://github.com/sylzys"]
-
-fichier: learnpython.py
-
+filename: learnpython-fr.py
 ---
 
 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.
-- 
cgit v1.2.3


From b28900b889c27f8500a44d9f9bcad5244f1f79bd Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Sun, 8 Sep 2013 22:52:09 -0700
Subject: Fixed up so it builds

---
 fr-fr/python-fr.html.markdown | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'fr-fr/python-fr.html.markdown')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index f9b98d41..2bf0afd0 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -1,10 +1,12 @@
 ---
-langage: python
+language: python
+filename: learnpython-fr.py
 contributors:
-    - ["Louie Dinh", "http://ldinh.ca"]
+  - ["Louie Dinh", "http://ldinh.ca"]
 translators:
   - ["Sylvain Zyssman", "https://github.com/sylzys"]
-filename: learnpython-fr.py
+  - ["Nami-Doc", "https://github.com/Nami-Doc"]
+lang: fr-fr
 ---
 
 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.
-- 
cgit v1.2.3


From 200298c7691e0f0b78b7e879fcf7fc4909cea16a Mon Sep 17 00:00:00 2001
From: C-Duv <github.accounts@claude.duvergier.fr>
Date: Fri, 11 Oct 2013 10:13:12 +0200
Subject: French translation typo in comments for slice syntax with omitted
 indexes

Translation typo in comments for slice syntax with omitted indexes:
"Omit the beginning" meant omit the beginning *of the list* (not the beginning of the range)
"Omit the end" meant omit the end *of the list* (not the end of the range)
---
 fr-fr/python-fr.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'fr-fr/python-fr.html.markdown')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index 2bf0afd0..9dbdafe1 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -156,9 +156,9 @@ 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 début de rang
+# Sans spécifier de fin de rang, on "saute" le début de la liste
 li[2:] #=> [4, 3]
-# Sans spécifier de fin de rang
+# 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"
-- 
cgit v1.2.3