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é")
|
\ Sort by:\ best rated\ newest\ oldest\
\\
Add a comment\ (markup):
\