Base de programmation en Python

Contenu

1. Base de programmation en Python#

Marc BUFFAT, dpt mécanique, Université Lyon 1

certains exemples sont inspirés du cours « Engineering Computations » du Pr L. Barba (Washington Univ.)

Ministry of Silly Walks: Monty Python Flying Circus

from IPython.display import display, Markdown, clear_output,HTML,IFrame
import numpy as np
def printmd(string):
    display(Markdown(string))
from metakernel import register_ipython_magics
register_ipython_magics()

1.1. Introduction#

attention utiliser systèmatiquement le bouton executer pour se déplacer dans un notebook !

1.1.1. sondage préliminaire#

Il y a plusieurs questions dans ces sondages. Cliquez sur Next pour répondre aux questions suivantes

1.1.2. Historique du langage Python#

Créé en 1989 par Guido van Rossum en hommage aux Monty Python

monty Python

1.1.3. Avantages du langage Python#

  • Langage interprété

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

    • calcul scientifique

    • traitement de données

    • web, jeux

    • 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

1.1.4. Limitations 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

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

Approche

  • 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 (C / Fortran)

  • utilisation des bibliothèques

1.2. 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!

1.2.1. Méthodologie d’utilisation de l’outil numérique#

  • analyse du problème pour définir ce que l’on doit faire (analyse)

  • définir la manière dont on doit le faire (algorithme)

  • mise en oeuvre sur ordinateur (programmation)

  • vérification / validation de la méthode (validation)

    • attention ne pas se baser uniquement sur les validations automatiques!

  • analyse « critique » des résultats

1.3. Langage 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

TYPE DE DONNEES interprétation des données binaires en mémoire: caractère, entier, nombre réel (virgule flottante)

INSTRUCTION est une étape élémentaire décrit dans un langage de programmation avec une syntaxe rigoureuse pour être traduit en code machine.

OPERATEUR numérique (+ - * / % (modulo) ) ou logique (égalité ==, différence !=)

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 (en général) est la valeur de la fonction. Attention une fonction informatique n’est pas une fonction mathématique (effet de bords, modifications des données,..).

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++)

1.3.1. Concept de base en informatique scientifique#

objectif: traiter de l’information (données) pour en obtenir de l’information scientifique (résultat)

  • modélisation numérique (calcul HPC)

  • traitement de données (BIG DATA)

  • assimilation de données (I.A.)

  • …

l’ordinateur n’est qu” un outil

l’important est de définir ce que l’on doit faire et comment (algorithmique)

le langage informatique (code) est une traduction de l’algorithme (pour l’ordinateur)

1.3.2. Structure d’un ordinateur#

images/Architecture_Von_Neumann.png

  • CPU = execute les instructions du processeur (push @1000, pull @1002, add R1,R2 …)

  • MEMORY = stocage des données à une adresse donnée (@1000 notation hexa.)

  • I/O (ou E/S) = entrée des données et sortie des résultats (clavier, écran, fichier, réseau , usb …)

1.3.3. Structure d’un programme informatique#

  • VARIABLES pour manipuler les données en mémoire (à la place d’adresse) = case mémoire

  • INSTRUCTIONS pour faire les calculs sur les données

  • FONCTIONS E/S de haut niveau : print, read, ….

1.3.4. Les différents type de données#

  • données numériques

  • données textuelles

  • données images / vidéos

  • données audio

mais au final on représente tout en code binaire sous forme de bits !

1.3.5. Difficultés !!#

représentation des données sous forme de bits

  • numérique: entier, flottant, réel

  • textuelles: codage des caractères, alphabet, accents , codes spéciaux (fin de ligne, tabulation, ..)

  • images: définition, couleurs, compression, ..

  • audio: échantillonnage, compression, ….

il est donc important de connaître la représentation des données et d’utiliser des formats standards et ouverts !

ord('A'),ord("a"),ord(' '),ord('1')

(65, 97, 32, 49)

exemple les 3 constantes suivantes représentent 1 pour un humain

    un    1     1.0

En programmation elles sont représentés sous la forme

    "un"   1    1.0

et qui sont codés en mémoire sous la forme suivante (valeur en hexa-decimal)

    "un"  sur 3 octets     0x02 0x75 0x6e
    1     sur 4 octets     0x00 0x00 0x00 0x01  avec un signe (1er bit=0 si >0 et 1 si <0)
    1.0   sur 8 octets     0x01 0x00 0x00 0x00 0x00 0x00 0x00 0x0a

1.3.6. Notion de variable informatique#

Les données sont stockés dans la mémoire de l’ordinateur. Pour manipuler ces données, l’ordinateur doit connaître où elles se trouvent dans la mémoire: c’est l’adresse mémoire (écrite en hexadécimal 0x1ac890), ainsi que le type de ces données (nombre d’octets) (entier, réel, caractères, chaînes, tableau …).

Dans les langages informatiques de haut niveau on utilise la notion de variable pour manipuler ces données en mémoire et c’est l’interpréteur (ou le compilateur) qui fait la correspondance entre les variables et les adresses dans la mémoire.

Une variable est donc une case mémoire (boite) qui sert à stocker une valeur.

  1. En python, une variable est définit comme un nom, commençant par une lettre, et constitué de lettres non accentuées, de chiffres, du caractère : _ à l’exception de tout autres caractères en particulier: l’espace , les opérateurs +-*/, du point ., des parenthèses (){}#. On doit aussi éviter d’utiliser des mots clés du langage (print , for, if …)

  2. En python, on ne définit pas explicitement le type de la valeur que l’on peut stocker dans une variable.

  3. En python, pour créer une variable on utilise une instruction d’affectation qui crée la variable et lui affecte une valeur (et donc un type)

    NOM_VARIABLE =  expression (valeur)

L’instruction suivante

   a = 2

crée une variable a et lui affecte la valeur 2 entière.

le bouton variable inspector ou le mot clé whos permetent d’obtenir la liste de toutes les variables

# création de variable
a = 2
b = 'deux'
c = 2.0
# utilisation de l'icone variable inspector

IFrame("https://pythontutor.com/iframe-embed.html#code=a%20%3D%202%0Ab%20%3D%20'deux'%0Ac%20%3D%202.0%0Ac%20%3D%202*c%20-%204*a&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false",width=800,height=400)

Attention l’instruction = est une instruction d’affectation (et non d’égalité)

que fait l’instruction suivante ?

x = 2

x = 2*x + 1
x

5

1.4. Données textuelles#

  • type de données:

    • caractère ou char

    • chaînes de caractères ou string

1.4.1. caractère sous python#

l’unité de base d’un texte est le caractère pour repésenter

  • les lettres minuscules a-w

  • les lettres majuscules A-W

  • les chiffres 0-9

  • les caractères spéciaux: tabulation \t , fin de ligne \n

Pour manipuler des caractères sur un ordinateur il faut traduire les caractères en nombre, en utilisant un code, qui respecte l’ordre alphabétique

  • codage ASCII: 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 (utilisation dans le code source des programmes informatiques).

  • codage UTF8: Pour pouvoir coder les accents ou les caractères non latin, on utilise maintenant un codage standard UTF-8 Universal Character Set Transformation Format, qui inclut le codage ASCII. (utilisation pour les données pour affichage ou traitement)

  • la fonction ord(ch) renvoie le codage du caractère ch

  • la fonction chr(code) donne le caractère de codage code

# affiche des caractères
print('a','B','\t','0','\n','9')

a B 	 0 
 9

# affiche le code 
print(ord('a'),ord('B'),ord('\t'),ord('0'),ord('\n'),ord('9'))

97 66 9 48 10 57

# affichage de caractère à partir du code
print(chr(97),chr(ord('a')))

a a

1.4.2. chaînes de caractères en Python#

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).

ma_variable = "Ceci est une chaîne de caractères."

1.4.3. opération sur les chaînes de caractères#

  • affichage: fonction print

  • concatenation: opérateur + sous python

  • indexation: sélection du ième élément (caractère) d’une chaîne

  • extraction: sélection d’une sous chaîne

  • fonctions ou méthodes sur les chaines:

    • compter les occurences d’un mot dans une phrase (count)

    • recherche d’un mot (find ou index)

'un' + ' ' + 'deux'

'un deux'

1.4.4. exercise#

Créer 2 variables mot_1 et mot_2 contenant respectivement Bonjour et Jupyter et créer une nouvelle variable ma_chaine contenant la concatenation des 2 variables avec un espace entre les deux.

   mot_1 = "Bonjour"
   mot_2 = "Jupyter"

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

# écrire ici votre solution
## BEGIN SOLUTION
mot_1 = "Bonjour"
mot_2 = "Jupyter"
ma_chaine = mot_1 + mot_2
print(ma_chaine)
print(mot_1 + ' ' + mot_2 + '!')
## END SOLUTION

BonjourJupyter
Bonjour Jupyter!

1.4.5. 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 commence à 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.

exercise

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

# écrire ici votre solution
## BEGIN SOLUTION
print("taille: ",len(ma_chaine))
print("debut: ",ma_chaine[0],ma_chaine[1])
print("fin  : ",ma_chaine[-2],ma_chaine[-1])
## END SOLUTION

taille:  14
debut:  B o
fin  :  e r

1.4.6. 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) 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 à 0 et si fin est omis, il correspond à -1.

exercise

  1. Dans la variable ma-chaine, sélectionnez le mot Jupyter en utilisant le slicing. De même selectionnez 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
## BEGIN SOLUTION
print(ma_chaine[:])
print(ma_chaine[7:])
b = "banana"
print(b[1],b[-1])
print(b[1:4],b[3:])
## END SOLUTION

BonjourJupyter
Jupyter
a a
ana ana

1.4.7. manipulation des chaînes?#

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().

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

1.4.7.1. 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 (sans accent pour tester)
AE_quote = "Tout le monde est un genie. Mais si vous jugez un poisson sur ses capacites a grimper a un arbre, \
il passera sa vie a croire qu'il est stupide."
print(AE_quote)

Tout le monde est un genie. Mais si vous jugez un poisson sur ses capacites a grimper a un arbre, il passera sa vie a croire qu'il est stupide.

1.4.7.2. 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')`

exercise déterminer le nombre d’occurence du mot “un” dans toute la phrase, et dans les 20 premiers caractères

documentation

  AE_quote.count?

AE_quote.count?

# écrire ici votre solution
## BEGIN SOLUTION
print("nbre de 'un' total   :",AE_quote.count('un'))
print("nbre de 'un' au debut:",AE_quote.count('un',0,20))
## END SOLUTION

nbre de 'un' total   : 3
nbre de 'un' au debut: 1

1.4.7.3. find()#

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

# écrire ici votre solution
## BEGIN SOLUTION
print("index de 'poisson '",AE_quote.find('poisson'))
print(AE_quote[50:50+len('poisson')])
## END SOLUTION

index de 'poisson ' 50
poisson

1.4.7.4. index() (variante)#

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 pour chercher poisson puis albert et comparer avec find:

# écrire ici votre solution
## BEGIN SOLUTION
print(AE_quote.index('poisson'),AE_quote.find('poisson'))
print(AE_quote.find('albert'))
#AE_quote.index('albert')
## END SOLUTION

50 50
-1

1.4.7.5. 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 'a' 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 le dernier mot est dans AE_quote.

# écrire ici votre solution
## BEGIN SOLUTION
print('nbre de a: ',AE_quote.count('a'))
print('nbre de a isole: ',AE_quote.count(' a '))
print("poition genie: ",AE_quote.index("genie")," jugez:",AE_quote.index("genie")," arbre",AE_quote.index('arbre'))
i = AE_quote.index('est',-20,-1)
print("position dernier ",AE_quote[i:i+3],' : ',i)
## END SOLUTION

nbre de a:  10
nbre de a isole:  3
poition genie:  21  jugez: 21  arbre 91
position dernier  est  :  131

1.4.8. nécéssité de structure de données#

Lorsque que l’on manipule une chaîne de caractères représentant une phrase, on peut vouloir déterminer l’ensemble des mots de la phrase et les manipuler.

\(\Rightarrow\) structure de données de type liste (ensemble ordonnée)

1.5. Les listes 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 forcement du même type, et on peut mélanger des entiers, des réels et des chaînes de caractères.

1.5.1. Exemple: liste des mots d’une phrase avec la méthode split()#

La 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 mots à «num».

Syntaxe:

str.split(séparateur, num)

exercise déterminer la liste des mots, le nombre de mots , le premier et le dernier de AE_quote

# exemple liste des mots de la phrase et nombre total de mots
## BEGIN SOLUTION
mots = AE_quote.split()
print("mots: ",mots)
print("nbre de mots :", len(mots))
print("premier et dernier mots: ",mots[0],mots[-1])
## END SOLUTION

mots:  ['Tout', 'le', 'monde', 'est', 'un', 'genie.', 'Mais', 'si', 'vous', 'jugez', 'un', 'poisson', 'sur', 'ses', 'capacites', 'a', 'grimper', 'a', 'un', 'arbre,', 'il', 'passera', 'sa', 'vie', 'a', 'croire', "qu'il", 'est', 'stupide.']
nbre de mots : 29
premier et dernier mots:  Tout stupide.

# exemple: ecrire une liste d'entiers
## BEGIN SOLUTION
entiers = [1, 2, 3, 4, 5]
print(entiers,len(entiers))
## END SOLUTION

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

# une liste avec des types d'éléments differents: entier, chaine ,liste 
## BEGIN SOLUTION
ma_liste = [2, 'pomme', 4.5, [5, 10]]
print(ma_liste,len(ma_liste))
## END SOLUTION

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

1.5.2. exercice:#

  1. Dans la liste entiers, afficher dernier, avant dernier, et premier élément

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

# écrire ici votre solution
## BEGIN SOLUTION
print(entiers[-1],entiers[-2],entiers[0])
print(entiers[1:4])
print(entiers[3:])
## END SOLUTION

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

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

La liste est une structure dynamique auquel on peut ajouter des éléments.

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

   entiers.append(6)

# ajouter 6 et 7 à la liste d'entiers
## BEGIN SOLUTION
entiers.append(6)
entiers.append(7)
print(entiers)
## END SOLUTION

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

question que fait l’instruction suivante:

entiers.append('[6,7]')

## BEGIN SOLUTION
entiers2 =  entiers.copy()
entiers2.append('[6,7]')
print(entiers2)
## END SOLUTION

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

1.5.4. test si un élément est dans la liste: opérateur in#

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

1.5.4.1. exercice#

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

   3 in malist
   4 in malist
   5 in malist
   7 in malist 
   [7] in malist

malist = [1, 2, 3, '4', [5, 'six'], [7]]
# écrire ici votre solution
## BEGIN SOLUTION
print(3 in malist)
print(4 in malist)
print('4' in malist)
print(5 in malist)
print(5 in malist[4])
print(7 in malist)
print([7] in malist)
## END SOLUTION

True
False
True
False
True
False
True

1.5.5. 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.

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
## BEGIN SOLUTION
print(4 in malist)
malist[malist.index('4')] = 4
print(4 in malist)
## END SOLUTION

False
True

1.6. 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.

1.6.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ée 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.

Commment 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.

# exercise: afficher "manger une " fruit, pour tous les éléments de la liste fruits
fruits = ['pomme', 'banane', 'orange', 'cerise', 'mandarine']
## BEGIN SOLUTION
for fruit in fruits:
    print("Manger un fruit: ",fruit)
## END SOLUTION

Manger un fruit:  pomme
Manger un fruit:  banane
Manger un fruit:  orange
Manger un fruit:  cerise
Manger un fruit:  mandarine

IFrame("https://pythontutor.com/iframe-embed.html#code=fruits%20%3D%20%5B'pomme',%20'banane',%20'orange',%20'cerise',%20'mandarine'%5D%0Afor%20fruit%20in%20fruits%3A%0A%20%20%20%20print%28%22Manger%20un%20fruit%3A%20%22,fruit%29%0Aprint%28'FIN'%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false",width=800,height=400)

1.6.2. Syntaxe et remarques importantes#

  • 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 spécifier à l’avance le nombre d’articles dans la liste!

1.6.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 () et .

    Noms = []
    Prenoms = []

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

Attention aux notations (rigueur !!) (choisir des conventions et si tenir!!!)

Prenom_noms = [['samuel', 'dupont'], ['zoe', 'martin'], ['nael', 'abu ammar'], ['thomas', 'perez']]
Prenoms = []
Noms    = []
# ecrire votre code ici
## BEGIN SOLUTION
for prenom_nom in Prenom_noms :
    Prenoms.append(prenom_nom[0])
    Noms.append(prenom_nom[1])
print("noms   :",Noms)
print("prenoms:",Prenoms)
## END SOLUTION

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

IFrame("https://pythontutor.com/iframe-embed.html#code=Prenom_noms%20%3D%20%5B%5B'samuel',%20'dupont'%5D,%20%5B'zoe',%20'martin'%5D,%20%5B'nael',%20'abu%20ammar'%5D,%20%5B'thomas',%20'perez'%5D%5D%0APrenoms%20%3D%20%5B%5D%0ANoms%20%20%20%20%3D%20%5B%5D%0A%23%20ecrire%20votre%20code%20ici%0Afor%20prenom_nom%20in%20Prenom_noms%20%3A%0A%20%20%20%20Prenoms.append%28prenom_nom%5B0%5D%29%0A%20%20%20%20Noms.append%28prenom_nom%5B1%5D%29%0Aprint%28%22noms%20%20%20%3A%22,Noms%29%0Aprint%28%22prenoms%3A%22,Prenoms%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false",width=800,height=600)

1.6.4. itération avec un compteur#

la forme de boucle précédente est la forme la plus naturelle d’un point de vue algorithmique. Cependant dans beaucoup de langage de programmation, on trouve plutot des boucles associées à un un compteur:

    Pour i de debut à fin
        faire
    fin de la boucle

le compteur i prend la valeur debut et est incrémenter à la fin de boucle jusqu’à ce qu’il prenne une valeur supérieur à fin

En python, ce type de boucle s’écrit de la façon suivante

    for i in range(n):
        faire quelque chose

où i varie de 0 (indice de début) à n (nbre d’itérations) exclus (car on compte à partir de 0 en python)

On peut généraliser en utilisant la forme générale de la fonction range()

  • range(deb,fin,pas) en spécifiant le debut, la fin “exclus) et la pas ((qui peut etre négatif)

**exercices sur les boucles

  1. écrire la boucle sur les fruits avec un compteur

  2. Calcul de la somme des 100 premiers nombres entiers positifs ou nuls

  3. Calcul de la somme des 100 premiers entiers >= 3

  4. Calcul de la somme des 100 premiers entiers impairs > 3

# exercise1: afficher "manger une " fruit, pour tous les éléments de la liste fruits
fruits = ['pomme', 'banane', 'orange', 'cerise', 'mandarine']
## BEGIN SOLUTION
for fruit in fruits:
    print("Manger un fruit: ",fruit)
## END SOLUTION

Manger un fruit:  pomme
Manger un fruit:  banane
Manger un fruit:  orange
Manger un fruit:  cerise
Manger un fruit:  mandarine

# exercise idem en utilisant un compteur
## BEGIN SOLUTION
for i in range(len(fruits)):
    print("Manger un fruit: ",fruits[i])
## END SOLUTION

Manger un fruit:  pomme
Manger un fruit:  banane
Manger un fruit:  orange
Manger un fruit:  cerise
Manger un fruit:  mandarine

IFrame("https://pythontutor.com/iframe-embed.html#code=fruits%20%3D%20%5B'pomme',%20'banane',%20'orange',%20'cerise',%20'mandarine'%5D%0Afor%20fruit%20in%20fruits%3A%0A%20%20%20%20print%28%22Manger%20un%20fruit%3A%20%22,fruit%29%0A%23%0Afor%20i%20in%20range%28len%28fruits%29%29%3A%0A%20%20%20%20mon_fruit%20%3D%20fruits%5Bi%5D%0A%20%20%20%20print%28%22Manger%20un%20fruit%3A%20%22,mon_fruit%29%0A%23&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false",width=800,height=400)

# exercise 2
## BEGIN SOLUTION
somme = 0
for i in range(100):
    somme = somme + i
print("somme=",somme)
## END SOLUTION

somme= 4950

IFrame("https://pythontutor.com/iframe-embed.html#code=somme%20%3D%200%0Afor%20i%20in%20range%285%29%3A%0A%20%20%20%20somme%20%3D%20somme%20%2B%20i%0Aprint%28%22somme%3D%22,somme%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false",width=800,height=400)

# affichage d'une liste dans l'ordre inverse
## BEGIN SOLUTION
for i in range(4,-1,-2):
    print("mangez une ",fruits[i])
## END SOLUTION

mangez une  mandarine
mangez une  orange
mangez une  pomme

# calcul de somme
S100 = 0

# test n=5 avec affichage
## BEGIN SOLUTION
S5 = 0
for i in range(5):
    print("i=",i,"S5=",S5)
    S5 = S5 + i
    print("S5 apres=",S5)
## END SOLUTION    

i= 0 S5= 0
S5 apres= 0
i= 1 S5= 0
S5 apres= 1
i= 2 S5= 1
S5 apres= 3
i= 3 S5= 3
S5 apres= 6
i= 4 S5= 6
S5 apres= 10

# somme des 100 entiers >= 3

# somme des 100 entiers impairs

# exercise 3
## BEGIN SOLUTION
somme = 0
for i in range(100):
    somme = somme + (i+3)
print("somme des entiers= ",somme)
# version 2
somme = 0
for i in range(3,103):
    somme = somme + i
print("somme des entiers= ",somme)
#
somme = 0
for i in range(100):
    somme = somme + (2*i+1)+4
print("somme des entiers impairs= ",somme)
# version 2
somme = 0
for i in range(5,205,2):
    somme = somme + i
print("somme des entiers impairs= ",somme)
## END SOLUTION

somme des entiers=  5250
somme des entiers=  5250
somme des entiers impairs=  10400
somme des entiers impairs=  10400

1.6.5. Tests#

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

  4. opérateurs logiques: == égal , !=, différent, >, >=, <, <=

On peut avoir besoin d’une boucle avec une condition plutôt qu’un compteur:

  1. while: instruction tant que

    `while` condition :
     instructions de boucle

  2. attention au risque de boucle infinie !

  3. les instructions dans la boucle doivent donc modifier la condition

condition = True
while condition:
    condition = False

# generateur aléatoire
import random

# code

# test avec 2 branches test si multiple de 2 ou non
x = random.randint(1,100)
print("x = ",x)
## BEGIN SOLUTION
if (x % 2) == 0: 
    print('x est un multiple de 2.')
else:
    print('x n"est pas un multiple de 2.')
## END SOLUTION

x =  67
x n"est pas un multiple de 2.

IFrame("https://pythontutor.com/iframe-embed.html#code=import%20random%0Ax%20%3D%20random.randint%281,100%29%0Aprint%28%22x%20%3D%20%22,x%29%0Aif%20%28x%20%25%202%29%20%3D%3D%200%3A%20%0A%20%20%20%20print%28'x%20est%20un%20multiple%20de%202.'%29%0Aelse%3A%0A%20%20%20%20print%28'x%20n%22est%20pas%20un%20multiple%20de%202.'%29%0Aprint%28'FIN'%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false",width=800,height=500)

# test de comparaison de 2 entiers: affiche un message
a = random.randint(1,5) 
b = random.randint(1,5)
print("a=",a,"b=",b)
## BEGIN SOLUTION
if a > b:
    print('a est plus grand que b')
elif a < b:
    print('a est plus petit que b')
else:
    print('a est égale à b')
## END SOLUTION

a= 3 b= 5
a est plus petit que b

# comparaison de 2 nombre a et b
a = random.randint(1,5)
b = random.randint(1,5)
print("a=",a," b=",b)
## BEGIN SOLUTION
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')
## END SOLUTION

a= 2  b= 1
a est plus grand que b

1.6.6. Exercice#

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

  • s’il est divisible par 2 et 3, vous affichez: Votre nombre est divisible par 2 et 3 (et donc 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 .

# code

# écrire ici votre solution
N = random.randint(1,9999)
print(N)
## BEGIN SOLUTION
if (N % 2) == 0:
    if (N % 3) == 0:
        print("N est divisble par 2 et 3")
    else:
        print("N est divisible par 2")
elif (N % 3) == 0:
    print("N est divisible par 3")
else:
    print("N n'est pas divisible par 2 et 3")
## END SOLUTION

3870
N est divisble par 2 et 3

exercices tests

  1. Calcul du plus grand entier p telle que la somme des p premiers entiers soit inférieur ou égale à 100

  2. Calcul du plus grand entier p telle que la somme des p premiers entiers pairs soit strictement inférieur à 100

somme = 0
## BEGIN SOLUTION
for i in range(1,1000):
    somme = somme + i
    if somme > 100:
        break
print("i=",i-1," somme=",somme-i)
# version 1
somme = 0
i = 0
while (somme+i) <= 100 :
    i = i+1
    somme = somme + i
print("i=",i," somme=",somme)
# version 2
somme=0
i = 1
while (somme+i) <= 100 :
    somme = somme + i
    i = i+1
print("i=",i-1," somme=",somme)

somme = 0
for i in range(2,1000,2):
    somme = somme + i
    if somme > 100:
        break
print("i=",i-2," somme=",somme-i)
# version 2
somme=0
i = 0
while (somme+i) <= 100 :
    i = i+2
    somme = somme + i
print("i=",i," somme=",somme)
## END SOLUTION

i= 13  somme= 91
i= 13  somme= 91
i= 13  somme= 91
i= 18  somme= 90
i= 18  somme= 90

1.7. Fonction#

objectif automatiser le traitement de données en évitant de réécrire des instructions

  • fonction: suite d’instructions à partir de données (argument) renvoie un résultat (valeur de retour)

  • 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)

1.7.1. points importants#

  • définir quelles sont les données à traiter (argument) ainsi que leurs propriété (type)

  • définir quel résultat on doit obtenir (valeur de retour et type)

  • définir comment on éffectue le traitement (algorithme)

  • attention: le nom des données (arguments) est arbitraire mais l’ordre esr important

  • en python utilisation du mot clé def et utilisation de l’indentation

1.7.2. définition d’une fonction#

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

Attention: dans une fonction les arguments (donnee1,donnee2,..) et les variables dans la fonction sont des variables locales.

1.7.3. utilisation d’une fonction#

  mon_res = MaFonction(ma_donnee1, ma_donnee2,)

Lors de l’appel d’une fonction, les arguments (ma_donnee1,ma_donnee2,..) peuvent être des expressions, des valeurs ou des variables (si elles sont initialisées) dont le nom n’a pas être identique à celui de la définition. Par contre l’ordre et le type doivent être respectés.

1.7.4. généralisation d’un code#

    1. Calcul de la somme des 100 premiers entiers impairs > 3

    1. généralisation: calcul de la somme des n premiers entiers impairs > p

écriture d’une fonction SommeImpairs(p,n)

## BEGIN SOLUTION
def SommeImpairs(p,n):
    """calcul de la somme des n premiers entiers impairs > p"""
    somme = 0
    q = p+1
    if q%2 == 0:
        q = p+2
    for i in range(n):
        somme = somme + q
        q = q+2
    return somme
## END SOLUTION

# verification
S10 = SommeImpairs(3,10)
print("Somme des 10 impairs > 3 :",S10)
S100 = SommeImpairs(3,100)
print("Somme des 100 impairs > 3 :",S100)

Somme des 10 impairs > 3 : 140
Somme des 100 impairs > 3 : 10400

IFrame("https://pythontutor.com/iframe-embed.html#code=def%20SommeImpairs%28p,n%29%3A%0A%20%20%20%20%22%22%22calcul%20de%20la%20somme%20des%20n%20premiers%20entiers%20impairs%20%3E%20p%22%22%22%0A%20%20%20%20somme%20%3D%200%0A%20%20%20%20q%20%3D%20p%2B1%0A%20%20%20%20if%20q%252%20%3D%3D%200%3A%0A%20%20%20%20%20%20%20%20q%20%3D%20p%2B2%0A%20%20%20%20for%20i%20in%20range%28n%29%3A%0A%20%20%20%20%20%20%20%20somme%20%3D%20somme%20%2B%20q%0A%20%20%20%20%20%20%20%20q%20%3D%20q%2B2%0A%20%20%20%20return%20somme%0A%23%20verification%0AS10%20%3D%20SommeImpairs%283,10%29%0Aprint%28%22Somme%20des%2010%20impairs%20%3E%203%20%3A%22,S10%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false",width=800,height=600)

1.7.5. exemple: fonction factoriel#

pour tout entier positif n, par définition $\( n! = \prod_{i=1}^n i\)$

un algorithme pour calculer n! consiste à itérer pour calculer ce produit

 Algorithme Factoriel(n)
       '''calcul de n! pour n entier > 0'''
       prod = 1
       pour i de 1 a n faire
           prod = prod*i
       fin
       retour prod

vérification:

 Factoriel(4) = 4! = 24

# ecrire une fonction qui calul n!
def Factoriel(n):
    '''calcul de n! pour n entier > 0'''
    ## BEGIN SOLUTION
    prod = 1
    for i in range(1,n+1):
        prod = prod * i
    return prod
    ## END SOLUTION

# verification pour n=4 -> 1*2*3*4 = 24
Factoriel(4)

24

IFrame("https://pythontutor.com/iframe-embed.html#code=def%20Factoriel%28n%29%3A%0A%20%20%20%20'''calcul%20de%20n!%20pour%20n%20entier%20%3E%200'''%0A%20%20%20%20prod%20%3D%201%0A%20%20%20%20for%20i%20in%20range%281,n%2B1%29%3A%0A%20%20%20%20%20%20%20%20prod%20%3D%20prod%20*%20i%0A%20%20%20%20return%20prod%0A%23%0Af4%20%3D%20Factoriel%284%29%0Aprint%28%224!%3D%22,f4%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false",width=800,height=600)

1.8. Exemple#

problème:

étude (numérique) de la somme des carrés des n premiers nombres en fonction de n

\[ somme_carre(n) = S \mbox{ avec } S = \sum_{i=1}^n i^2 \]

1.8.1. algorithme#

  • écriture d’une fonction somme_carre() qui calcule la somme des carrés des n premiers entiers

  • calcul de la valeur pour différentes valeurs de n = 5,10,20,40

  • tracer la courbe de ces valeurs

  • en déduire l’ordre \(p\) de la suite, i.e. :

\[ S_n = \sum_{i=1}^n i^2 \approx C\,n^p \]

  • passage en échelle log $\( \ln S_n = p \ln n + ln C \)$

1.8.2. code python#

  • utilisation de matplotlib pour tracer une courbe

  • utilisation de numpy pour calcul des log

# traduction en python
import matplotlib.pyplot as plt
## BEGIN SOLUTION
def somme_carre(n):
    somme = 0
    for i in range(1,n+1):
        somme = somme + i**2
    return somme
#
X = [5,10,20,40]
Y = [somme_carre(X[0]),somme_carre(X[1]),somme_carre(X[2]),somme_carre(X[3])]
print(X,Y)
#plt.plot(X,Y,'x-')
## END SOLUTION

[5, 10, 20, 40] [55, 385, 2870, 22140]

# calcul ordre: passage en échelle log
## BEGIN SOLUTION
import numpy as np
#plt.loglog(X,Y,'x-')
print(np.log(X),np.log(Y))
d = (np.log(Y[-1])-np.log(Y[-2]))/(np.log(X[-1])-np.log(X[-2]))
print("ordre d=",d)
## END SOLUTION

[1.60943791 2.30258509 2.99573227 3.68887945] [ 4.00733319  5.95324333  7.96206731 10.00514121]
ordre d= 2.9475325801058654

1.9. Lecture des données sur fichier#

Les données sont en général stockées dans des fichiers sur disque. 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)

  2. lire les données par exemple lignes par lignes

  3. fermer le fichier

La première étape consiste à ouvrir le fichier pour pouvoir lire son contenu et l’enregistrer dans une variable Python pour pouvoir l’utiliser par la suite.

La fonction open() avec le nom de fichier entre " " comme argument renvoie un objet fichier (file) Python.

Il faut ensuite lire le contenu du fichier et il existe plusieurs façons de le faire.

Enfin, une fois les données lues, il faut fermer le fichier en utilisant la méthode .close() de l’objet fichier.

Pour lire le fichier, on peut utiliser la méthode de fichier read (), mais on obtient une (très grande) chaîne avec tout le contenu du fichier. A la place, on utilisera la méthode readlines(), qui renvoie une liste de chaînes, où chaque chaîne contient une ligne dans le fichier.

    F = open('data.txt')
    lignes  = F.readlines()
    F.close()

F = open('data.txt')
lignes  = F.readlines()
F.close()
print(lignes)

['MGC1020M:Mécanique des structures: 6 ECTS:semestre 1\n', '\n', "  Le but de ce cours est de modéliser les structures élastiques et de simuler leur comportement statique linéaire à l'aide de la méthode des éléments finis.  \n", '\n', 'MGC1049M:Communication:3 ECTS:semestre 2 \n', '\n', "L'objectif est de savoir élargir sa base de recherche documentaire vers des documents techniques, scientifique, normatif, sociétaux, historiques, innovants, multiculturels et etre en mesure de défendre et d'argumenter un point de vue.\n", '\n', 'MGC1021M:Mécanique des fluides et énergétique:6 ECTS: semestre 1 \n', '\n', "Le cours compléte la formation des étudiants qui possèdent des connaissances de base en mécanique des fluides: applications aux écoulements à grands nombres de REYNOLDS (Modèle de fluide parfait et approximations de la couche limite) ainsi qu'aux échanges de chaleur et de masse qui leurs sont associés. \n", '\n', 'MGC1054M:Projet:6 ECTS: semestre 2 \n', '\n', "  L'objectif est la gestion d'un projet complet sur une étude de cas réelle avec l'encadrement d'un professionnel en sachant organiser son temps et répartir les rôles dans une équipe de 3 étudiants.\n", '\n', 'MGC1023M:Outils pour la mécanique:3 ECTS:semestre 1 \n', '\n', "  Le cours a pour objectif de (re)donner aux étudiants les connaissances de base en Mécanique pour suivre le programme de M1 et de valider l'acquisition de ses connaissances à travers un système de devoirs en ligne sur le site pédagogique du département. \n", '\n', 'MGC1024M:Mécanique des milieux continus:3 ECTS :semestre 1 \n', '\n', "Le cours a pour objectif de permettre à l'étudiant d'écrire les lois de conservation (masse, quantité de mouvement, énergie) et de les compléter par des lois de comportements appropriées afin de fermer le système.\n", '\n', 'MGC1056M: Méthodes des éléments finis pour la mécanique:6 ECTS: semestre 1\n', '\n', "L' objectif du cours est de donner les bases de la méthodes des éléments finis appliquées à des problèmes de Mécanique.\n", '\n', 'MGC1029M:EDP de la mécanique, méthodes numériques:6 ECTS:semestre 2\n', '\n', "L'objectif du cours est de connaître les propriétés des EDP de la mécanique, et les différentes méthodes de résolution de ces équations aux dérivées partielles par les méthodes de différences finies.\n", '\n', 'MGC1061M:Ateliers numériques & CAO:6 ECTS:semestre 2\n', '\n', "Le cours comprends une initiation à la CAO et une formation à la modélisation numérique avec des outils informatiques, articulé autour de séances de bureau d'étude (TP), pour une mise en œuvre pratique des concepts du cours.\n", '\n', 'MGCLG1AM: Anglais pour la Communication Professionnelle niveau 1:3 ECTS:semestre 2 \n', '\n', "Ce cours est un cours d'anglais scientifique, pour préparer la certification TOIC obligatoire en master.\n", '\n', 'MGC1017M:Vibration des structures:6 ECTS:semestre 1 \n', '\n', "Le cours traite des Vibrations d'un système réductible plusieurs degrés de liberté ( 1DL 2DL puis généralisé à N DL ) : réponses forcées permanentes et transitoires pour des excitations déterministes.  \n", '\n', 'MGC1058M:Mécanique des Fluides Approfondis / Turbomachines: 6 ECTS:semestre 2\n', '\n', "L'objectif de l'UE est d'étudier les écoulements monophasiques dans les machines tournantes en dévrivant les interactions entre les parties tournantes et fixes (rotor/stator) aussi bien d'un point de vue cinématique qu'énergétique.\n", '\n']

Attention

Avec cette méthode générale, on a les données uniquement sous forme de texte. Il faut ensuite extraire du texte les données utiles pour les convertir par exemple en nombre entier ou en nombre réel. On utilise pour cela les fonctions (méthodes) de manipulation des chaînes de caractères, par exemple le méthode split()

1.10. 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 livre du Cours « 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

Contenu