2. Rêgles de programmation sous Python

2.1. Rêgles de base

1. Rigueur

• La programmation scientifique est une école de rigueur !

2. Savoir et comprendre ce que l’on doit faire

• Ecrire un algorithme en français décrivant ce que l’on doit faire

3. Identifier les donnéees et les résultats

• Définir les données du problème et les résultats attendus

4. Vérifier et valider

• Afficher les valeurs intermédiaires du calcul avec print

• Vérifier le résultat sur des cas simples

2.2. Variables

dans un programme, les variables permettent de manipuler les données

1. création (avec initialisation)

      nom = valeur
   

   • attention on ne peut utiliser une variable que si elle a été initialisée

2. Définition des variables

Une variable est définit par un nom (identifiant), et une valeur avec un type

• nom = suite de caractères et de chiffres sans accents ni ponctuation

  • attention majuscule # minuscule

  • utiliser plutôt des noms en minuscule ayant un sens

  • réserver les majuscules pour les constantes

  • utiliser un _ pour les noms longs

• valeur définie le type. Les types de base

  • chaîne (string ou str) entre "

  • entier (int)

  • réel en virgule flottante (float)

2.3. Liste et dictionnaire

liste = structure de données qui contient une série de valeurs, de type éventuellement différent, et dont le nombre peut varier.

attention: on compte à partir de 0 en Python

1. création (liste de valeurs entre [et ])

   ma_liste = [ val1, val2, val3 ]
   

2. accès avec un indice à partir de 0

   ma_liste[i]  élément i-1 de la liste
   ma_liste[0]  premier élément
   ma_liste[-1] dernier élément
   ma_liste[debut:fin:pas] sous-liste 
   

dictionnaire: liste avec un accès par mot clés

     dict = { 'cle1': val1, 'cle2': val2 }
     
     dict['cle']  valeur du dictionnaire pour le mot clé 

2.4. Coder de façon simple et lisible

Un bon programme n’est pas uniquement fait pour etre exécuter par un ordinateur, mais surtout pour être compris par un humain !

• syntaxe python

  • une instruction par ligne

  • indentation pour définir des blocs

  • aérer le code (utilisation des espaces)

2.5. Instructions conditionnelles

important noté les : et l’indentation

• valeur logique True et False

• test logique

  if  condition :
     instruction 1
  elif :
     instruction 2
  else :
     instruction 3
  

2.6. instructions de répétition

attention: on compte à partir de 0 en Python

important noté les : et l’indentation

• boucle sur les valeurs d’une liste ou d’un tableau

  for val in Tab :
     instructions
     val = valeurs successives de Tab 
  

• boucle avec un compteur entier

  for i in range(n) :
     instructions
     i compteur de 0 à n (exclus)
  

• boucle avec un compteur et une valeur

  for k, val in enumerate(Tab) :
     instructions
     k compteur de 0 à len(Tab) (exclus)
     val kieme valeur de Tab
  

• boucle avec condition tant que (while)

   while condition :
     instructions
     on doit modifier la valeur de la condition, sinon boucle infinie
  

2.7. Fonction / algorithme

C’est une bonne pratique de programmation d” éviter de répéter les instructions et d’écrire du code qui soit réutilisable, non seulement parce qu’il conduit à moins de temps de développement, mais aussi parce qu’il réduit les erreurs. Si vous devez faire le même calcul plusieurs fois, il vaut mieux l’encapsuler dans une fonction.

Rappelez-vous un des concepts clé de la programmation structurée:

• Une fonction est une collection compacte de code qui exécute une action sur ses arguments ou données et qui renvoie le résultat.

Une fois défini, vous pouvez appeler une fonction autant de fois que vous le souhaitez. Lorsque nous appelons une fonction, nous exécutons tout le code à l’intérieur de la fonction. Le résultat de l’exécution dépend de la définition de la fonction et des valeurs qui y sont passées en arguments. Les fonctions peuvent ou non renvoyer des valeurs lors de leur dernière opération.

La syntaxe pour définir ses propres fonctions est la suivante:

def nom_fonction (arg_1, arg_2, ...):
    '''
    docstring: description de la fonction
    '''
    <corps de la fonction>
    return valeur

Le docstring d’une fonction est un message du programmeur documentant ce qu’il a construit. Les docstrings doivent être descriptifs et concis. Ils sont importants car ils expliquent (ou rappellent) l’utilisation prévue de la fonction aux utilisateurs. Vous pouvez accéder ultérieurement à la docstring d’une fonction en utilisant la fonction help () et en passant le nom de la fonction. Si vous êtes dans un notebook, vous pouvez également ajouter un point d’interrogation ? avant le nom de la fonction et exécuter la cellule pour afficher les informations d’une fonction.

Pour appeler une fonction, on donne une valeurs aux arguments et on récupère le résultat, en général dans une variable:

# appel de la fonction 
resultat = nom_fonction(val1, val2, ..)

2.8. Lecture des données sur fichier

Pour lire l’information dans un fichier au format texte, il faut effectuer les étapes suivantes:

1. ouvrir le fichier en lecture en spécifiant son nom complet (i.e. avec le répertoire)

    F = open("nom complet du fichier","r")
   

2. lire les données par exemple lignes par lignes, puis les décoder

    lignes = F.readlines()
   

3. fermer le fichier

    F.close()
   

2.9. Tracé de résultats

Pour tracer des courbes, on utilise la bibliothèque matplotlib et la fonction plt.plot

import matplotlib.pyplot as plt

Pour avoir un résultat de qualité, il faut ajouter un titre lisible, des labels sur les axes et sur les courbes:

• plt.title

• plt.xlabel, plt.ylabel

• plt.legend

   X = [ k for k in range(n)]
   Y = [ sum(X[:k]) for k in range(n)]
   plt.plot(X,Y)

import matplotlib.pyplot as plt

n = 10
X = [ k for k in range(n)]
Y = [ sum(X[:k]) for k in range(n)]
plt.plot(X,Y)

[<matplotlib.lines.Line2D at 0x7fc3a2672560>]

plt.plot(X,Y,'-+')
plt.title("Somme des p premiers entiers")
plt.xlabel("p")
plt.ylabel("somme $\sum_{i=0}^p i$");

2.10. FIN de la leçon