Partie 2: Types de Données Simples

Qu'est-ce qu'une Donnée ?

• Une donnée est la représentation d’un objet abstrait ou concret dans le monde.

• Chaque donnée est codée et stockée dans une mémoire.

• Elle est spécifiée par :

  • Son nom : il désigne la donnée dans l'algorithme (doit être compréhensible).

  • Son type : il décrit le domaine de valeurs que peut prendre la donnée.

  • Sa nature : variable (peut changer de valeur) ou constante.

  • Son contenu : la valeur en mémoire à laquelle le nom fait référence.

Types de Données Simples

• Une donnée de type simple ne contient qu'une seule information.

La Table ASCII (American Standard Code for Information Interchange) utilise un codage 7 bits. La table étendue (8 bits) permet de coder les caractères accentués.

Types de Données Composées (Exemples)

Variables en Python

• En Python, les variables n'ont pas de type fixe. Leur type peut changer dynamiquement selon la valeur qui leur est assignée.

• Les opérations sont contraintes par le type du contenu actuel de la variable.

>>> pi = 3.1415
>>> print(pi)
3.1415
>>> pi = 12
>>> print(pi)
12
>>> pi = "coucou"
>>> print(pi)
coucou

Opérateurs et Expressions

• Un opérateur est une fonction qui associe à une série de valeurs d'entrée une valeur de sortie.

• Caractéristiques d'un opérateur :

  • Arité : donnée par le nombre de ses entrées (unaire, binaire, etc.).

  • Position : préfixe (devant), infixe (milieu) ou postfixe (derrière).

  • Type : donné par le type de ses entrées et celui de sa sortie.

Exemples d'Opérateurs Algorithmiques

• Opérateur binaire, infixe:
  

• Opérateur unaire, préfixe:
  

Opérateurs Numériques

Si toutes les entrées sont des entiers, la sortie est un entier.

Si au moins une entrée est un réel, la sortie est un réel.

Exception : La division réelle / renvoie toujours un réel, même avec des entiers.

Opérateurs de Comparaison

Entrées numériques ou caractères. La sortie est un booléen.

Les caractères ASCII sont comparables selon leur ordre dans la table.

Opérateurs Logiques

Entrées des booléens. La sortie est un booléen.

Expressions

• Une expression est une composition d'opérations.

• Une expression est bien formée si chaque opération s'applique sur des entrées de type autorisé.

• Le type d'une expression est donné par le type de sa valeur de sortie.

• Exemples :

  • Si et sont des entiers, est une expression bien formée de type booléen.

  • est une expression mal formée (opérateur logique ou avec des types incompatibles).

• Utiliser les parenthèses pour expliciter l'ordre des combinaisons d'opérations et éviter les erreurs d'interprétation.

  Ex: est différente de .

Instructions Simples

L'instruction d'affectation

• Consiste à assigner une valeur à une donnée.

• Représentation en pseudo-code: variable ← expression.

• En Python: variable = expression.

• L'opérateur d'affectation (=) est différent de l'opérateur d'égalité (==).

x = 2.0  // x prend la valeur 2.0
y = 4.0  // y prend la valeur 4.0
y = y + 1 // y est incrémenté et prend la valeur 5.0
x = y // x prend la valeur de y, c'est-à-dire 5.0

Affectations Composées

• Modifient la valeur d'une variable en effectuant une opération sur elle-même.

Instructions d'Entrée/Sortie

• L'instruction lire (input en Python):

  • variable = input()

  • Reçoit une valeur entrée au clavier et l'affecte à la variable.

• L'instruction afficher (print en Python):

  • print(données)

  • Affiche les données à la sortie standard (l'écran).

Algorithme : calculeVitesse
début
  afficher "Distance : " // Affiche la chaîne "Distance : "
  lire distance // Lit la valeur saisie et l'affecte à 'distance'
  afficher "Temps : "
  lire temps
  vitesse ← distance / temps
  afficher "Vitesse : ", vitesse // Affiche "Vitesse : " suivi de la valeur de 'vitesse'
fin

Codage de Données

• L'informatique utilise plusieurs systèmes de codage de données :

  • Décimal (base 10) : utilisé en mathématiques.

  • Binaire (base 2) : utilisé dans la mémoire électronique.

  • Hexadécimal (base 16) : utilisé pour interpréter les données binaires ().

Codage Décimal (Base 10)

• Tout entier positif est codé par une séquence de chiffres .

• Chaque chiffre (ou case) a une valeur de 0 à 9.

• Nombre de cases : .

• Définition : .

Exemple : $1.100.924 = 1 \cdot 10^6 + 1 \cdot 10^5 + 0 \cdot 10^4 + 0 \cdot 10^3 + 9 \cdot 10^2 + 2 \cdot 10^1 + 4 \cdot 10^0$

Codage Binaire (Base 2)

• Tout entier positif est codé par une séquence de chiffres .

• Chaque chiffre (ou case) a la valeur 0 ou 1 (un bit).

• Nombre de cases : .

• Définition : .

Exemple : $75_{10} = 1001011_2 = 1 \cdot 2^6 + 0 \cdot 2^5 + 0 \cdot 2^4 + 1 \cdot 2^3 + 0 \cdot 2^2 + 1 \cdot 2^1 + 1 \cdot 2^0$

Codage Hexadécimal (Base 16)

• Tout entier positif est codé par une séquence de chiffres .

• Chaque case a une valeur dans .

• Nombre de cases : .

• Définition : .

• Chaque paquet de 4 bits est regroupé et codé par un chiffre hexadécimal.

• Exemple : en binaire est . En groupant par 4 bits : correspond à , et correspond à . Donc .

Structure d'un Programme Python

• Le code source d'un programme Python contient trois éléments essentiels :

  1. Commentaires : préfixés par # pour une ligne, ou encadrés par """ pour plusieurs lignes.

  2. Inclusions de modules : fonctions supplémentaires préfixées par import (ex: import random).

  3. Fonction principale : exécutée au démarrage du programme.

import random # Importe le module 'random'
"""
Ce programme affiche un nombre aléatoire
entre deux nombres fournis par l'utilisateur
"""
i = int(input("Rentrez le premier nombre:")) # Commentaire en fin de ligne
j = int(input("Rentrez le second nombre:"))
k = random.randint(i, j) # Utilisation d'une fonction du module 'random'
print(k)

Partie 3: Structures de Contrôle

Blocs d'Instructions

• En pseudo-code : une liste ordonnée d'instructions identifiée par une barre verticale et terminée par le mot-clé fin.

  • La barre et fin peuvent être omis si le bloc ne contient qu'une seule instruction.

• En Python : une séquence d'instructions rassemblées dans un même niveau d'indentation.

  • Attention : <tab> et <espace> ne sont pas les mêmes et peuvent causer des erreurs (préférez les espaces).

// Pseudo-code
si a < b alors
| afficher "correct"
sinon
| c ← a
| a ← b
| b ← c
fin

Python

if a < b: print("Correct") else: c = a a = b b = c

Les Conditions (Tests)

L'instruction "si alors" (if)

• Syntaxe pseudo-code : si <condition> alors <bloc>

• Syntaxe Python : if condition: \n ... <bloc>

• La condition est une expression booléenne.

• Le bloc n'est exécuté que si la condition est vraie. S'il est faux, le programme saute le bloc et continue le code non indenté.

• Ne pas oublier les deux points " : " après la condition en Python.

Algorithme : valeurAbsolue
début
  lire x
  y ← x
  si y < 0 alors
  | y ← -y
  fin
  afficher y
fin

# Python - Exemple de valeur absolue
x = float(input("Entrez un nombre: "))
y = x
if y < 0:
    y = -y
print(y)

L'instruction "si alors sinon" (if-else)

• Syntaxe pseudo-code : si <condition> alors <bloc 1> sinon <bloc 2>

• Syntaxe Python : if condition: \n ... <bloc 1> \n else: \n ... <bloc 2>

• Le bloc 1 est exécuté si la condition est vraie.

• Le bloc 2 est exécuté si la condition est fausse.

• Ne pas oublier les deux points " : " après la condition et else en Python.

Algorithme : racineCarrée
début
  lire x
  si x ≥ 0 alors
  | y ← sqrt(x)
  | afficher y
  sinon
  | afficher "Valeur indéfinie"
  fin
fin

# Python - Exemple de racine carrée
import math
x = float(input("Entrez un réel: "))
if x >= 0:
    print("La racine est: ", math.sqrt(x))
else:
    print("Valeur indéfinie")

Tests Imbriqués

• Les tests peuvent être imbriqués, formant une structure arborescente.

• Chaque sommet interne représente la condition d'un "si alors (sinon)".

• Chaque feuille représente un bloc d'instructions exécuté. L'exécution de l'algorithme est un chemin de la racine à une feuille.

Algorithme : étatDeLeau
début
  lire T
  si T < 0 alors
  | afficher "solide"
  sinon
  | si T < 100 alors
  | | afficher "liquide"
  | sinon
  | | afficher "gaz"
  | fin
  fin
fin

Les Boucles (Itérations)

La boucle "pour" (for)

• Utilisée lorsque le nombre d'itérations est connu à l'avance.

• Contrôlée par un compteur qui parcourt un intervalle spécifié.

• Syntaxe pseudo-code : pour i de x à y faire <instruction> (exécutée fois).

• Syntaxe Python : for compteur in intervalle: \n ... <bloc>

• Définition des intervalles en Python avec range() :

  • range(n) : de 0 à .

  • range(j, n) : de à .

  • range(j, n, p) : de à par pas de .

• Attention : Le compteur ne doit jamais être modifié par le bloc d'instructions qui l'utilise.

• Ne pas oublier les deux points " : " après l'intervalle en Python.

Algorithme : somme de 1 à n
début
  lire n
  s ← 0
  pour i de 1 à n faire
  | s ← s + i
  fin
  afficher s
fin

# Python - Exemple de somme de 1 à n
s = 0
n = int(input("Entrez un entier: ")) # Supposons n = 3
for i in range(1, n + 1): # i prend les valeurs 1, 2, 3
    s = s + i
print(s) # Affiche 6

La boucle "tant que" (while)

• Utilisée lorsque le nombre d'itérations n'est pas connu à l'avance.

• Elle exécute le bloc d'instructions tant que la condition reste vraie.

• Syntaxe pseudo-code : tant que condition faire <instruction> (exécutée jusqu'à ce que la condition soit fausse).

• Syntaxe Python : while condition: \n ... <bloc>

• À chaque itération, le programme teste la condition.

• Le bloc peut être exécuté zéro fois si la condition est initialement fausse.

• Ne pas oublier les deux points " : " après la condition en Python.

Algorithme : sommeDesEntrées
début
  s ← 0
  n ← 1 // Initialisation pour entrer dans la boucle
  tant que n ≠ 0 faire
  | afficher "Entrer un entier (0 pour arrêter) :"
  | lire n
  | s ← s + n
  fin
  afficher s
fin

# Python - Exemple de somme des entrées jusqu'à 0
s = 0
n = 1 # Initialisation pour entrer dans la boucle
while n != 0:
    n = int(input("Entrer un entier (0 pour arrêter): "))
    s = s + n
print(s)