Variables, affectations

Variables

Remarque. Le langage Python est sensible à la casse : ma_variable, maVariable et mavariable sont donc trois identificateurs différents (préférer la première écriture).

Conventions.

• Le premier caractère de l’identificateur doit être une lettre ou un blanc souligné (_).

• Les caractères suivant peuvent être alphanumériques ou des blanc soulignés (_).

• Les majuscules et les minuscules ne sont pas confondues.

• Le tableau ci-après, contient les mots-clés du langage Python. Il est impossible de choisir un identificateur correspondant à l’un de ces mots-clés.

  and	as	assert	break	class	del	elif	continue	def
  else	except	exec	finally	for	from	global	if	import
  in	is	lambda	nonlocal	not	or	pass	print	raise
  return	try	while	with	yield	None	True	False

Déclaration et affectation des variables

Vocabulaire

Note. La déclaration d’une variable doit donc précéder son utilisation.

Affectation d’une valeur à une variable

Affectation simple

Python est un langage à typage dynamique : il n’est pas nécessaire de déclarer le type de la valeur référencée par la variable.

1

a = 3

1
2

int a;
a = 3;

Remarque. On peut noter dès à présent qu’une affectation en Python ne consiste pas au stockage d’une valeur dans une variable, contrairement à ce qui se passe dans d’autres langages de programmation (pour les types primitifs). En Python, les objets (entiers, flottants, chaînes de caractères, …) sont référencés : lors d’une affectation, c’est une référence à un objet (et non une valeur) qui est définie, que l’objet vienne d’être créé ou qu’il s’agisse d’un objet préexistant.

Exemples.

1
2
3

>>> un_entier = 12
>>> une_chaine = 'cartable' 
>>> un_flottant = -2 + 3.12 + 17

Affectations multiples

1
2
3
4
5
6
7

>>> x = y = z = 1
>>> x 
1 
>>> y 
1 
>>> z 
1

Remarque. Pour bien comprendre comment fonctionne l’affectation multiple, ci-dessus, lire l’instruction de la droite vers la gauche. Ainsi, on affecte à la variable z l’entier 1, à la variable y la valeur référencée par la variable z, à la variable x la valeur référencée par la variable y. L’instruction précédente est donc équivalente à l’enchaînement :

1
2
3

>>> z = 1
>>> y = z 
>>> x = y

Affectation de « tuples »

1
2
3
4
5
6
7

>>> a, b, c = 1, 2, 3
>>> a 
1 
>>> b 
2 
>>> c 
3

Remarque. Le fonctionnement de cette affectation sera détaillé dans un prochain chapitre.

Opérateurs d’affectation

Le langage Python possède un certain nombre de raccourcis permettant de très rapidement écrire la mise à jour de la valeur d’une variable à partir d’une expression faisant elle même référence au contenu de la variable. Ici aussi, il est nécessaire de lire l’instruction de la droite vers la gauche.

Formatage des chaînes de caractères

Comme nous l’avons vu dans le précédent chapitre, une chaîne de caractère est un type pré-défini incontournable du langage Python.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

>>> type("abcd")
<class 'str'>
>>> type('abcd')
<class 'str'>
>>> type("Python, c'est super !")
<class 'str'>
>>> type('Python, c'est super !')
    File "<pyshell>", line 1 
       type('Python, c'est super !') 
                         ^
     SyntaxError: invalid syntax
>>> type("2")
<class 'str'>
>>> type("a")
<class 'str'>
>>> type('-2.3')
<class 'str'>

Il faut donc être capable de manipuler ces chaînes de caractères, et en particulier d’y incorporer le résultat de l’évalution d’expressions.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

>>> '{}, {}, {}'.format('a', 'b', 'c')
' a, b, c' 
>>> '{0}, {1}, {2}'.format('a', 'b', 'c') 
' a, b, c' 
>>> "La somme de 1 + 2 est {}".format(1 + 2) 
' La somme de 1 + 2 est 3' 
>>> "La somme de {1} + {2} est {0}".format(2 + 3, 2, 3) 
' La somme de 2 + 3 est 5' 
>>> '{0}{1}{0}'.format('abra', 'cad') 
' abracadabra' 
>>> '{:f}; {:f}'.format(3.14, -3.14) # :f est un marqueur 
'3.140000; -3.140000'

Certaines mises en forme nécessitent de préciser le type de la donnée et la façon de l’afficher. Le marqueur de formatage : permet d’introduire des drapeaux :

• Le drapeau s indique que la donnée à insérer est une chaîne de caractères.
  C’est le drapeau implicite et il est inutile de le préciser ;

• Le drapeau d indique que la donnée à insérer est un nombre qu’il faut convertir en nombre entier si nécessaire ;

• Les drapeaux f, g et e indiquent que les données à insérer sont des nombres flottants.
  Le drapeau g est le plus général, il correspond au drapeau f si le nombre n’est pas trop grand, à la notation avec puissances de 10 e, si l’écriture du nombre prend beaucoup de place ;

• …

Pour finir, il est possible d’indiquer le nombre minimal de chiffres à utiliser (ils n’ont pas besoin d’être visibles, seule la place nécessaire pour l’affichage compte) et le nombre de chiffres après la virgule à afficher.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

>>> "Nombre : {0:2f}".format(3333.3333)  # au moins 2 chiffres avant la virgule, notation décimale
'Nombre : 3333.333300'
>>> "Nombre : {0:20f}".format(3333.3333) # au moins 20 chiffres avant la virgule
'Nombre :          3333.333300'
>>> "Nombre : {0:2.2f}".format(3333.3333) # au moins 2 chiffres avant et 2 chiffres après
'Nombre : 3333.33'
>>> "Nombre : {0:2.2f}".format(3333.3383) # au moins 2 chiffres avant et 2 chiffres après
' avant3333.34'
>>> "Nombre : {0:2.2e}".format(3333.3333) # au moins 2 chiffres avant et 2 chiffres après, notation scientifique
'Nombre : 3.33e+03'

Exercices du chapitre

1
2
3

>>> prix = 20
>>> tva = 18.6
>>> total = prix + prix * tva /100

1
2
3
4
5
6

>>> prix
20
>>> tva
18.6
>>> total
23.72

1
2
3

>>> prix = 20
>>> tva = 18.6
>>> prix = prix + prix * tva /100

1
2
3
4

>>> prix
23.72
>>> tva
18.6

1
2
3
4

>>> a = 5 
>>> b = 7 
>>> b = a 
>>> a = b

1
2
3
4

>>> a = 5 
>>> b = 7 
>>> a = b 
>>> b = a

1
2
3
4

>>> a
5 
>>> b
5

1
2
3
4

>>> a
7 
>>> b 
7

1
2
3
4

>>> tmp = a
>>> a = c
>>> c = b
>>> b = a

1
2
3
4
5
6
7

def conversion_franc_euro(francs: float) -> str: 
    """ 
    Conversion d'une somme en francs en euros. Le message retourné donne les deux valeurs.

    >>> conversion_franc_euro(100)
    '100 francs correspondent à 15.244901723741037 euros.' 
    """

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

def conversion_franc_euro(francs: float) -> str: 
    """ 
    Conversion d'une somme en francs en euros. Le message retourné donne les deux valeurs.

    >>> conversion_franc_euro(100)
    '100 francs correspondent à 15.244901723741037 euros.' 
    """
    change = 6.55957
    euros = francs / change
    
    return '{} francs correspondent à {} euros.'.format(francs, euros)

1
2
3
4
5
6
7

def salutation(nom: str, prenom: str, naissance: int) -> str:
    """ 
    À partir des nom, prénom et année de naissance, retourne un message d'accueil indiquant l'âge.

    >>> salutation("Dupond", "Patrick", 1961)
    'Bonjour Patrick Dupond, vous avez 58 ans.'
    """

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

def salutation(nom: str, prenom: str, annee_naissance: int) -> str:
    """ 
    À partir des nom, prénom et année de naissance, retourne un message d'accueil indiquant l'âge.

    >>> salutation("Dupond", "Patrick", 1961)
    'Bonjour Patrick Dupond, vous avez 58 ans.'
    """
    annee_en_cours = 2021
    age = annee_en_cours - annee_naissance
    
    return 'Bonjour {} {}, vous avez {} ans.'.format(prenom, nom, age)

1
2
3
4
5
6
7

def age_aleatoire(age_min: int, age_max: int) -> str:
    """
    À partir de deux ages limites, retourne un message contenant un age déterminé aléatoirement.

    >>> age_aleatoire(20, 100) 
    'Votre age est : 85 ans !' 
    """

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from random import randint

def age_aleatoire(age_min: int, age_max: int) -> str:
    """
    À partir de deux ages limites, retourne un message contenant un age déterminé aléatoirement.

    >>> age_aleatoire(20, 100) 
    'Votre age est : 85 ans !' 
    """
    age = randint(age_min, age_max)

    return 'Votre age est : {} ans !'.format(age)