9 Resume

Introduction à
l’informatique
9 - Résumé
Julien Deantoni
Introduction à l’informatique Adapted from Pierre Lezowski’s courses

Contenue de l’UE (non contractuel)
1) Introduction, notion de variables, de type de données simple et structuré
2) Variables, séquence d’instructions en mémoire, Notion d’algorithme, de

boucles et de branchements conditionnels
3) Logique Booléenne et comparaison, lecture/écriture dans un fichier
4) Écrire des fonctions afin de rendre le code plus lisible et réutilisable
5) Contrôle continu intermédiaire
6) Introduction au web, structure d’une page en web en HTML
7) Front-end et back-end
8) Sucre syntaxique
9) Résumé
Une resource intéressante:
https://inforef.be/swi/download/apprendre_python3_5.pdf
Introduction à l’informatique 2
Créer une variable
●
NomVariable : type = type( valeurInitiale )
●
i1: int = int(0)
●
i2: int = int(‘123’)
●
s1: str = str(‘zaza’)
●
s2: str = str(123)
●
liste1: list = list( [1,2,3] )
●
liste2: list[int] = list([42,18])
type des éléments de la liste

●
liste2: list[str] = list([‘toto’,’titi’])
●
i3: int = i1 + i2
Référence ou valeur référencée ?
●
À gauche du signe d’affectation (=), on parle de l’étiquette elle même, c’est
à dire de la référence. Ailleurs, on parle de la valeur référencée.
● i1: int = int(0)
● i2: int = int(‘123’)
● i3: int = i1 + i2
L’étiquette (ou référence) La valeur référencée par

i3 l’étiquette i1
● i2 = i3 print(i2, i3)
L’étiquette La valeur référencée La valeur référencée La valeur référencée

i2 par l’étiquette i3 par l’étiquette i2 par l’étiquette i3
Référence ou valeur référencée ?
●
À gauche du signe d’affectation (=), on parle de l’étiquette elle même, c’est
à dire de la référence. Ailleurs, on parle de la valeur référencée.
● i1: int = int(0)
● i2: int = int(‘123’)
● i3: int = i1 + i2
C’est une affectation, pas une

égalité ! Cela se lit de droite à gauche
● i2 = i3 print(i2, i3)
L’étiquette La valeur référencée

i2 par l’étiquette i3
Créer une variable d’un type structuré
●
Personne Type structuré

nom: str p1: Personne = Personne('titi',19)
Variable
p2: Personne = Personne('zaza',18)
age: int
contenue dans
le type structuré
●

1 2
1 nom: str p1: Personne = Personne('titi',19)
2 Variable
age: int
contenue dans
le type structuré
●

1 2
1 nom: str p1: Personne = Personne('titi',19)
2 Variable
age: int
contenue dans
le type structuré
●
Accès aux variables internes des variables structurées
p1.nom p1.age == 18 ?
p2.nom p2.nom == p1.nom ?
Type structuré Point2D
from dataclasses import dataclass
@ dataclass Annotation pour se simplifier la vie

class Point2D: Mot clé class suivi du nom du type et de ‘ :’
x : int Ensemble de variables internes
y : int typées et ordonnées
Point2D Type structuré

x : int
Variable pointA
y : int
contenue dans
le type structuré
: Point2D : int
x 1
y : int
2
pointA: Point2D = Point2D(1,2)

Encodage des images
●
Quelle est la structure de données permettant de stocker les informations
d’un image ?
●
une image numérique brute est un ensemble de pixel où chaque
pixel a une couleur particulière, encodée par exemple en RGB. De
plus la largeur et la hauteur est donnée.
Pixel
red : int Dans le langage Python
green : int
blue : int
ImagePPM
format : str
largeur : int
hauteur : int
pixels : list[Pixel]
Opérations sur les variables
●
On peut réaliser les opérations sur les variables telles que définis par le
type. Par exemple en Python
NomVar : type = initialization value
1 i : int = int(42) #déclaration de la variable i, initialisée à 42
2 j : int = 2 #déclaration de la variable j, initialisée à 2
3 k: int = i + j #déclaration de la variable i, initialisée à 44
4 # appel de l'opération addition avec pour paramètres i et j
5 l: int = k // 2 #déclaration de la variable l, initialisée à 22
6 # appel de l'opération division entière avec pour paramètres k et 2
7 s1: str = str("Hello")
8 s2: str = str(" ")
9 s3: str = "world"
10 greeting: str = s1+s2+s3 #déclaration de la variable greeting, initialisée à Hello World
# 2 appels de l'opération concaténation avec pour
# paramètres s1 et s2 puis le résultat de s1+s2 et s3
Pas d’exécution et valeurs dans la mémoire
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
: int
42
Représentation du contenu de la mémoire non exact mais suffisante pour comprendre les notions qui vont suivre
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
: int
i 42
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
: int
: int
i j 2
42
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
: int
: int
i j 2
42 : int
k 44
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
: int
: int
i j 2
42 : int
k 44
: str
s1 Hello
‘Hello’
1 i: int = int(42)
2 j: int = 2
3 k: int = i+j
4
6 s2: str = str(" !")
7 s3: str = s1+s2
: int
: int
i j 2
42 : int
k 44
: str : str
s1 Hello
‘Hello’ s2 Hello
‘ !’
: str
s3 Hello!’
‘Hello
Structuration de l’information
Opération sur les variables (3/3)
●
On peut réaliser les opérations sur les variables telles que définis parle
type. Par exemple en Python
Pour information, la liste de toutes les opérations possibles est consultable ici :
https://www.w3schools.com/python/python_operators.asp
i: int = int(42) # déclaration de la variable i, initialisée à 42

j: int = int(2) # déclaration de la variable j, initialisée à 2
j= i–j # affectation de la valeur 15 à la variable j
b1: bool = bool( i < j ) # comparaison entre deux entier. Renvoie vrai ou faux
b2: bool = bool( i == j )
b3: bool = bool(not b1)
f : float = float(j / i) # approximation de la valeur de j / i stockée dans un float

# attention ne jamais comparer 2 float avec une égalité (==)
j = i**2 # i puissance 2 (au carré)

f2 : float = j**(1/2) # j puissance 1/2 (racine carrée de j)
Accès aux éléments d’une liste
list1: list = list([1,34,67,100])
list1 : list
[0] [1] [2] [3]
: int : int : int : int

1 34 67 100
●
On utilise la position de l’élément dans la liste. On parle de l’indice de
l’élément dans la liste.
i1 : int = int( list1[0] + 2)

i2 : int = int( list1[i1] )
i3 : int = int( list1[ list1[0] ] ) #34
list1[i1] = 42
list1[ list1[0] ] = list1[i1-1]
Mutable versus immutable data types
???
???
Mutable versus Immutable data types
●
Python, comme tout langage informatique définit deux sortes différentes de type de données :
les mutables et les immutables.
●
Immutable : int, str, float, bool
●
Le contenu des cases mémoires associé aux variables ne peut pas être modifié !
●
Mutable : list, tous les types structurés
●
Le contenu des cases mémoires associé aux variables peut être modifié
●
les mutable et les immutables.
●
●
●
●
●
●
●
: int
42
●
●
●
●
●
: int
i 42
●
●
●
●
●
: int
i 42 j
●
●
●
●
●
: int
i 42 j
: int
43
●
●
●
●
●
: int
i 42 j
: int
43
●
●
●
●
●
: int
i 42 j
: int
43
●
●
●
●
●
: int
i 42 j
: int
43
●
●
: list
[0], [1], [2]
: int : int : int

1 2 3
●
●
●
: int
i 42 j
: int
43
●
●
l
: list
[0], [1], [2]
: int : int : int

1 2 3
●
●
●
: int
i 42 j
: int
43
●
●
l
: list
: int [0], [1], [2]
2
: int : int : int
1 2 3
●
●
●
: int
i 42 j
: int
43
●
●
l
: list
: int [0], [1], [2]
2
: int : int : int
1 2 3
●
●
●
: int
i 42 j
: int
43
●
●
: Pixel : int
r 0
g : int
b 0
: int
0
●
●
●
: int
i 42 j
: int
43
●
●
p1
: Pixel : int
r 0
g : int
b 0
: int
0
●
●
●
: int
i 42 j
: int
43
●
●
p1
p2 : Pixel : int
r 0
g : int
b 0
: int
0
●
●
●
: int
i 42 j
: int
43
●
●
p1 : int
255
p2 : Pixel : int
r 0
g : int
b 0
: int
0
Mutable versus immutable data types
False
True
id(var) à la rescousse
●
La fonction id(var) donne l’adresse de la variable var dans la mémoire
●
●
●
Mutable : list, Point2D
●

pointA
x : int
y : int Variable
contenue dans : Point2D : int
le type structuré x 1
y
: int
2
id(var) à la rescousse
●
La fonction id(var) donne l’adresse de la variable var dans la mémoire
●
●
●
Mutable : list, Point2D
●

pointA
x : int
: int
y : int Variable
: Point2D 2
contenue dans : int
le type structuré x 1
y
: int
2
Premiers algorithmes
●
Un algorithme est une séquence d’instructions dont l’exécution résout un
problème particulier posé à l’avance. Le problème a résoudre peut être
généraliste ou spécifique
● On a un ensemble de 4 points dans une liste nommée allPoints.
●
On désire appliquer une translation de 1 selon l’axe des ordonnées à tous
les points de la liste
Points souhaités
Points de départ
●
On a un ensemble de 4 points dans une liste nommée allPoints.
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
Points souhaités
Points de départ
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
1 allPoints[0].y = allPoints[0].y +1
2
4 Séquence d’instructions
6
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]

0 1 2 3
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
allPoints : list
1 allPoints[0].y = allPoints[0].y +1 [0],[1],[2],[3]
2
3 allPoints[1].y = allPoints[1].y +1 : Point2D : Point2D : Point2D : Point2D
4 Séquence d’instructions x x x x
y y y y
6 : int : int : int : int : int : int : int : int
7 allPoints[3].y = allPoints[3].y +1 1 2 2 4 3 6 4 8
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]

0 1 2 3
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
allPoints : list
2
4 x x x x
y y y y
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
allPoints : list
2
4 x x x x
y y y y
: int
3
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
allPoints : list
2
4 x x x x
y y y y
: int
3
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
allPoints : list
2
4 x x x x
y y y y
: int : int
3 5
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
allPoints : list
2
4 x x x x
y y y y
: int : int : int
3 5 7
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
allPoints : list
2
4 x x x x
y y y y
3 5 7 9
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
allPoints : list
2
4 x x x x
y y y y
3 5 7 9
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]
0 1 2 3
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
2
4
6
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]

0 1 2 3
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
1 p: Point2D = allPoints[0]
2 p.y = p.y + 1 allPoints
: list
3
[0],[1],[2],[3]
4 p = allPoints[1]
5 p.y = p.y + 1
: Point2D : Point2D : Point2D : Point2D
6 x x x x
7 p= allPoints[2] y y y y
8 p.y = p.y + 1 : int : int : int : int : int : int : int : int
9 1 2 2 4 3 6 4 8
10 p = allPoints[3]
11 p.y = p.y + 1
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
: list
3 p [0],[1],[2],[3]
4 p = allPoints[1]
5 p.y = p.y + 1
6 x x x x
9 1 2 2 4 3 6 4 8
10 p = allPoints[3]
11 p.y = p.y + 1
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
: list
3 p [0],[1],[2],[3]
4 p = allPoints[1]
5 p.y = p.y + 1
6 x x x x
9 1 2 2 4 3 6 4 8
10 p = allPoints[3] : int
11 p.y = p.y + 1 3
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
: list
3 p [0],[1],[2],[3]
4 p = allPoints[1]
5 p.y = p.y + 1
6 x x x x
9 1 2 2 4 3 6 4 8
10 p = allPoints[3] : int
11 p.y = p.y + 1 3
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
: list
3 p [0],[1],[2],[3]
4 p = allPoints[1]
5 p.y = p.y + 1
6 x x x x
9 1 2 2 4 3 6 4 8
10 p = allPoints[3] : int : int
11 p.y = p.y + 1 3 5
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
: list
3 p
[0],[1],[2],[3]
4 p = allPoints[1]
5 p.y = p.y + 1
6 x x x x
9 1 2 2 4 3 6 4 8
10 p = allPoints[3] : int : int : int
11 p.y = p.y + 1 3 5 7
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
: list
3 p
[0],[1],[2],[3]
4 p = allPoints[1]
5 p.y = p.y + 1
6 x x x x
9 1 2 2 4 3 6 4 8
10 p = allPoints[3] : int : int : int : int
11 p.y = p.y + 1 3 5 7 9
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
p.y = p.y + 1 allPoints
2 : list
p
3 [0],[1],[2],[3]
4 p = allPoints[1]
p.y = p.y + 1 : Point2D : Point2D : Point2D : Point2D
5 x x x x
6 y y y y
7 p= allPoints[2] : int : int : int : int : int : int : int : int
8 p.y = p.y + 1 1 2 2 4 3 6 4 8
9 : int : int : int : int
p = allPoints[3] 3 5 7 9
10
11 p.y = p.y + 1 [(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]
0 1 2 3
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]
indice: int = 0 0 1 2 3
p: Point2D = allPoints[indice] p: Point2D = allPoints[0]

p.y = p.y + 1
indice = indice + 1
p.y = p.y + 1
p: Point2D = allPoints[indice] p = allPoints[1]

p.y = p.y + 1 p.y = p.y + 1
indice = indice + 1
p= allPoints[2]
p: Point2D = allPoints[indice]
p.y = p.y + 1 p.y = p.y + 1
indice = indice + 1
p = allPoints[3]
p: Point2D = allPoints[indice] p.y = p.y + 1
p.y = p.y + 1
indice = indice + 1
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]
0 1 2 3
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]
indice: int = 0 0 1 2 3
p.y = p.y + 1
indice = indice + 1
p: Point2D = allPoints[indice] Séquences d’instructions

p.y = p.y + 1 exactement identiques
indice = indice + 1
⇒ l’ordinateur sait répéter la
p.y = p.y + 1
même chose plein de fois
indice = indice + 1
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]
p.y = p.y + 1
indice = indice + 1 0 1 2 3
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]
indice: int = 0 0 1 2 3
p.y = p.y + 1
indice = indice + 1

indice = indice + 1
⇒ Tant que indice est inférieur ou
p: Point2D = allPoints[indice] égal à 3, on exécute la séquence
p.y = p.y + 1
indice = indice + 1
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]
p.y = p.y + 1
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]
indice: int = 0 0 1 2 3
p.y = p.y + 1
indice = indice + 1

indice = indice + 1
⇒ Tant que indice est inférieur à 4,
p: Point2D = allPoints[indice] on exécute la séquence
p.y = p.y + 1
indice = indice + 1
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]
p.y = p.y + 1
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]
indice: int = 0 0 1 2 3
p.y = p.y + 1
indice = indice + 1

indice = indice + 1
⇒ Tant que indice < 4,
p.y = p.y + 1
indice = indice + 1
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]
p.y = p.y + 1
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]
indice: int = 0 0 1 2 3
p.y = p.y + 1
indice = indice + 1

indice = indice + 1
⇒ while (indice < 4):
p.y = p.y + 1
indice = indice + 1
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]
p.y = p.y + 1
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]
indice: int = 0 0 1 2 3
p.y = p.y + 1
indice = indice + 1

indice = indice + 1
⇒ while (indice < 4):
p: Point2D = allPoints[indice] p: Point2D = allPoints[indice]
p.y = p.y + 1 p.y = p.y + 1
indice = indice + 1 indice = indice + 1
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]
p.y = p.y + 1
Premiers algorithmes La boucle While
●
●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]

0 1 2 3

●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
Le bloc de code identifié par le

retrait du bord de la page est le code
à exécuter tant que la condition est vraie

●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]

0 1 2 3
Lorsque la condition est

fausse, on va directement à
la ligne qui suit le bloc de
code répété
●
Une boucle (loop en anglais) vous permet de répéter des blocs
d’instructions selon vos besoins.
●
Il existe différentes manières de définir des boucles en python
●
La boucle tant que (while en anglais) est définie par un bloc de code à
répéter ainsi qu’une expression booléenne appelée condition
Le bloc de code identifié par le

retrait du bord de la page est le code
à exécuter tant que la condition est vraie
Lorsque la condition est fausse, on va directement à la ligne qui suit le
bloc de code répété

●
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

0 1 2 3
[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]

0 1 2 3

●
allPoints = [??]
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]
0 1 2 3

●
allPoints = [??]
[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]
0 1 2 3
⇒ le problème a changé et devient plus générique puisque l’on ne sait pas a priori
combien de fois il faut répéter le bloc de code représentant le traitement
→ on va donc inspecter la variable allPoints et modifier la condition de
répétition en conséquence.
● On a un ensemble de points dans une liste nommée allPoints.

●
allPoints = [??]
⇒ le problème a changé et devient plus générique puisque l’on ne sait pas a priori
combien de fois il faut répéter le bloc de code représentant le traitement
→ on va donc inspecter la variable allPoints et modifier la condition de
répétition en conséquence.
Ici la fonction len(var) est définie si var est de type list
et elle renvoie le nombre d’élément dans la liste var
https://www.google.com/search?q=longueur+list+pytho
n
●
Une boucle (loop en anglais) vous permet de répéter des blocs d’instructions
selon vos besoins.
●
●
La boucle tant que (while en anglais) est définie par un bloc de code à répéter
ainsi qu’une expression booléenne appelée condition
●
La condition porte habituellement sur une ou plusieurs variables qui sont
modifiées dans le bloc de code à répéter pour éviter d’avoir une boucle
infinie
⇒ Boucle infinie car (indice < 4)

sera toujours vrai
La ligne 6 ne sera jamais exécutée
●
Une boucle (loop en anglais) vous permet de répéter des blocs d’instructions
selon vos besoins.
●
●
La boucle tant que (while en anglais) est définie par un bloc de code à répéter
ainsi qu’une expression booléenne appelée condition
●
La condition porte habituellement sur une ou plusieurs variables qui sont
modifiées dans le bloc de code à répéter pour éviter d’avoir une boucle
infinie
⇒ Boucle finie car (indice < 4)

finira par être faux
Premiers algorithmes Le branchement conditionnel If
●
●
Si l’ordonnée d’un point est négative, on désire la remplacer par sa valeur
absolue
●
Si l’ordonnée d’un point n’est pas négative, alors on lui ajoute 1
Points souhaités
Points de départ
1)On a un ensemble de 4 points dans une liste nommée allPoints.
2)Si l’ordonnée d’un point est négative, on désire la remplacer par sa valeur
absolue
3)Si l’ordonnée d’un point n’est pas négative, alors on lui ajoute 1
Points souhaités
Points de départ
1) On parcours toute la liste comme précédemment

2) On ajoute du code qui représente le traitement conditionnel
1) On remarque que les points 2 et 3 ci dessus sont exclusifs !
●
●
absolue
●
Points souhaités
Points de départ
●
●
absolue
●
Points souhaités
Points de départ
Si la condition est vraie, alors le bloc de code qui suit la condition est
exécuté, sinon le bloc de code qui suit le mot clef else est exécuté.
Rappel : les blocs de code sont définis en fonction de l’indentation (du retrait par
rapport au bord du fichier)
●
●
absolue
●
Points souhaités
optionnel
Points de départ
Si la condition est vraie, alors le bloc de code qui suit la condition est
exécuté, sinon le bloc de code qui suit le mot clef else est exécuté.
optionnel
Rappel : les blocs de code sont définis en fonction de l’indentation (du retrait par
rapport au bord du fichier)
Algorithmes
●
Les structures de code conditionnel et les boucles peuvent s’imbriquer de
nombreuses manières, engendrant des comportements différents.
●
Il est important de pratiquer afin de progresser. N’hésitez pas à jouer dans
l’éditeur utilisé en TP et à mettre des print pour voir les valeurs des
variables à chaque ligne, mais aussi pour comprendre quel est le flot
d’exécution.
●
Challengez vous les uns les autres. Posez vous des questions, entre aidez
vous.
●
Si vous avez des questions particulières et que personne autour de vous
n’a la réponse, n’hésitez pas à me contacter moi ou les chargés de
TD/TP.
Premiers algorithmes : compréhension
●
Plus généralement le début du

TD2 doit être clair pour vous.
⚠️
Premiers algorithmes : écriture
●
• recopie d’une liste de pixels

Soit une liste de pixels nommée inputPixels. Écrire un algorithme permettant de
créer une nouvelle liste nommée outputPixels contenant des pixels ayant la
même valeur que ceux de la liste inputPixels. Cependant assurez vous que la
modification des éléments de inputPixels n’impacte pas la liste outputPixels

●

même valeur que ceux de la liste inputPixels. Cependant assurer vous que la
⚠️
⇒ ici les étiquettes de outputPixels référencent

les même objets que celle de inputPixels

●

même valeur que ceux de la liste inputPixels. Cependant assurer vous que la
Création d’un
nouveau pixel

●
2.4.2 Changement de couleur
Soit une variable nommée img de type ImagePPM. ImagePPM est le type
définit précédemment. Soit une variable nommée pRef de type Pixel.
Soit une autre variable nommée Pnew de type Pixel. Écrire un
algorithme permettant changer tous les pixels de img qui sont égaux à
pRef par des pixels égaux à pNew.

●

●

●

●
⚠️
●
⚠️
●

Algèbre de Boole ?
L'algèbre de Boole, ou calcul booléen, est la partie des mathématiques qui s'intéresse à une approche algébrique de la logique, vue en termes de
variables, d'opérateurs et de fonctions sur les variables logiques, ce qui permet d'utiliser des techniques algébriques pour traiter les expressions à
deux valeurs du calcul des propositions. Elle fut lancée en 1854 par le mathématicien britannique George Boole. Aujourd'hui, l'algèbre de Boole trouve
de nombreuses applications en informatique et dans la conception des circuits électroniques.
Elle fut utilisée la première fois pour les circuits de commutation téléphonique par Claude Shannon.
●
C’est l’algèbre sous-jacente aux prédicats utilisés dans les boucles et les
branchements conditionnels
Points souhaités
Points de départ

Algèbre de Boole ?
●
Points souhaités
Points de départ

Algèbre de Boole ?
●
Points souhaités
Points de départ

Algèbre de Boole ?
●
●
Pour faire des raisonnements rigoureux sur des objets mathématiques
●
Pour mécaniser voire automatiser les raisonnements.
●
Pour faire des raisonnements rigoureux en général !

Opérateurs logiques binaires
●
Les opérateurs sont définis par des tables de vérité
⚠️le ou (∨) est inclusif

Ce n'est pas forcément le même sens qu'en français « courant ».
En logique, fromage ou dessert est vraie si
●
je prends du fromage et pas de dessert
●
je prends du dessert et pas de fromage
●
je prends du dessert et du fromage

Construire une table de vérité
●
Écrire sur la première ligne les propositions atomiques et les formules,
une colonne pour chaque.
●
Déterminer le nombre de lignes : 2n où n nombre de propositions
atomiques.
●
Exemple : si n=3, alors 2n=8 lignes.
●
Compléter les lignes avec toutes les combinaisons possibles.
●
Technique : Compter jusque 2n en binaire pour n'oublier aucune
ligne. (0=F et 1=V)
●
Remplir les colonnes de droite, éventuellement en découpant les formules
compliquées.

Construire une table de vérité et sauver un étudiant
●
Écrire sur la première ligne les propositions atomiques et les formules, une colonne pour chaque.
●
Déterminer le nombre de lignes : 2n où n nombre de propositions atomiques.
●
Exemple : si n=3, alors 2n=8 lignes.
●
Compléter les lignes avec toutes les combinaisons possibles.
●
Technique : Compter jusque 2n en binaire pour n'oublier aucune ligne. (0=F et 1=V)
●
Remplir les colonnes de droite, éventuellement en découpant les formules compliquées.
Un prisonnier étudiant doit choisir entre deux cellules, chaque cellule pouvant contenir une princesse ou
un tigre. S’il tombe sur le tigre il est dévoré, s’il délivre la princesse il est gracié. Sur chaque cellule, Il y a
une inscription qui peut être vraie ou fausse. Le roi dit une phrase qui est vraie.
Une des affiches

dit la vérité,
l’autre ment.
Il y a une Il y a une
princesse dans princesse dans
cette cellule et un une cellule et il y
tigre dans l’autre. a un tigre dans
une cellule.
1
2

Construire une table de vérité et sauver un étudiant
Un prisonnier étudiant doit choisir entre deux cellules, chaque cellule pouvant contenir une princesse ou
un tigre. S’il tombe sur le tigre il est dévoré, s’il délivre la princesse il est gracié. Sur chaque cellule, Il y a
une inscription qui peut être vraie ou fausse. Le roi dit une phrase qui est vraie.
Une des affiches

dit la vérité,
l’autre ment.
Il y a une Il y a une
princesse dans princesse dans
cette cellule et un une cellule et il y
tigre dans l’autre. a un tigre dans
une cellule.
1
2

Logique dans le code python
⚠️ en Python le simple = est

une affectation et se lit de
droite à gauche !

Fonctions
L’un des concepts les plus importants en programmation est celui de fonction. Les
fonctions permettent en effet de décomposer un programme complexe en une série de
sous-programmes plus simples, lesquels peuvent à leur tour être décomposés en
fragments plus petits, et ainsi de suite. D’autre part, les fonctions sont réutilisables : si
nous disposons d’une fonction capable de calculer une racine carrée, par exemple,
nous pouvons l’utiliser un peu partout dans nos programmes sans avoir à la ré-écrire à
chaque fois.
https://inforef.be/swi/download/apprendre_python3_5.
pdf Page 69

Fonctions prédéfinis
●
Nous avons déjà utilisé des fonctions prédéfinies. Par exemple
print print(‘Bonjour’, name)
⇒ Elle permet d’afficher les arguments donnés entre parenthèse sur

l’écran.
len len(list1)
⇒ Elle retourne la longueur d’une liste passée en argument.

●
Lorsque nous l’utilisons , nous disons que nous appelons une fonction.
Ces fonctions sont directement accessible dans python

Fonctions importées
●
Nous avons déjà utilisé des fonctions importées. Par exemple
sqrt r: float = sqrt(1)
⇒ Elle retourne la racine carrée d’un nombre passé en arguments . Elle

est définit dans le module math et on doit donc l’importer pour l’utiliser :
from math import sqrt
loadImage i: ImagePPM = loadImage(‘./pict/img.ppm’)
⇒ Elle permet de désérialiser une image ppm sur le disque dur et de

retourner une variable de type ImagePPM. Elle est définit dans le
module iiwHelper et on doit donc l’importer pour l’utiliser :
from iiwHelper import loadImage

Définition d’une fonction originale
●
Définition d’une fonction avec paramètre :
●
Appel de la fonction ci dessus :

●
nomParam1 : type, nomParam2 : type, etc
●
: int
6

●
nomParam1 : type, nomParam2 : type, etc
●
i base
: int
6

●
i base
: int
4

●
i base
: int : int
4 8

●
blanc : Pixel : int

r 255
g
b

●
p : int
0
blanc : Pixel : int
r 255
g
b

●
Définition d’une fonction avec paramètre et type de retour :
Le mot clé return stop le flux d’exécution de la fonction et revient à la ligne d’appel

●
Définition d’une fonction avec ‘code mort’ :

●
Définition d’une fonction avec multiples return:

●
Définition d’une fonction avec paramètre par defaut:

HTTP, HTML et compagnie

Internet versus web ?
●
Internet est un ensemble d’ordinateurs, reliés entre eux par un réseau, leur
permettant ainsi d’échanger toutes sortes de données.
●
Basé sur l’ensemble de protocoles TCP/IP
●
Sans centre névralgique
●
permet des applications variées comme le courrier électronique, la
messagerie instantanée, le partage de fichiers en pair-à-pair, le
streaming, le podcasting, la téléconférence et aussi le World Wide
Web
●
Le « Web » est un système hypertexte public fonctionnant sur Internet. Le
Web permet de consulter (avec un navigateur), des pages accessibles
sur des sites.

TCP/IP
●
Internet Protocol :
●
C’est un protocole basé sur une notion d’adresse unique pour chaque nœud
publique directement lié au réseau internet (par exemple votre box internet) →
l’adresse IP publique.
●
L’adresse IP s’obtient en ayant un fournisseur d’accès à internet.
●
L’adresse IP permet non seulement d’envoyer les bonnes données au bon endroit
mais elle permet aussi d’estimer approximativement où se trouve l’ordinateur lié
à internet (https://mon-adresse-ip.fr/)
●
Sur un ordinateur, l’adresse de la machine sur laquelle on « travaille » est toujours
127.0.0.1 par convention, avec le nom localhost
●
Transmission Control Protocol :
●
Permet d’établir une liaison entre un serveur et un client afin d’échanger des
données

HTTP et le web
●
L’Hypertext Transfer Protocol, généralement abrégé HTTP, littéralement « protocole de
transfert hypertexte », est un protocole de communication client-serveur développé pour
le World Wide Web. HTTPS (avec S pour secure, soit « sécurisé ») est la variante sécurisée
par le chiffrement et l'authentification.
●
Client - Serveur :
●
Le client est un programme qui veut récupérer du contenu, par exemple votr navigateur
web
●
Le serveur attend qu’un client se connecte et lui permet d’accéder à un document donné
https://www.afternerd.com/blog/python-http-server/
HTTP et le web

HTTP et le web
●
URL de la page demandée : Chemin de la requête
http://www.i3s.unice.fr/~deantoni/index.html
protocol serveur hôte chemin fichier
e
●
Actions effectuées :
1) Demande de l’adresse ip du serveur hôte à un serveur particulier nommé
DNS (Domain Name Server)

HTML : Hyper Text Markup Language
●
Langage à balise pour l’hyper text. Ce n’est pas un langage de programmation.
Aucun algorithme n’est décrit.
Langage à balise
●
En informatique, les langages à balise représentent une classe de langages
spécialisés dans l'enrichissement d'information textuelle. Ils utilisent des
balises, unités syntaxiques délimitant une séquence de caractères ou
marquant une position précise à l'intérieur d'un flux de caractères (par
exemple un fichier texte).
●
L'inclusion de balises permet de transférer à la fois la structure du document et son
contenu. Cette structure est compréhensible par un programme informatique,
ce qui permet un traitement automatisé du contenu.
●
Exemple : Texte du titre
<title> ceci est un titre avec un mot en gras </title>

●
Balises ouvrantes Balises fermantes

Contenu en gras
Introduction à l’informatique https://fr.wikipedia.org/wiki/Langage_de_balisage 147
●
Le document est de type HTML (sa DTD est celle d’HTML)
<!DOCTYPE html>
<html>
●
Le document html commence <head>
<title>Titre</title>
●
L’entête définit différentes choses dont </head>
le titre de l’onglet puis se termine <body>
</body>
●
Le corps du document est ici vide, </html>
c’est à dire que la page sera vide
●
Le document html finit
⚠️qui Les balises ne doivent pas être entrelacées, la première qui ouvre est la dernière
ferme … 
<!DOCTYPE html>
<html>
<head>
<title>Titre de la page</title>
</head>
<body>
This is the body
</body>
</html>

Structure arborescente d’HTML Une manière simpliste parmi d’autres
html
1 2
head
1 2 body
• title: simple body
meta title 1 2 3 4
• charset : utf-8
1
Titre de la page
This is the body a br img

• href: http://univ-cotedazur.fr • src: ./assets/images/logo.png
• width : 200
racine noeud feuille • attribut : valeur
●
Cette structure, en mémoire est facile à manipuler informatiquement et est
largement utilisée. Le concept est générique et peut être adapté à
différents cas (arbre d’expression, arbre binaire de recherche,
grammaire, html)

<!DOCTYPE html>
<html>
<head>
<link href="fichierDeStyle.css" rel="stylesheet" />
</head>
<body>
This is the body
<a href="http://univ-cotedazur.fr"> site UCA </a>
 
<img src="./assets/images/logo.jpg" width=200/>
</body>
</html>
HTML ne définit que la structure, pas la manière de représenter visuellement le

texte sous jacent, même si il y a une représentation par défaut.
→ un fichier spécifique dans un autre langage (CSS) permet de donner la
couche représentation, c’est à dire le style de chaque élément. La bonne
pratique est de référencer le fichier css depuis le fichier html par la balise
orpheline <link> Les liens peuvent être relatifs ou absolus;
locaux ou non.
CSS : Cascading Style Sheets
●
Les feuilles de style en cascade (CSS) sont utilisées pour formater la mise en
page d'une page Web.
●
Avec CSS, vous pouvez contrôler la couleur, la police, la taille du texte,
l'espacement entre les éléments, la manière dont les éléments sont
positionnés et disposés, les images d'arrière-plan ou les couleurs d'arrière-
plan à utiliser, différents affichages pour différents appareils et tailles
d'écran, et beaucoup plus!
●
Le mot cascade signifie qu'un style appliqué à un élément parent s'appliquera
également à tous les éléments enfants du parent. Ainsi, si vous définissez la
couleur du corps du texte sur "bleu", tous les titres, paragraphes et autres
éléments de texte du corps auront également lahttps://www.w3schools.com/html/html_css.as
même couleur (sauf si vous
spécifiez autre chose) ! p
●
CSS est basé sur la notion de règle qui s’applique à des nœuds particuliers de
l’arbre de la structure html.
Notes : Pour 1 document il peut y avoir une infinité de styles :
http://www.csszengarden.com
On ne verra pas toutes les propriétés ! https://www.w3schools.com/w3css/defaulT.asp

CSS : Cascading Style Sheets
<!DOCTYPE html>
<html>
<head>
<link href="fichierDeStyle.css" rel="stylesheet" />
</head>
<body>
This is the body
<a href="http://univ-cotedazur.fr"> site UCA </a>
</body>
</html>
body {
background-color: powderblue;
color: brown;
}
3 règles a{
CSS color: yellow;
}
img {
border: 2px solid #7FFFD4;
}
fichierDeStyle.css

Syntaxe
Les sélécteurs permettent de spécifier les nodes de l’arbre sous jacent à HTML
selector, … {
property: value …;
…
} Toutes les balises h1, h2, h3
• Examples:
h1, h2, h3 {
Border: 2px solid grey;
} Toutes les balises avec
.title { l’attribut class = “title”
font-weight: bold;
}
#main { La balise avec id=“main”
font-style: italic;
}
* { Toutes les balises
font-style: italic;
}
Introduction à l’informatique slide from Nicolas Ferry 155
Sélécteurs avancés Les sélécteurs avancés permettent de spécifier
des relations dans l’arbre sous jacent à HTML
(i.e., des sous arbres)
Tous les p suivant un h1

h1 + p {
…
}
Tous les p dans un h1

h1 p {
…
}
Tous les p directement fils d’un
h1 > p {
h1
…
} Tous les h1 avec l’attribut title
h1[title]{
…
}

slide from Nicolas Ferry
Requetes HTTP client - server

Requetes HTTP client - server

One slide conclusion
●
L’informatique permet de traiter de l’information en écrivant des
algorithmes.
●
L’informatique donne des méthodes, des langages et des « frameworks »
permettant de décrire l’information et les algorithmes.
●
Écrire un algorithme ne s’apprend pas en un jour. Il est nécessaire de
pratiquer afin de comprendre certains automatismes de pensée.
●
Rien n’est perdu pour personne mais rien n’arrive sans travail ni
rigueur.
●
Pratiquez par vous même (même en reprenant au TP2 si nécessaire).
Relisez les cours. Demandez à quelqu’un de relire votre code pour des
corrections et des conseils. C’est mon rôle mais aussi celui des autres
chargés de Tps/Tds. (Cela peut aussi être avec d’autres personnes de la
promo).

9 Resume

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

9 Resume

Transféré par

Droits d'auteur :

Formats disponibles

Introduction à

Introduction à l’informatique Adapted from Pierre Lezowski’s courses

1) Introduction, notion de variables, de type de données simple et structuré

2) Variables, séquence d’instructions en mémoire, Notion d’algorithme, de

3) Logique Booléenne et comparaison, lecture/écriture dans un fichier

4) Écrire des fonctions afin de rendre le code plus lisible et réutilisable

5) Contrôle continu intermédiaire

6) Introduction au web, structure d’une page en web en HTML

type des éléments de la liste

L’étiquette (ou référence) La valeur référencée par

L’étiquette La valeur référencée La valeur référencée La valeur référencée

C’est une affectation, pas une

L’étiquette La valeur référencée

Personne Type structuré

Personne Type structuré

Personne Type structuré

p2.nom p2.nom == p1.nom ?

from dataclasses import dataclass

@ dataclass Annotation pour se simplifier la vie

Point2D Type structuré

pointA: Point2D = Point2D(1,2)

i: int = int(42) # déclaration de la variable i, initialisée à 42

f : float = float(j / i) # approximation de la valeur de j / i stockée dans un float

j = i**2 # i puissance 2 (au carré)

list1: list = list([1,34,67,100])

: int : int : int : int

i1 : int = int( list1[0] + 2)

: int : int : int

: int : int : int

Point2D Type structuré

Point2D Type structuré

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

p: Point2D = allPoints[indice] p: Point2D = allPoints[0]

p: Point2D = allPoints[indice] p = allPoints[1]

p: Point2D = allPoints[indice] Séquences d’instructions

p: Point2D = allPoints[indice] Séquences d’instructions

p: Point2D = allPoints[indice] Séquences d’instructions

p: Point2D = allPoints[indice] Séquences d’instructions

p: Point2D = allPoints[indice] Séquences d’instructions

p: Point2D = allPoints[indice] Séquences d’instructions

[(x=1, y=2), (x=2, y=4), (x=3, y=6), (x=4, y=8)]

[(x=1, y=3), (x=2, y=5), (x=3, y=7), (x=4, y=9)]