Syntaxes, Définitions

Définitions

  1. Définition D1 : classe

  2. Définition D1 : point d'entrée du programme

  3. Définition D1 : test

  4. Définition D1 : variable

  5. Définition D10 : frozenset

  6. Définition D2 : constante

  7. Définition D2 : fonction

  8. Définition D2 : instantiaion

  9. Définition D3 : fonction récursive

  10. Définition D3 : méthode

  11. Définition D3 : type immuable (ou immutable)

  12. Définition D4 : attribut

  13. Définition D4 : chaîne de caractères

  14. Définition D4 : portée d'un variable

  15. Définition D5 : méthode statique

  16. Définition D5 : tuple

  17. Définition D5 : variable locale

  18. Définition D6 : attribut statique

  19. Définition D6 : type modifiable (ou mutable)

  20. Définition D6 : variable globale

  21. Définition D7 : héritage

  22. Définition D7 : liste

  23. Définition D8 : dictionnaire

  24. Définition D8 : surcharge

  25. Définition D9 : set

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.

entrée originale

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.

entrée originale

Définition D1 : test

Les tests permettent d’exécuter des instructions différentes selon la valeur d’une condition logique.

entrée originale

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.

entrée originale

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.

entrée originale

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.

entrée originale

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.

entrée originale

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.

entrée originale

Définition D3 : fonction récursive

Une fonction récursive est une fonction qui s’appelle elle-même.

entrée originale

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.

entrée originale

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.

entrée originale

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.

entrée originale

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.

entrée originale

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.

entrée originale

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.

entrée originale

Définition D5 : tuple

System Message: INFO/1 (somewhere/workspace/teachpyx/teachpyx_UT_39_std/_doc/sphinxdoc/source/c_lang/types.rst, line 4); backlink

Duplicate implicit target name: « 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).

entrée originale

Définition D5 : variable locale

Une variable locale est une variable dont la portée est réduite à une fonction.

entrée originale

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.

entrée originale

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.

entrée originale

Définition D6 : variable globale

Une variable globale est une variable dont la portée est l’ensemble du programme.

entrée originale

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$.

entrée originale

Définition D7 : liste

Les listes sont des collections d’objets qui peuvent être de tout type. Elles sont modifiables.

entrée originale

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.

entrée originale

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.

entrée originale

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é.

entrée originale

Syntaxe

  1. Syntaxe S1 : Attraper une exception

  2. Syntaxe S1 : Déclaration d'une classe

  3. Syntaxe S1 : Tests

  4. Syntaxe S1 : importer un module (1)

  5. Syntaxe S10 : Déclaration d'un attribut statique

  6. Syntaxe S11 : Déclaration d'une propriété

  7. Syntaxe S12 : Déclaration d'une propriété (2)

  8. Syntaxe S13 : Déclaration de l'opérateur __copy__

  9. Syntaxe S14 : Déclaration d'attributs figés

  10. Syntaxe S15 : Héritage

  11. Syntaxe S16 : Surcharge de méthodes héritées

  12. Syntaxe S2 : Instanciation d'une classe

  13. Syntaxe S2 : Instruction pass

  14. Syntaxe S2 : Lever une exception

  15. Syntaxe S2 : importer un module (2)

  16. Syntaxe S3 : Boucle while

  17. Syntaxe S3 : Déclaration d'une méthode

  18. Syntaxe S3 : importer un module (3)

  19. Syntaxe S4 : Appel d'une méthode

  20. Syntaxe S4 : Boucle for

  21. Syntaxe S5 : Déclaration d'un attribut

  22. Syntaxe S5 : Liste en extension

  23. Syntaxe S6 : Déclaration d'un constructeur

  24. Syntaxe S6 : Déclaration d'une fonction

  25. Syntaxe S7 : Appel d'un constructeur

  26. Syntaxe S7 : Appel d'une fonction

  27. Syntaxe S8 : Déclaration de l'opérateur __str__

  28. Syntaxe S8 : Valeurs par défaut

  29. Syntaxe S9 : Déclaration d'une méthode statique

  30. Syntaxe S9 : Nombre indéfini de paramètres

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

entrée originale

Syntaxe S1 : Déclaration d’une classe

class nom_classe :
    # corps de la classe
    # ...

entrée originale

Syntaxe S1 : Tests

if condition1 :
   instruction1
   instruction2
   ...
else :
   instruction3
   instruction4
   ...

entrée originale

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

entrée originale

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

entrée originale

Syntaxe S11 : Déclaration d’une propriété

class nom_classe :
    nom_propriete = property (fget, fset, fdel, doc)

entrée originale

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

entrée originale

Syntaxe S13 : Déclaration de l’opérateur __copy__

class nom_classe :
    def __copy__ () :
        copie = nom_classe(...)
        # ...
        return copie

entrée originale

Syntaxe S14 : Déclaration d’attributs figés

class nom_classe (object) :
    __slots__ = "attribut_1", ..., "attribut_n"

entrée originale

Syntaxe S15 : Héritage

class nom_classe (nom_ancetre) :
    # corps de la classe
    # ...

entrée originale

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

entrée originale

Syntaxe S2 : Instanciation d’une classe

cl = nom_classe()

entrée originale

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

entrée originale

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.

entrée originale

Syntaxe S2 : importer un module (2)

import module_exemple as alias

c = alias.exemple_classe()
print(c)
print(alias.exemple_fonction())

entrée originale

Syntaxe S3 : Boucle while

while cond :
    instruction 1
    ...
    instruction n

entrée originale

Syntaxe S3 : Déclaration d’une méthode

class nom_classe :
    def nom_methode(self, param_1, ..., param_n):
        # corps de la méthode...

entrée originale

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())

entrée originale

Syntaxe S4 : Appel d’une méthode

cl = nom_classe()    # variable de type nom_classe
t  = cl.nom_methode (valeur_1, ..., valeur_n)

entrée originale

Syntaxe S4 : Boucle for

for x in ensemble:
    instruction 1
    ...
    instruction n

entrée originale

Syntaxe S5 : Déclaration d’un attribut

class nom_classe :
    def nom_methode (self, param_1, ..., param_n) :
        self.nom_attribut = valeur

entrée originale

Syntaxe S5 : Liste en extension

[ expression for x in ensemble ]

entrée originale

Syntaxe S6 : Déclaration d’un constructeur

class nom_classe :
    def __init__(self, param_1, ..., param_n):
        # code du constructeur

entrée originale

Syntaxe S6 : Déclaration d’une fonction

def fonction_nom (par_1, ..., par_n) :
    instruction_1
    ...
    instruction_n
    return res_1, ..., res_n

entrée originale

Syntaxe S7 : Appel d’un constructeur

x = nom_classe (valeur_1,...,valeur_n)

entrée originale

Syntaxe S7 : Appel d’une fonction

x_1, ..., x_n = fonction_nom (valeur_1, valeur_2, ..., valeur_n)

entrée originale

Syntaxe S8 : Déclaration de l’opérateur __str__

class nom_class :
    def __str__ (self) :
        # corps de l'opérateur
        return...

entrée originale

Syntaxe S8 : Valeurs par défaut

def fonction_nom (param_1, param_2 = valeur_2, ..., param_n = valeur_n):
    ...

entrée originale

Syntaxe S9 : Déclaration d’une méthode statique

class nom_class :
    @staticmethod
    def nom_methode(params, ...) :
        # corps de la méthode
        ...

entrée originale

Syntaxe S9 : Nombre indéfini de paramètres

def fonction (param_1, ..., param_n, *liste, **dictionnaire) :

entrée originale