learnxinyminutes-docs/python-fr.html.markdown at fa9f9fd5639458b7865a48192c4dc18e7ef15d66

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 ou par e-mail: louiedinh [at] [google's email service]
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.
# 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

# 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)
14 KiB

Raw Blame History

Prêt à aller plus loin?

En ligne gratuitement

Format papier

14 KiB Raw Blame History

Prêt à aller plus loin?

En ligne gratuitement

Format papier

14 KiB

Raw Blame History
