Un bloc de code est une séquence d’instructions exécutées ensemble.

En Python, les blocs de code sont définis par l’indentation, c’est-à-dire l’espace au début de chaque ligne.

Par convention, on utilise 4 espaces pour indenter un bloc de code.

Un bloc de code peut être une fonction, une boucle, une condition, etc.

def hello_world():
    print("Hello, World!")  # Bloc de code indenté

Les commentaires sont des lignes de code qui ne sont pas exécutées. Ils sont utilisés pour expliquer le code ou pour laisser des notes.

En Python, les commentaires commencent par le caractère # :

# Ceci est un commentaire
print("Hello, World!")  # Ceci est aussi un commentaire

Les commentaires sont importants pour rendre le code plus lisible et compréhensible.

En Python, une variable est créée par l’affectation d’une valeur à un nom de variable.

• La syntaxe est simple : nom_variable = valeur.

• Les variables peuvent contenir différents types de données, comme des entiers, des chaînes de caractères, des listes, etc.

my_var = 10          # Variable entière
my_str = "Bonjour"   # Variable chaîne de caractères
my_list = [1, 2, 3]   # Variable liste

• Les variables peuvent être réaffectées à d’autres valeurs ou types de données :

my_var = 10      # Variable entière
# Réaffectation de la variable x
my_var = 20      # x prend une nouvelle valeur entière

En Python, les variables peuvent contenir différents types de données :

• Entiers (int): Représentent des nombres entiers, e.g. 42.
• Flottants (float): Représentent des nombres à virgule flottante, e.g. 3.14.
• Chaînes de caractères (str): Représentent du texte, e.g. "Bonjour".
• Booléens (bool): Représentent des valeurs de vérité, soit True soit False.

Ces types de données sont fondamentaux en Python et permettent de manipuler des valeurs de manière efficace.

Les valeurs peuvent être affichées à l’aide de la fonction print() :

print("La valeur de pi est :", 3.14)
print("Le résultat de 2 + 3 est :", 2 + 3)

L’affichage se fait dans la console ou le terminal, et peut être utilisé pour déboguer ou afficher des résultats intermédiaires.

La saisie de valeurs se fait à l’aide de la fonction input() :

nom = input("Entrez votre nom : ")
print("Bonjour,", nom)
age = int(input("Entrez votre age : "))
print("Vous avez", age, "ans.")

La fonction input() affiche un message et attend que l’utilisateur saisisse une valeur. La valeur saisie est toujours une chaîne de caractères, il est donc souvent nécessaire de la convertir en un autre type de données, par exemple en entier (int()) ou en flottant (float()).

Les opérateurs arithmétiques permettent de réaliser des opérations mathématiques de base sur les variables numériques :

a = 10
b = 3
c = a + b   # Addition
d = a - b   # Soustraction 
e = a * b   # Multiplication     
f = a / b   # Division
g = a % b   # Modulo
h = a ** b  # Puissance
i = a // b  # Division entière

Suivant le type de données, les résultats peuvent varier. Par exemple, la division entre deux entiers donne un flottant en Python.

Les opérateurs d’affectation permettent de modifier la valeur d’une variable en fonction de son ancienne valeur :

a = 10
a += 5   # Équivalent à a = a + 5
a -= 3   # Équivalent à a = a - 3
a *= 2   # Équivalent à a = a * 2
a /= 4   # Équivalent à a = a / 4
a %= 3   # Équivalent à a = a % 3
a **= 2  # Équivalent à a = a ** 2
a //= 2  # Équivalent à a = a // 2

Les opérateurs de comparaison permettent de comparer des valeurs et de renvoyer un booléen (True ou False) :

a = 10
b = 5
c = a > b   # Plus grand que
d = a < b   # Moins grand que
e = a == b  # Égal à
f = a != b  # Différent de
g = a >= b  # Plus grand ou égal à
h = a <= b  # Moins grand ou égal à

Ces opérateurs sont souvent utilisés dans les conditions.

Les opérateurs logiques permettent de combiner des expressions booléennes :

a = True
b = False
c = a and b  # ET logique
d = a or b   # OU logique
e = not a    # Négation logique

Ces opérateurs sont utiles pour construire des conditions complexes.

Les opérateurs d’appartenance permettent de vérifier la relation entre des objets :

a = [1, 2, 3]
b = [1, 2, 3]
c = 2 in a      # Vérifie si 2 est dans la liste a
d = 4 not in a  # Vérifie si 4 n'est pas dans la liste a

Ces opérateurs sont utiles pour vérifier l’appartenance des objets à des collections.

Il est également possible de regrouper plusieurs valeurs dans des collections :

• Listes (list): Collections ordonnées d’éléments, p-ex [1, 2, 3].
• Dictionnaires (dict): Collections de paires clé-valeur, p-ex {"nom": "Alice", "age": 30}.
• Ensembles (set): Collections non ordonnées d’éléments uniques, p-ex {1, 2, 3}.
• Tuples (tuple): Collections ordonnées et immuables d’éléments, p-ex (1, 2, 3).

Il existe également des types plus avancés et même la possibilité de créer vos propres types de données.

Les listes sont des collections ordonnées d’éléments qui peuvent être modifiées. Elles sont créées en utilisant des crochets [] :

# Création d'une liste
ma_liste = ['zero', 'un', 'un', 'deux', 'trois']
# Accès à un élément de la liste
print(ma_liste[0])  # Affiche le premier élément (zero)
# Ajout d'un élément à la liste
ma_liste.append('cinq')  # Ajoute 'cinq' à la fin de la liste
# Suppression d'un élément de la liste par son index
ma_liste.pop(1)  # Supprime l'élément à l'index 1 (un)
# Suppression d'un élément de la liste
ma_liste.remove('deux')  # Supprime le premier élément égal à 'deux'
# Longueur de la liste
print(len(ma_liste))  # Affiche la longueur de la liste (4)

Les matrices sont des listes de listes, permettant de représenter des tableaux à n dimensions. Elles sont créées en utilisant des crochets imbriqués [] :

# Création d'une matrice à 2 dimensions
ma_matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# Accès à un élément de la matrice
print(ma_matrice[0][1])  # Affiche l'élément à la première ligne, deuxième colonne (2)
# Ajout d'une nouvelle ligne à la matrice
ma_matrice.append([10, 11, 12])  # Ajoute une nouvelle ligne
# Suppression d'une ligne de la matrice
ma_matrice.pop(1)  # Supprime la deuxième ligne
# Longueur de la matrice
print(len(ma_matrice))  # Affiche le nombre de lignes (3)

Les dictionnaires sont des collections de paires clé-valeur. Ils sont créés en utilisant des accolades {} :

# Création d'un dictionnaire
mon_dict = {"nom": "Alice", "age": 30}
# Accès à une valeur dans le dictionnaire
print(mon_dict["nom"])  # Affiche "Alice"
# Ajout d'une nouvelle paire clé-valeur
mon_dict["ville"] = "Paris"  # Ajoute "ville": "Paris"
# Suppression d'une paire clé-valeur
del mon_dict["age"]  # Supprime la paire dont la clé est "age"
# Longueur du dictionnaire
print(len(mon_dict))  # Affiche la longueur du dictionnaire (2)

Les ensembles sont des collections d’éléments uniques. Ils sont créés en utilisant des accolades {} ou la fonction set() :

# Création d'un ensemble
mon_set = {1, 2, 3}
# Ajout d'un élément à l'ensemble
mon_set.add(4)  # Ajoute 4 à l'ensemble
mon_set.add(4)  # N'ajoute pas 4 car il est déjà présent
# Suppression d'un élément de l'ensemble
mon_set.remove(2)  # Supprime 2 de l'ensemble
# Vérification de l'appartenance
print(3 in mon_set)  # Affiche True si 3 est dans l'ensemble
# Longueur de l'ensemble
print(len(mon_set))  # Affiche la longueur de l'ensemble (3)

Les tuples sont des collections ordonnées et immuables d’éléments. Ils sont créés en utilisant des parenthèses () :

# Création d'un tuple
mon_tuple = (1, 2, 3, 4)
# Accès à un élément du tuple
print(mon_tuple[0])  # Affiche le premier élément (1)
# Les tuples sont immuables, donc on ne peut pas modifier leurs éléments
# Longueur du tuple
print(len(mon_tuple))  # Affiche la longueur du tuple (4)

Les conditions permettent d’exécuter du code en fonction de la véracité d’une expression booléenne :

if condition:
    # Code à exécuter si la condition est vraie
    print("Condition vraie")
elif autre_condition:
    # Code à exécuter si l'autre condition est vraie
    print("Autre condition vraie")
else:
    # Code à exécuter si aucune condition n'est vraie
    print("Condition fausse")

Il peut y avoir plusieurs elif pour tester différentes conditions, mais il ne peut y avoir qu’un seul if et un seul else.

Exemple d’utilisation des conditions pour vérifier si un film est un court-métrage, moyen-métrage ou long-métrage en fonction de sa durée :

duree = 120
if duree < 40:
    print("Court-métrage")
elif duree < 90: 
    print("Moyen-métrage")
else:
    print("Long-métrage")

Les conditions sont essentielles pour contrôler le flux d’exécution de l’algorithme en fonction des valeurs des variables.

Les boucles while permettent d’exécuter un bloc de code tant qu‘une condition est vraie :

nb_repetitions = 5
while nb_repetitions > 0:
    print("Nombre de répétitions restantes :", nb_repetitions)
    nb_repetitions  -= 1  # Décrémentation de la variable

Il est important de s’assurer que la condition finira par devenir fausse, sinon la boucle risque de s’exécuter indéfiniment.

Les boucles for permettent d’itérer sur une séquence (comme une liste, une chaîne de caractères, etc.) :

l = ["a", "b", "c"]
for element in l:
    print("Élément :", element)

Il est possible d’utiliser la fonction range() pour générer une séquence de nombres :

# Itère de 2 (inclus) à 11 (exclu) avec un pas de 3
for i in range(2,11,3):  
    print("Itération :", i)

Il est possible d’ignorer le premier paramètre de range() pour commencer à 0, et le troisième paramètre pour itérer avec un pas de 1.

Les fonctions permettent de regrouper du code réutilisable et de le structurer.

• Réutilisabilité : Éviter la duplication de code en regroupant des opérations similaires dans des fonctions.
• Lisibilité : Rendre le code plus clair et plus facile à comprendre en lui donnant une structure logique.
• Maintenance : Faciliter la mise à jour et la correction du code en centralisant la logique dans des fonctions.

Les fonctions peuvent prendre des paramètres et/ou retourner des valeurs.

Voici un exemple simple de fonction qui calcule le discriminant d’une équation du second degré :

def calculer_discriminant(a, b, c):
    """
    Calcule le discriminant d'une équation du second degré.
    :param a: Coefficient de x^2
    :param b: Coefficient de x
    :param c: Terme constant
    :return: Le discriminant (b^2 - 4ac)
    """
    return b**2 - 4*a*c

# Appel de la fonction
d1 = calculer_discriminant(1, -3, 2)
print("Le discriminant est :", d1)
# La fonction peut être appelée plusieurs fois, 
# avec différents arguments
d2 = calculer_discriminant(1, 2, 1)
print("Le discriminant est :", d2)

Les fonctions peuvent avoir des paramètres avec des valeurs par défaut, ce qui permet de les appeler sans spécifier tous les arguments :

def saluer(nom="Bob"):
    print("Bonjour,", nom)

saluer()          # Affiche "Bonjour, Bob"
saluer("Alice")   # Affiche "Bonjour, Alice"