Base de programmation en Python

Contenu

3.2. Base de programmation en Python#

Marc BUFFAT, dpt mécanique, Université Lyon 1 et [1]

[1] inspiré librement du cours « Engineering Computations » du Pr L. Barba (Washington Univ.) et des Monty Python scriptol.fr

Python & Monty Python

from IPython.display import display, Markdown, clear_output
def printmd(string):
    display(Markdown(string))
from metakernel import register_ipython_magics
register_ipython_magics()

3.2.1. Questions préliminaires#

Cliquez sur Next pour répondre à la question suivante

#%activity /usr/local/commun/ACTIVITY/IntroPython/questionLangage

#%activity /usr/local/commun/ACTIVITY/IntroPython/questionProg

#%activity /usr/local/commun/ACTIVITY/IntroPython/questionPython

#%activity /usr/local/commun/ACTIVITY/IntroPython/questionProgrammation

3.2.2. Historique#

Python a été créé en 1989 par Guido van Rossum en hommage aux Monty Python

../_images/ungood-guido-van-rossum.jpeg ../_images/monty_python.jpg

3.2.3. Pourquoi Python#

3.2.3.1. Avantages du langage Python#

  • Langage interprété

  • Usage général : on peut tout faire

    • interfaces graphiques

    • calcul scientifique

    • applications webs

    • base de données

    • IA

    • robotique

  • Vaste librairie de modules

  • Syntaxe cohérente

    • langage orienté objet

    • langage fonctionnel

  • Facile à apprendre / agréable à utiliser

  • Excellent premier langage

3.2.3.2. Défauts du langage Python#

  • selon les circonstances, les programmes écrits en Python peuvent comporter des problèmes de performance

  • c’est le cas de tous les langages interprétés

3.2.3.3. Approche générale de développement#

  • on commence à développer en Python

  • on identifie éventuellement les sections de code qui posent un problème de performance

    • on réécrit les sections de code problématiques dans un autre langage tel que le C/C++

  • Python est conçu pour s’interfacer facilement aux autres langages

  • utilisation des bibliothèques

3.2.4. Philosophie de Python (Zen of python)#

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

3.2.5. Concepts de base#

Euclide al-Khwarizmi

3.2.5.1. Algorithme#

Un algorithme est une suite finie et non ambigüe d’opérations ou d’instructions permettant de résoudre un problème. Les algorithmes sont connus depuis l’antiquité (Euclide).

Le mot algorithme vient du nom du mathématicien perse du 9ième siècle (AJC)

  • Abu Abdullah Muhammad ibn Musa al-Khwarizmi (photo ci dessus).

L’algorithmique correspond à la phase préparatoire avant une quelconque programmation. Elle permet de décrire un problème sous une forme que l’on peut ensuite programmer sur un ordinateur et ceci dans un langage naturel, indépendant d’un langage de programmation.

algorithme numérique suite finie et non ambiguë d’opérations ou d’instructions sur des nombres permettant de résoudre un problème.

Et il n’est pas nécessaire d’avoir un ordinateur pour exécuter un algorithme (ex: machine de Turing inventé en 1936 avant l’ordinateur)!

3.2.5.2. Programme informatique#

ORDINATEUR est une machine qui exécute (très rapidement) des algorithmes sous la forme de programmes informatiques

PROGRAMME est une suite non ambigüe d’instructions permettant de traiter des données stockées dans des variables pour obtenir un résultat.

VARIABLE est le nom (symbol) donné à un espace de stockage dans la mémoire de l’ordinateur pour stocker des données numériques. Attention une variable informatique n’est pas une variable mathématique (pourquoi ?).

INSTRUCTION est une étape élémentaire décrit dans un langage de programmation avec une syntaxe rigoureuse.

FONCTION permet est un regroupement d’instructions qui traitent des données qui sont les arguments de la fonction pour calculer un résultat qui est la valeur de la fonction. Attention une fonction informatique n’est pas une fonction mathématique (pourquoi ?).

CODE MACHINE est une suite d’instructions binaires exécutée par le processeur. La traduction des instructions en code machine se fait automatiquement soit avec un interpréteur pour les langages interprétés (comme Python ou Matlab) ou avec un compilateur pour les langages compilés (comme C ou C++)

3.2.6. Les chaînes de caractères en Python#

Les chaînes de caractères sont un exemple de données textuelles que sait manipuler un ordinateur. Pour manipuler des caractères sur un ordinateur, il faut traduire les caractères en nombre, en utilisant un code. Le premier système de codage date des années 1960: c’est le code ASCII American Standard Code for Information Interchange, qui est encore la norme de codage utilisée pour les caractères latins sans accents. Pour pouvoir coder les accents ou les caractères non latin, on utilise maintenant un codage standard UTF-8 ou UTF-16 Universal Character Set Transformation Format sur 8 ou 16 bits, qui inclut le codage ASCII.

Sous Python, une chaîne est composée d’une séquence de caractères entre deux guillemets, et elle est de type str (string en anglais).

3.2.6.1. exercice#

Créer 2 variables mot_1 et mot_2 contenant respectivement Bonjour et Python et créer une nouvelle variable ma_chaîne contenant la concaténation des 2 variables avec un espace entre les deux.

   mot_1 = "Bonjour"
   mot_2 = "Python"

Comment peut-on ajouter un point d’exclamation !à la fin de cette chaîne.

# écrire ici votre solution
mot_1 = ""
mot_2 = ""
ma_chaine = ""

# solution
mot_1 = "Bonjour"
mot_2 = "Python"
ma_chaine = mot_1 + " " + mot_2 + "!"
print(ma_chaine)

Bonjour Python!

3.2.6.2. Indexation#

Nous pouvons accéder à chacun des caractères d’une chaîne de caractère en utilisant un indice, c.a.d un entier indiquant la position du caractère par rapport au début de la chaîne. Les indices sont placés entre crochets après le nom de la variable de chaîne et commencent à partir de 0. Par exemple, le 1er élément (caractère) de ma_chaine correspond à ma_chaine[0], et le 3ième à ma_chaine[2]. On peut aussi compter à partir du dernier caractère en utilisant des indices négatifs. Ainsi le dernier caractère correspond à ma_chaine[-1] et l’avant dernier à ma_chaine[-2].

Et Oui! en Python, nous commençons à compter à partir de 0 (comme en C/C++).

la fonction len(chaine) renvoie le nombre de caractères de la chaîne.

exercice

afficher dans la cellule suivante, le premier et second caractère de ma_chaine, ainsi que l’avant-dernier et le dernier.

# écrire ici votre solution

# solution
ma_chaine[0],ma_chaine[1],ma_chaine[-2],ma_chaine[-1]

('B', 'o', 'n', '!')

3.2.6.3. sous-chaînes#

Pour sélectionner plusiers caractères consécutifs d’une chaîne, on utilise la notation slicing entre crochets avec : «[debut:fin]», où «debut» est l’index pour commencer la tranche, et «end» est l’index (non inclusif,i.e. non inclus) pour terminer la tranche. Par exemple, pour saisir le mot Bonjour dans notre chaîne, on utilise:

    ma_chaine[0:7]

si debut est omis, il correspond au premier (i.e. 0) et si fin est omis, il correspond au dernier caractère.

exercise

  1. Dans la variable ma_chaine, sélectionnez le mot Python en utilisant le slicing. De même sélectionnez toute la chaine avec un slicing le plus simple possible.

  2. Définissez une variable b contenant banana et afficher le premier et le dernier a en utilisation une indexation de b.

  3. De même, saisissez les 2 slices possibles qui correspondent au mot ana et affichez-les.

# écrire ici votre solution

# solution 1
print(ma_chaine[8:-1])
print(ma_chaine[:])
# solution 2
b = 'banana'
print(b[1],b[-1])
# solution 3
print(b[1:4],b[3:])

Python
Bonjour Python!
a a
ana ana

3.2.6.4. manipulation des chaînes de caractères#

Python a de nombreuses fonctions intégrées utiles pour les chaînes.Un détail technique : en Python, certaines fonctions sont associées à une classe particulière d’objets (par exemple, des chaînes ou string). Le mot méthode est utilisé dans ce cas, et nous avons une nouvelle façon de les appeler avec l’opérateur point. C’est un peu contre-intuitif en ce que le nom de la méthode vient après le point, tandis que le nom de l’objet particulier sur lequel elle agit vient en premier. Comme ceci: ma_chaine.method().

3.2.6.4.1. commentaires#

on peut ajouter des commentaires dans un code python en utilisant le caractère #

3.2.6.4.2. application#

../_images/einstein_quote.jpg

Utilisons une citation d’Albert Einstein comme chaîne et appliquons quelques méthodes de chaîne utiles.

 AE_quote = "Tout le monde est un génie. Mais si vous jugez un poisson sur ses capacités à grimper à un arbre, il passera sa vie à croire qu'il est stupide."

# création d'une chaine contenant la citation
AE_quote = "Tout le monde est un génie. Mais si vous jugez un poisson sur ses capacités à grimper à un arbre, il passera sa vie à croire qu'il est stupide."

3.2.6.4.3. count()#

La méthode count() donne le nombre d’occurrences d’une sous-chaîne dans une plage. Les arguments de la plage sont facultatifs.

Syntaxe:

str.count(sous-chaîne, début, fin)

Ici, «debut» et «fin» sont des entiers qui indiquent les indices où commencer et terminer le comptage. Par exemple, pour calculer combien de lettres e il y a dans AE_quote, il suffit d’écrire:

AE_quote.count('e')

13

3.2.6.4.4. find() & index()#

La méthode find() nous indique si une chaîne substr apparaît dans la chaîne sur laquelle nous appliquons la méthode. Les arguments de la plage sont facultatifs.

Syntaxe:

str.find(substr, debut, fin)

«debut» et «fin» sont des indices indiquant où commencer et terminer la tranche sur laquelle appliquer la méthode find().

Si la chaîne substr est dans la chaîne d’origine, la méthode find() retournera l’index où la sous-chaîne commence, sinon elle retournera -1.

Par exemple, trouvons le mot «poisson» dans la citation d’Albert Einstein et sélectionnons ensuite le mot dans la phrase

AE_quote.find('poisson')

50

AE_quote[50:50+len('poisson')]

'poisson'

3.2.6.4.5. index()#

Une méthode similaire est index(): elle fonctionne comme la méthode find(), mais renvoie une erreur si la chaîne que nous recherchons n’est pas trouvée.

Syntaxe:

str.index(substr, début, fin)

Essayez les instructions suivantes:

    AE_quote.index('poisson')
    AE_quote.index('albert')

la dernière instructions renvoie une erreur, car albert n’est pas un mot de la pharse

# écrire ici votre solution

# solution
AE_quote.index('poisson')

50

3.2.6.4.6. exercices:#

  1. Utilisez la méthode count() pour compter le nombre de lettres 'a' dans AE_quote?

  2. En utilisant la même méthode, combien de lettres isolées 'à' se trouvent dans AE_quote?

  3. Utilisez la méthode index() pour trouver la position des mots « génie », « jugez » et « arbre » dans AE_quote.

  4. À l’aide d’un slicing, extrayez les mots de la question précédente dans AE_quote.

#  écrire ici votre solution

# solution
print("nbre de a=",AE_quote.count('a'))
print("nbre de à isolé =",AE_quote.count(' à '))
print(AE_quote.index("génie"),AE_quote.index("jugez"),AE_quote.index("arbre"))
# remplacer la valeur de mot par le mot choisie
mot = "génie"
pos = AE_quote.index(mot)
print(AE_quote[pos:pos+len(mot)])

nbre de a= 7
nbre de à isolé = 3
21 41 91
génie

3.2.6.4.7. split()#

Cette méthode split() renvoie une liste de tous les mots d’une chaîne. Nous pouvons également définir un séparateur autre que l’espace et diviser notre chaîne en fonction de ce séparateur, et éventuellement limiter le nombre de divisions à «num».

Syntaxe:

str.split(séparateur, num)

print(AE_quote.split())

['Tout', 'le', 'monde', 'est', 'un', 'génie.', 'Mais', 'si', 'vous', 'jugez', 'un', 'poisson', 'sur', 'ses', 'capacités', 'à', 'grimper', 'à', 'un', 'arbre,', 'il', 'passera', 'sa', 'vie', 'à', 'croire', "qu'il", 'est', 'stupide.']

3.2.7. Les listes en Python#

Les crochets ci-dessus indiquent une liste (list) en Python. Une liste est un type de données constitué d’une séquence de valeurs, par exemple des nombres ou des chaînes. Les listes fonctionnent à bien des égards de la même manière que les chaînes: leurs éléments sont numérotés à partir de zéro, le nombre d’éléments est donné par la fonction len (), ils peuvent être manipulés avec la notation de slicing.

Le moyen le plus simple de créer une liste consiste à placer une séquence de valeurs séparées par des virgules entre crochets.

Les éléments d’une liste ne sont pas forcément du même type, et on peut mélanger des entiers, des réels et des chaînes de caractères.

# une liste d'entiers
entiers = [1, 2, 3, 4, 5]
print(entiers)

[1, 2, 3, 4, 5]

# une liste avec des types d'éléments differents 
ma_liste = [2, 'pomme', 4.5, [5, 10]]
print(ma_liste)

[2, 'pomme', 4.5, [5, 10]]

3.2.7.1. exercice:#

  1. Dans la liste entiers, écrire le slicing contenant «[2, 3, 4]» puis «[4, 5]».

# écrire ici votre solution

entiers[1:4], entiers[3:]

([2, 3, 4], [4, 5])

3.2.7.2. append(): ajout d’éléments#

Nous pouvons ajouter des éléments à une liste en utilisant la méthode append(): elle ajoute l’objet que nous passons dans la liste existante. Par exemple, pour ajouter l’élément 6 à notre liste entiers, nous pouvons écrire:

   entiers.append(6)

# écrire ici votre solution

# solution
entiers.append(6)
entiers

[1, 2, 3, 4, 5, 6]

3.2.7.3. in : test si dans la liste#

La vérification de l’appartenance à une liste en Python ressemble assez à un anglais simple!

Syntaxe:

Pour vérifier si un élément est dans une liste:

element in liste

Pour vérifier si un élément n’est pas dans une liste:

element not in liste

3.2.7.3.1. exercice#

  1. Étant donné la liste alist = [1, 2, 3, '4', [5, 'six'], [7]] exécutez ce qui suit dans des cellules séparées et discutez le résultat:

   4 in alist
   5 in alist
   7 in alist 
   [7] in alist

alist = [1, 2, 3, '4', [5, 'six'], [7]]
# écrire ici votre solution

# solution
print(4 in alist)
print(5 in alist)
print(7 in alist)
print([7] in alist)

False
False
False
True

3.2.7.4. Modifier les éléments d’une liste#

Nous pouvons non seulement ajouter des éléments à une liste, mais également modifier un élément spécifique. Réutiliser la liste de l’exercice ci-dessus en remplaçant le caractère '4' par l’entier 4.

     print(4 in alist)
     alist[alist.index('4')] = 4
     print(4 in alist)

Remarque: on peut modifier avec une affectation un élément d’une liste mais pas un caractère d’une chaîne. Une chaîne de caractère est par défaut immuable.

# écrire ici votre solution

# solution
print(alist)
print(4 in alist)
alist[alist.index('4')] = 4
print(alist)
print(4 in alist)

[1, 2, 3, '4', [5, 'six'], [7]]
False
[1, 2, 3, 4, [5, 'six'], [7]]
True

3.2.8. Itérations et tests#

Un ordinateur est très efficace pour répéter une série d’instructions. Dans les langages de programmation, c’est la notation d’itération et de boucle.

3.2.8.1. Itération avec for#

L’idée de l’itération est de répéter des instructions plusieurs fois. Si vous connaissez un autre langage de programmation C/C++ ou java, vous savez créer une itération avec des instructions for. Mais l’instruction for est un peu différente en Python.

En Python, l’instruction for permet d’itérer sur les éléments d’une séquence (ou liste). Supposons que l’on a créé une liste Fruits contenant des noms de fruits, on peut écrire

    for  fruit in fruits:
        faire quelque chose avec chaque élément (fruit) de la liste

Ici, pour la première fois, nous rencontrerons une particularité du langage Python: l’indentation. Pour délimiter ce que Python doit faire avec chaque fruit dans la liste des fruits, nous plaçons la ou les déclarations suivantes en retrait à partir de la gauche.

Comment indenter ? C’est une question de style, et chacun a une préférence : deux espaces, quatre espaces, une tabulation… sont tous des styles valables : mais choisissez un style et soyez cohérent !

un conseil : utiliser plutôt des espaces qu’une tabulation. Nous choisirons dans la suite une indentation de 4 espaces.

fruits = ['pomme', 'banane', 'orange', 'cerise', 'mandarine']

for fruit in fruits:
    print("Manger une ",fruit)

Manger une  pomme
Manger une  banane
Manger une  orange
Manger une  cerise
Manger une  mandarine

3.2.8.2. Attention:#

  • l’instruction for se termine par un deux-points,:

  • la variable fruit est implicitement définie dans l’instruction for

  • fruit prend la valeur (chaîne) de chaque élément de la liste fruits, dans l’ordre

  • l’instruction indentée print() est exécutée pour chaque valeur de fruit

  • une fois que Python est à court de fruits, il s’arrête

  • nous n’avons pas besoin de savoir à l’avance le nombre d’articles dans la liste!

3.2.8.3. Exercice:#

A partir de la liste de listes (c.a.d, une liste imbriquée) suivante:

prenom_noms = [['samuel', 'dupont'], ['zoe', 'martin'], ['nael', 'abu ammar'], ['thomas', 'perez']]

Écrire le code qui crée deux listes simples : une avec les prénoms, une autre avec les noms de la liste imbriquée ci-dessus, mais en majuscules.

Pour commencer, vous devez créer deux listes vides (empty) en utilisant les crochets sans rien à l’intérieur et utiliser les méthodes de liste append ().

    noms = []
    prenoms = []

Nous l’avons fait pour vous ci-dessous. (conseil: utilisez la méthode de liste append ()!)

prenom_noms = [['samuel', 'dupont'], ['zoe', 'martin'], ['nael', 'abu ammar'], ['thomas', 'perez']]
prenoms = []
noms    = []
# ecrire votre code ici

for pnom in prenom_noms:
    prenoms.append(pnom[0])
    noms.append(pnom[1])
print(prenoms,noms)

['samuel', 'zoe', 'nael', 'thomas'] ['dupont', 'martin', 'abu ammar', 'perez']

3.2.8.4. Test avec if#

Parfois, on a besoin de vérifier une condition et modifier le comportement du programme en fonction de la condition. C’est le but de l’instruction if, qui peut prendre l’une des trois formes suivantes:

  1. if: test simple

     si condition alors instruction1

  2. if-else : test avec 2 branches

    si condition alors instruction1 
sinon instruction2

  3. if-elif-else: test le plus complet

    si condition1 alors instruction1 
sinon-si condition 2 alors instruction2
sinon instruction 3

# test simple
a = 8 
b = 3
if a > b:
    print('a est plus grand que b')

a est plus grand que b

# test avec 2 branches
x = 1547
if x % 17 == 0: 
    print('x est un multiple de 17.')
else:
    print('x n"est pas un multiple de 17.')

x est un multiple de 17.

a = 3
b = 5
if a > b:
    print('a est plus grand que b')
elif a < b:
    print('a est plus petit que b')
else:
    print('a est egale a b')

a est plus petit que b

3.2.8.5. Exercice#

En utilisant les instructions if, elif et else, écrire un code où on test un nombre entier N à 4 chiffre:

  • s’il est divisible par 2 et 3, vous affichez: Votre nombre n'est pas seulement divisible par 2 et 3 mais aussi par 6.

  • S’il est divisible par 2, vous affichez: Votre nombre est divisible par 2.

  • S’il est divisible par 3, vous affichez: Votre nombre est divisible par 3.

  • Dans tous les autres cas, vous affichez: Votre nombre n'est pas divisible par 2, 3 ou 6.

# écrire ici votre solution

N = 1200

if N%2 == 0 :
    if N%3 == 0 :
        print(N," est divisible par 2, 3, 6")
    else:
        print(N," est divisible par 2")
elif N%3 == 0:
    print(N," est divisible par 3")
else:
    print(N," n'est divisible par 2, 3 ou 6")

1200  est divisible par 2, 3, 6

3.2.9. Type de variables#

variable:

  • case mémoire pour stocker de l’information

  • doit être déclaré (initialisé) avant d’être utilisé

  • son type dépend de la valeur d’initialisation et est fonction du type de l’information (entier, réel, chaine)

la fonction python type(var) permet d’avoir le type de la variable

x=1
print(x,type(x))
x=1.0
print(x,type(x))
x='1'
print(x,type(x))

1 <class 'int'>
1.0 <class 'float'>
1 <class 'str'>

# erreur variable non définit
try:
    x = y
except Exception as err:
    print("Exception:",err) 

Exception: name 'y' is not defined

3.2.10. Fonction#

  • implémentation d’un algorithme qui traite des données pour obtenir un résultat.

  • définition de la fonction (aucun code n’est exécuté)

  • utilisation de la fonction (exécution de la fonction avec les données fournies)

3.2.10.1. définition d’une fonction#

  def  MaFonction(donnees)
        '''documentation'''
        ...
        resultat = calculer a partir des donnees
        ...
        return resultat

Attention: dans une fonction les arguments et les variables dans la fonction sont des variables locales.

3.2.10.2. utilisation d’une fonction#

  mon_res = MaFonction(mes_donnees)

Lors de l’appel d’une fonction, les arguments (mes_donnees) peuvent être des expressions, des valeurs ou des variables (si elles sont initialisées)

3.2.10.3. Exemple#

Ecrire une fonction qui calcule \(n!\) pour \(n\ge 0\)

# definition
def factoriel(n):
    '''calcul n!  pour n>=0 '''
    fac = 1

    return fac

# validation 3! -> 6
factoriel(3)

1

# utilisation calcul de n!! pour n=4
n = 4
fn = factoriel(n)
fnn = factoriel(fn)
print(fnn)
factoriel(factoriel(n))

1

1

3.2.10.3.1. exécution du code avec des « print »#

# verification avec des print
a=3
c=-3
def func1(a,b):
    c=0
    print("dans func1 a={} b={} c={}".format(a,b,c))
    def func2(a,b):
        c = a - b
        print("dans func2 a={} b={} c={}".format(a,b,c))
        return c
    c=func2(b,a)
    print("fin func1 a={} b={} c={}".format(a,b,c))
    return c
a=func1(2,1)
try:
    print("a={} c={}".format(a,c))
    print("b={}".format(b))
except Exception as err:
    print("Exception:",err) 

dans func1 a=2 b=1 c=0
dans func2 a=1 b=2 c=-1
fin func1 a=2 b=1 c=-1
a=-1 c=-3
b=5

3.2.11. Liste et tableau#

  • liste: ensemble ordonné de valeurs

    • ajout et suppression d’éléments

    • la taille et le type peuvent variés

  • tableau: ensemble ordonné de valeurs de même type

    • vecteurs, matrices

    • taille fixée

  • indice: on compte à partir de 0

    • indice à partir de 0

    • [ ] pour sélectionner un élèment

    • [0] premier element

    • [-1] dernier element

    • [n0:n1:p] selection des elements de l’indice n0 (defaut 0) à n1 (exclus) avec un pas p (defaut 1)

  • aliasing attention à la copie

    • A = B aliasing (A et B sont identiques)

    • A = B[:] copie

3.2.11.1. Test aliasing#

# question 1 uniquement
%activity /usr/local/commun/ACTIVITY/IntroPython/questionAlgorithme1

3.2.11.2. vérification#

# pble aliasing
L=[1,2,3]
L1=L
print(L,L1)
L[0]=2
print(L,L1)

[1, 2, 3] [1, 2, 3]
[2, 2, 3] [2, 2, 3]

#  manipulation de liste
L=[1,2,3]
L1=L[:]
print(L,L1)
L1[0]=2
print(L,L1)

[1, 2, 3] [1, 2, 3]
[1, 2, 3] [2, 2, 3]

3.2.12. Erreur algorithmique#

3.2.12.1. exemple 1#

Pour éffectuer une permutation circulaire à droite d’un tableau X : \(X_{i+1}=X_i\) (décalage à droite), on utilise l’un des deux programmes suivants. L’un est algorithmiquement faux. Lequel ?

# question 3 uniquement
%activity /usr/local/commun/ACTIVITY/IntroPython/questionAlgorithme3

X = [1,2,3,4,5]
n = len(X)
# decalage a droite: version 1
a = X[-1]
for i in range(n-1):
    X[i+1]=X[i]
X[0]=a

Y = [1,2,3,4,5]
n = len(Y)
# decalage a droite: version 2
x=Y[-1]
for i in range(1,n):
    Y[n-i]=Y[n-i-1]
Y[0]=x

# test de validation
print(X)
print(Y)

[5, 1, 1, 1, 1]
[5, 1, 2, 3, 4]

3.2.12.2. exemple 2#

Calcul de l’expression suivante: itération de Gauss-Seidel

  pour i de a N
\[ Y_i = Y_i - \frac{\sum_{j=1}^{N} A_{ij} Y_j - B_i}{A_{ii}} \]

Pour calculer cette expression, on utilise l’une des deux fonctions suivantes. L’une est algorithmiquement fausse. Laquelle ?

# version 1
def iteration1(A,B,X):
    n = len(X)
    Y = X[:]
    for i in range(n):
        sum=0.0
        for j in range(n):
            sum = sum + A[i][j]*Y[j]
            Y[i] = Y[i] - (sum - B[i])/A[i][i]
    return Y

# version 2
def iteration2(A,B,X):
    n = len(X)
    Y = X[:]
    for i in range(n):
        sum=0.0
        for j in range(n):
            sum = sum + A[i][j]*Y[j]
        Y[i] = Y[i] - (sum - B[i])/A[i][i]
    return Y

# exemple de validation

X=[1,2,3]
A=[[1,2,3],[4,5,6],[7,8,9]]
B=[1,1,2]
# 
X1=iteration1(A,B,X)
print("X1=",X1)
X2=iteration2(A,B,X)
print("X2=",X2)

X1= [-16.0, 7.4, 6.088888888888887]
X2= [-12.0, 6.2, 4.044444444444444]

3.2.13. programmation récursive#

  • la fonction s’appelle elle-même

  • calcul factorielle n!

    • n! = n*(n-1)!

def fac(n):
    ''' calcul recursif de n!'''
    if n>1 :
        return n*fac(n-1)
    else :
        return 1

# validation
fac(3)

6

3.2.13.1. example 2#

Que calcule la fonction récursive suivante ?

def fonc(L):
    print("appel fonc avec ",L)
    if not L:
        return 0
    else:
        res = 1 + fonc(L[1:])
        print("res=",res)
        return res

# resultat
fonc([1,2,3,4])

appel fonc avec  [1, 2, 3, 4]
appel fonc avec  [2, 3, 4]
appel fonc avec  [3, 4]
appel fonc avec  [4]
appel fonc avec  []
res= 1
res= 2
res= 3
res= 4

4

3.2.14. Erreur sous Python#

retour erreur

   Traceback (most recent call last):
    File "test.py", line 6, in <module>
    test()
    File "test.py", line 3, in test
    print table[4]
    IndexError: list index out of range

** code d’erreurs**

  • IndentationError :

      expected an indented block

  • IndexError:

      list index out of range

  • SyntaxError :

      inconsistent use of tabs and spaces in indentation

  • NameError :

      name 'X' is not defined

  • ImportError :

      no module named X

  • ZeroDivisionError :

      X division or modulo by zero

3.2.15. Programmation sctructuré#

principe: « Divide and Conquer »

3.2.15.1. analyse descendante: top-down design#

  • définition des différentes étapes pour résoudre le problème

  • on découpe le problème en une série de sous-problèmes plus simples (si possible indépendant)

  • on spécifie ce qui doit résolu dans chacun des sous-problèmes sans forcément dire comment

  • puis on itère au niveau des sous problèmes.

analyse top-down

3.2.15.2. programmation ascendante: bottom-up programming#

  • on programme d’abord les sous-problèmes(sous forme de fonction)

  • on validation les fonctions

  • puis on réitère en remontant dans l’arbre jusqu’au programme principal

  • on crée une bibliothéque

  • on éffectue l’analyse et la validation globale

règles réutiliser les fonctions déjà écrites et validées (bibliothèques): principe du moindre effort !

3.2.15.3. Méthodologie#

  1. Réflexion algorithmique

  2. Création d’une bibliothèque de fonctions pour résoudre les sous-pbles:

     fichier mabib.py

  3. Utilisation d’un environnement de programmation (éditeur / jupyter lab/ shell)

  4. Validation de la bibliothèque

  5. Ecriture du programme principale en utilisant la bibliothéque

     import mabib.py

  6. Utilisation d’un notebook jupyter

  7. Analyse et validation du résultat (tracé de courbes)

  8. Ecriture d’un rapport au format \(\LaTeX\)

3.2.16. Bibliographie#

  • Python. The official Python web site.

  • Python tutorials. Le tutoriel officiel Python.

  • Think Python. “”How to Think Like a Computer Scientist”” by Allen B. Downey (free book).

  • COURS InProS Cours en vidéo d“« INtroduction à la Programmation Scientifique””

  • Scientific Python Le site officiel de SciPy, qui regroupe les bibliothèques scientifiques les plus utilisées en Python: numpy, scipy, matplotlib, sympy et pandas

3.2.17. FIN de la leçon#

Contenu