Syntaxes et définitions#
Définitions#
Définition D1 : classe
Une classe est un ensemble incluant des variables ou attributs et des fonctions ou méthodes. Les attributs sont des variables accessibles depuis toute méthode de la classe où elles sont définies. En python, les classes sont des types modifiables.
Définition D1 : point d’entrée du programme
Le point d’entrée d’un programme est la première instruction exécutée par l’ordinateur lors de l’exécution de ce programme.
Définition D1 : test
Les tests permettent d’exécuter des instructions différentes selon la valeur d’une condition logique.
Définition D1 : variable
Une variable est caractérisée par :
un identificateur : il peut contenir des lettres, des chiffres, des blancs soulignés mais il ne peut commencer par un chiffre. Minuscules et majuscules sont différenciées. Il est aussi unique.
un type : c’est une information sur le contenu de la variable qui indique à l’interpréteur python, la manière de manipuler cette information.
Définition D10 : frozenset
Un set est un ensemble de valeurs uniques. Ajouter une valeur déjà dans la liste n’a donc aucun impact. On s’en sert beaucoup pour récupérer une liste d’éléments uniques. Ce type est dit immutable car il est impossible d’ajouter des valeurs. En contrepartie, on peut s’en servir comme clé dans un dictionnaire ou comme valeur dans un set ou frozenset.
Définition D2 : constante
Les constantes sont le contraire des variables, ce sont toutes les valeurs numériques, chaînes de caractères, …, tout ce qui n’est pas désigné par un nom. Les constantes possèdent un type mais pas d’identificateur.
Définition D2 : fonction
Une fonction est une partie d’un programme - ou sous-programme - qui fonctionne indépendamment du reste du programme. Elle reçoit une liste de paramètres et retourne un résultat. Le corps de la fonction désigne toute instruction du programme qui est exécutée si la fonction est appelée.
Définition D2 : instantiaion
Une instance d’une classe C désigne une variable de type C.
Le terme instance ne s’applique qu’aux variables dont le type est une classe.
Définition D3 : fonction récursive
Une fonction récursive est une fonction qui s’appelle elle-même.
Définition D3 : méthode
Les méthodes sont des fonctions qui sont associées de manière explicite à une classe. Elles ont comme particularité un accès privilégié aux données de la classe elle-même.
Définition D3 : type immuable (ou immutable)
Une variable de type immuable ne peut être modifiée. Une opération sur une variable de ce type entraîne nécessairement la création d’une autre variable du même type, même si cette dernière est temporaire.
Définition D4 : attribut
Les attributs sont des variables qui sont associées de manière explicite à une classe. Les attributs de la classe se comportent comme des variables globales pour toutes les méthodes de cette classe.
Définition D4 : chaîne de caractères
Le terme « chaîne de caractères » ou string en anglais signifie une suite finie de caractères, autrement dit, du texte.
Définition D4 : portée d’un variable
La portée d’une variable associée à un identificateur recouvre la portion du programme à l’intérieur de laquelle ce même identificateur la désigne. Ceci implique que, dans cette portion de code, aucune autre variable, aucune autre fonction, aucune autre classe, ne peut porter le même identificateur.
Définition D5 : méthode statique
Les méthodes statiques sont des méthodes qui peuvent être appelées même si aucune instance de la classe où elles sont définies n’a été créée.
Définition D5 : tuple
Les tuple sont un tableau d’objets qui peuvent être de tout type. Ils ne sont pas modifiables (les tuple sont immuables ou immutable).
Définition D5 : variable locale
Une variable locale est une variable dont la portée est réduite à une fonction.
Définition D6 : attribut statique
Les attributs statiques sont des attributs qui peuvent être utilisés même si aucune instance de la classe où ils sont définis n’a été créée. Ces attributs sont partagés par toutes les instances.
Définition D6 : type modifiable (ou mutable)
Une variable de type modifiable peut être modifiée, elle conserve le même type et le même identificateur. C’est uniquement son contenu qui évolue.
Définition D6 : variable globale
Une variable globale est une variable dont la portée est l’ensemble du programme.
Définition D7 : héritage
On dit qu’une classe $B$ hérite d’une autre classe $A$ si la déclaration de $B$ inclut les attributs et les méthodes de la classe $A$.
Définition D7 : liste
Les listes sont des collections d’objets qui peuvent être de tout type. Elles sont modifiables.
Définition D8 : dictionnaire
Les dictionnaires sont des listes de couples. Chaque couple contient une clé et une valeur. Chaque valeur est indicée par sa clé. La valeur peut-être de tout type, la clé doit être de type immuable, ce ne peut donc être ni une liste, ni un dictionnaire. Chaque clé comme chaque valeur peut avoir un type différent des autres clés ou valeurs.
Définition D8 : surcharge
Lorsqu’une classe B hérite de la classe A et redéfinit une méthode de la classe A portant le même nom, on dit qu’elle surcharge cette méthode. S’il n’est pas explicitement précisé qu’on fait appel à une méthode d’une classe donnée, c’est toujours la méthode surchargée qui est exécutée.
Définition D9 : set
Un set est un ensemble de valeurs uniques. Ajouter une valeur déjà dans la liste n’a donc aucun impact. On s’en sert beaucoup pour récupérer une liste d’éléments uniques. Ce type est dit mutable car il est possible d’ajouter des valeurs. Comme pour les dictionnaires, les valeurs stockées dans un ensemble doivent être immutables. Sans cela, le langage ne pourrait garantir l’unicité.
Figures#
Problèmes#
Syntaxe#
Syntaxe S1 : Attraper une exception
try:
# ... instructions à protéger
except type_exception_1:
# ... que faire en cas d'erreur de type type_exception_1
except (type_exception_i, type_exception_j):
# ... que faire en cas d'erreur de type type_exception_i ou type_exception_j
except type_exception_n:
# ... que faire en cas d'erreur de type type_exception_n
except:
# ... que faire en cas d'erreur d'un type différent de tous
# les précédents types
else:
# ... que faire lorsque une erreur aucune erreur n'est apparue
Syntaxe S1 : Déclaration d’une classe
class nom_classe :
# corps de la classe
# ...
Syntaxe S1 : Tests
if condition1 :
instruction1
instruction2
...
else :
instruction3
instruction4
...
Syntaxe S1 : importer un module (1)
import importlib
import module_exemple
module_exemple.exemple_variable = 10
importlib.reload(module_exemple)
print(module_exemple.exemple_variable) # affiche 3
Syntaxe S10 : Déclaration d’un attribut statique
class nom_class :
attribut_statique = valeur
def nom_methode (self,params, ...):
nom_class.attribut_statique2 = valeur2
@staticmethod
def nom_methode_st (params, ...) :
nom_class.attribut_statique3 = valeur3
Syntaxe S11 : Déclaration d’une propriété
class nom_classe :
nom_propriete = property (fget, fset, fdel, doc)
Syntaxe S12 : Déclaration d’une propriété (2)
class nom_classe :
@property
def fget_variable(self):
return self.variable
@variable.setter
def fset_variable(self, v):
self.variable = v
Syntaxe S13 : Déclaration de l’opérateur __copy__
class nom_classe :
def __copy__ () :
copie = nom_classe(...)
# ...
return copie
Syntaxe S14 : Déclaration d’attributs figés
class nom_classe (object) :
__slots__ = "attribut_1", ..., "attribut_n"
Syntaxe S15 : Héritage
class nom_classe (nom_ancetre) :
# corps de la classe
# ...
Syntaxe S16 : Surcharge de méthodes héritées
class nom_classe (nom_ancetre) :
def nom_autre_methode (self, ...) :
# ...
def nom_methode (self, ...) :
nom_ancetre.nom_methode (self, ...)
# appel de la méthode définie chez l'ancêtre
nom_ancetre.nom_autre_methode (self, ...)
# appel d'une autre méthode définie chez l'ancêtre
self.nom_autre_methode (...)
# appel d'une méthode surchargée
Syntaxe S2 : Instanciation d’une classe
cl = nom_classe()
Syntaxe S2 : Instruction pass
signe = 0
x = 0
if x < 0: signe = -1
elif x == 0:
pass # signe est déjà égal à 0
else :
signe = 1
Syntaxe S2 : Lever une exception
raise exception_type(message)
Cette instruction lance l’exception exception_type associée au message
message. Le message est facultatif, lorsqu’il n’y en a pas, la syntaxe
se résume à raise exception_type.
Syntaxe S2 : importer un module (2)
import module_exemple as alias
c = alias.exemple_classe()
print(c)
print(alias.exemple_fonction())
Syntaxe S3 : Boucle while
while cond :
instruction 1
...
instruction n
Syntaxe S3 : Déclaration d’une méthode
class nom_classe :
def nom_methode(self, param_1, ..., param_n):
# corps de la méthode...
Syntaxe S3 : importer un module (3)
from module_exemple import * # décommmandé
from module_exemple import exemple_classe, exemple_fonction
c = exemple_classe()
print(c)
print(exemple_fonction())
Syntaxe S4 : Appel d’une méthode
cl = nom_classe() # variable de type nom_classe
t = cl.nom_methode (valeur_1, ..., valeur_n)
Syntaxe S4 : Boucle for
for x in ensemble:
instruction 1
...
instruction n
Syntaxe S5 : Déclaration d’un attribut
class nom_classe :
def nom_methode (self, param_1, ..., param_n) :
self.nom_attribut = valeur
Syntaxe S5 : Liste en extension
[ expression for x in ensemble ]
Syntaxe S6 : Déclaration d’un constructeur
class nom_classe :
def __init__(self, param_1, ..., param_n):
# code du constructeur
Syntaxe S6 : Déclaration d’une fonction
def fonction_nom (par_1, ..., par_n) :
instruction_1
...
instruction_n
return res_1, ..., res_n
Syntaxe S7 : Appel d’un constructeur
x = nom_classe (valeur_1,...,valeur_n)
Syntaxe S7 : Appel d’une fonction
x_1, ..., x_n = fonction_nom (valeur_1, valeur_2, ..., valeur_n)
Syntaxe S8 : Déclaration de l’opérateur __str__
class nom_class :
def __str__ (self) :
# corps de l'opérateur
return...
Syntaxe S8 : Valeurs par défaut
def fonction_nom (param_1, param_2 = valeur_2, ..., param_n = valeur_n):
...
Syntaxe S9 : Déclaration d’une méthode statique
class nom_class :
@staticmethod
def nom_methode(params, ...) :
# corps de la méthode
...
Syntaxe S9 : Nombre indéfini de paramètres
def fonction (param_1, ..., param_n, *liste, **dictionnaire) :