Résumé chap 1

1. Préambule : Notion d'algorithme

• Définition : Un algorithme est une suite finie d'instructions permettant de résoudre un problème.
• Phases de l’algorithme :
1. Entrée des données : L’algorithme reçoit des données en entrée.
2. Traitement : Les données sont traitées via des opérations.
3. Sortie : Le résultat final est produit.
• Étude des algorithmes : Elle permet de prouver leur correction, de comparer leur efficacité (complexité) et de fournir des exemples concrets.

2. Introduction à Python

• Qu’est-ce que Python ? : Un langage de programmation de haut niveau, interprété, inventé en 1991 par Guido van Rossum.
• Avantages :
• Simple à utiliser pour écrire des scripts basiques.
• Puissant grâce à ses nombreuses bibliothèques (sciences, data, web, etc.).
• Utilisé par des entreprises comme Google, Microsoft et la NASA.
• Outils de programmation : Pour écrire du code Python, il faut un IDE (Environnement de Développement Intégré). Exemple : EduPython.

3. Variables

• Rôle : Les variables stockent des valeurs utilisées au cours de lexécution dun programme.
• Nommage : Une variable a un nom explicite, formé de lettres et de chiffres, sans espace. En Python, le nom ne commence pas par un chiffre, et les majuscules/minuscules sont distinctes.
• Type dynamique : En Python, une variable prend automatiquement le type de la valeur assignée (pas de déclaration explicite comme dans d'autres langages).

4. Types de variables en Python

• Types courants :
• Entiers (int) : Nombres sans décimales.
• Réels (float) : Nombres avec décimales.
• Booléens (bool) : Vrai ou Faux (True ou False).
• Chaînes de caractères (str) : Séquences de caractères (texte).
• Listes (list) : Séquences d’éléments modifiables.
• Tuples (tuple) : Séquences d’éléments non modifiables.

5. Affectations

• Affectation de valeur : Le symbole = est utilisé pour affecter une valeur à une variable.
• Exemples d’opérateurs :
• a += b équivaut à a = a + b.
• a -= b équivaut à a = a - b.
• a *= b équivaut à a = a * b.
• a /= b équivaut à a = a / b.
• Fonction input() : Permet de récupérer une entrée de l'utilisateur sous forme de chaîne de caractères.

6. Séquence d'instructions

• Les instructions sont exécutées dans l’ordre où elles apparaissent, sauf mention contraire.
• Exemple : Avec a, b = 3, 7, puis a = b et b = a, l’ordre des lignes influe sur le résultat.

7. Transtypage

• Définition : Le transtypage permet de changer le type d'une variable.
• Fonctions utiles :
• int(chaîne) : Convertit une chaîne de caractères en entier.
• float(chaîne) : Convertit une chaîne en nombre réel.
• str(nombre) : Convertit un nombre en chaîne de caractères.

8. Expressions booléennes

• Définition : Une expression booléenne est soit vraie (True), soit fausse (False).
• Opérateurs de comparaison : == (égal), != (différent), <, >, <=, >=.
• Opérateurs logiques : and, or, not, xor (ou exclusif).

9. Structures conditionnelles

• Les conditions permettent de réaliser des branches de code différentes en fonction de la valeur d'une expression.
• Syntaxe :
• if condition : ... (exécuter le bloc si la condition est vraie).
• else : (bloc exécuté si la condition est fausse).
• elif condition : (autre condition si la première est fausse).
• Exemple :

      a = int(input("Entrer un nombre :"))
      if a > 100:
          print("Nombre à 3 chiffres")
      elif a == 100:
          print("Plein dans le mille")
      else:
          print("Tu joues petit")
    

10. Boucles bornées (for)

• Définition : Les boucles permettent de répéter des instructions un nombre défini de fois.
• Syntaxe :

      for i in range(début, fin, pas):
          # instructions
    

• range() : Génère une séquence d'entiers entre le début et la fin (exclus).
• Boucles imbriquées : Une boucle peut contenir une autre boucle.

11. Boucles non bornées (while)

• Définition : Une boucle while répète les instructions tant qu’une condition est vraie.
• Syntaxe :

      while condition :
          # instructions
    

• Attention aux boucles infinies : une mauvaise gestion des conditions d'arrêt peut bloquer le programme.

12. Fonctions

• Définition : Une fonction est un bloc de code réutilisable défini avec le mot-clé def.
• Syntaxe :

      def nom_de_la_fonction(paramètres):
          # instructions
          return valeur
    

• Exemple :

      def est_pair(n):
          return n % 2 == 0
    

13. Portée des variables

• Variables locales : Définies dans une fonction, elles ne sont accessibles qu’à l’intérieur de celle-ci.
• Variables globales : Définies à l'extérieur des fonctions, accessibles partout.
• Exemple :

      x = 1
      def f(x):
          x = x + 1
          return x
    

14. Fonctions et procédures intégrées dans Python

• Exemples : print(), input(), len(), etc.
• Modules : Des fichiers contenant des fonctions supplémentaires (ex : math pour les fonctions mathématiques).
• Importer un module :

        import math
        print(math.sin(math.pi / 2))
    

15. Spécifications

• Définition : Les spécifications indiquent ce qu'une fonction est censée faire (préconditions et postconditions).
• Docstring : La documentation est inscrite entre """ au début de la fonction.
• Exemple :

        def est_pair(n):
            """
            Description : Retourne True si n est pair.
            Entrée : entier n
            Sortie : booléen
            """
            return n % 2 == 0
    

16. Mise au point d'un jeu de tests

• Objectif : Valider le comportement des fonctions en testant différents cas.
• Exemple :

      print(est_pair(3))  # False
      print(est_pair(-2)) # True
      print(est_pair(0))  # True
    

• Remarque : Le succès d’un test ne garantit pas l’absence d’erreurs dans le programme.