Chapitre 12 : Langages de programamtion

Les langages de programmation présentent une unité car ils possèdent un corpus d'instructions élémentaires commun.
Leur diversité réside dans leur syntaxe :

• ces mêmes structures communes s'écrivent différemment d'un langage à un autre,
• dans les types de variables qu'ils proposent
• et dans leur paradigme de programmation.

Retrouver la liste des langages de programmation sur cet article de Wikipédia.

Retrouver le classement des langages les plus utilisés sur la page de l' Index TIOBE.

Séquences et affectation

Une séquence est une suite d'instruction.
Une affectation est le fait de donner une valeur à une variable.

x ← 5
texte ← "Hello"    
    

i = 5
texte = "Hello"
    

int i ;
i = 5 ;
char texte[] = "Hello" ;
    

$i = 5;
$texte = "Hello";           
    

let i = 5 ;
var texte = "Hello" ;        
    

INTEGER :: I
CHARACTER(len=20) :: texte
I = 5
texte = 'Hello'        
    

L'affectation dans les langages de programmation se distingue par le typage des variables et leur domaine de définition.

• Chaque langage propose différents types de variables. Les plus communs sont : entier, flottant, chaîne de caractère, etc. Certains langages utilisent un typage fort (C++, java), c'est-à-dire qu'une variable ne peut pas changer de type au cours d'un programme. D'autre utilise un typage dynamique (python) : une variable change de type en fonction de la valeur qui lui est affectée.
• Le domaine de définition correspond à la partie du code où la variable est définie. Par exemple en javascript, le mot clé var définit une variable globale tandis que let définit une variable seulement dans le bloc courant.

def double(x):
    return 2*x
    
a = 5
print(double(a))
    

def double(x):
    print(a)  # Ne renvoie pas d'erreur
    return 2*x
    
a = 5
print(double(a))
    

def double(x):
    a = 2
    print(a)  # Affiche 2
    return 2*x
    
a = 5
print(double(a))
print(a)  # Affiche 5, la variable "a" n'a pas été modifiée.
        

def double(x):
    global a
    a = 2
    print(a)  # Affiche 2
    return 2*x
    
a = 5
print(double(a))
print(a)  # Affiche 2, la variable "a" a été modifiée.
                    

Structure de contrôle du flux d'exécution

Une structure de contrôle permet de gérer le flux d'exécution en modifiant l'ordre d'exécution des lignes du code.

Structure conditionnelle

Une structure conditionnelle définie une partie de code à exécuter dans le cas où une condition est vérifiée. Cette condition doit être une expression booléenne : test d'égalité, d'inégalité ou expression logique.

Les opérateurs de comparaison utilisent très souvent la syntaxe ==, > ou >= mais on trouve aussi gt pour « greater than », ou lt pour « lower than » etc. Les opérateurs Booléens s'écrivent : or, and et not en python mais dans de nombreux langages on trouvera respectivement : ||, && et !.

Le modèle if

SI condition1 
ALORS instruction1
SINON SI condition2
ALORS instruction2
SINON instruction3            
    

if condition1 :
    instruction1  # Indentation
elif condition2 :
    instruction2
else :
    instruction3
    

If condition1 Then
    instruction1
Else If condition2 then
    instruction2
Else
    Instruction3
End If      
    

if (condition1) { # Accolades
    instruction1 ;
}
else if (condition2) {
    instruction2 ;
}
else {
    instruction3 ;
}           
    

Le modèle switch

Certain langage propose une syntaxe particulière qui est une manière plus condensée de traiter une structure conditionnelle : le modèle switch.

switch ($x) {
    case 1 :  # (si $x = 1)
        instruction1 ;      
        break;
    case 2:   # (si $x = 2)
        instruction2 ;      
        break;
    default : # (sinon)
        instruction3 ;
}    
        

switch (i) {  # (i entier)
    case 1:
        instruction1 ;      
        break;
    case 2:
        instruction2 ;      
        break;
}
        

when (x) {
    1 -> {instruction1}
    2 -> {instruction2}
    else -> {instruction3}
             
        

Boucle bornée (modèle for)

Une boucle bornée permet d'exécuter des instructions un nombre de fois connu dès le départ.

POUR i ALLANT DE 0 A 9 FAIRE
...instructions...
FIN DU POUR       
    

for i in range (10):    
    instructions   # indentation    
    

int i ;
for (i=0 ; i<10 ; i++) {
    # instructions
}  
    

for (i=0 ; i<10 ; i++) {
    // instructions
}             
    

for ($i = 1 ; $i<10 ; $i++) {
    # instructions 
}     
    

for (i in 0:9) {
    ### instructions 
}       
    

Boucle non-bornée (modèle while)

Une boucle non-bornée permet d'exécuter des instructions tant qu'une condition est vérifiée. Il est important que cette condition soit réévaluée à chaque itération de la boucle pour éviter de tomber dans une boucle infinie.

TANT QUE condition FAIRE 
... instructions ...
FIN DU TANT QUE             
    

while condition:    
    instructions  # indentation  
    

while (condition) {
    # instructions
}               
    

do {
    # instructions
} while (condition)
    

Fonction

Une fonction est un bloc d'instructions séparé du reste du code afin de les appeler autant de fois que souhaité dans le reste du code. Elle possède son propre domaine de variables et peut accepter 0, 1 ou plusieurs arguments.

def double(a) :
    b = a*2   # indentation
    return b
    

int double(int a) {   
    b = a*2 ;
    return b ;
    }                   
    

function double($a) {
    $b = $a*2 ;
    return $b ;
}                       
    

function double(a) {
    return a*2
}     
    

def double(x):
    print(a)  # Ne renvoie pas d'erreur
    return 2*x
    
a = 5
print(double(a))
    

age = 12
if age >= 18:
    print("majeur")
else:
    print("mineur")
    

i = 0
while i < 4:
    i += 2
print("C'est fini !")
    

Paradigme de programmation

Un paradigme est un ensemble de méthodes reconnu par une communauté. Il existe plusieurs paradigmes de programmation. Un même langage peut proposer plusieurs paradigmes.

• Paradigme impératif : Le code est structuré comme une séquence d'instruction à exécuter.
• Paradigme procédural : Le code réutilisable est factorisé sous forme de fonctions ou de modules (procédure).
• Paradigme fonctionnel (programme de terminale NSI) : Les fonctions ne peuvent pas modifier l'état du système, évitant ainsi des bugs appelés "effets de bord" : on parle de fonction pure. Les variables sont immuables (comme un tuple en comparaison d'une liste).
• Paradigme objet (programme de terminale NSI) : Le code est construit autour d'objet ayant des attributs (données) et des opérations (méthodes).

# Récupère la liste de nombres
liste = input("Entrez la liste de nombres séparés par un espace : \n").replace(",", ".").split()
somme = 0
for nb in liste:  # boucle sur la liste
    somme = somme + float(nb)

print(somme) # affiche la somme
    

def somme_liste(liste):  # définit la fonction (procédure) pour effectuer le calcul
    somme = 0
    for nb in liste:
        somme = somme + float(nb)
    return somme

# Récupère la liste de nombres
liste = input("Entrez la liste de nombres séparés par un espace : \n").replace(",", ".").split()
s = somme_liste(liste)  # récupère la somme
print(s)  # affiche la somme