Bienvenue à notre documentation en ligne

Vous y retrouverez tous les aide-mémoires que nous rédigeons pour nos ateliers et nos présentations.

Table des matières

Installation de Python

Sous Windows et Mac OS

La problématique principale sous Windows et Mac OS est la nécessité de compiler certains modules sur votre poste.

En effet, si vous n’avez pas installer explicitement un compilateur, vos tentatives d’installation de module externe échoueront.

Il existe heureusement des distributions qui nous rendent la vie plus facile.

En voici 3:

Les instructions suivantes s’appliquent pour l’utilisation d’Anaconda, mais sentez-vous bien à l’aise d’utiliser ActivePython ou PythonXY.

Installer Anaconda

Téléchargez la distribution anaconda et installez le sur votre poste

Tester votre installation

Tester le tout en tapant les commandes suivantes dans votre terminal.

1
2
3
$ conda info
$ conda install fabric
$ fab --help

La première commande nous affiche des détails sur Anaconda et conda.

La deuxième commande installe le module Fabric qui nécessite une compilation du module PyCrypto.

La troisème commande affiche l’aide de la commande fab qui provient du module Fabric.

Si tout se déroule bien pour ces étapes, vous êtes en bateau !

Environnements virtuels

Installer des paquets en Python à l’aide de pip ou easy_install demande par défaut les accès administrateurs. Leur installation terminent également dans votre installation système, ce qui peut causer des ennuis.

Pour remédier à ce problème, Vous pouvez créer un environnement virtuel:

1
2
3
4
5
6
7
8
# Installer virtualenv si ce n'est pas déjà fait
sudo pip install virtualenv

# Créer un virtualenv
virtualenv monvenv

# Activer l'environnement virtuel
source ./monvenv/bin/activate

Si vous publiez votre code par github, bitbucket ou similaire, il est recommandé de fournir un fichier requirements.txt qui permet de recréer l’environnement virtuel, soit les dépendances de votre projet:

1
pip freeze > ./requirements.py

Pour recréer votre environnement:

1
pip install -r ./requirements.txt

Python

Création de variables

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# Peut être True ou False
un_bool = True

un_chiffre = 1000

chaine_de_caractere = "bacon ipsum"

une_liste_mutable = [1, 2, 3, 4]

une_liste_non_mutable = (1, 2, 3, 4) # Aussi nommée tuple

un_dictionnaire = {
    "une_cle": "une_valeur",
    "une_2e_cle": "une_2e_valeur",
}

# Ne contiendra qu'une seule fois pomme
un_ensemble = {
    "pomme",
    "pomme",
    "orange",
    "poire",
    "banane",
}

Structures de contrôle

Si logique
1
2
3
4
5
6
if une_condition:
    print("Oui")
elif une_autre_condition:
    print("Non")
else:
    print("Aucune condition dans le if ou le elif n'est Vraie")
Boucle For
1
2
3
4
couleurs = ["rouge", "bleu", "vert"]

for couleur in couleurs:
    print(couleur)
1
2
3
4
5
6
7
8
donnees = [False, False, True, False]

for x in donnees:
    if not x:
        # Arrête l'exécution et sort de la boucle
        break
else:
    print("Affiche ceci s'il n'y a pas eu de break")

Opérations

Arithmétique
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
x = 3; y = 4

# Addition
x + y
# Soustraction
x - y
# Multiplication
x * y
# Division
x / y
# Division entière
x // y
# Modulo (reste de la division)
x % y
# Puissance
x ** y
Comparaison
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
x = 3; y = 4; z = 5; a = [1, 2, 3, 4, 5]

# Égalité
(x == y, x != y)
# Inégalité
(x > y, x < y, x >= y, x <= y)
# Chaînage de comparaisons
x < y < z
# Opérateur "dans"
y in a
# Opérateur "est"
y is z

# Tout élément non nul ou non vide est évalué à vrai
if z:
    print("Sera affiché")

Les fonctions

1
2
3
4
5
6
7
8
def bien_le_bonjour(prenom):
    """
    Cette fonction souhaite une bonne journée au prénom
    en paramètre
    """
    print "Bonjour {}".format(prenom)

bien_le_bonjour("Bernard")

Programmation orienté objet

Les classes
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
class Automobile:
    couleur = ""
    marque = ""
    position_x = 0
    position_y = 0

    def __init__(self, couleur, marque):
        """
        Un constructeur
        """
        self.couleur = couleur
        self.marque = marque

    def roule(self, x, y):
        """
        Roule ma boule !
        """
        self.position_x, self.position_y = x, y
L’héritage
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# Animal est un Objet
class Animal:
    def __init__(self):
        pass

# Cheval est un Animal
class Cheval(Animal):
    """
    Une classe qui hérite d'une autre contient tous les attributs et
    méthodes de son parent. Ici, Cheval hérite d'Animal.
    """
    def galoper(self):
        """
        Définition d'une fonction propre à Cheval.
        """
        print("Je galope!")

class Humain(Animal):
    def __init__(self):
        print("Init de Humain")

    def parler(self):
        print("Je parle!")

# Centaure est un Cheval et un Humain
class Centaure(Cheval, Humain):
    def __init__(self):
        # super() utilise le MRO pour trouver l'objet parent
        # Dans ce cas-ci, tente d'appeler le __init__ de Cheval, sinon repli
        # sur celui de Humain. Puisque Cheval n'a pas de __init__ qui lui
        # est propre, celui de Humain() est appelé.
        super().__init__()

        # Appel explicite utilisant le polymorphisme
        Humain.__init__(self)

        # Cet appel exécutera le __init__ de Animal
        Cheval.__init__(self)

        # Appel des méthodes héritées
        self.galoper()
        self.parler()

Les modules

1
2
3
4
5
6
7
8
9
# Importation absolue
from python import antigravity
import random

print random.shuffle([1, 2, 3])

# Importation relative
from .module_dans_le_repertoire_courant import unObjet
from ..mon_module import unObjet

Les exceptions

1
2
3
4
5
6
7
8
9
# Les blocs else et finally sont optionnels
try:
    raise Exception("Mon Exception")
except (Exception, MemoryError) as e:
    print("Erreur survenue: ", e)
else:
    print("Si aucune erreur n'est survenue, afficher ceci")
finally:
    print("Toujours affiché")

Compréhensions

Liste
1
2
3
4
a = [1, 2, 3, 4]

carres = [x**2 for x in a]
pairs = [x for x in a if not x % 2]
Ensemble
1
2
3
4
a = {1, 2, 3, 4}

carres = {x**2 for x in a}
pairs = {x for x in a if not x % 2}
Dictionnaire
1
carres = {x: x**2 for x in (2, 4, 6)}