1re NSI / Cours

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 :

avec des structures qui s'écrivent différemment d'un langage à un autre,

des types de variables proposés différents,

et des paradigmes de programmation.

Un programme est souvent utilisé pour présenter la syntaxe d'un langage de programmation. Il s'agit du programme consistant à afficher « Hello world! ».

Aller sur le site onlinegdb pour découvrir ce programme écrit dans plusieurs langages.
Comparer les syntaxes en python, javascript, C et Bash.

Ressources :

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.
Infographie statista 2019

Séquences et affectation

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

algorithmique python C

algorithmique	python	C
`x ← 5 texte ← "Hello"`	`i = 5 texte = "Hello"`	`int i ; i = 5 ; char texte[] = "Hello" ;`
PHP	javascript	Fortran
`$i = 5; $texte = "Hello";`	`let i = 5 ; var texte = "Hello" ;`	`INTEGER :: I CHARACTER(len=20) :: texte I = 5 texte = 'Hello'`

x ← 5
texte ← "Hello"

i = 5
texte = "Hello"

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

PHP javascript Fortran

$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.

Dans le script python suivant, quel est le domaine de définition des variables a et x ?
```
def double(x):
    return 2*x

a = 5
print(double(a))
```
La variable a est définie dans le domaine principal du script. La variable x est définie dans le domaine de la fonction.
Que se passe-t-il si l'on essaye de modifier la variable a dans le bloc de la fonction ?
La variable a n'est pas globale et ne peut donc pas être modifiée dans le bloc de la fonction.
On obtient une erreur : UnboundLocalError: local variable 'a' referenced before assignment
Que se passe-t-il si l'on invoque la variable a dans le bloc de la fonction ?
La variable a n'est pas globale mais étant définie dans le domaine principal du script, sa valeur peut être invoquée dans la fonction.
```
def double(x):
    print(a)  # Ne renvoie pas d'erreur
    return 2*x

a = 5
print(double(a))
```
Que se passe-t-il si l'on affecte une valeur à une variable a dans le bloc de la fonction ?
La variable b définie dans le bloc de la fonction n'est pas la même variable b définie en dehors de la fonction.
```
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.
```

Comment rendre une variable globale en python ?

Avec l'instruction global .

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 !.

Réaliser un tableau répertoriant la syntaxe des opérateurs de comparaison et des opérateurs Booléens pour les langages : Python, javascript, C, OCaml...

langage	opérateurs de comparaison	opérateurs Booléens
python	==	>	>=	!=	and	or	not
javascript	==	>	>=	!=	&&	\|\|	!
C	==	>	>=	!=	&&	\|\|	!
OCaml	==	>	>=	<> =!	&& and	\|\| or	not
...	...	...	...	...	...	...	...

2.1.1. Le modèle `if`

algorithmique python

algorithmique	python
`SI condition1 ALORS instruction1 SINON SI condition2 ALORS instruction2 SINON instruction3`	`if condition1 : instruction1 # Indentation elif condition2 : instruction2 else : instruction3`
VBA	C, PHP, javascript, java, Kotlin
`If condition1 Then instruction1 Else If condition2 then instruction2 Else Instruction3 End If`	`if (condition1) { # Accolades instruction1 ; } else if (condition2) { instruction2 ; } else { instruction3 ; }`

SI condition1
ALORS instruction1
SINON SI condition2
ALORS instruction2
SINON instruction3

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

VBA C, PHP, javascript, java, Kotlin

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

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

2.1.2. 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.

PHP C Kotlin

PHP	C	Kotlin
`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}`

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}

2.2. 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.

algorithmique python C

algorithmique	python	C
`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 }`
javascript	PHP	R
`for (i=0 ; i<10 ; i++) { // instructions }`	`for ($i = 1 ; $i<10 ; $i++) { # instructions }`	`for (i in 0:9) { ### instructions }`

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
}

javascript PHP R

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

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

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

2.3. 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.

algorithmique	python
`TANT QUE condition FAIRE ... instructions ... FIN DU TANT QUE`	`while condition: instructions # indentation`
C, PHP, javascript	C (autre syntaxe)
`while (condition) { # instructions }`	`do { # instructions } while (condition)`

2.4. Fonction (`def`, `function`)

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.

python C

python	C
`def double(a) : b = a*2 # indentation return b`	`int double(int a) { b = a*2 ; return b ; }` `b`b est un entier (mot clé `int` en début de fonction). Utiliser `void` si la fonction ne retourne rien.
PHP	javascript
`function double($a) { $b = $a*2 ; return $b ; }`	`function double(a) { return a*2 }`

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

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

bb est un entier (mot clé int en début de fonction).
Utiliser void si la fonction ne retourne rien.

PHP javascript

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

function double(a) {
    return a*2
}

Donner l'ordre d'exécution des lignes d'instructions pour les scripts python suivants :

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).

Langage	impératif	procédural	fonctionnel	objet
Assembleur	✓
C	✓	✓
C++	✓	✓		✓
Perl	✓	✓
PHP	✓	✓		✓
Python	✓	✓	~	✓
Java	✓	✓	~	✓
C#	✓	✓	~	✓
JavaScript	✓	✓	✓	✓
Kotlin	✓	✓	✓	✓
Swift	✓	✓	✓	✓

Implémenter en python un programme qui demande à l'utilisateur d'entrer des nombres et en effectue la somme :

selon le paradigme de programmation impératif (instructions simples sans fonction).

# 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

selon le paradigme de programmation procédural (définition d'une procédure sous forme d'une fonction).

L'avantage du paradigme procédural est la réutilisation facile du code, ici par l'appel d'une fonction, mais cela peut être aussi par l'utilisation de module.

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

Cours

Séquences et affectation

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

Structure conditionnelle

2.1.1. Le modèle if

2.1.2. Le modèle switch

2.2. Boucle bornée (modèle for)

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

2.4. Fonction (def, function)

Paradigme de programmation

2.1.1. Le modèle `if`

2.1.2. Le modèle `switch`

2.2. Boucle bornée (modèle `for`)

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

2.4. Fonction (`def`, `function`)