Variables, types et opérations

Apprendre à programmer en python

python

Une variable est une zone de la mémoire de l'ordinateur dans laquelle une valeur est stockée. Aux yeux du programmeur, cette variable est définie par un nom

Ouvrir Thonny dont le raccourci devrait être dans le dossier informatique :

idle_1

Noms de variables

Le nom d’une variable s’écrit avec des lettres (non accentuées), des chiffres ou bien l’underscore _ Le nom d’une variable ne doit pas commencer par un chiffre.

En langage Python, l’usage est de ne pas utiliser de lettres majuscules pour nommer les variables (celles-ci sont réservées pour nommer les classes).

Exemple : age, mon_age, temperature1

A éviter : Age, AGE, MonAge, monAge, Temperature1

Le type int , integer : nombres entiers

Pour affecter (on dit aussi assigner) la valeur 17 à la variable age il suffit de taper dans l'ordre age=17. Le signe = ne signifie pas égal mais prend la valeur. Ainsi dans un code informatique on peut trouver a=a+1.

>>> age = 17

La fonction print affiche la valeur de la variable :

>>> print(age)
17

La fonction type() retourne le type de la variable :

>>> print(type(age))
>class 'int'>

int est le type des nombres entiers.

>>> # ceci est un commentaire
>>> age = age + 1	# en plus court : age += 1
>>> print(age)
18
>>> age = age - 3	# en plus court : age -= 3
>>> print(age)
15
>>> age = age * 2		# en plus court : age *= 2
>>> print(age)
30
>>> a = 6*3 - 20
>>> print(a)
-2
>>> b = 25
>>> c = a + 2*b
>>> print(b, c)          # ne pas oublier la virgule
25 48

Calculs, opérations

Dans le tableau ci-après, sont présentés les symboles utilisés pour les opérations de base.

Opérations Symboles Exemples
addition + 2 + 5 donne 7
soustraction - 8 - 2 donne 6
multiplication * 6 * 7 donne 42
exponentiation (puissance) ** 5 ** 3 donne 125
division / 7 / 2 donne 3.5 en python3
division / 7.0 / 2 donne 3.5
reste de division entière %
(modulo)
7 % 3 donne 1
quotient de division entière // 7 // 3 donne 2

L’opérateur // donne la division entière :

>>> 4 // 3  # 4 = 3 * 1 + reste
1
>>> tour = 450//360
>>> print(tour)
1

L’opérateur % donne le reste de la division (opération modulo) :

>>> angle = 450 % 360
>>> print(angle)
90

L’opérateur ** donne la puissance :

>>> mo = 2 ** 20 # 2 puissance 20
>>> print(mo)
1048576
>>> racine2 = 2 ** 0.5 # 2 puissance 1/2
>>> print(racine2)
1.41421356237

Le type float (nombres en virgule flottante)

>>> b = 17.0 	# le séparateur décimal est un point (et non une virgule)
>>> print(b)
17.0
>>> print(type(b))
class 'float'>

>>> c = 14.0 / 3.0
>>> print(c)
4.66666666667

>>> c = 14.0 // 3.0	# division entière
>>> print(c)
4.0

Attention : avec des nombres entiers, l’opérateur / renvoie généralement un flottant :

>>> c = 14 / 3
>>> print(c)
4.666666666666667

Notation scientifique :

>>> a = -1.784892e4
>>> print(a)
-17848.92

Les fonctions mathématiques

Pour utiliser les fonctions mathématiques, il faut commencer par importer le module math :

>>> import math

On peut lister un paquet avec la fonction dir()

>>> dir(math)
['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan',
'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf',
'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum',
'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p',
'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

Pour appeler une fonction d’un module, la syntaxe est la suivante : module.fonction(arguments)

Pour accéder à une donnée d’un module : module.data

>>> print(math.pi)		# donnée pi du module math (nombre pi)
3.14159265359
>>> print(math.sin(math.pi/4.0)) # fonction sin() du module math (sinus)
0.707106781187
>>> print(math.sqrt(2.0)) 	# fonction sqrt() du module math (racine carrée)
1.41421356237
>>> print(math.sqrt(-5.0))
Traceback (most recent call last):
    print(math.sqrt(-5.0))
ValueError: math domain error
>>> print(math.exp(-3.0)) 	# fonction exp() du module math (exponentielle)
0.0497870683679
>>> print(math.log(math.e)) 	# fonction log() du module math (logarithme népérien)
1.0

Le type str (string : chaîne de caractères)

>>> nom = 'Dupont' 	# entre apostrophes
>>> print(nom)
Dupont
>>> print(type(nom))

>>> prenom = "Pierre" 	# on peut aussi utiliser les guillemets
>>> print(prenom)
Pierre
>>> print(nom, prenom) 	# ne pas oublier la virgule
Dupont Pierre

La concaténation désigne la mise bout à bout de plusieurs chaînes de caractères. La concaténation utilise l’opérateur +

>>> chaine = nom + prenom	# concaténation de deux chaînes de caractères
>>> print(chaine)
DupontPierre
>>> chaine = prenom + nom	# concaténation de deux chaînes de caractères
>>> print(chaine)
PierreDupont
>>> chaine = prenom + ' ' + nom
>>> print(chaine)
Pierre Dupont
>>> chaine = chaine + ' 18 ans'	# en plus court : chaine += ' 18 ans'
>>> print(chaine)
Pierre Dupont 18 ans

La fonction len() retourne la longueur (length) de la chaîne de caractères :

>>> len("abc")
3

Indices et tranches (index and slices en anglais) :

>>> print(chaine[0]) 	# premier caractère (indice 0)
P
>>> print(chaine[1])	# deuxième caractère (indice 1)
i
>>> print(chaine[1:4])	# slicing
ier
>>> print(chaine[2:])	# slicing
erre Dupont 18 ans
>>> print(chaine[-1])	# dernier caractère (indice -1)
s
>>> print(chaine[-6:])	# slicing
18 ans

En résumé :

lettre chaine          :   M   u   r   i   e   l
position depuis 0      :   0   1   2   3   4   5
position depuis la fin :  -6  -5  -4  -3  -2  -1

Attetion aux apostrophes et guillemets dans les chaînes de caractères !

>>> chaine = 'Aujourd'hui'
SyntaxError: invalid syntax
>>> chaine  = 'Aujourd\'hui'		# séquence d'échappement \'
>>> print(chaine)
Aujourd'hui
>>> chaine  = "Aujourd'hui"
>>> print(chaine)
Aujourd'hui

La séquence d’échappement \n représente un saut ligne :

>>> chaine = 'Premiere ligne\nDeuxieme ligne'
>>> print(chaine)
Premiere ligne
Deuxieme ligne

Plus simplement, on peut utiliser les triples guillemets (ou les triples apostrophes) pour encadrer une chaîne définie sur plusieurs lignes :

>>> chaine = """Premiere ligne
Deuxième ligne"""
>>> print(chaine)
Premiere ligne
Deuxieme ligne

On ne peut pas mélanger les serviettes et les torchons (ici type str et type int) :

>>> chaine = '17.45'
>>> print(type(chaine))

>>> chaine = chaine + 2
TypeError: cannot concatenate 'str' and 'int' objects

La fonction float() permet de convertir un type str en type float

>>> nombre = float(chaine)
>>> print(nombre)
17.45
>>> print(type(nombre))
class 'float'>
>>> nombre = nombre + 2		# en plus court : nombre += 2
>>> print(nombre)
19.45

Inversement, str transforme un nombre en chaîne de caractère :

>>> a = 1
>>> b = str(a)
>>> type(b)
class 'str'>

La fonction input()

La fonction input() lance une invite de commande (en anglais : prompt) qui permet à l'utilisateur du programme de saisir une variable. Il y a différents types de variables. La variable saisie par l'instruction input sera par défaut du type texte.

>>> # saisir une chaîne de caractères et valider avec la touche Enter
>>> chaine = input("Entrer un nombre : ")
Entrer un nombre : 14.56
>>> print(chaine)
14.56
>>> print(type(chaine))
class 'str'>
>>> nombre = float(chaine)	# conversion de type
>>> print(nombre**2)
211.9936

En Python 3, le résultat de input est toujours une chaîne de caractère.

Entrainement 1 :

Réaliser un prgramme en python qui permet de demander et d'afficher le prenom et l'age d'une personne.

Voir une solution

Autres types

Nous avons survolé les types les plus courants. Il en existe bien d’autres :

  • booléen
  • complex (nombres complexes, par exemple 1+2.5j)
  • tuple (structure de données)
  • set (structure de données)
  • file (fichiers)

A retenir :

  1. Nommer une variable :
    1. Doit commencer par une lettre ou un underscore
    2. pas d'espace : utiliser les underscores (_)
    3. pas de caractères spéciaux
  2. Fonctions principales :
    1. print(faustin) ou print("faustin") : afficher à l'écran
    2. input() : lire au clavier
    3. type() : retourne le type d'une donnée
  3. Types principaux :
    1. Entier : int
    2. nombre flottant (réel) : float
    3. chaine de caractères : str
    4. booléen : bool

Entrainement 2 : Ecrire un programme qui calcule l'aire et le périmètre d'un rectangle. L'utilisateur doit donner les deux dimensions du rectangle avec input.

Voir une solution

Entrainement 3 :

Quel sera le résultat de chaque opération ? (utiliser la calculatrice avant de vérifier dans Thony)

>> 5 + 2
>>> 5 + a
>>> a = 2
>>>> 5 - a
>>> 5 / 2
>>> 9 / 2
>>> 2 ** 3
>>> 5 % 4
>>> 8 % 4
>>> 5 // 4
>>> 8 // 4

Entrainement 4 :

Quel sera la valeur de a à la fin du programme ?

a = 19
a = a + 1
a = a * 2
a = a / 5
Voir une solution

Entrainement 5 :

Quel sera la valeur de a et b à la fin du programme ?

a = 4
b = 2
a = a + b
b = a + b
Voir une solution

QCM

QCM sur les types int, float et str

Source : Fabrice Sincère - Contenu sous licence CC BY-NC-SA 3.0