Fondamentaux - Cours

Solution.

1 Variable

Une variable est un élément qui associe une valeur à un nom. On dit que l’on affecte une valeur à une variable. Une valeur peut être de type Entier, Réel, Chaîne de caractères, Booléen ou Vide.

Table 1 – Types de valeur de base
Type de valeur Description
Entier Tout nombre entier (p.ex., 1, 2, 3)
Réel Tout nombre incluant des décimales (p.ex., 0.001, 3.14, 12.7)
Chaine de caractères Tout texte, déclaré en étant entouré de guillemets (p.ex., "Hello World!", "ESTIA", "J'aime")
Booléen N’a que deux valeurs possibles, True (vrai) ou False (faux)
Vide Représente l’absence de valeur ou une valeur nulle (None)

1.1 Syntaxe

# default_start
# Affectation d'une variable
variableName = value
# default_end

1.2 Exemple

# default_start
# Affectation des variables
a = 18
b = 3.14
c = "Hello"
d = False
e = None
# Affichage des variables
print("a:", a)
print("b:", b)
print("c:", c)
print("d:", d)
print("e:", e)
# default_end
Note
  • Les noms de variables peuvent contenir des lettres (a-z, A-Z), des chiffres (0-9), et des underscores (_). Ils doivent commencer par une lettre ou un underscore.
  • Les noms de variables sont sensibles à la casse. Par exemple, maVar et mavar sont des variables différentes.
Astuce
  • En utilisant le symbole #, tout ce qui suit sur la ligne est mis en commentaire. Un commentaire est essentiellement une note textuelle qui donne une explication sur le code source.
  • En utilisant la fonction print(), vous affichez le message spécifié à l’écran. Vous pouvez l’utiliser pour afficher des messages formatés à l’écran et éventuellement trouver des erreurs dans votre code source.

1.3 Premier pas

  1. Créer une variable \(var1\) et lui affecter le nombre entier \(24\)
  2. Créer une variable \(var2\) et lui affecter la chaine de caractères \(\q{heures}\)
  3. Afficher la valeur de \(var1\) suivie de la valeur de \(var2\)

Votre réponse

# exercice: check 
# default_start
print("Hello, World!")

# default_end
# solution_start
var1 = 24
var2 = "heures"
print(var1, var2)
# solution_end

2 Expression

Une expression est une combinaison de valeurs (e.g., 18, 3.14, "Hello", True), de variables (e.g., x, y, my_var, myVar) et d’opérateurs (e.g., +, >=, and) qui produit une valeur. Les expressions peuvent être simples ou complexes, mais elles se résolvent toujours à une seule valeur. Nous allons couvrir 3 groupes d’opérations qui sont : Arithmétique, Comparaison, et Logique.

Les opérateurs arithmétiques sont utilisés avec des valeurs numériques pour effectuer des opérations mathématiques courantes.
Opérateurs arithmétiques Description
+ Addition (e.g., x + y)
- Soustraction (e.g., x - y)
* Multiplication (e.g., x * y)
/ Division (e.g., x / y)
% Modulo (e.g., x % y)
** Exponentiation (e.g., x ** y)
// Division entière (e.g., x // y )
Les opérateurs de comparaison sont utilisés pour comparer deux valeurs et ils retournent toujours une valeur booléenne (True ou False).
Opérateurs de comparaison Description
== Égal (p. ex., x == y)
!= Différent (p. ex., x != y)
> Plus grand que (p. ex., x > y)
< Plus petit que (p. ex., x < y)
>= Plus grand ou égal à (p. ex., x >= y)
<= Plus petit ou égal à (p. ex.,x <= y)
Les opérateurs logiques sont utilisés pour combiner des conditions et ils retournent toujours une valeur booléenne (True ou False).
Opérateurs logiques Description
and Retourne True si les deux conditions sont vraies (e.g., x > 1 and y > 1)
or Retourne True si une des conditions est vraie (e.g., x > 1 or y > 1)
not Inverse le résultat, retourne False si le résultat est vrai (e.g., not(x > 1 and y > 1))

2.1 Syntaxe

# exercice: show
# default_start
#  Pour l'opérateur `not`
operator(expression)

# Pour tous les autres opérateurs
expression operateur expression
# default_end

2.2 Exemple

# exercice: demo
# default_start
# Opération arithmétique
a = 10
b = 3.25
result1 = a + b   # additionne les valeurs de `a` et `b`
print("a + b :", result1)

# Opération logique
c = True
d = False
result2 = c and d # vrai si les conditions `c` et `d` sont vraies
print("c and d :", result2)

# Opération de comparaison
e = 7.5
f = 5
result3 = e > f   # vrai si la valeur de `e` est plus grande que celle de `f`
print("e > f :", result3)
# default_end
Note

Comme en mathématiques, les parenthèses () ont la plus haute priorité dans les expressions. Dans l’exemple not(x > 1 and y > 1), l’expression à l’intérieur des parenthèses x > 1 and y > 1 est évaluée en premier, puis not est appliqué au résultat.

Priorité des opérateurs Description
() Parenthèses
* / % Multiplication, division, et modulo arithmétiques
+ - Addition et soustraction arithmétiques
== != > >= < <= Opérateurs de comparaison
not Négation logique
and ET logique
or OU logique

2.3 Premier pas

  1. Créer une variable \(var1\) et lui affecter le nombre entier \(-10\)
  2. Créer une variable \(var2\) et lui affecter la valeur booléenne \(True\)
  3. Créer une variable \(result1\) et lui affecter le résultat du test : \(var1\) est plus petit ou égal à \(0\)
  4. Afficher la valeur de \(result1\)
  5. Créer une variable \(result2\) et lui affecter le résultat du test : \(var2\) n’est pas égal à vrai
  6. Afficher la valeur de \(result2\)
  7. Créer une variable \(result3\) et lui affecter le résultat du test : \(result1\) n’est pas égal à vrai ou \(result2\) est égal à vrai
  8. Afficher la valeur de \(result3\)

Votre réponse

# exercice: check 
# default_start
print("Hello, World!")

# default_end
# solution_start
var1 = -10
var2 = True
result1 = var1 <= 0
print(result1)
result2 = not(var2 == True)
print(result2)
result3 = not(result1 == True) or (result2 == True)
print(result3)
# solution_end

3 Alternative

Les alternatives désignent des structures de contrôle de flux qui permettent de prendre des décisions et d’exécuter certains blocs d’instructions en fonction de conditions spécifiques.

3.1 Syntaxe

# exercice: show
# default_start
if condition1:
    instruction1
    instruction2
    ...
[ 
elif condition2:
    instruction1
    instruction2
    ...
]
[ 
else:
    instruction1
    instruction2
    ...
]
# default_end

3.2 Exemple

# exercice: demo
# default_start
age = 18 
if age >= 18: # si l'âge est supérieur ou égal à 18
    print("Vous êtes un adulte.")
elif age >= 13: # sinon, si l'âge est supérieur ou égal à 13
    print("Vous êtes un adolescent.")
elif age >= 1: # sinon l'âge est supérieur ou égal à 1
    print("Vous êtes un enfant.")
else: # sinon l'âge est inférieur à 1
    print("Votre âge n'est pas valide.")
# default_end

3.3 Premier pas

  1. Créer une variable \(note\) et lui affecter le nombre réel \(14.0\)
  2. Afficher la chaine de caractères \(\q{Note\; trop\; petite}\) si \(note\) est inférieure à \(0\)
  3. Afficher la chaine de caractères \(\q{F}\) si \(note\) est entre \(0\) (inclus) et \(10\) (exclus)
  4. Afficher la chaine de caractères \(\q{E}\) si \(note\) est entre \(10\) (inclus) et \(12\) (exclus)
  5. Afficher la chaine de caractères \(\q{D}\) si \(note\) est entre \(12\) (inclus) et \(14\) (exclus)
  6. Afficher la chaine de caractères \(\q{C}\) si \(note\) est entre \(14\) (inclus) et \(16\) (exclus)
  7. Afficher la chaine de caractères \(\q{B}\) si \(note\) est entre \(16\) (inclus) et \(18\) (exclus)
  8. Afficher la chaine de caractères \(\q{A}\) si \(note\) est entre \(18\) (inclus) et \(20\) (inclus)
  9. Afficher la chaine de caractères \(\q{Note\; trop\; grande}\) si \(note\) est supérieure à \(20\)

Votre réponse

# exercice: check 
# default_start
print("Hello, World!")

# default_end
# solution_start
note = 14.0
if note < 0:
    print("Note trop petite")
elif note < 10.0:
    print("F")
elif note < 12:
    print("E")
elif note < 14:
    print("D")
elif note < 16:
    print("C")
elif note < 18:
    print("B")
elif note <= 20:
    print("A")
else:
    print("Note trop grande")
# solution_end

4 Boucle

Les boucles designent une structure de contrôle de flux qui permet d’exécuter un bloc de code de manière répétée, tant qu’une condition donnée est vraie. Les boucles sont utiles pour automatiser des tâches répétitives et parcourir des structure de données.

4.1 Syntaxe

# exercice: show
# default_start
while condition:
    instruction1
    instruction2
    ...
# default_end

4.2 Exemple

# exercice: demo
# default_start
count = 0 
while count < 5: # tant que le compteur est inférieur à 5
    print("count:", count) # on affiche le compteur
    count = count + 1 # on incremente le compteur de 1
# default_end

4.3 Premier pas

  1. Créer une variable \(x\) et lui affecter le nombre entier \(5\)
  2. Créer une boucle qui affiche chaque valeur de \(x\) jusqu’à \(0\) inclus

Votre réponse

# exercice: check 
# default_start
print("Hello, World!")

# default_end
# solution_start
x = 5
while x >= 0:
    print(x)
    x = x - 1
# solution_end

5 Fonction

Les fonctions sont utilisées pour factoriser les instructions, en permettant de diviser un algorithme en segments plus petits et plus gérables. Une fonction est un bloc d’instructions qui s’exécute seulement lorsqu’il est appelé. Vous pouvez utiliser des données, appelées paramètres, dans une fonction. Une fonction doit retourner un résultat en sortie.

5.1 Syntaxe

# exercice: show
# default_start
# Définition d'une fonction
def functionName(parameterName1, parameterName2, ...):
    instruction1
    instruction2
    ...
    return expression

# Appel de la fonction
variableName = functionName(expression1, expression2, ...)
# default_end

5.2 Exemple

# exercice: demo
# default_start
# Déclaration de la fonction addNumbers
# Entrée: deux entiers `a` et `b` 
# Sortie: la somme de `a` et `b`
def addNumbers(a, b):
    result = a + b 
    return result

# Appel de la fonction addNumbers avec les valeurs 3 et 5
result = addNumbers(3, 5)

# Affichage du résultat obtenu
print("result:", result) 
# default_end

5.3 Premier pas

  1. Définir une fonction \(absoluteNumber(a)\) qui prends en paramètre un nombre entier \(a\) et retourne sa valeur absolue (c’est-à-dire la valeur de \(a\) sans son signe).
    Par exemple, si \(a\) vaut \(-3\) la fonction retourne \(3\), et si \(a\) vaut \(4\), elle retourne \(4\)
  2. Afficher le resultat de l’appel à la fonction \(absoluteNumber(-3)\)
  3. Afficher le resultat de l’appel à la fonction \(absoluteNumber(4)\)

Votre réponse

# exercice: check 
# default_start
print("Hello, World!")

# default_end
# solution_start
def absoluteNumber(a):
    res = 0
    if a < 0:
        res = -a
    else:
        res = a
    return res

print(absoluteNumber(-3))
print(absoluteNumber(4))
# solution_end