Le langage Python

Avant tout le langage python est un langage interprété

Variable :

assigne 3 à la variable bonjour ex: bonjour=3
assigne bonjour*2 à la variable bonjourx2 ex: bonjourx2=2*bonjour
ajoute 2 à la variable bonjour bonjour+=2
assigne 3 à x et y ex: x = y = 3
Permutation de deux variable :
a = 5
b = 32
a,b = b,a # permutation

Chaine de caractères:

bonjour="Salut les p'tits loups" ou bonjour='Salut les p\'tits loups' ou bonjour="""Salut les p'tits loups"""
sur plusieurs ligne /n (retour à la ligne)

fonction associées

Pour l'aide des fonctions de chaine help("str")

La fonction format

Opération sur les chaines

Listes et tuples

Pour ajouter un argument à la liste

Insérer un élément dans la liste

Le mot-clé «del»

La méthode «remove»

La méthode «enumerate»

Les Tulpes

Création et édition de dictionnaires

Créer un dictionnaire

Les fonctions :

syntaxe : nom_de_la_fonction(parametre_1,parametre_2,…,parametre_n).

La fonction « type »

Cette fonction permet de déterminer le type de la variable paramètre
ex : type(3.2) -> <class 'float'>

La fonction « print»

Les structures conditionnelles

La fonction « if/else»

L'instruction « elif»

Le mot clé elif est une contraction de « else if », que l'on peut traduire très littéralement par « sinon si ».
if a > 0: # Positif
print("a est positif.")
elif a < 0: # Négatif
print("a est négatif.")
else: # Nul
print("a est nul.")
->a est supérieur à 0.

Les opérateurs

La fonction « input»

Cette fonction permet de saisir une variable sous forme de chaine.
annee = input("Saisissez une année : ")
Par contre si nous voulons convertir cette variable en numérique entier
annee = int(annee)

Les boucles

La boucle while

nb = 7
i = 0
while i < 10:
print(i + 1, "*", nb, "=", (i + 1) * nb)
i += 1 # On incrémente i de 1 à chaque tour de boucle

La boucle for

syntaxe : for element in sequence: chaine = "Bonjour les ZER0S"
for lettre in chaine:
print(lettre)
Autre exemble
chaine = "Bonjour les ZER0S"
for lettre in chaine:
if lettre in "AEIOUYaeiouy": # lettre est une voyelle
print(lettre)
else: # lettre est une consonne... ou plus exactement, lettre n'est pas une voyelle
print("*")

syntaxe : def nom_de_la_fonction(parametre1, parametre2, parametre3, parametreN):
def table_par_7():
nb = 7
i = 0
while i < 10:
print(i + 1, "*", nb, "=", (i + 1) * nb)
i += 1
Particularité :
def table(nb, max=10): # La valeur par défaut de max est 10 si omis
"""Fonction affichant la table de multiplication par nb de 1*nb à max*nb (max >= 0)""" i = 0
while i < max:
print(i + 1, "*", nb, "=", (i + 1) * nb)
i += 1

L'instruction «return»

L'instruction «lambda»

Le mot-clé «break»

Le mot-clé «continue»

Les modules

Les modules sont des bouts de codes à inclure directement dans le programme

La méthode import

Emprisonnons notre programme dans un fichier pour en faire un module (.py)

# -*-coding:Latin-1 -*

import os # On importe le module os qui dispose de variables
          # et de fonctions utiles pour dialoguer avec votre
          # système d'exploitation

# Programme testant si une année, saisie par l'utilisateur, est bissextile ou non

annee = input("Saisissez une année : ") # On attend que l'utilisateur fournisse l'année qu'il désire tester
annee = int(annee) # Risque d'erreur si l'utilisateur n'a pas saisi un nombre

if annee % 400 == 0 or (annee % 4 == 0 and annee % 100 != 0):
    print("L'année saisie est bissextile.")
else:
    print("L'année saisie n'est pas bissextile.")

# On met le programme en pause pour éviter qu'il ne se referme (Windows)
os.system("pause")

Pour lancer les fichiers avec des arguments
>>> import sys >>> sys.argv=[mes_arguments] >>> execfile("test.py") # pour autant que test.py traite le(s) sys.argv

Les fichiers

Changer le répertoire de travail courant

Lecture et écriture dans un fichier

Fermer le fichier

Lire l'intégralité du fichier

Écriture dans un fichier

Le mot-clé «with»

Enregistrer des objets dans des fichiers

Récupérer nos objets enregistrés

Portée des variables et références

La portée des variables

Les références

Modifier une liste sans toucher à l'autre

Nos premiers attributs

class Personne: # Définition de notre classe Personne
	"""Classe définissant une personne caractérisée par :
	- son nom
	- son prénom
	- son âge
	- son lieu de résidence"""
	def __init__(self, nom, prenom):
		"""Constructeur de notre classe"""
		self.nom = nom
		self.prenom = prenom
		self.age = 33 # Cela n'engage à rien
		self.lieu_residence = "Paris"

Attributs de classe

class TableauNoir:
	"""Classe définissant une surface sur laquelle on peut écrire,
	que l'on peut lire et effacer, par jeu de méthodes. L'attribut modifié est 'surface'"""
	def __init__(self):
		"""Par défaut, notre surface est vide"""
		self.surface = ""
	def ecrire(self, message_a_ecrire):
		"""Méthode permettant d'écrire sur la surface du tableau.
		Si la surface n'est pas vide, on saute une ligne avant de rajouter le message à écrire"""
		if self.surface != "":
			self.surface += "\n"
		self.surface += message_a_ecrire

Les propriétés en action

class Personne:
	"""Classe dénissant une personne caractérisée par : son nom ; son prénom ; son âge ; son lieu de résidence"""
	def __init__(self, nom, prenom):
		"""Constructeur de notre classe"""
		self.nom = nom
		self.prenom = prenom
		self.age = 33
		self._lieu_residence = "Paris" # Notez le souligné _ devant le nom
	def __repr__(self):
		"""Quand on entre notre objet dans l'interpréteur"""
		return "{} {}, âgé de {} ans".format(self.prenom, self.nom, self.age)
	def __del__(self):
		"""Méthode appelée quand l'objet est supprimé"""
		print("C'est la fin ! On me supprime !")
	def _get_lieu_residence(self):
		"""Méthode qui sera appelée quand on souhaitera accéder en lecture à l'attribut 'lieu_residence'"""
		print("On accéde à l'attribut lieu_residence !")
		return self._lieu_residence
	def _set_lieu_residence(self, nouvelle_residence):
		"""Méthode appelée quand on souhaite modifier le lieu de résidence"""
		print("Attention, il semble que {} déménage à {}.".format(self.prenom, nouvelle_residence))
		self._lieu_residence = nouvelle_residence
	# On va dire à Python que notre attribut lieu_residence pointe vers une propriété
	lieu_residence = property(_get_lieu_residence, _set_lieu_residence)

Les méthodes spéciales

Exemple complet

class Duree:
	"""Classe contenant des durées sous la forme d'un nombre de minutes et de secondes"""
	def __init__(self, min=0, sec=0):
		"""Constructeur de la classe"""
		self.min = min # Nombre de minutes
		self.sec = sec # Nombre de secondes
	def __str__(self):
		"""Affichage un peu plus joli de nos objets"""
		return "{0:02}:{1:02}".format(self.min, self.sec)
	def __repr__(self):
		"""Quand on entre notre objet dans l'interpréteur"""
		return "{0:02}:{1:02}".format(self.min, self.sec)
	def __iadd__(self, objet_a_ajouter):
		"""L'objet à ajouter est un entier, le nombre de secondes"""
		# On travaille directement sur self cette fois
		# On ajoute la durée
		self.sec += objet_a_ajouter
		# Si le nombre de secondes >= 60
		if self.sec >= 60:
			self.min += self.sec // 60
			self.sec = self.sec % 60
			# On renvoie self
		return self
	def __eq__(self, autre_duree):
		"""Test si self et autre_duree sont égales"""
		return self.sec == autre_duree.sec and self.min == autre_duree.min
	def __gt__(self, autre_duree):
		"""Test si self > autre_duree"""
		# On calcule le nombre de secondes de self et autre_duree
		nb_sec1 = self.sec + self.min * 60
		nb_sec2 = autre_duree.sec + autre_duree.min * 60
		return nb_sec1 > nb_sec2

Exemple

class Exemple:
    """Un petit exemple de classe"""
    def __init__(self, nom, prenom):
        """Exemple de constructeur"""
        self.nom = nom
		self.prenom = prenom
        self.age = 33
        self.autre_attribut = "une valeur"
	def __del__(self):
        """Méthode appelée quand l'objet est supprimé"""
        print("C'est la fin ! On me supprime !")
	def __str__(self):
        """Méthode permettant d'afficher plus joliment notre objet"""
        return "{} {}, âgé de {} ans".format(self.prenom, self.nom, self.age)
	def __getattr__(self, nom):
        """Si Python ne trouve pas l'attribut nommé nom, il appelle
        cette méthode. On affiche une alerte"""
        print("Alerte ! Il n'y a pas d'attribut {} ici !".format(nom))
		

Première approche du tri

Trier une liste d'objets

class Etudiant:
	"""Classe représentant un étudiant.
	On représente un étudiant par son prénom (attribut prenom), son âge
	(attribut age) et sa note moyenne (attribut moyenne, entre 0 et 20).
	Paramètres du constructeur :
		prenom -- le prénom de l'étudiant
		age -- l'âge de l'étudiant
		moyenne -- la moyenne de l'étudiant"""
	def __init__(self, prenom, age, moyenne):
		self.prenom = prenom
		self.age = age
		self.moyenne = moyenne
	def __repr__(self):
		return "<Étudiant {} (âge={}, moyenne={})>".format(self.prenom, self.age, self.moyenne)

L'héritage

class Personne:
    """Classe représentant une personne"""
    def __init__(self, nom):
        """Constructeur de notre classe"""
        self.nom = nom
        self.prenom = "Martin"
    def __str__(self):
        """Méthode appelée lors d'une conversion de l'objet en chaîne"""
        return "{0} {1}".format(self.prenom, self.nom)

class AgentSpecial(Personne):
    """Classe définissant un agent spécial.
    Elle hérite de la classe Personne"""
    
    def __init__(self, nom, matricule):
        """Un agent se définit par son nom et son matricule"""
        # On appelle explicitement le constructeur de Personne :
        Personne.__init__(self, nom)
        self.matricule = matricule
    def __str__(self):
        """Méthode appelée lors d'une conversion de l'objet en chaîne"""
        return "Agent {0}, matricule {1}".format(self.nom, self.matricule)

Deux fonctions très pratiques