PREAMBULES.

Voir les conventions sur les variables utilisées dans dans ce site ...

CRÉATION ET AFFECTATION.

Sous Python, il n’est pas nécessaire de déclarer une variable avec son type, néanmoins toutes variables doit être dument déclarer (créée), avec ou sans valeur, avant toute utilisation par le programme, sauf la variable de controle d'une boucle for.

Une variable sera créer automatiquement lors de sa première affectation, son type sera défini en fonction de la valeur associée à la variable, et sa portée (local ou global) sera établie en fonction où elle se trouve dans le script.

Dans Python l'affectation est représentée par le symbole "=".

 !!! ATTENTION !!!  Il ne s'agit pas d'une égalité. 

 L'égalité dans Python est représentée par le symbole "==". 

Pour ne pas confondre affectation et égalité dîtes : variable reçoit la valeur (ex. nom reçoit la valeur Dupont). 

L'affectation créer un lien entre une dénomination de la variable et son type d'objet, sa valeur reçu, et la réservation de sa place dans la mémoire de l'ordinateur.

Si l'on réaffecte un nom de variable déjà utilisé avec un autre type d'objet, Python détruit la première occurrence de la variable, et créer un nouvelle objet du nouveau type déclaré. Par exemple : 

var = 7, créer un objet int ( ) nommé var avec la valeur 7.

var = "bonjour", détruit la référence à l'objet int ( ) nommée var, puis, créer un nouvel objet str ( ) nommé var et lui donne la valeur bonjour.

On peut à se titre considérer que toutes variables dans Python sont de type speudo-variant.

AFFECTATION DIRECT.

nom_de_la_variable = valeur

a = 3, créer un nouvel objet int ( ), nommé a, réserve une place en mémoire, et lui affecte la valeur 3.

AFFECTATION INDIRECT.

nom_de_la_variable = objet

nom_de_la_variable = valeur

a = int ( ), créer un objet de type int ( ) vide nommé a, réserve une place en mémoire ;

a = 2, affecter la valeur 2 à l'objet nommée a créer précédemment.

Notez que cette méthode, ne garantit pas, contrairement à d'autres langages, que la variable a sera toujours du type int ( ). 

a = int ( )

a = 8

print ( a ) retourne 8

print ( type ( a ) ) retourne <class 'int'>

a = "huit"

print ( a ) retourne 'huit'

print ( type ( a ) ) retourne <class 'str'>

AFFECTATION MULTIPLE.

variabla1 , variable2 , variable3 = valeur1 , valeur2 , valeur3

a , b , c = 2 , 4 , 6 créer un objets  int ( ) nommé a avec la valeur 2, un objet  int ( ) nommé b avec la valeur 4, créer un objet  int ( ) nommé c avec la valeur 6.

Les objets peuvent être de types différents.

rayon , pi , forme = 7 , 3.14 , "cercle"

print ( f"Le rayon est { rayon } - pi vaut { pi } - c'est un { forme }" ) retourne Le rayon est 7 - pi vaut 3.14 - c'est un cercle

print ( type ( rayon ) ) retourne <class 'int'>

print ( type ( pi ) ) retourne <class 'float'>

print ( type ( forme ) ) retourne <class 'str'>

Ce type d'affectation est très utile pour permuter des valeurs.

a = 7

b = 10

print ( a , b ) retourne 7 10

a , b = b , a

print ( a , b ) retourne 10 7

Attention à ne pas confondre ce type d'affection, avec l'affectation d'un objet tuple ( ).

a  = 3 , 7 , 11

print ( a ) retourne (3, 7, 11)

print ( type ( a ) ) retourne <class 'tuple'>

AFFECTATION MULTIPLE PAR DÉBALLAGE (UNPACKING).

Il est aussi possible d'affecter plusieurs noms de variables simultanément, en déballant, les valeurs des éléments d'un objet collection (list ( ), tuple ( )).

LST_Premiers = [ 2 , 3 , 5 , 7 , 11 , 13 , 17 ]

a , b , c , d , e , f , g = LST_Premiers

print ( a , b , c , d , e , f , g ) retourne 2 3 5 7 11 13 17 

Chaque variable a reçue la valeur d'un élément de la liste comme affectation.

print ( LST_Premiers ) retourne [2, 3, 5, 7, 11, 13, 17]

Notez que la liste d'origine n'est pas modifiée.

TPL_Voyelles = ( "a" , "e" , "i" , "o" , "u" , "y" )

a , b , c , d , e , f = TPL_Voyelles

print ( a , b , c , d , e , f ) retourne a e i o u y

Chaque variable a reçue la valeur d'un élément du tuple comme affectation.

print ( TPL_Voyelles ) retourne ('a', 'e', 'i', 'o', 'u', 'y')

Le tuple d'origine n'est pas modifié.

Attention cependant, car la collection doit avoir autant d'éléments qu'il y a de variables à initialiser.

a , b , c , d , e , f , g , h , i = TPL_Voyelles retourne ValueError: not enough values to unpack (expected 9, got 6)

TPL_Voyelles ne comporte que 6 éléments alors que l'on souhaite initialiser 9 variables avec.

a , b , c = TPL_Voyelles retourne ValueError: too many values to unpack (expected 3)

Il n'y a pas suffisamment de variables à initialiser pour les 6 éléments que comporte la collection TPL_Voyelles.

AFFECTATION CONDITIONNELLE.

variable = valeurs1 si le test est vrai sinon variable = valeur2

Ce type d'affection est aussi appelée opération tertiaire.

ville = "Paris"

prix = 200 if ville == "Paris" else 150

print ( prix ) retourne 200

ville = "Bruxelle"

prix = 200 if ville == "Paris" else 150

print ( prix ) retourne 150

for kchiffre in range ( 10 ) :

kpair = "pair" if kchiffre % 2 == 0 else "impair"

kpremier = "est" if kchiffre in [ 2 , 3 , 5 , 7 ] else "n'est pas"

print ( f"Le chiffre { kchiffre } est { kpair } et il { kpremier } premier." )

retourne

Le chiffre 0 est pair et il n'est pas premier.

Le chiffre 1 est impair et il n'est pas premier.

Le chiffre 2 est pair et il est premier.

Le chiffre 3 est impair et il est premier.

Le chiffre 4 est pair et il n'est pas premier.

Le chiffre 5 est impair et il est premier.

Le chiffre 6 est pair et il n'est pas premier.

Le chiffre 7 est impair et il est premier.

Le chiffre 8 est pair et il n'est pas premier.

Le chiffre 9 est impair et il n'est pas premier.

Notez qu'il est possible d'imbriquer plusieurs conditions.

for kchiffre in range ( 12 ) :

kreste = "il reste 0" if kchiffre % 3 == 0 else ( "il reste 1" if kchiffre % 3 == 1 else "il reste 2" )

print ( f"Quand on divise { kchiffre } par 3, { kreste }." )

retourne

Quand on divise 0 par 3, il reste 0

Quand on divise 1 par 3, il reste 1

Quand on divise 2 par 3, il reste 2

Quand on divise 3 par 3, il reste 0

Quand on divise 4 par 3, il reste 1

Quand on divise 5 par 3, il reste 2

Quand on divise 6 par 3, il reste 0

Quand on divise 7 par 3, il reste 1

Quand on divise 8 par 3, il reste 2

Quand on divise 9 par 3, il reste 0

Bien, que les parenthèses soient optionnelles, l'écriture  kreste = "il reste 0" if kchiffre % 3 == 0 else "il reste 1" if kchiffre % 3 == 1 else "il reste 2" est déconseillée pour des raisons de maintenance et de lisibilité.

AFFECTATION PAR COMPRÉHENSION DE LISTE.

Les objets itérables (list ( ), tuple ( ), dict ( ), set ( ), fonzenset ( ), ... ) peuvent recevoir une affectation de leurs éléments par compréhension.

Affectation rapide d'une liste :

LST_Chiffres = list ( range ( 10 ) )

print ( LST_Chiffres ), retourne [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].

Affectation par compréhension de liste.

LST_Carres = [ kvaleur * kvaleur for kvaleur in range ( 10 ) ]

print ( LST_Carres ) retourne [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Affectation conditionnelle par compréhension de liste.

LST_CertainsCubes = [ kvaleur ** 3 for kvaleur in range ( 29 ) if kvaleur % 3 == 2 ]

print ( LST_CertainsCubes ) retourne [8, 125, 512, 1331, 2744, 4913, 8000, 12167, 17576]

REMARQUE.

Il existe parfois des affectations spécifiques à l'objet créer (voir pour chaque objet pour plus de détails).

GÉNÉRALITÉS SUR LES VARIABLES DANS PYTHON 3.x.

Dans Python 3 les variables utilisateurs (variables créées et utilisées par l'utilisateur) sont, en réalité, des références des objets. En effet, à chaque fois qu'il crée une nouvelle variable, l'utilisateur crée, en fait, un nouvel objet. Cet objet est donc créé avec ses attributs et ses méthodes. Ceci est un point important de la programmation sous Python 3.

Par exemple, lorsque vous codez kchiffre = 2, Python crée un nouvelle objet int ( ) (interger), réserve la place en mémoire. Puis l'objet kchiffre reçoit la valeur 2.

Notez aussi que 2 est aussi un objet dans python. Donc ici, il faut bien penser que kchiffre est une nouvelle référence à l'objet 2. Puisque 2 est un objet immuables, si on réaffecte une nouvelle valeur à kchiffre, on ne fait que faire "pointer" kchiffre vers un autre objet.

kchiffre = 4 et knombre = 4 sont en fait 2 références du même objet 4. 

En revanche kchiffre = list ( ) référence bien kchiffre à un nouvel objet crée lors de l'affectation et knombre = list ( ) fait de même. Les deux variables, kchiffre et knombre, "pointent" bien vers 2 objets distincts.

Le nommage des variables sous python est très libre et intuitif.  A la condition que le nom de la variable commence par une lettre, et qu'il ne soit pas un mot réservé (mot clé), ou commençant par un mot réservé, sont autorisées toutes les suites et combinaisons de :

- lettres minuscules (de a à z) ;

- lettres majuscules (de A à Z) ;

- chiffres (de 0 à 9) ;

- symbole de soulignement ( _ ).

Cependant retenez que sont interdits :

- les caractères spéciaux ;

- les espaces (blancs) ;

- les lettres accentuées ;

- le soulignement ( symbole _ ) seul ;

TYPES DE VARIABLES SOUS PYTHON.

Variables numériques.

int (entier) : entiers compris entre -2 147 483 648 et 2 147 483 647.

long (entier long) : entiers compris entre et -2 147 483 647 ou entre 2 147 483 648 (obsolète en python 3).

float (à virgule flottante) : permet une approximation de nombres réels.

complex (complexes) : nombres complexes.

Variables itérables.

str (alphanumérique) : chaînes de caractères.

unicode (caractère unicode) : chaînes de caractères encodées selon la norme Unicode.

basestring : (chaîne de caractères) : str + unicode.

tuple (tuple) : collections de valeurs non modifiables.

list (liste) : collections de valeurs modifiables.

xrange (intervalle) : collections de valeurs pouvant être générées automatiquement.

dict (dictionnaire) : collections de couples nom/valeur modifiables.

set (ensemble) : collections désordonnées de valeurs uniques modifiables.

frozenset (ensemble figé) : collections désordonnées de valeurs uniques non modifiables.

file (fichier) : fichiers informatiques.

Autres variables.

None (rien) : objet vide, sans valeur affectée.

type (type) : types du type de l'objet.

object (objet) : type basique des objets.

slice (partie) : objets extensibles.

NotImplementedType (absence d'implémentation) : objets non référencés.

bool (valeur booléenne) : true / false (vrai / faux) ou 0 / 1.

exception (exception) : messages d'erreurs.

function (fonction) : fonctions.

module (module) : modules.

CONVERSION DE TYPAGE.

Python 3 propose plusieurs fonctions permettant de forcer un type vers un autre type :

- int ( ) : permet de modifier une variable en entier.

- float ( ) : permet la transformation en flottant.

- str ( ) : permet de transformer des variables numérique en chaînes de caractère.

- repr ( ) : similaire à str ( ).

- eval ( ) : évalue le contenu de son argument comme si c’était du code Python.

- unicode ( ) : convertit en Unicode.

PORTEE DES VARIABLES.

Les variables, selon l'endroit où elles sont déclarées, sont de portée globale ou locale.

Une variable déclarée dans un bloc (de script) comme : une fonction (def) ; une boucle (for, while) ; un traitement ( if , elif , else, try ) ; est dite de portée locale ou, plus simplement, locale.

Une variable déclarée en dehors de tout bloc (de script) est dite de portée globale ou, plus simplement, globale.

Une variable globale :

- doit être déclarée en dehors de tous blocs ;

- peut être lue (sa valeur peut être retournée) dans  tout le programme ;

- peut être modifiée en dehors de tous blocs ;

- ne peut pas être modifiée dans un bloc, sans avoir était spécifiée comme modifiable dans ce bloc avec l'instruction global ;

- n'est jamais détruite, sauf si on utilise la fonction del pour cela (mais elle peut faire référence à un autre objet par réaffectation).

Une variable locale :

- doit être déclarée dans le bloc où elle sera utilisée ;

- peut être lue (sa valeur peut être retournée) uniquement dans le bloc où elle est déclarée, et les sous-blocs de celui-ci ;

- n'existe que dans le bloc où elle est déclarée, et les sous-blocs de celui-ci ;

- ne peut être modifiée que dans le bloc où elle est déclarée, et les dans sous-blocs de celui-ci ;

- est détruite à la sortie du bloc dans lequel elle est déclarée.

Quand Python rencontre une variable (utilisateur), il cherche si elle a été déclaré dans le blocs, sinon il recherche dans le bloc parent, puis dans le bloc parent du parent, tant qu'il ne trouve pas de déclaration de cette variable et, ainsi de suite jusqu'à sortir de tous blocs. Si il ne trouve aucune déclaration de la variable dans le bloc, à quelque niveau que ce soit, il recherche dans le code en dehors de tous blocs s'il trouve une déclaration de la variable. Si aucune déclaration n'est trouvée, une exception est levée. 

Cette recherche type est nommée LEGB :

- L pour local, c'est dire le bloc en cours de traitement ;

- E pour englobant, c'est à dire tous les blocs parents du bloc en cours de traitement ;

- G pour global, c'est à dire en dehors de tous blocs ;

- B pour builtins, c'est à dire les fonctions natives de python ou importer avec import.

Notez l'exception des variables des boucles for. En plus de ne pas avoir à les déclarer avant leur utilisation , leur dernière valeur est conservée à la sortie du bloc (for), mais pas à la sortie du bloc fonction où la boucle for se trouve.

Si vous souhaitez utiliser une variable de portée globale, qui devra être modifiée dans de nombreuse fonctions définies (def), et que vous ne souhaitez pas utiliser l'instruction global, donc l'oubli pourrait instaurer des retours non souhaités et délicats à traiter, il vous est possible de déclarer cette valeur comme élément unique d'un objet list ( ), ou regrouper vos variables dans un objets dict ( ). Attention cependant à rester très prudent dans de telles pratiques. 

Par exemple :

import random

LST_Score = [ 0 ]

LST_Vie = [ 3 ]

LST_Sante = [ 100 ]

def FNC_Sante ( ) :

LST_Sante [ 0 ] = LST_Sante [ 0 ] - random.randint ( 10 , 20 )

if LST_Sante [ 0 ] < 1 : 

LST_Vie [ 0 ] = LST_Vie [ 0 ] - 1

LST_Sante [ 0 ] = 100 if LST_Vie [ 0 ] != 0 else 0

print ( "\n\nNOUVELLE VIE\n\n" )

while LST_Vie [ 0 ] :

LST_Score [ 0 ] = LST_Score [ 0 ] + random.randint ( 3 , 7 )

FNC_Sante ( )

print ( f"score { LST_Score [ 0 ] }, santé { LST_Sante [ 0 ] }, vie : { LST_Vie [ 0 ] }" )

print ( "\n\n--- FIN ---\n\n" )

ou :

import random

DCT_Joueur = { "score" : 0 , "vie" : 3 , "sante" : 100 }

def FNC_Sante ( ) :

DCT_Joueur [ "sante" ] = DCT_Joueur [ "sante" ] - random.randint ( 10 , 20 )

if DCT_Joueur [ "sante" ] < 1 : 

DCT_Joueur [ "vie" ] = DCT_Joueur [ "vie" ] - 1

DCT_Joueur [ "sante" ] = 100 if DCT_Joueur [ "vie" ] != 0 else 0

print ( "\n\nNOUVELLE VIE\n\n" )

while DCT_Joueur [ "vie" ] :

DCT_Joueur [ "score" ] = DCT_Joueur [ "score" ] + random.randint ( 3 , 7 )

FNC_Sante ( )

print ( f"score { DCT_Joueur [ 'score' ] }, santé { DCT_Joueur [ 'sante' ] }, vie : {     DCT_Joueur [ 'vie' ] }" )

print ( "\n\n--- FIN ---\n\n" )

à la place de :

import random

GBL_Score = 0

GBL_Vie = 3

GBL_Sante = 100

def FNC_Sante ( ) :

global GBL_Sante , GBL_Vie

GBL_Sante -= random.randint ( 10 , 20 )

if GBL_Sante < 1 : 

GBL_Vie -= 1

GBL_Sante = 100 if GBL_Vie != 0 else 0

print ( "\n\nNOUVELLE VIE\n\n" )

while GBL_Vie :

GBL_Score += random.randint ( 3 , 7 )

FNC_Sante ( )

print ( f"score { GBL_Score }, santé { GBL_Sante }, vie : { GBL_Vie }" )

print ( "\n\n--- FIN ---\n\n" )

VARIABLES ET CONSTANTES.

Contrairement à d'autres langages de programmation, Python n'a pas de type constante  (variable dont la valeur ne peut plus être modifiée après la première déclaration). En effet, les variables globales sont protégées des modifications involontaires, sauf si l'on indique qu'il sera possible de leur affecter une nouvelle valeur, et de les retyper selon cette valeur, avec l'instruction global.

Cependant, si l'on souhaite vraiment protéger la valeur initiale d'une variable, dans tout le script, c'est à dire même en dehors de tout blocs, il suffit de déclarer cette variable comme tuple ( ), avec un unique élément, les tuple ( ) étant, inversement aux list ( ) et dict ( ), immuables.

TPL_Largeur = ( 640 , )

TPL_Hauteur = ( 480 , )

print ( "Dimension de l'écran :" , TPL_Largeur [ 0 ] , "x" , TPL_Hauteur [ 0 ] , "pixels" )

TPL_Largeur [ 0 ] = 800

retourne 

Dimension de l'écran : 640 x 480 pixels

Traceback (most recent call last):

  File "C:\Users\Mini PC\Documents\Programmation\test.py", line 4, in <module>

    TPL_Largeur [ 0 ] = 800

TypeError: 'tuple' object does not support item assignment

>>>