Programmation en Python

1. Types de variables en Python

En Python, le type d'une variable est attribué automatiquement lors de sa création, ce qui permet à l'ordinateur de savoir comment interpréter les données (nombre, texte, booléen, etc.).

2. Opérations sur les variables

a) Opérations sur les nombres (int et float)

b) Comparaisons sur les nombres

Les comparaisons retournent des booléens (True ou False).

c) Opérations sur les booléens (bool)

d) Opération sur les chaînes de caractères (str)

• Concaténation : joindre deux chaînes bout à bout avec +.

Exemple :

"Petit poisson" + " deviendra grand"  # renvoie "Petit poisson deviendra grand"

À retenir : En Python, le type d'une variable est automatiquement défini à sa création, et chaque type possède des opérations spécifiques adaptées à sa nature (arithmétique pour les nombres, logique pour les booléens, concaténation pour les chaînes).

1. Variables et affectations

a) Variable

• Une variable est l’association entre un nom et une valeur.
• Elle agit comme une boîte nommée dans laquelle on stocke une valeur qui peut changer au cours du programme.
• La valeur d’une variable peut varier (d’où le nom).

b) Affectation

• L’affectation associe une valeur à une variable.
• Syntaxe :

  nom_de_la_variable = valeur
  

• Exemple :

  a = 4
  b = 7 + 1  # b vaut 8
  c = a + b  # c vaut 12
  a = a + 10  # a vaut maintenant 14
  

c) Tableau d’état des variables

• Permet de suivre l’évolution des valeurs des variables au fil des instructions.

• Plusieurs affectations simultanées possibles :

  x, y, z = 4, 8, 3
  

  équivaut à

  x = 4
  y = 8
  z = 3
  

d) Suppression d’une variable

• Pour supprimer une variable :

  del ma_variable
  

e) Affichage du contenu d’une variable

• Pour afficher la valeur d’une variable :

  print(ma_variable)
  

• En console interactive, taper simplement le nom de la variable affiche sa valeur.

2. Transtypage (conversion de type)

• Permet de changer le type d’une donnée pour appliquer certaines fonctions ou opérations.
• Syntaxe : appliquer la fonction du type désiré à la donnée.

• Attention : certains transtypages peuvent échouer (ex. int("coucou") provoque une erreur).

3. Opérations selon le type

• Le comportement des opérations dépend du type des données.
• Exemple avec l’opérateur + :

À retenir : Le type d’une donnée détermine les opérations et fonctions applicables.

1. Instructions conditionnelles

Les instructions conditionnelles permettent d'exécuter un bloc d'instructions uniquement si une condition est vraie. La condition est une expression qui renvoie une valeur booléenne (True ou False). Les instructions à exécuter doivent être indentées.

a) Structure simple

if condition:
    instructions

• Le bloc instructions s'exécute si condition est vraie.
• Sinon, il est ignoré.

b) Structure avec else

if condition:
    instructions1
else:
    instructions2

• instructions1 s'exécutent si la condition est vraie.
• instructions2 s'exécutent sinon.

c) Structure avec elif

Permet de tester plusieurs conditions successivement.

if condition1:
    instructions1
elif condition2:
    instructions2
elif condition3:
    instructions3
else:
    instructions4

• On teste condition1, puis condition2, etc.
• La première condition vraie déclenche l'exécution du bloc associé.
• Si aucune condition n'est vraie, on exécute le bloc else.

d) Exemple

n = 10
if n % 2 == 0:
    n = n // 2
else:
    n = 3 * n + 1

• Si n est pair, on divise par 2.
• Sinon, on calcule 3*n + 1.

2. Rappel sur les variables

• Une variable a un nom, une adresse mémoire (invisible) et un type.
• En Python, le type peut changer selon la valeur affectée.
• Pour connaître le type d'une variable, utiliser :

  type(ma_variable)
  

3. Boucles conditionnelles (while)

Une boucle conditionnelle exécute un bloc d'instructions tant que la condition est vraie.

while condition:
    instructions

• Le bloc instructions se répète tant que condition est True.
• Risque de boucle infinie si la condition ne devient jamais fausse.
• Le bloc doit modifier des variables pour que la condition finisse par être fausse.

À retenir :
Une instruction conditionnelle exécute un bloc d'instructions uniquement si la condition est vraie. Le bloc else permet d'exécuter un autre bloc si la condition est fausse. Les boucles while répètent un bloc tant que la condition est vraie, attention aux boucles infinies.

1. Boucles en Python

a) Boucle for

• La boucle for permet de répéter un bloc d'instructions un nombre déterminé de fois.
• Syntaxe :

  for i in range(0, n):
      instructions
  

• La variable i prend successivement les valeurs de la séquence générée par range.
• range(start, stop, step) génère une séquence d'entiers de start (inclus) à stop (exclu), avec un pas step (par défaut 1).

• On peut aussi parcourir directement une séquence (liste, chaîne de caractères, etc.) :

  for element in objet:
      instructions
  

• La variable prend successivement toutes les valeurs de la séquence.

b) Boucle while

• La boucle while répète un bloc d'instructions tant qu'une condition est vraie.
• Syntaxe :

  while condition:
      instructions
  

• Exemple :

  n = 35
  q = 0
  while n - 4 >= 0:
      n = n - 4
      q = q + 1
  

  Ici, la boucle s'exécute tant que n - 4 >= 0. À la fin, q contient le nombre de fois que 4 a été soustrait à n.

c) Comparaison for / while

À retenir : La boucle for exécute son bloc exactement $n$ fois pour range(0, n), avec i allant de 0 à $n-1$.

2. Fonctions en Python

a) Définition

• Une fonction est définie avec le mot-clé def :

  def nom_de_la_fonction(arguments):
      """
      Spécification / documentation
      """
      instructions
      return valeur  # optionnel
  

• Le corps de la fonction est indenté.
• La fonction peut retourner une valeur avec return. Sans return, la fonction renvoie None (procédure).

b) Portée des variables

• Variables globales : définies dans l'espace global, accessibles partout sauf dans les fonctions où une variable locale du même nom existe.
• Variables locales : définies dans une fonction, elles n'existent que dans cette fonction.
• Une affectation dans une fonction crée une variable locale, même si une variable globale du même nom existe.
• Pour modifier une variable globale dans une fonction, il faut la déclarer avec le mot-clé global (à éviter si possible).

c) Exemple de portée

x = 1

def deca(x):
    x = 10 * x
    return x

print(deca(x))  # affiche 10
print(x)        # affiche 1 (x global inchangé)

def deca_global():
    global x
    x = 10 * x
    return x

print(deca_global())  # affiche 10
print(x)              # affiche 10 (x global modifié)

À retenir : Sans global, une fonction ne modifie pas les variables globales par affectation.

1. Spécification d’une fonction

• Spécification : décrit la tâche de la fonction, les pré-conditions (contraintes sur les paramètres) et les post-conditions (résultat attendu).
• S’écrit entre triples guillemets au début de la fonction.
• La fonction help permet d’afficher la spécification si elle est disponible.

2. Tests des pré-conditions avec assert

• Permet de vérifier que les paramètres respectent certaines contraintes.
• Si une condition n’est pas remplie, le programme s’arrête avec un message d’erreur explicite.
• Syntaxe : assert condition, "message d'erreur"

Exemple : fonction inverse

def inverse(x):
    assert (type(x) == int or type(x) == float), "le paramètre doit être un entier ou un float"
    assert x != 0, "attention on ne peut pas appliquer la fonction inverse à 0"
    return 1/x

Exemple : fonction racine définie sur $[-3, +\infty[$

from math import sqrt

def f(x):
    assert (type(x) == int or type(x) == float), "le paramètre doit être un entier ou un float"
    assert x >= -3, "attention la fonction f ne peut pas prendre de valeurs inférieures à -3"
    return sqrt(x + 3)

3. Fonctions à support géométrique (procédures)

• Certaines fonctions ne retournent aucune valeur (elles sont appelées procédures).
• Exemple avec le module turtle pour dessiner :

from turtle import *

forward(120)
left(90)
color("red")
forward(80)
reset()

4. Opérations sur les chaînes de caractères

Pour un seul caractère, car = "e" dans voyelles renverra True.

À retenir : La spécification et les assertions garantissent que la fonction est utilisée correctement, évitant ainsi des erreurs d’exécution difficiles à diagnostiquer.