TP - Chapitre 1 : Langage de programmation Python

N.B. Niveau : Première Générale, enseignement de spécialité NSI (Numérique et Sciences Informatiques)

Chapitre 1 - Variables, types et opérateurs

1 - Codage de l'information

Dans un ordinateur une case mémoire ne peut prendreque deux états, 0 ou 1.
Donc toute donnée introduite dans un ordinateur doit être traduite par une suite de 0 et de 1.
Ceci est vrai pour du texte, des nombres, des images, du son, des commandes comme « aller à la ligne ».
L’unité élémentaire de stockage est le bit (binary digit) qui prend la valeur 0 ou 1.
Un ensemble de 8 bits forme un octet (byte), par exemple : 01101011.
Et voilà ce que cela donne :

vu de l'humain...	vu de la puce...	Codage binaire utilisé
Vrai / Faux	0/1	Type "Booléen"
Le nombre entier 82	01010010	Numération binaire positionnelle
La lettre R majuscule	01010010	Codage ASCII
La couleur jaune	1111111 11111111 100000000	Codage RVB
Le nombre décimal 3,14151	01000000 01001001 00001110 10000000	Codage IEEE-754 simple précision
Le mot "pomme"	01110000 01101111 01101101 01101101 01100101	Codage ASCII
Un dessin	10001001 01010000 01001110 01000111 00001101 00001010 00011010 00001010 00000000 00000000 00000000 00001101 01001001 01001000... (etc sur 1.592 octets)	Format graphique PNG
Un morceau de musique	01010010 01001001 01000110 01000110 01110111 00011101 00000000 00000000 01010111 01000001 01010110 01000101 01100110 01101101... (etc sur 60.392 octets)	Format audio WAV
Une photo	11111111 11011000 11111111 11100011 10011001 11001100 10001010 11110000 11010010 11001100 00000000 00000000 10011010 10011010... (etc sur 20.503.928 octetss)	Format graphique JPEG

On notera que ‘R’ et 82 sont codés de la même façon!?

a. Les multiples de l’octet

Depuis 1998 on a la norme suivante : (unités décimales)
Le kilo-octet(noté ko) = 1000 octets
Le méga-octet(noté Mo) = 10^6 octets
Le giga-octet(noté Go) = 10^9 octets
Le téra-octet(noté To) = 10^12 octets
Le péta-octet(noté Po) = 10^15 octets

Pour avoir un ordre de grandeur on peut dire que :

3 ko = une page format A4
6 Mo = une photo numérique en haute résolution
10 Mo = 1 minute de son haute fidélité
16 Go = 2 heures de vidéo HD

Mais il est d’usage d’utiliser encore les unités traditionnelles d’avant 1998, à savoir : (unités binaires)
1 ko = 2^10 octets et 2^10 = 1024 ≈1000 octets
1 Mo = 1024 ko et 2^20 = 1048576 ≈10^6 octets
1 Go = 1024 Mo et 2^30 = 1 073 741 824 ≈10^9 octets
1 To = 1024 Go et 2^40 = 1 099 511 627 776 ≈10^12 octets
1 Po = 1024 To et 2^50 = 1 125 899 906 842 624 ≈10^15 octets

Selon la norme de 1998 ces unités devraient s’appeler et se noter :

2^10 octets = 1 kibioctet (Kio) pour « kilo binaire »
2^20 octets = 1 mébioctet (Mio) pour « méga binaire »
2^30 octets = 1 gibioctet (Gio) pour « giga binaire »
2^40 octets = 1 tébioctet (Tio) pour « térabinaire » etc ………

Ainsi, un disque dur de 100 giga-octets (100×10^9 octets, norme 1998) contient le même d'octets qu'un disque de 93,13 gibioctets (93,13×2^30 octets), donc 93 Go norme d’avant 1998, soit 7% dedifférence.

Cette nouvelle norme est donc commercialement plus vendeuse.

b. Le code binaire

En base 10, le nombre 432 peut se décomposer ainsi :

    4 x100     +     3 x 10     +     2 x1
= 4 x 10^2 +     3 x 10^1 +     2 x 10^0

En base 2, donc binaire, le nombre 1100 1001 (2) se décompose ainsi :

    1 x 2^7 + 1 x 2^6 + 0 x 2^5 + 0 x 2^4 + 1 x 2^3 + 0 x 2^2 + 0 x 2^1 + 1 x 2^0
= 128     +    64      +    0 +      0     +   8       +   0       +     0   + 1 = 201

L'association de :

Nbr de bits	Nom	Non signé	Signé
1	booléen (Boolean)	0 / 1	-
8	Octet (Byte)	0 à 255	-128 à +127
16	Mot (short)	0 à 65535	-32768 à 32767
32	Entier (int)	0 à 4 294 967 295	-2 147 483 648 à 2 147 483 647

Une variable est un espace mémoire dans lequel il est possible de stocker une valeur (une donnée).

c. Le code hexadécimal

En Base 16, les unités comprennent 16 symboles : 0-1-2-3-4-5-6-7-8-9-A-B-C-D-E-F

Pour passer de la base binaire à l'héxadécimal, on coupe le binaire en quartets. Prennons la couleur jaune :

En binaire : 0b 1111 1111 1111 1111 0000 0000 0000 0000
En décimal        15    15        15 15        0    0        0      0
En Héxa :    0x F F           F F         0 0            0 0

Pour passer de l'héxadécimal au décimal on divise le nombre par 16 (la base) et on cherche le reste de la division

43 / 16 = 2, reste 11    (le 11ème symbole est un B)

Donc : 42 = 0x2A    (ou #2A)

Ouvrir Edupyton :
Démarrer → Programmes → Edupython

2- Le type `int` (integer : nombres entiers)

Pour affecter (on dit aussi assigner) la valeur 17 à la variable nommée Age :

>>> Age = 17

La fonction print affiche la valeur de la variable :

>>> print (Age)
17

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

>>> type (Age)
<type '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

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

>>> d = 450//360
>>> print (d)
1

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

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

L'opérateur ** donne la puissance :

>>> Mo = 2**20
>>> print (Mo)
1048576

3- 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
>>> type(b)
<type 'float'>

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

>>> c = 14//3	# division entière
>>> print (c)
4.0

Notation scientifique :

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

4- Les fonctions mathématiques

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

>>> import math

La fonction dir() retourne la liste des fonctions et données d'un module :

>>> 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)) # fonction sin() du module math (sinus)
0.707106781187
>>> print (math.sqrt(2)) 	# fonction sqrt() du module math (racine carrée)
1.41421356237
>>> print (math.sqrt(-5))
Traceback (most recent call last):
    print math.sqrt(-5.0)
ValueError: math domain error
>>> print (math.exp(-3)) 	# fonction exp() du module math (exponentielle)
0.0497870683679
>>> print (math.log(math.e)) 	# fonction log() du module math (logarithme népérien)
1.0

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

>>> Nom = 'Dupont' 	# entre apostrophes
>>> print (Nom)
Dupont
>>> type(Nom)
<type 'str'>
>>> 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 :

>>> print len(chaine)
20

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

>>> 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 = 'Première ligne\nDeuxième ligne'
>>> print (chaine)
Première ligne
Deuxième ligne

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

>>> chaine = """Première ligne
Deuxième ligne"""
>>> print (chaine)
Première ligne
Deuxième ligne

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

>>> chaine = '17.45'
>>> type(chaine)
<type 'str'>
>>> 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
>>> type(nombre)
<type 'float'>
>>> nombre = nombre + 2		# en plus court : nombre += 2
>>> print (nombre)
19.45

La fonction raw_input() lance une invite de commande (en anglais : prompt) pour saisir une chaîne de caractères.

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

6- Conversions des types

Un Float vers un entier

>>> b = 17.5 	
>>> type(b)
>>> b=int(b)
>>> print (b)
>>> type(b)

Une chaine de caractère vers un entier

>>> b = '12z' 	
>>> type(b)
>>> b=int(b)
>>> print (b)
>>> type(b)

Un chiffre en une chaine

>>> b = 12 	
>>> type(b)
>>> b=str(b)
>>> print (b)
>>> type(b)

7- Le type `list` (liste)

Une liste est une structure de données.
Le premier élément d'une liste possède l'indice (l'index) 0.
Dans une liste, on peut avoir des éléments de plusieurs types.

>>> InfoPerso = ['Pierre' , 'Dupont' , 17 , 1.75 , 72.5]
>>> # la liste InfoPerso contient 5 éléments de types str, str, int, float et float
>>> type(InfoPerso)
<type 'list'>
>>> print (InfoPerso)
['Pierre', 'Dupont', 17, 1.75, 72.5]
>>> print ('Prénom : ',InfoPerso[0])	# premier élément (indice 0)
Prénom :  Pierre
>>> print ('Age : ',InfoPerso[2])	# le troisième élément a l'indice 2
Age :  17
>>> print ('Taille : ',InfoPerso[3])	# le quatrième élément a l'indice 3
Taille :  1.75

La fonction range() crée une liste d'entiers régulièrement espacés :

>>> liste = list(range(10))
>>> print (liste)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> type(liste)
<type 'list'>

>>> liste = list(range(1,10,2))		# range(début,fin non comprise,intervalle)
>>> print (liste)
range(1, 10, 2)
>>> print (liste[2])
5

On peut créer une liste de listes, qui s'apparente à un tableau à 2 dimensions (ligne, colonne) :

0 1 2
10 11 12
20 21 22

>>> liste = list([[0,1,2],[10,11,12],[20,21,22]])
>>> print (liste[0])
[0, 1, 2]
>>> print (liste[0][0])
0
>>> print (liste[2][1])		# élément à la troisième ligne et deuxième colonne
21
>>> liste[2][1] = 69		# nouvelle affectation
>>> print (liste)
[[0, 1, 2], [10, 11, 12], [20, 69, 22]]

8- Le type `bool` (booléen)

Deux valeurs sont possibles : True et False

>>> a = True
>>> type(a)
<type 'bool'>

Les opérateurs de comparaison :

Opérateur	Signification	Remarques
<	strictement inférieur
<=	inférieur ou égal
>	strictement supérieur
>=	supérieur ou égal
==	égal	Attention : deux signes `==`
!=	différent
`is`	identique	Deux conditions : égal et même type
`is not`	non identique

>>> b = 10
>>> print (b>8)
True
>>> print (b==5)
False
>>> print (b!=10)
False
>>> print (0<= b <=20)
True

Les opérateurs logiques : and, or, not

>>> note=13.0
>>> mentionAB = note>=12.0 and note<14.0 # ou bien : mentionAB = 12.0 <= note < 14.0
>>> print (mentionAB)
True
>>> print (not mentionAB)
False
>>> print (note==20.0 or note==0.0)
False

L'opérateur in s'utilise avec des chaînes (type str) ou des listes (type list) :

>>> chaine = 'Bonsoir'
>>> #  la sous-chaîne 'soir' fait-elle partie de la chaîne 'Bonsoir' ?
>>> a = 'soir' in(chaine)
>>> print (a)
True
>>> print ('b' in(chaine))
False

>>> liste = list([4,8,15])
>>> #  le nombre entier 9 est-il dans la liste ?
>>> print (9 in(liste))
False
>>> print (8 in (liste))
True
>>> print (14 not in(liste))
True

9- Le type `dict` (dictionnaire)

Un dictionnaire stocke des données sous la forme clé ⇒ valeur.
Une clé est unique et n'est pas nécessairement un entier (comme c'est le cas de l'indice d'une liste).

>>> moyenne = {'math':12.5,'anglais':15.8}	# entre accolades
>>> type(moyenne)
<type 'dict'>
>>> print (moyenne['anglais'])		# entre crochets
15.8
>>> moyenne['anglais']=14.3		# nouvelle affectation
>>> print (moyenne)
{'anglais': 14.3, 'math': 12.5}
>>> moyenne['sport']=11.0		# nouvelle entrée
>>> print (moyenne)
{'sport': 11.0, 'anglais': 14.3, 'math': 12.5}

10- Autres types

Nous avons vu les types les plus courants.
Il en existe bien d'autres :

long (nombres entiers de longueur quelconque, par exemple 4284961775562012536954159102L)
complex (nombres complexes, par exemple 1+2.5j)
tuple (structure de données)
set (structure de données)
file (fichiers)
...

11- Programmation Orientée Objet (POO)

Python est un langage de programmation orienté objet (comme les langages C++, Java, PHP, Ruby...).
Une variable est en fait un objet d'une certaine classe.

Par exemple, la variable amis est un objet de la classe list.
On dit aussi que la variable amis est une instance de la classe list.
L'instanciation (action d'instancier) est la création d'un objet à partir d'une classe (syntaxe : NouvelObjet = NomdelaClasse(arguments)) :

>>> # instanciation de l'objet amis de la classe list
>>> amis = ['Nicolas','Julie']	# ou bien : amis = list(['Nicolas','Julie'])
>>> type(amis)
<type 'list'>

Une classe possède des fonctions que l'on appelle méthodes et des données que l'on appelle attributs.

La méthode append() de la classe list ajoute un nouvel élément en fin de liste :

>>> # instanciation d'une liste vide
>>> amis = list()
>>> amis.append('Nicolas')	# synthase générale : objet.méthode(arguments)
>>> print (amis)
['Nicolas']
>>> amis.append('Julie')	# ou bien : amis = amis + ['Julie']
>>> print (amis)
['Nicolas','Julie']
>>> amis.append('Pauline')
>>> print (amis)
['Nicolas','Julie','Pauline']

>>> amis.sort()			# la méthode sort() trie les éléments
>>> print amis
['Julie', 'Nicolas', 'Pauline']

>>> amis.reverse()		# la méthode reverse() inverse la liste des éléments
>>> print amis
['Pauline', 'Nicolas', 'Julie']

La méthode lower() de la classe str retourne la chaîne de caractères en casse minuscule :

>>> # la variable chaine est une instance de la classe str
>>> chaine = "BONJOUR"		# ou bien : chaine = str("BONJOUR")
>>> chaine2 = chaine.lower()	# on applique la méthode lower() à l'objet chaine
>>> print (chaine2)
bonjour
>>> print chaine
BONJOUR

La méthode upper() de la classe str retourne la chaîne de caractères en casse majuscule

La méthode pop() de la classe dict supprime une clé :

>>> # instanciation de l'objet moyenne de la classe dict
>>> moyenne = {'sport': 11.0, 'anglais': 14.3, 'math': 12.5}
>>> # ou : moyenne = dict({'sport': 11.0, 'anglais': 14.3, 'math': 12.5})
>>> moyenne.pop('anglais')
14.3
>>> print (moyenne)
{'sport': 11.0, 'math': 12.5}

>>> print (moyenne.keys())	# la méthode keys() retourne la liste des clés
dict_keys(['sport', 'math'])

>>> print (moyenne.values())	# la méthode values() retourne la liste des valeurs
dict_values([11.0, 12.5])

Exercices

Exercice 1.1 ☆ Décompresser le fichier labirynthe.zip dans vos documents, ouvrir le fichier labirynthe.py. A la fin du programme, avant la dernière ligne, rajoutez les instructions avance(nombre de case), gauche() ou droite() pour faire sortir la tortue du labirynthe. Cliquer sur le bouton play pour exécuter le programme, puis sur le labirynthe pour quitter.

Modifier l'arrière plan de la fenêtre du labirynthe pour qu'il soit jaune

Faire valider le script par le professeur

Exercice 1.2 ☆ Afficher la taille en octets et en bits d'un fichier de 536 ko.
On donne : 1 ko (1 kibi octet) = 2¹⁰ octets !!!
1 octet = 1 byte = 8 bits

Faire valider le script par le professeur

Exercice 1.3 ★ Le numéro de sécurité sociale est constitué de 13 chiffres auquel s'ajoute la clé de contrôle (2 chiffres).
Exemple : n° : 1 89 11 26 108 268 clé de contrôle : 91
La clé de contrôle est calculée par la formule : 97 - (numéro de sécurité sociale modulo 97)

Rappel : le modulo est le reste de la division (%)

Retrouver la clé de contrôle de votre numéro de sécurité sociale.
Quel est l'intérêt de la clé de contrôle ?

Faire valider le script par le professeur

Exercice 1.4 ★ A partir des deux variables Prenom et Nom, afficher les initiales (par exemple LM pour Léa Martin).

Faire valider le script par le professeur

Exercice 1.5 ★☆ L'identifiant d'accès au réseau du lycée est construit de la manière suivante : initiale du prénom puis les 8 premiers caractères du nom (le tout en minuscule).
Exemple : Alexandre Lecouturier → alecoutur
A partir des deux variables Prenom et Nom, construire l'identifiant.

Faire valider le script par le professeur

Exercice 1.6 ★★☆ Conversion de base

1) Convertir la chaine de caractère b='0b1101' en un entier décimal

2) Convertir l'entier décimal d=95 en hexadécimal. Pour passer le résultat en hexadécimal, créez une chaine hexa='0123456789ABCDEF'

3) Testez les fonctions bin et hex et int et faire afficher en hexadécimal la valeur binaire 0b1100110

4) Convertir un nombre entier compris entre 0 et 255 en binaire :

Algorithme :

Mémoriser le nombre entier à convertir dans la variable nbr
Initialiser une chaine de caractères vide bin=""
Ajouter le reste de la division par 2 transformé en str à bin
Stocker dans nbr le résultat de la division entière entre nbr et 2.
répéter 7 fois les deux lignes précédentes
afficher le résultat stocké dans bin

5) Quel nombre faut-il ajouter à nbr après la première ligne pour convertir les nombres négatifs ?

6) Conversion binaire d'un nombre décimal inférieur à 1 et supérieur à zéro sur un octet

Algorithme :

Mémoriser le nombre décimal à convertir dans la variable dec
Initialiser une chaine de caractères vide bin=""
Stocker dans dec : dec * 2
Ajouter à la chaine bin la partie entière de dec transformée en str
soustraire à dec la partie entière de dec
Répéter 7 fois les 3 lignes précédentes
afficher le résultat stocké dans bin

Faire valider le script par le professeur

Exercice 1.7

Copier et collez le script suivant

from tkinter import *
from tkinter.colorchooser import *
def getColor():
    color = askcolor()
    print (color)
Button(text='Choisir la couleur', command=getColor).pack()
mainloop()

Exécuter le programme, choisir une couleur et observez le résultat et le format de la variable couleur dans la console.

Modifier dans le programme la ligne print (couleur) afin que le résultat soit affiché de la manière suivante :

Rouge=82 Vert=228 Bleu=145 Hex=#52E491

Faire valider le script par le professeur

Exercice 1.8 ★★

Ce programme permet de lire le contenu mémoire de la variable data codée en flottant simple précision. La variable mem (b'bdcccccd', 4) est un tupple contenant en position 0 les octets et en position 1 le nombre d'octets occupés par -0.1

Copier et collez le script suivant :

import sys
import struct
import codecs

hexa=codecs.getencoder('hex')
data = [-0.1]
mem=(hexa(struct.pack('>%df' % len(data), *data)))
print(mem)

Modifier la dernière ligne afin que le résultat s'affiche de cette manière :

-0.1 se code BD CC CC BD

_{on peut convertir les octets b'bdcccccd' en str pour faciliter le traitement de l'affichage}

Faire valider le script par le professeur

QCM

QCM sur les types int, float et str

Contenu sous licence CC BY-NC-SA 3.0
Fabrice Sincère ; version 1.3.5.29
Modifié et adapté par Pascal Hassenforder 17/09/2019

TP - Chapitre 1 : Langage de programmation Python

Chapitre 1 - Variables, types et opérateurs

1 - Codage de l'information

a. Les multiples de l’octet

b. Le code binaire

c. Le code hexadécimal

2- Le type int (integer : nombres entiers)

3- Le type float (nombres en virgule flottante)

4- Les fonctions mathématiques

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

6- Conversions des types

7- Le type list (liste)

8- Le type bool (booléen)

9- Le type dict (dictionnaire)

10- Autres types

11- Programmation Orientée Objet (POO)

Exercices

QCM

2- Le type `int` (integer : nombres entiers)

3- Le type `float` (nombres en virgule flottante)

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

7- Le type `list` (liste)

8- Le type `bool` (booléen)

9- Le type `dict` (dictionnaire)