Chapitre 1 : Constructions élémentaires¶

Programme officiel (B.O.)¶

B.O. spécial n° 1 du 22 janvier 2019 - NSI Première

Contenus	Capacités attendues	Commentaires
Constructions élémentaires.	Mettre en évidence un corpus de constructions élémentaires (affectation, séquence, conditionnelle, boucle bornée, boucle non bornée, appel de fonction).	Les constructions élémentaires communes aux langages de programmation impératifs sont étudiées en Python.
Diversité et unité des langages de programmation.	Repérer, dans un nouveau langage de programmation, les traits communs et les traits particuliers à ce langage.	L'objectif est de montrer qu'il est possible de programmer dans des langages différents et qu'ils partagent des structures communes.

1. Les constructions élémentaires¶

Tout programme impératif se construit à partir de six briques de base, communes à pratiquement tous les langages de programmation.

1.1 L'affectation¶

L'affectation associe une valeur à un nom de variable.

x = 42
nom = "Alice"
pi = 3.14159

L'opérateur = en Python est une affectation, pas une égalité mathématique. L'expression x = x + 1 est parfaitement valide : elle prend la valeur de x, lui ajoute 1 et range le résultat dans x.

1.2 La séquence¶

La séquence est l'exécution d'instructions les unes après les autres, dans l'ordre où elles sont écrites.

a = 5
b = 3
c = a + b
print(c)      # 8

L'ordre compte : inverser deux lignes peut changer le résultat.

1.3 La conditionnelle (if / else)¶

La conditionnelle permet d'exécuter un bloc de code seulement si une condition est vraie.

age = 17
if age >= 18:
    print("Majeur")
else:
    print("Mineur")

Variantes :

# Sans else
if temperature < 0:
    print("Il gèle")

# Avec elif (sinon si)
if note >= 16:
    mention = "Très bien"
elif note >= 14:
    mention = "Bien"
elif note >= 12:
    mention = "Assez bien"
else:
    mention = "Pas de mention"

1.4 La boucle bornée (for)¶

La boucle bornée répète un bloc de code un nombre déterminé de fois.

# Afficher les nombres de 0 à 4
for i in range(5):
    print(i)

# Parcourir un tableau
noms = ["Alice", "Bob", "Charlie"]
for nom in noms:
    print(nom)

# Boucle avec pas
for i in range(0, 20, 2):    # 0, 2, 4, ..., 18
    print(i)

1.5 La boucle non bornée (while)¶

La boucle non bornée répète un bloc de code tant qu'une condition est vraie. Le nombre de répétitions n'est pas connu à l'avance.

n = 1
while n < 100:
    n = n * 2
print(n)      # 128

Attention

Une boucle while dont la condition ne devient jamais fausse produit une boucle infinie. Il faut s'assurer que la condition finira par être fausse.

# Boucle infinie (à éviter !)
while True:
    print("Infini")

1.6 L'appel de fonction¶

Une fonction est un bloc de code réutilisable, identifié par un nom, qui peut recevoir des paramètres et renvoyer un résultat.

def aire_rectangle(largeur, hauteur):
    return largeur * hauteur

surface = aire_rectangle(5, 3)
print(surface)    # 15

Terme	Définition
Définition	Création de la fonction avec `def`
Paramètres	Variables dans la parenthèse de `def` (ici `largeur`, `hauteur`)
Appel	Utilisation de la fonction : `aire_rectangle(5, 3)`
Arguments	Valeurs passées lors de l'appel (ici `5` et `3`)
Retour	Valeur renvoyée par `return`

2. Variables locales et globales¶

2.1 Portée des variables¶

Une variable définie à l'intérieur d'une fonction est locale : elle n'existe que pendant l'exécution de la fonction.

def ma_fonction():
    x = 10        # variable locale
    print(x)

ma_fonction()     # affiche 10
print(x)          # ERREUR : x n'existe pas ici

Une variable définie en dehors de toute fonction est globale : elle est accessible partout.

message = "Bonjour"    # variable globale

def saluer():
    print(message)     # accès en lecture autorisé

saluer()               # affiche "Bonjour"

Attention

En Python, une fonction peut lire une variable globale mais ne peut pas la modifier sans le mot-clé global (déconseillé). La bonne pratique est de passer les valeurs en paramètres et de renvoyer les résultats avec return.

2.2 Passage de paramètres¶

Les paramètres d'une fonction reçoivent une copie de la valeur pour les types simples (entiers, flottants, booléens, chaînes), mais une référence pour les types mutables (listes, dictionnaires).

def doubler(n):
    n = n * 2       # modifie la copie locale
    return n

x = 5
y = doubler(x)
print(x)            # 5 (inchangé)
print(y)            # 10

def ajouter(liste, element):
    liste.append(element)    # modifie la liste originale

ma_liste = [1, 2, 3]
ajouter(ma_liste, 4)
print(ma_liste)     # [1, 2, 3, 4] (modifiée)

3. Diversité des langages de programmation¶

3.1 Pourquoi tant de langages ?¶

Il n'existe pas de langage de programmation « universel ». Chaque langage a ses forces et ses faiblesses, adaptées à des domaines différents :

Langage	Créé en	Domaines privilégiés
Python	1991	Enseignement, science des données, IA, scripts
JavaScript	1995	Pages Web interactives, serveurs
Java	1995	Applications d'entreprise, Android
C	1972	Systèmes d'exploitation, embarqué, performance
C++	1983	Jeux vidéo, systèmes, performance
PHP	1995	Sites Web côté serveur
SQL	1974	Bases de données

3.2 Traits communs¶

Malgré leur diversité, tous les langages impératifs partagent les mêmes constructions élémentaires :

Construction	Python	JavaScript	C
Affectation	`x = 5`	`let x = 5;`	`int x = 5;`
Conditionnelle	`if x > 0:`	`if (x > 0) {`	`if (x > 0) {`
Boucle bornée	`for i in range(n):`	`for (let i=0; i<n; i++) {`	`for (int i=0; i<n; i++) {`
Boucle non bornée	`while x > 0:`	`while (x > 0) {`	`while (x > 0) {`
Fonction	`def f(x):`	`function f(x) {`	`int f(int x) {`
Bloc de code	Indentation	Accolades `{ }`	Accolades `{ }`

3.3 Traits particuliers¶

Les langages diffèrent sur plusieurs points :

Trait	Python	C / Java
Typage	Dynamique (pas de déclaration de type)	Statique (type déclaré : `int x = 5;`)
Délimitation	Indentation obligatoire	Accolades `{ }`
Point-virgule	Non	Obligatoire
Compilation	Interprété	Compilé

3.4 Exemple : le même algorithme en 3 langages¶

Calcul de la factorielle de n :

PythonJavaScriptC

def factorielle(n):
    resultat = 1
    for i in range(1, n + 1):
        resultat = resultat * i
    return resultat

function factorielle(n) {
    let resultat = 1;
    for (let i = 1; i <= n; i++) {
        resultat = resultat * i;
    }
    return resultat;
}

int factorielle(int n) {
    int resultat = 1;
    for (int i = 1; i <= n; i++) {
        resultat = resultat * i;
    }
    return resultat;
}

La structure est identique (variable, boucle, multiplication, retour). Seule la syntaxe change.

À retenir¶

Les six constructions élémentaires : affectation, séquence, conditionnelle, boucle bornée (for), boucle non bornée (while), appel de fonction.
Les variables locales n'existent que dans la fonction où elles sont définies.
Les paramètres de types simples sont passés par copie, les mutables par référence.
Tous les langages impératifs partagent les mêmes constructions : seule la syntaxe change.
Typage dynamique (Python) : pas de déclaration de type. Typage statique (C, Java) : type obligatoire.
Pour comprendre un nouveau langage, il faut identifier : la délimitation des blocs, la syntaxe des boucles et conditions, la gestion des types.