Cours Ateliers Numériques en Mécanique

Contenu

Cours Ateliers Numériques en Mécanique#

par Marc BUFFAT, dpt Mécanique, Université Lyon 1 [1]

_images/programmation.png — Fig. 1 démarche illustré du calcul scientifique#

1. Introduction#

1.1. Objectif du cours#

L’objectif de ce cours est d’apprendre à maîtriser les outils numériques utilisées pour la modélisation de problèmes en Mécanique

En particulier, on va mettre en oeuvre une méthode, que l’on peut qualifier de démarche du calcul scientifique, dont les étapes sont les suivantes:

Analyse physique du problème
Définition d’un modèle mathématique
Recherche d’une solution (approchée) numérique
Mise en oeuvre d’une solution algorithmique
Programmation sur un ordinateur
Validation et Analyse physique du résultat

Important

L’assimilation du cours nécessite une méthode de travail avec:

une démarche rigoureuse pour méthodes de base
un travail régulier pour savoir appliquer ces méthodes
apprendre à vérifier systématiquement sa démarche
savoir l’expliquer (avec des phrases)
savoir prendre des notes manuscrites pour apprendre !

1.1.1. Outils informatiques:#

Pour mettre en oeuvre cette démarche, on utilisera en particulier les outils informatiques suivants:

Linux, qui est un système d’exploitation de type Unix
des outils de programmation numériques sous Python

avec en particulier les bibliothèques suivantes:

numpy, scipy pour le calcul numérique:
sympy pour le calcul formel:
matplotlib pour la visualisation:

des logiciels Éléments Finis: FreeFem, Comsol

1.1.2. Applications#

Cette démarche sera utilisée pour résoudre divers problèmes de mécanique, dont:

la modélisation d’un treillis
la vibration d’une membrane
l’étude d’une turbo-voile
l’écoulement autour d’une pale d’éolienne

2. Histoire et enjeux de l’informatique scientifique#

boulier chinois

2.1. Historique de l’informatique#

Dès l’apparition des mathématiques, on a cherché à traiter automatiquement des données, ce qui a conduit aux premiers algorithmes

2.1.1. Premiers Algorithmes#

Euclide ~ 300 av JC: premier algorithme pour le pavage d’une pièce (PGCD)

2.1.2. Origine du nom Algorithme#

Mathématicien perse Al-Khawarizmi né vers 783

2.1.3. Prémices de l’informatique#

machine mécanique : la pascaline de Blaise Pascal en 1642

2.1.4. Les pionniers: machine de Turing#

machine éléctro-mécanique

On Computable Numbers article de 1936 d’Alan Turing (1912-1954)
The imitation Game film sur Turing et sa machine Enigma

2.1.5. Premiers ordinateurs électronique#

machine à tubes: UNIVAC I en 1951 (Hergé Objectif lune)
mainframes (transistor) IBM, CDC .. à partir de 1960

2.1.6. Naissance de la micro-informatique ~ 1970#

premier ordinateur personnel français Micral en 1975
TRS 80 à base de microprocesseur 8 bits Zilog Z80 en 1977 (à droite)
Apple II à base de microprocesseur 8 bits Mos 6502 en 1977
Tavernier à base de microprocesseur 16 bits 6809 en 1982 (à gauche)

2.1.7. L’ère internet (à partir 1990)#

Arpanet (1969 réseau militaire) devient internet TCPI/IP (1989)
applications World Wide Web: WWW, HTML, mail (1989 CERN)
premier noyau Linux (Linus Towarld + Unix) 1991
- création de la Free Software Fondation

2.1.8. L’ère actuelle: mobilité , données#

1er IPhone Apple 2007
Supercalculateur IDRIS HPC-IA = 14 PetaFlops ($14. 10^{15}$ ops) (à gauche)
micro-ordinateur ARM Rasberry PI4 14 GigaFlops mais consommation de 6W (à droite)
big DATA, IA

2.1.9. Conclusion#

le numérique (informatique) est maintenant présente partout
puissance du matériel augmente sans cesse (mais pble consommation!)
nécessité de développer des outils logiciels (algorithmique)
- IA aucune intelligence dans la machine, mais dans les algorithmes (traitement de données: Big Data)
nécessité de maîtriser et comprendre les outils pour
- modéliser (simulation numérique)
- analyser (les données expérimentales)

2.2. Utilité d’un ordinateur en science#

Un ordinateur exécute très rapidement des instructions élémentaires: $\approx 4*30. 10^9$ FLOPS sur un ordinateur de bureau (Intel Core I7 4 coeurs). Et il les exécute de façon mécanique.

Question: Comment peut-on utiliser un ordinateur pour simuler un problème physique ?

Par exemple calculer le mouvement d’un pendule, puisque l’ordinateur ne connaît ni la mécanique, ni les équations, ni les méthodes de résolutions de ces équations !

2.2.1. Modélisation numérique#

le scientifique imagine un algorithme pour résoudre le problème de façon mécanique, et le traduit ensuite dans un langage de programmation pour être exécuté par un ordinateur. Il peut ensuite faire l’étude paramétrique du problème comme avec une expérience.

2.2.2. Méthode#

Problème physique

Modèle mathématique: mise en équation

\[ m l \frac{d^2 \theta}{d t^2} = m g \sin(\theta) \]

\[ Y = [ \theta, \frac{d \theta}{dt} ] \]

\[ Y_0=[\theta_0, 0]\]

\[ \frac{d Y}{dt} = F(Y,t) \]

Solution Algorithme RK2

    ....
    Y = Y0
    t = 0
    Pour i de 1 a n
        solution a t+dt/2
        Y12 = Y + 0.5 * dt *F(Y,t)
        solution a t+dt
        Y = Y +  dt *F(Y12,t+dt/2)
        t=t+dt
    Fin Pour

Programmation Python: traduction dans un langage de programmation

  .... 
  Y = np.array([theta0, 0.])
  t = 0.0
  for i in range(n):
       # prediction Y(t+dt/2)
       Y12 = Y + 0.5*dt*F(Y,t)
       # solution Y(t+dt)
       Y = Y + dt*F(Y12,t+0.5*dt)
       t = t + dt
  # fin

2.3. Utilisation de l” informatique en science#

2.3.1. modélisation en mécanique de système complexe#

2.3.2. expérience numérique fondamentale#

DNS simulation numérique directe en mécanique des fluides

2.3.3. CFD = Computational Fluid Dynamics#

simulation numérique à l’ONERA pour Airbus Industrie

2.3.4. CFD = Color Fluid Dynamics ?#

2.3.5. Attention au mirage de la simulation numérique#

Les logiciels sont de plus en plus sophistiqués et fournissent toujours une réponse
Mais la réponse est-elle correcte ?
Il est important de comprendre les principes de base
Importance de la validation des simulations !

Un problème majeur est que la plupart des scientifiques n’ont reçu presque aucune formation en informatique, ce qui devient désormais problématique car la plupart d’entre eux passent une grande partie de leur temps à utiliser des ordinateurs, pour de la modélisation, l’acquisition et le traitement de données expérimentales

acculturation l’IA $\rightarrow$ fournit des corrélations mais pas d’explication !

échecs dans la modélisation

lors du 1er tir d’Ariane V en 1996 , un bug a détruit la fusée après le décolage
destruction d’une plateforme pétrolière concue entièrement sur ordinateur (erreur de modélisation)
biais sur les données d’apprentissage en IA (W.A.S.P White Anglo-Saxon Male Protestant)

2.4. FIN de la leçon#

3. Python pour les scientifiques#

Cette partie est une introduction à la programmation sous Python pour les scientifiques.

I learned Python last night! Everything is so simple! I just typed:

   import antigravity

Python COMICS d'après le site XKCD

Python COMICS d’après le site XKCD

Contenu

3.1. Introduction au calcul scientifique avec Python#

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

(**) voir aussi le cours « Scientific Python Lectures » by Robert Johansson

Mise à disposition selon les termes de la Licence Creative Commons
Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 2.0 France.

%matplotlib inline
import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
# option de mise en page
from IPython.core.display import HTML,display

/tmp/ipykernel_268606/3841631963.py:6: DeprecationWarning: Importing display from IPython.core.display is deprecated since IPython 7.14, please import from IPython.display
  from IPython.core.display import HTML,display

3.1.1. Objectifs#

3.1.1.1. Apprendre:#

concept fondamentaux en programmation
différentes techniques de base
démarche de programmation scientifique
syntaxe du langage Python

3.1.1.2. À la fin du cours, vous pourrez:#

résoudre des problèmes scientifiques (à l’aide de Python)
appliquer la démarche de programmation scientifique avec d’autres langages (matlab, scilab, ..)

3.1.2. Fonctionnement d’un ordinateur#

ordinateur = matériel (CPU, mémoire, disque,..) + logiciel (OS, programmes,..)

3.1.2.1. composants d’un ordinateur#

OS

Système d’exploitation (OS) = gestion d’un ordinateur + environement

Linux/Unix = vue abstraite et générique indépendante du matériel

programmes + données

programme = processus
données = fichiers (files, devices, streams)
gestion des droits: notion d’utilisateur (user), groupes (group), autres (other)
super-utilisateur: root

Principes

small is beautiful
generality is better than specificity
communication is important (format ouvert pour les données)

3.1.2.2. programmes / processus#

processus = programme executé sur un ordinateur

pid = numéro du processus
programme (utilisateur ou commande système)
E/S: entrée par défaut (input stream=stdin), sortie par défaut (output stream=stdout)
sortie programme = entrée d’un autre programme : pipe ou |
pge 1 | pge 2 | pge 3
controle des processus: kill pid ou ctrl+C, stop (ctrl+Z) , tache de fond (bg) , ps, top
éxecution des commandes à travers une interface
- un terminal avec un shell (interpérteur de commande): bash (avec auto-complétion)
- un GUI (gnome, KDE, ..)
syntaxe (attention majuscule # minuscule, espace = séparateur d’arguemnts)

cde [-options] arguments

%%bash
ps -au buffat | head

    PID TTY          TIME CMD
 245164 ?        00:00:00 systemd
 245165 ?        00:00:00 (sd-pam)
 

245172 ?        00:00:00 pipewire
 245173 ?        00:00:00 pipewire-media-
 245174 ?        00:06:2

0 pulseaudio
 245177 ?        00:00:00 gnome-keyring-d
 245181 ?        00:00:06 dbus-daemon
 245187

 tty2     00:00:00 gdm-x-session
 245189 tty2     00:06:44 Xorg

3.1.2.3. Système de fichiers (Unix)#

vu arborescente abstraite indépendante du matériel à partir de la racine (root) /
notation
- fichier = nom de fichier + répertoire + droits d’accés
- / séparateur de répertoire (directory)
- . répértoire courant
- .. répértoire parent
- pwd : affiche répertoire courant
- lien symbolique
- fichiers cachés: commence par .
principales commandes
- ls : liste des fichiers
- mkdir : création répertoire
- rm : éfface un fichier
- cd : change de répertoire (directory)
- help cde : aide
- cat file : affiche le contenu du fichier

%%bash
ls -al | head

total 21364
drwxrwxr-x 6 buffat buffat     4096 avril  9 09:36 .
drwxrwxr-x 4 buffat buffat     4096

 févr. 10  2025 ..
lrwxrwxrwx 1 buffat buffat       39 févr. 10  2025 Algorithme.ipynb -> MGC1061M

/04_Algorithme/Algorithme.ipynb
-rw-rw-r-- 1 buffat buffat     1854 févr. 10  2025 alunissage.py
-r

w-rw-r-- 1 buffat buffat     2136 févr. 10  2025 anim_pendule.py
-rw-rw-r-- 1 buffat buffat    2543

0 févr. 10  2025 BaseProgrammation.ipynb
lrwxrwxrwx 1 buffat buffat       39 févr. 10  2025 BasePy

thon.ipynb -> MGC1061M/02_BasePython/BasePython.ipynb
-rw-rw-r-- 1 buffat buffat    34861 févr. 10 

 2025 BasePython.md
-rw-rw-r-- 1 buffat buffat    27355 févr. 10  2025 BibliothequeScientifique.ipy

nb

3.1.3. Execution d’un programme#

3.1.3.1. Calcul de la somme d’une série:#

\[ S = x - \frac{x^2}{2} + \frac{x^3}{3} + .. = \sum_{i=1}^n (-1)^{i+1} x^i/i \]

démarche:

algorithme
programmation
execution du code machine sur l’ordinateur

3.1.3.2. Algorithme de base#

Algorithme Serie(x,n)
   somme = 0
   pour i de 1 a n
      somme=somme + (-1)^(i+1)*x^i/i
   retour somme

Ecrire un algorithme plus efficace en notant que:

\[ (-1)^{i+1} \frac{x^i}{i} = - \frac{x}{i} (-1)^{i} x^{i-1} \]

3.1.3.3. Execution sur un ordinateur#

L’ordinateur (le CPU) n’éxécute que des instructions machines codées en binaire.

Problème: comment transformer un algorithme en langage machine ?

3.1.3.4. Langage machine (binaire)#

suite d’instruction binaire executer par le processeur: 01010111 (suite 0 ou 1 : bits)
représentation en hexadécimal (octet ou bytes):
- f8 = 248
instructions et données sont stockées en mémoire (à une adresse donnée)
- @000141 instruction f8
spécifiques au processeur (intel, ARM, power, AMD, ..)
spécifique au système d’exploitation OS

%%bash
od -x -N 100 data/a.out
./data/a.out

0000000 457f 464c 0102 0001 0000 0000 0000 0000
0000020 0002 003e 0001 0000 0870 0040 0000 0000
0000

040 0040 0000 0000 0000 21b0 0000 0000 0000
0000060 0000 0000 0040 0038 0009 0040 001e 001b
0000100 

0006 0000 0005 0000 0040 0000 0000 0000
0000120 0040 0040 0000 0000 0040 0040 0000 0000
0000140 01f8

 0000
0000144

Calcul de la serie pour n=20 et x=0.2
Somme de la serie = 0.182322
Log(1+x)=0.182322

3.1.4. Langages de programmation#

conversion d’une programme en code machine
plusieurs centaine de langages différents

-langage le plus complexe: malbolge

3.1.4.1. Langage assembleur#

L’assembleur traduit le code source en code binaire

notation des instructions machines (move, push, load, add, mul)
programme + assembleur = code machine

%%bash
head -15 data/serie.s

	.file	"serie.C"
	.local	_ZStL8__ioinit
	.comm	_ZStL8__ioinit,1,1
	.text
	.globl	_Z5seriedi
	.type	_

Z5seriedi, @function
_Z5seriedi:
.LFB971:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_

offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	movsd	%xmm0, -40(%rbp)

3.1.4.2. Langage compilé: compilateur#

le compilateur transforme le code source en assembleur (compilation), éffectue l’édition avec des librairies pour obtenir un binaire qui dépend de l’ordinateur cible, mais qui s’exécute sans le compilateur et sans le code source.

C++ Fortran C
programme source + compilateur = programme binaire
programme source = portable
programme binaire = spécifique à l’ordinateur (non portable)

_images/C.jpeg langage C

%%bash
head -17 data/serie.C

#include <stdlib.h>
#include <math.h>
#include <iostream>
//
// calcul de la somme de n termes de la

 serie x-x^2/2+x^3/3-
//
double serie(double x,int n)
{
	double coef=x;
	double somme=0.0;
	for (int

 i=1; i<=n; i++)
	{
		somme = somme + coef/i;
		coef = -coef*x;
	}
	return somme;
}

%%bash
g++ data/serie.C -o serie
./serie

Calcul pour n=20 et x=0.2
Somme   = 0.182322
Log(1+x)= 0.182322

3.1.4.3. Langage interprété:#

l’interpéteur exécute de façon interactive chaque ligne du fichier pour la traduire en code machine et l’execute interactivement. Pour exécuter le code, on a donc toujours besoin de l’interpréteur et du code source.

Python, Matlab
programme + interpréteur
portable = indépendant du système (Linux, MacOS, Windows)

3.1.4.3.1. Matlab (Matrix Laboratory)#

Matlab est un logiciel propriétaire qui est une boite à outils (toolbox) de calcul matriciel et numérique développé par Mathworks Inc. Il fonctionne sous Windows, Mac et Unix et permet d’écrire rapidement des scripts pour faire du calcul scientifique.

De nombreuses alternatives libres et de qualité existent, et notamment les logiciels : Scilab, Octave et surtout Python avec numpy.

%%bash
cat data/serie.m

% programme matlab
% ================
x=0.2; n=20;
% calcul de la serie
coef=x;
somme=0.0;
for i=1:n

;
somme = somme+coef/i;
coef  = -coef*x;
end;
display(sprintf('Calcul de la serie pour x=%g et n=%d'

,x,n))
display(sprintf('somme    = %g',somme))
display(sprintf('log(1+x) = %g',log(1+x)))
exit

3.1.4.3.2. langage python#

Python est un language de programmation moderne de haut niveau, logiciel libre, généraliste, multi-plateformes, multi-architecture, multi-OS (linux, windows, MacOS,..). Un programme python peut s’executer sur un tout petit raspberry Pi à 30€ (ARM), sur des smartphones, des portables, des PC jusqu’aux super-calculateurs HPC avec $10^9$ coeurs de calcul.

%%bash
cat data/serie.py

#! /usr/bin/env python
from math import log

def serie(x,n):
    """ calcul de la somme de n termes 

de la serie x-x^2/2+x^3/3- """
    coef=x
    somme=0.0
    for i in range(1,n+1):
        somme = s

omme + coef/i
        coef  = -coef*x
    return somme
#
x=0.2
n=20
print("Calcul de la serie pour x

=",x," et n=",n)
print("somme    = ",serie(x,n))
print("log(1+x) = ", log(1+x))

%%bash
python data/serie.py

Calcul de la serie pour x= 0.2  et n= 20
somme    =  0.18232155679395456
log(1+x) =  0.1823215567939

3.1.5. Historique des langages de programmation#

Années 1950 (approches expérimentales) :
- FORTRAN, LISP, COBOL…
Années 1960 (langages universels) :
- ALGOL, PL/1, PASCAL…
Années 1970 (génie logiciel) :
- C, MODULA-2, ADA…
Années 1980 (programmation objet) :
- C++, Eiffel…
Années 1980 (boites à outils):
- LabView, Matlab…
Années 1990 (langages interprétés objet) :
- Java, Perl, Python…

3.1.5.1. Langages les plus utilisées par les scientifiques#

Pour le calcul intensif (HPC) (Argonne Lab)

C,C++
Fortran
Python

Matlab est très utilisé pour le traitement des données, mais peut être avantageusement remplacer par Python avec ses librairies numpy et matplotlib et pandas

3.1.6. Exigences du calcul scientifique#

« Le logiciel (software) est une des pierres angulaires de la science moderne. Sans logiciel, la science du vingt et unième siècle serait impossible. Mais sans de meilleurs logiciels, la science ne peut pas progresser » [http://sciencecodemanifesto.org/]

Réplicabilité et de reproductibilité sont des pierres angulaires de la méthode scientifique. En ce qui concerne le travail numérique, se conformer à ces concepts a des implications pratiques suivantes:

Réplicable: L’auteur d’un article scientifique qui implique des calculs numériques doit être en mesure de relancer les simulations et de reproduire les résultats sur demande. D’autres scientifiques devraient également être en mesure d’effectuer les mêmes calculs et d’obtenir les mêmes résultats, compte tenu des informations sur les méthodes utilisées dans une publication.
Reproductible: Les résultats obtenus à partir de simulations numériques doivent être reproductibles avec une mise en oeuvre indépendante du procédé, ou en utilisant un procédé tout à fait différent.

En résumé: un résultat scientifique solide doit être reproductible, et une étude scientifique solide doit être réplicable.

importance de la documentation
importance de la validation
importance de la maîtrise du code et des transformations de données (logiciels libres)

3.1.6.1. Démarche du calcul scientifique#

Modèle mathématique
Discrétisation numérique: solution approchée
Recherche solution algorithmique
Programmation
Validation

3.1.7. Documentation#

Python. The official Python web site.
Python tutorials. The official Python tutorials.
Think Python. “”How to Think Like a Computer Scientist”” by Allen B. Downey (free book).
COURS InProS “”Introduction à la Programmation Scientifique””

3.1.7.1. Installation (logiciel libre)#

Distribution pour Linux, Windows, Mac
Distribution Anaconda
accès aux serveurs Jupyter à l’UCB Lyon 1:

3.1.8. Fin de la leçon#

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

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#

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

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.
Définissez une variable b contenant banana et afficher le premier et le dernier a en utilisation une indexation de b.
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#

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

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

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

3.2.6.4.6. exercices:#

Utilisez la méthode count() pour compter le nombre de lettres 'a' dans AE_quote?
En utilisant la même méthode, combien de lettres isolées 'à' se trouvent dans AE_quote?
Utilisez la méthode index() pour trouver la position des mots « génie », « jugez » et « arbre » dans AE_quote.
À 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:#

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#

É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:

in alist
in alist
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:

if: test simple
```
 si condition alors instruction1
```

if-else : test avec 2 branches

si condition alors instruction1 
sinon instruction2

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

<class 'int'>
0 <class 'float'>
<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)

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

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)

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

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#

Réflexion algorithmique
Création d’une bibliothèque de fonctions pour résoudre les sous-pbles:
```
 fichier mabib.py
```
Utilisation d’un environnement de programmation (éditeur / jupyter lab/ shell)
Validation de la bibliothèque
Ecriture du programme principale en utilisant la bibliothéque
```
 import mabib.py
```
Utilisation d’un notebook jupyter
Analyse et validation du résultat (tracé de courbes)
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#

3.3. Tableaux avec numpy et courbes avec matplotlib#

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

images/numpy_array.png

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

3.3.1. Introduction#

Pour beaucoup d’applications en mécanique, on est amené à manipuler des tableaux qui sont des séquences de données du même type. Ils ressemblent beaucoup aux listes, à l’exception de la contrainte sur le type des éléments. Cela apporte un énorme avantage en termes d’efficacité aux tableaux par rapport aux listes. Ainsi, les méthodes sur les tableaux s’exécutent beaucoup plus rapidement que celles sur les listes.

Grâce aux bibliothèques, le langage Python permet de traiter efficacement des applications numériques en sciences et technologie. Pour le calcul scientifique, la bibliothèque la plus importante est NumPy (Numerical Python), qui fournit les structures de données de tableaux (array) à n dimensions ( ndarray), avec toutes les fonctions, opérations et algorithmes pour les calculs d’algèbre linéaire. Nous utiliserons aussi la bibliothèque Matplotlib pour tracer les données en deux dimensions.

3.3.2. Importation de bibliothèques#

En Python, les bibliothèques ne sont pas chargées automatiquement, mais doivent etre importés explicitement en utilisant la commande import. Par exemple, pour importer NumPy, avec toutes ses fonctions d’algèbre linéaire, on utilise

# soit
import numpy
# ou
import numpy as np

La deuxième forme, que nous utiliserons, permet de donner un nom abrégé (ici sp) à la bibliothèque, que l’on utilise à la place du nom de la bibliothèque (i.e. numpy).

Une fois la bibliothéque chargée, on peut utiliser les fonctions de la bibliothèque en ajoutant devant le nom de la bibliothéque ou son nom abrégé. Par exemple, certaines fonctions couramment utilisées avec numpy sont:

Suivez les liens pour voir la documentation de ces fonctions NumPy très utiles, ou utiliser le menu Aide->Numpy Reference!

import numpy as np

3.3.3. Création de tableaux#

Pour créer un tableau NumPy à partir d’une liste existante de valeurs ( homogènes), on utilise numpy.array():

   numpy.array([3, 5, 8, 17])

NumPy propose de nombreuses façons de créer des tableaux (cliquez sur le lien).

Par exemple numpy.ones() et numpy.zeros() créent des tableaux remplis de uns et de zéros, respectivement. On passe en argument le nombre souhaité d’éléments du tableau.

Créer dans la cellule suivante un tableau de 1 de dimension 5 et un tableau de 0 de dimension 3.

# écrire votre code ici

# solution

Une autre fonction numpy.arange() crée un tableau de valeurs régulièrement espacées de pasdans un intervalle définit [debut,fin] mais où finest exclu.

Syntaxe:

numpy.arange(debut, fin, pas)

où debut vaut par défaut zéro,fin est exclus du tableau et pas a une valeur par défaut de 1.

Utiliser les commandes suivantes et analyser le résultat:

np.arange(4)
np.arange(2, 6)
np.arange(2, 6, 2)
np.arange(2, 6, 0.5)

# écrire votre code ici

la fonction numpy.linspace() est similaire à numpy.arange(), mais utilise un nombre d’échantillons N au lieu du pas. Il renvoie un tableau de N valeurs avec des nombres régulièrement espacés sur l’intervalle spécifié [debut,fin] où finest inclu.

Syntaxe:

numpy.linspace(debut,fin,N)

Utiliser les commandes suivantes et analyser les résultats:

  np.linspace(2.0, 3.0)
  len(np.linspace(2.0, 3.0))
  np.linspace(2.0, 3.0, 6)
  np.linspace(-1, 1, 9)

# écrire votre code ici

3.3.4. Opérations sur les tableaux#

En affectant un tableau à une variable, on peut ensuite faire simplement des opérations sur le tableau, qui correspondent à des opérations éffectuées sur chaque élément du tableau (i.e. terme à terme).

Utiliser les commandes suivantes et analyser les résultats

   X = np.linspace(-1, 1, 9)
   Y = X * X
   Z = np.sqrt(Y)
   W = X + Z

# écrire votre code ici

Nous pouvons également diviser des tableaux, mais il faut faire attention à ne pas diviser par zéro. Cette opération se traduira par un nan qui signifie Not a Number. Python effectuera toujours la division, mais nous informera du problème.

Tester le résultat de l’opération

   X / Y

# écrire votre code ici

3.3.5. Tableaux multidimensionnels#

3.3.5.1. tableaux 2D#

NumPy peut créer des tableaux de N dimensions. Par exemple, un tableau 2D ressemble à une matrice et est créé à partir d’une liste imbriquée comme suit:

  A = np.array([[1, 2], [3, 4]])

Les opérations sur matrices sont des opérations terme à terme sur chaque élément.

A partir des 2 matrices A, B suivantes, affichez le résultat de

A + B
A - 2B
A * B

questions

Que se passet-t-il si les matrices ne sont pas de la même dimension ?
Peut on utiliser une notation implicite pour les opérations p.e. 2B ?

A = np.array([[1, 2], [3, 4]])
B = np.array([[1, -1], [0, 1]])
# votre code ici

Attention la dernière opération A*B ne correspond pas à la multiplication matricielle (réfléchissez pourquoi ?)

La multiplication matricielle est obtenue avec l’opérateur @ ou la fonction numpy.dot()

    A @ B
    np.dot(A,B)

Dans la cellule suivante calculer le produit matriciel des 2 matrice A et B.

Si X est le vecteur donné ci dessous, calculer le produit matrice vecteur $A X$

Que fournit l’expression

A*X

X = np.array([1,2])

# votre code ici

3.3.5.2. algèbre linéaire#

En mécanique, on doit manipuler assez souvent des systèmes d’équations linéaires. Numpy possède une sous-bibliothèque d’algèbre linéaire linalg fournissant les fonctions suivantes pour un système linéaire $$ A X = D $$

np.linalg.det(A) calcule le déterminant de A
np.linalg.inv(A) calcule $A^{-1}$ l’inverse de A
np.linalg.solve(A,D) calcule la solution X du système linéaire $A X = D$
np.linalg.eigvals(A)calcul les valeurs propres de A
np.linalg.eig(A)calcul les valeurs et les vecteurs propres de A

remarque importante

pour résoudre un système linéaire numériquement on n’utilise jamais la méthode mathématique $ X = A^{-1} D$ en calculant $A^{-1}$ l’inverse de A, car même si on sait calculer l’inverse de A numériquement avec np.linalg.inv(A). Cette méthode est sujette à des erreurs importantes d’arrondie et est inefficace. On utilise à la place la méthode d’élimination de Gauss (que vous verrez dans le cours de méthodes numériques) qui correspond à la fonction np.linalg.solve(A,D).
pensez à consultez la documentation numpy et numpy.linalg (menu Aide->numpy)

exercise En utilisant le vecteur D suivant et la matrice A précédente, calculer la solution Y de $$ A Y = D $$ et mettre le résultat dans la variable Y

Comment peut-on vérifier le résultat ?

D = np.array([5,11])
# votre code ici
Y = 0

3.3.5.3. sélection des éléments d’un tableau#

Pour accéder aux éléments d’une matrice on utilise la notation classique [ligne,colonne].

Pour sélectionner une ligne entière on utilise : à la place de ligne, et idem pour une colonne.

Pour sélectionner une partie du tableau on utilise la notation debut:fin pour afficher les valeurs de debut à fin (attention fin est exclu)

Exercices

afficher la valeur de la première ligne, première colonne de A,
afficher la valeur de la première ligne, deuxième colonne de A,
afficher la première ligne de A,
afficher la seconde colonne de A.

# votre code ici

3.3.5.4. boucle sur les éléments d’un tableau#

la bibliothèque numpy possède de nombreuses fonctions pour manipuler des tableaux. par contre dans certain cas on doit effectuer des calculs particuliers qui nécessitent de faire des boucles itératives sur les éléments d’un tableau.

Python offre divers formes de boucles itératives à utiliser suivant les besoins. Nous verrons ici uniquement des boucles sur des tableaux 1D ou vecteurs:

3.3.5.4.1. boucle sur les valeurs#

soit un tableau Tab, on s’intéresse à la valeur val des éléments successifs du tableau? C’est la boucle classique en Python:

   for val in Tab:
      print(val)

exercise on veut déterminer le nombre de valeurs d’un tableau qui sont supérieures à une valeur donnée. Par exemple dans le tableau X suivant, on veut connaître le nombre de valeurs supérieure à 0.5

X = np.random.rand(5)
print(X)
# votre code ici

[0.33661121 0.75305157 0.6049483  0.00343809 0.25299808]

3.3.5.4.2. boucle sur les indices et les valeurs#

Si l’on souhaite modifier les valeurs du tableau, la boucle précédente ne le permet. Il faut avoir accés aussi à l’indice i de la valeur val dans le tableau Tab.

En python la boucle s’écrit alors:

   for i,val in enumerate(Tab):
      print(val,"se trouve a l'indice ",i)

exercise en reprenant l’exemple précédent, on souhaite écrêter le tableau X en remplaçant les valeurs supérieures à 0.5 par 0.5.

# votre code ici

3.3.5.4.3. boucle sur les indices uniquement#

enfin on peut vouloir faire une boucle uniquement sur les indices, dans le cas ou manipule plusieurs tableaux.

En python la boucle s’écrit alors:

   for i in range(len(Tab)):
      print("pour l'indice ",i," la valeur vaut ",Tab[i])

On a besoin de la taille du tableau Tab que l’on peut obtenir par la fonction générique len() ou la méthode .size() pour un tableau ndarray

exercise en reprenant l’exemple précédent, on souhaite écrêter le tableau X en remplaçant les valeurs supérieures à 0.5 par la valeur d’un autre tableau Y de même dimension que X

Y = 0.5*np.random.rand(5)
# votre code ici

3.3.5.5. Aliasing#

lors d’un instruction d’affectation

    X = Y

si X,Y sont des scalaires pas d’aliasing
si X,Y sont des listes ou des tableaux , alors aliasing
utilisation d’une copie explicite

print("pas d'aliasing avec les scalaires")
x=2
y=x
x=3
print(x,"#",y)

pas d'aliasing avec les scalaires
3 # 2

print("mais aliasing avec les listes et tableaux")
X=[1,2,3]
Y=X
X[0]=0
print(X,"==",Y)

mais aliasing avec les listes et tableaux
[0, 2, 3] == [0, 2, 3]

print("pas d'aliasing si copie explicite des valeurs")
X=np.array([1,2,3])
Y=X.copy()
X[0]=0
print(X,Y)
Y=np.zeros(X.shape)
Y[:]=X
X[0]=3
print(X,Y)

pas d'aliasing si copie explicite des valeurs
[0 2 3] [1 2 3]
[3 2 3] [0. 2. 3.]

3.3.5.5.1. Question test#

%activity /usr/local/commun/ACTIVITY/IntroPython/questionAlgorithme1

3.3.5.6. Notation matricielle#

Attention par defaut opération sur les éléments
les fonctions mathématiques dans numpy ont pour aguments des tableaux

np.dot produit scalaire
np.outer produit tensorielle
np.inner

X=np.arange(1,4,1)
print("X=",X)
print("X*X=",X*X)
print("X.X=",np.dot(X,X))
print("XoX=",np.outer(X,X))
print("XiX=",np.inner(X,X))

X= [1 2 3]
X*X= [1 4 9]
X.X= 14
XoX= [[1 2 3]
 [2 4 6]
 [3 6 9]]
XiX= 14

A=np.array(np.outer(np.arange(3),np.arange(3)))
print(type(A),A.shape)
print("A*X=\n",A*X)
print("A.X=\n",np.dot(A,X))
print("AoX=\n",np.outer(A,X))
print("AiA=\n",np.inner(A,A))
print("A.At=\n",np.dot(A,A.transpose()))

<class 'numpy.ndarray'> (3, 3)
A*X=
 [[ 0  0  0]
 [ 0  2  6]
 [ 0  4 12]]
A.X=
 [ 0  8 16]
AoX=
 [[ 0  0  0]
 [ 0  0  0]
 [ 0  0  0]
 [ 0  0  0]
 [ 1  2  3]
 [ 2  4  6]
 [ 0  0  0]
 [ 2  4  6]
 [ 4  8 12]]
AiA=
 [[ 0  0  0]
 [ 0  5 10]
 [ 0 10 20]]
A.At=
 [[ 0  0  0]
 [ 0  5 10]
 [ 0 10 20]]

3.3.5.7. attention:#

on évite les boucles explicites pour des questions d’efficacité
mais on commence toujours par écrire la forme explicite avec des boucles , puis ensuite la forme vectorielle

exemple: calcul de la forme quadratique $$ \Phi = \sum_{i=1}^n \sum_{j=1}^n A_{ij} X_i X_j - \sum_{j=1}^n B_j X_j$$

# calcul explicite
Phi=0.0
n=X.size
B=np.ones(X.shape)
### BEGIN SOLUTION
for i in range(n):
    sum=0.0
    for j in range(n):
        sum = sum + A[i,j]*X[j]
    Phi = Phi + (sum - B[i])*X[i]
print(Phi)
### END SOLUTION

58.0

# fonction numpy
print(np.dot(np.dot(A,X)-B,X))

58.0

3.3.5.7.1. Question test#

%activity /usr/local/commun/ACTIVITY/IntroPython/questionAlgorithme2

%activity /usr/local/commun/ACTIVITY/IntroPython/questionAlgorithme3

3.3.6. Tracé avec matplotlib#

Pour tracer des courbes, nous utiliserons la bibliothèque matplotlib et son module pyplot. Sous Jupyter on utilise les instructions suivantes:

  %matplotlib inline
  import matplotlib.pyplot as plt

pour utiliser cette librairie avec le nom raccourci plt. La première instruction permet d’afficher les courbes dans le notebook (inline) plutôt que dans une fenêtre à part.

exemple

pour $x\in[0,2]$, on veut tracer les courbes $y_1=x^2$, $y_2=x^3$ et $y_3=\sqrt{x}$. Pour cela on crée un tableau X de valeurs entre 0 et 2, et on calcule ensuite les valeurs des courbes, puis on trace les 3 courbes avec des commandes du type

  plt.plot(X,Y1)

%matplotlib inline
import matplotlib.pyplot as plt

X  = np.linspace(0,2,41)
Y1 = X*X
Y2 = X**3
Y3 = np.sqrt(X)

3.3.6.1. tracé basique#

faire un tracé basique des 3 courbes dans la cellule suivante.

Attention ce genre de tracé n’est à utiliser que pour des tests et pas pour présenter des résultats, car les courbes n’ont pas de titre, les axes pas de label. Il faut regarder le code pour éventuellement comprendre.

N’utilisez jamais ce tracé basique pour présenter vos résultats !!!

# tracer basique

3.3.6.2. tracé de résultats#

Pour avoir un résultat de qualité, il faut ajouter un titre lisible, des labels avec les fonctions:

plt.title
plt.xlabel
plt.figure
plt.legend

# tracer avec des titres et des labels
# utilisation de taille de caractères plus grande
plt.rc('font', family='serif', size='18')
# tracer d'une figure plus grande
plt.figure(figsize=(10,8))
# plot x^2
plt.plot(X, Y1, color='r', linestyle='-', label='$x^2$')
# plot x^3
plt.plot(X, Y2, color='g', linestyle='--', label='$x^3$')
# plot sqrt(x)
plt.plot(X, Y3, color='b', linestyle=':',  label='$\sqrt{x}$')
# ajoute un titre et des labels 
plt.title('Courbes étudiées')
plt.xlabel('x')
plt.ylabel('y')
# ajoute la legende au meilleur endroit
plt.legend(loc='best');

_images/a241d50206d5af0023ff7888c90751a9a7e52b64bb4b9e03b74d329bcacf7fff.png

On a utiliser une notation $\LaTeX$ pour afficher des expressions mathématiques: $x^2$ pour afficher $x^2$ ou $\sqrt{x}$ pour afficher $\sqrt{x}$.

Consulter le site de matplotlib https://matplotlib.org pour avoir un aperçu des immenses possibilités de tracé de matplotlib.

3.3.6.3. tracé avec des sous-figures#

# tracer de plusieurs sous figure
fig = plt.figure(figsize=(10,8))
# plot x^2
plt.subplot(3,1,1)
plt.plot(X, Y1, color='r', linestyle='-', label='$x^2$')
plt.title('Courbes étudiées')
plt.ylabel('$y_1$ $[m]$')
plt.legend(loc='best')
# plot x^3
plt.subplot(3,1,2)
plt.plot(X, Y2, color='g', linestyle='--', label='$x^3$')
plt.ylabel('$y_2$ $[m/s]$')
plt.legend(loc='best')
# plot sqrt(x)
plt.subplot(3,1,3)
plt.plot(X, Y3, color='b', linestyle=':',  label='$\sqrt{x}$')
# ajoute un titre et des labels 
plt.ylabel('$y_3$ $[m/s^2]$')
plt.xlabel('x [m]')
plt.legend(loc='best');

_images/793cf9bbf871d8bb56f5b3d9c286bccc9af736c246e8eb6a0ac8c1febabff127.png

3.3.6.4. mise sur fichier#

fonction savefig()

attention: sauvegarde la figure dans une variable fig

fig.savefig(nom_fichier)

format pdf (vectoriel) ou image (png)

# sauvegarde de la figure
fig.savefig("mafig.png")
! ls -al mafig.png

-rw-rw-r-- 1 buffat buffat 63616 avril  9 13:57 mafig.png

3.3.6.5. Gallerie matplotlib#

from IPython.display import HTML
HTML('<iframe src=https://matplotlib.org/gallery.html width=800 height=500></iframe>')

/home/buffat/venvs/jupyter/lib/python3.10/site-packages/IPython/core/display.py:475: UserWarning: Consider using IPython.display.IFrame instead
  warnings.warn("Consider using IPython.display.IFrame instead")

3.3.7. Méthodologie#

Réflexion algorithmique
Création d’une bibliothèque de fonctions pour résoudre les sous-pbles:
```
 fichier mabib.py
```
Utilisation d’un environnement de programmation (éditeur / jupyter lab/ shell)
Validation de la bibliothèque
Ecriture du programme principale en utilisant la bibliothéque
```
 import mabib.py
```
Utilisation d’un notebook jupyter
Analyse et validation du résultat (tracé de courbes)
Ecriture d’un rapport au format $\LaTeX$

3.3.8. 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.3.9. FIN de la leçon#

3.4. Vidéo d’introduction à Python#

Il s’agit de la première leçon d’un ensemble de modules d’apprentissage pour les étudiants en sciences et technologie. Ces modules utilisent le langage Python, mais en présupposant aucune expérience de programmation préalable. Le premier objectif sera de vous apprendre à utiliser un environnement numérique Python avec des notebooks Jupyter permettant de résoudre des problèmes et de gérer des données scientifiques.

vidéo du cours introduction à Python

3.5. Vidéo sur les notebooks Jupyter#

Cette cidéo décrit l’utilisation des notebooks Jupyter pour un cours ou TP sur les plateformes jupyter nbgrader du département mécanique.

Une erreur s’est glissée dans la vidéo du cours: seriez vous capable de la trouver?

vidéo du cours sur les notebook jupyter

3.6. Bibliographie#

Engineering Computations cours du Pr L. Barba (Washington Univ.) qui a inspiré ce cours
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

et pour les plus curieux d’entre vous

Algorithms in Python implementation en Python de nombreux algorithmes
Tensor Flow in Python pour utiliser la bibliothèque d’IA de Google avec Python

1. Introduction à Unix#

1.1. Notions de système d’exploitation: « OS »#

1.1.1. Principes#

types: Unix (Linux), Windows (Win 95/98, Win NT, XP), Mac OS …

BIOS
Chargeur=Boot (LILO)
Noyau=Kernel (vmlinuz)
Interpréteurs de commande=shell (sh, bash, csh)
Interfaces graphiques=GUI (X11, gestionnaires de fenetres KDE, NexStep)

1.2. Système de fichiers#

arborescence logique: répertoires (dossier, directory)

racine ou root « / »
répertoires systèmes « /bin » « /lib » « /usr »
répertoires utilisateurs « /home/nom_utilisateur »

arborescence physique: disque et partitions

partitions locales et distantes\

[buffat@ufrmeca Cours]$ df 
Filesystem           1k-blocks Use% Mounted on
/dev/sda2                54441 55% /                      
/dev/sda6               995115 40% /home
/dev/sda7               792800 87% /home1
/dev/sda5               995115 80% /usr
/dev/sda8               567548 75% /home2
/dev/sdb1              1981000 47% /home3
/dev/sdb2              1981000 49% /home4
/dev/sdb3              1981000  1% /home5  
/dev/sdb4              2687444  0% /home6
mecapar:/home7         2640869 36% /mnt

1.3. Controle d’accès#

login + password

permissions
protection des fichiers

[buffat@ufrmeca cours_unix]$ ls -al base.tex
-rw-r--r--   1 buffat   aero        28044 Jan 29  1995 base.tex                

et des répertoires

[buffat@ufrmeca Latex]$ ls -al cours_unix
total 732
drwxr-xr-x   8 buffat   aero         1024 Sep 10 13:56 .
drwxr-xr-x  24 buffat   aero         1024 Jul 28 16:00 ..
drwxr-xr-x   2 buffat   aero         1024 May 18 13:21 BE
drwxr-xr-x   3 buffat   aero         1024 Apr 20 09:42 Cours
drwxr-xr-x   6 buffat   aero         1024 Feb 17  1997 Demo
-rw-r--r--   1 buffat   aero        28044 Jan 29  1995 base.tex  

Modification des protections d’un fichier: chmod.

chmod {a,u,g,o}{+,-}{r,w,x}

avec all (tous), user (propriétaire), group (groupe) , ou other (les autres).

1.3.1. liens sur les fichiers#

commande ln

   ln {-as}

   ln -s ../Cours/doc.tex doc1.tex

1.4. Commandes du shell#

cd Change le répertoire de travail courant.
Syntaxe: cd \
ls Affiche des informations sur les fichiers ou répertoires.
Syntaxe: ls …
Exemple : ls -lF /usr/bin affichera le contenu du répertoire /usr/bin.\
cp Copie un (des) fichier(s) dans un autre fichier ou répertoire.
Syntaxe: cp …
Exemple : cp ../frog joe copie le fichier ../frog dans le fichier ou le répertoire joe.\
mv Déplace un (des) fichier(s) vers un autre fichier ou répertoire.
Syntaxe: mv …
Exemple : mv ../frog joe déplace le fichier ../frog dans le fichier ou le répertoire joe.\
rm Supprime des fichiers..
Syntaxe: rm …
Options: -i demandera confirmation avant chaque effacement de fichier.
Exemple : rm -i /home/dupont/recettes/cassoulet /home/dupont/recettes/vomitifs/macdo effacera les fichiers cassoulet et macdo si l’opération est bien confirmée par l’opérateur.\
mkdir Crée de nouveaux répertoires.
Syntaxe: mkdir …
Exemple : mkdir /tmp/test créera le répertoire test dans le répertoire /tmp.\
rmdir Cette commande supprime les répertoires vides.
Syntaxe: rmdir …
Où à sont les répertoires à supprimer.
Exemple : rmdir /tmp/test supprime le répertoire test dans /tmp, si il est vide (et s’il existe).\
man Affiche la page de manuel pour la commande ou la ressource donnée.
Syntaxe: man
Exemple : man ls donne la description de la commande ls.\
more Affiche le contenu des fichiers, un écran à la fois.
Syntaxe: more …
Exemple : more /etc/termcap affiche le fichier
/etc/termcap.
cat Normalement destinée à concaténer des fichiers, la commande cat est aussi utilisée pour afficher tout le contenu d’un fichier d’un coup.
Syntaxe: cat …
Exemple : cat /etc/passwd affiche le contenu du fichier /etc/passwd.\
echo Affiche simplement les arguments qu’on lui passe.
Syntaxe: echo …
Example: echo "Bonjour tout le monde" affichera la chaı̂ne « Bonjour tout le monde ».\
grep Affiche toutes les lignes dans le (les) fichier(s) correspondant à l’expression donnée.
Syntaxe: grep …
Où est une expression rationnelle, et à les fichiers dans lesquels la rechercher.
Exemple : grep local /etc/hosts affichera toutes les lignes du fichier /etc/hosts qui contiennent l’expression « local ».\

1.5. Caractères génériques du shell#

* remplace n’importe quelle suite de caractère
? remplace 1 caractère
[ccc] remplace un caractère parmi ccc; (0-9) et (a-b) sont possibles
x protection du caractère x (i.e non interprétation)
“xxx” prend xxx littéralement sans interprétation
"xxx" idem mais avec interprétation de
‘cde‘ remplace par le résultat de la commande
# début de commentaire
; fin de commande

1.6. les entrées sorties#

entrée standard stdin, sortie standard stdout, sortie d’erreur stderr
redirection des E/S

: *prog file* remplace l’entrée standard de prog par le contenu de file.
str : prog `` str l’entrée standard suit jusqu’à l’apparition de « str » dans le flot de données.
: *prog file* écrit la sortie standard de prog dans file.
: *prog file* ajoute la sortie standard de prog dans file.
| : prog1 | prog2 création d’un « pipe » en connectant la sortie de prog1 à l’entrée de prog2

1.7. contrôle de processus#

commande ps

[buffat@ufrmeca COURS_UNIX]$ ps
  PID TTY          TIME CMD
 6289 pts/1    00:00:00 bash
11272 pts/1    00:00:00 ps

processus en avant-plan, arrière-plan
arrêt d’un processus
kill pid

1.8. Editeur de texte#

un éditeur simple, mais puissant vi ou autre kwrite,.. xemacs..

2. Réseau#

2.1. Définition#

nom de machine hostname
nom de domaine domainname\

[buffat@ufrmeca COURS_UNIX]$ hostname -a
ufrmeca
[buffat@ufrmeca COURS_UNIX]$ hostname -d
univ-lyon1.fr  
[buffat@ufrmeca COURS_UNIX]$ hostname
ufrmeca.univ-lyon1.fr  

numéro IP = numéro carte ethernet unique

[buffat@ufrmeca COURS_UNIX]$ /sbin/ifconfig
eth0      Lien encap:Ethernet  HWaddr 00:C0:4F:C9:62:03
          inet adr:134.214.93.120  Bcast:134.214.95.255  Masque:255.255.252.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          Paquets Reçus:5443720 erreurs:13 jetés:13 débordements:0 trames:13
          Paquets transmis:697928 erreurs:0 jetés:0 débordements:0 carrier:0
          collisions:6850 lg file transmission:100
          Interruption:19 Adresse de base:0xdce0
 
lo        Lien encap:Boucle locale
          inet adr:127.0.0.1  Masque:255.0.0.0
          UP LOOPBACK RUNNING  MTU:3924  Metric:1
          Paquets Reçus:4636 erreurs:0 jetés:0 débordements:0 trames:0
          Paquets transmis:4636 erreurs:0 jetés:0 débordements:0 carrier:0
          collisions:0 lg file transmission:0                                   

Numero de réseau et masque

[buffat@ufrmeca COURS_UNIX]$ cat ifcfg-eth0
DEVICE=eth0
IPADDR=134.214.93.120
NETMASK=255.255.252.0
NETWORK=134.214.92.0

2.2. Protocol de communication#

transmission de packets sur le réseau avec un protocol de communication (TCP/IP)
accès à un service entre 2 machines

| num. IP destination | num. IP source | service (port) |  message |\\

2.3. Serveur de noms#

transformation $IP <-> hostname$
fichier local $/etc/host$

[buffat@ufrmeca Cours]$ cat /etc/hosts | more
127.0.0.1       localhost
134.214.94.123  alien.univ-lyon1.fr     alien
134.214.93.120  ufrmeca.univ-lyon1.fr   ufrmeca
# UCB
#134.214.92.151 biomeca
134.214.92.164  mecaflu4.univ-lyon1.fr  mecaflu4
134.214.94.124  mecapar.univ-lyon1.fr   mecapar
134.214.92.100  secret-meca.univ-lyon1.fr       secret-meca 

serveur de noms

[buffat@ufrmeca Cours]$ cat /etc/resolv.conf
search univ-lyon1.fr
nameserver 134.214.100.6
nameserver 134.214.100.245
nameserver 156.18.22.3

resolution des noms

[buffat@ufrmeca Cours]$ nslookup
Default Server:  cismsun.univ-lyon1.fr
Address:  134.214.100.6
 
> athena.mecaflu.ec-lyon.fr
Server:  cismsun.univ-lyon1.fr
Address:  134.214.100.6
 
Non-authoritative answer:
Name:    athena.mecaflu.ec-lyon.fr
Address:  156.18.40.105        

2.4. Routage#

Porte=GATEWAY

[buffat@ufrmeca Cours]$ cat /etc/sysconfig/network
NETWORKING=yes
HOSTNAME=ufrmeca.univ-lyon1.fr
DOMAINNAME=univ-lyon1.fr
GATEWAY=134.214.92.1
GATEWAYDEV=eth0
FORWARD_IPV4=no     

Table de routage

[buffat@ufrmeca Cours]$ /sbin/route -n
Table de routage IP du noyau
Destination     Passerelle      Genmask         Indic Metric Ref    Use Iface
134.214.93.120  0.0.0.0         255.255.255.255 UH    0      0        0 eth0
134.214.92.0    0.0.0.0         255.255.252.0   U     0      0        0 eth0
127.0.0.0       0.0.0.0         255.0.0.0       U     0      0        0 lo
0.0.0.0         134.214.92.1    0.0.0.0         UG    0      0        0 eth0   

Test de routage

[root@ufrmeca Cours]# traceroute athena.mecaflu.ec-lyon.fr
traceroute to athena.mecaflu.ec-lyon.fr (156.18.40.105), 30 hops max, 40 byte packets
accel101-1ercycle (134.214.92.1)  3.336 ms  18.720 ms  2.632 ms
cs7505-cism (134.214.200.225)  1.202 ms  1.156 ms  0.964 ms
u-1-cism-villeurbanne (193.48.222.2)  2.021 ms  5.537 ms  2.071 ms
lyon.aramis.ft.net (193.48.66.13)  21.626 ms  9.631 ms  8.879 ms
centrale-lyon.aramis.ft.net (193.48.66.62)  6.949 ms  29.308 ms  60.353 ms
193.54.216.1 (193.54.216.1)  19.696 ms  47.226 ms  22.045 ms
eclgw.servers.ec-lyon.fr (156.18.19.254)  9.213 ms  110.096 ms  36.818 ms
athena.mecaflu.ec-lyon.fr (156.18.40.105)  41.103 ms  39.818 ms  80.468 ms 

Test d’une connection: $ping$

[root@ufrmeca Cours]# ping athena.mecaflu.ec-lyon.fr
PING athena.mecaflu.ec-lyon.fr (156.18.40.105): 56 data bytes
64 bytes from 156.18.40.105: icmp_seq=0 ttl=248 time=51.9 ms
64 bytes from 156.18.40.105: icmp_seq=1 ttl=248 time=53.0 ms
64 bytes from 156.18.40.105: icmp_seq=2 ttl=248 time=79.7 ms
64 bytes from 156.18.40.105: icmp_seq=3 ttl=248 time=16.5 ms
 
--- athena.mecaflu.ec-lyon.fr ping statistics ---
4 packets transmitted, 4 packets received, 0% packet loss
round-trip min/avg/max = 16.5/50.2/79.7 ms            

2.5. Services#

service= port + protocol (TCP,UDP)// messagerie (mail)= port 25 TCP

[buffat@ufrmeca Cours]$ telnet mecalpha 25
Trying 134.214.95.86...
Connected to mecalpha.univ-lyon1.fr.
Escape character is '^]'.
220 mecalpha.univ-lyon1.fr ESMTP Sendmail 8.8.7/8.8.7; Wed, 22 Sep 1999 01:00:39 +0200
helo mecalpha
250 mecalpha.univ-lyon1.fr Hello buffat@ufrmeca [134.214.93.120], pleased to meet you
......  

ssh nom@hostname\

connexion sécurisée
[buffat@p2chpd-visu2]$ ssh buffat@athena.mecaflu.ec-lyon.fr
buffat@athena.mecaflu.ec-lyon.fr's password:xxxxxxx
Last login: Thu Jul 10 09:46:01 from lns-th2-10-82-64
Digital UNIX V4.0D  (Rev. 878); Mon Dec 13 15:29:15 MET 1999
athena.mecaflu.ec-lyon.fr>exit
athena.mecaflu.ec-lyon.fr> logout
Connection to athena.mecaflu.ec-lyon.fr closed.

telnet « hostname »
ancien mode de connexion (non sécurisé)
scp user@host1:fichier1 fichier2

scp fichier1 user@host1:fichier2 transfert de fichier sécurisé

scp lstree.txt buffat@athena.mecaflu.ec-lyon.fr:toto.txt
buffat@athena.mecaflu.ec-lyon.fr's password: xxxxxx
lstree.txt       100%  206   962.5KB/s   00:00

ftp « hostname »
transfert de fichiers (non scurisé)

mail : messagerie
envoi (en général avec un client)

[buffat@ufrmeca COURS_UNIX]$ mail buffat@mecapar.univ-lyon1.fr
Subject: essai mail
Hello,
essai de mail
Marc
^D
Cc: buffat 

reception

You have mail in /var/spool/mail/buffat
[buffat@ufrmeca COURS_UNIX]$ mail
Mail version 8.1 6/6/93.  Type ? for help.
"/var/spool/mail/buffat": 1 message 1 new
>N  1 buffat@ufrmeca.univ-  Wed Sep 15 14:12  16/439   "essai mail"
& q

3. Cours algorithmique#

Marc Buffat dpt mécanique, UCB Lyon 1

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
from IPython.display import HTML

3.1. Algorithmes numériques de base#

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

Abu Abdullah Muhammad ibn Musa al-Khwarizmi.

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!

3.2. Méthode d’analyse algorithmique#

programmation procédurale en informatique, la programmation procédurale est un paradigme qui se fonde sur le concept d’appel procédural.

Une procédure, aussi appelée routine, sous-routine ou fonction contient simplement une série d’étapes à réaliser en fonction de données (arguments) et fournit des résultats (valeur).

top down algorithm / design

on découpe le problème en sous problèmes plus simples

bottom up programming

on programme d’abord les algorithmes des sous-problèmes, avant de passer à la résolution globale:

 - utilisation de librairies
 - définition des fonctions

3.3. Différents types d’algorithme#

algorithme itératif

Un algorithme itératif est basé sur les procédures d’itération que sont le Tant que et le Pour. Il réalise donc une boucle jusqu’à ce que la condition d’arrêt soit respectée (test , nbre d’itérations, ..).

algorithme récursif

récursion méthode algorithmique où la solution du problème s’exprime en fonction de solutions du même problème, mais sur des données plus petites.

3.3.1. Exemple : calcul de n!#

version itérative

\[ n! = \prod_{i=1}^n i \]
version récursive

\[ n! = n * (n-1)! \]

programmation dans le notebook !

3.4. Algorithme d’Euclide#

Soit une pièce rectangulaire de taille $a \times b$, déterminer la taille du plus grand carré permettant un pavage exacte de la pièce:

Analyse

propriétés
1. pavage(a,b) = pavage(a-b,b) si a>b
2. pavage(a,b) = pavage(a,b-a) si a<b
3. pavage(a,b) = a si a=b
algorithmes
1. version récurrente
2. version itérative

def PGCD(a,b):
    if a==b :
        return a
    elif a>b :
        return PGCD(a-b,b)
    else :
        return PGCD(a,b-a)

%timeit PGCD(100,75)

380 ns ± 1.87 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)

def PGCD1(a,b):
    while a!=b :
        if a>b :
            a = a-b
        else:
            b = b-a
    return a

timeit PGCD1(100,75)

244 ns ± 1.76 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)

3.5. Algorithme du calcul du déterminant d’une matrice#

soit $A$ une matrice d’ordre $n$, la méthode de Cramer permet le calcul récursif du déterminant par développement par rapport à la 1ere colonne

\[ det(A) = \sum_{k=1}^n (-1)^{k+1} A_{k,1} \times det(A^k) \]

où $A^k$ est la sous-matrice obtenu par élimination de la colonne 1 et de la ligne $k$ de $A$

Pour une matrice de dimension 1 $$ det(a) = a $$

### Version recursive
def determinant(A):
    
    return

3.5.1. Algorithme déterminant#

 Algorithme determinant(A)
     n = dim(A)
     si n==1 alors
         retour A[0,0]
     fin si
     # A1 sous matrice d'ordre n-1
     A1 = tableau(n-1,n-1)
     det = 0
     signe = 1
     # développement par rapport a la 1ere colonne
     pour k de 0 a n-1
         # sous matrice Ak
         A1[0:k,:] = A[0:k ,1:n]
         A1[k:,:]  = A[k+1:,1:n]
         det = det + signe*A[k,0]*determinant(A1)
         signe = -signe
         fin pour
     retour det

3.5.2. Programme Python (solution)#

from numpy.linalg import det

def determinant(A):
    """ calcul du déterminant d'une matrice A """
    n=A.shape[0]
    if n==1 :
        return A[0,0]
    A1 = np.zeros((n-1,n-1))
    det = 0.
    signe = 1
    for k in range(n):
        A1[0:k,:] = A[0:k  ,1:n]
        A1[k: ,:] = A[k+1:n,1:n]
        det = det + signe*A[k,0]*determinant(A1)
        signe = -signe
    return det
# verification
M = np.array([[2.,0.,0],[0.,3.,0],[0,0,4.]])
delta = determinant(M)
print("determinant :",delta, det(M))

determinant : 24.0 23.999999999999993

# comparaison avec scipy
M = np.random.rand(8,8)
print(M)
delta = determinant(M)
print("determinant M:",delta,det(M))

[[0.7393828  0.2230019  0.8562197  0.99433771 0.1565653  0.79930796
  0.90192473 0.3823761 ]
 [0.94994486 0.89859604 0.43061165 0.04686198 0.14548221 0.53549263
  0.49002993 0.41966703]
 [0.26416228 0.37261767 0.18743199 0.11021367 0.04673572 0.14852054
  0.10712103 0.53171711]
 [0.88452029 0.74424527 0.89223583 0.56639971 0.92099731 0.70744181
  0.8429787  0.98633387]
 [0.9449187  0.4625425  0.68669302 0.57388277 0.26252077 0.95048458
  0.18627193 0.81260822]
 [0.16122013 0.81540555 0.39614714 0.26859707 0.55721694 0.1317386
  0.10457908 0.4932543 ]
 [0.44160171 0.34201614 0.59957683 0.43623267 0.13137884 0.34305066
  0.68123181 0.62833921]
 [0.11252061 0.33153549 0.69243258 0.47728407 0.1615201  0.80683352
  0.64448575 0.19659104]]
determinant M: 0.00944264046079138 0.009442640460791378

## Efficacité
%time determinant(M)

CPU times: user 142 ms, sys: 0 ns, total: 142 ms
Wall time: 142 ms

0.00944264046079138

%time det(M)

CPU times: user 42 μs, sys: 0 ns, total: 42 μs
Wall time: 44.1 μs

0.009442640460791378

3.6. Algorithmes classiques#

méthode de Newton
méthode des trapèzes
méthode d’Euler
tour de Hanoi
tri par insertion
bubble sort

3.7. Bibliothèques scientifiques#

numpy
scipy

3.8. FIN#

4. Stucture de données#

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

Mise à disposition selon les termes de la Licence Creative Commons
Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 2.0 France.

Table des matières

1 Structure simple
2 Exemple
3 Structure complexe
- 3.1 Enregistrement (structure)
  - 3.1.1 structure avec définition explicite
  - 3.1.2 structure dynamique
4 TP: système solaire
5 Fin

%matplotlib inline
import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
from matplotlib import rcParams
rcParams['font.family'] = 'serif'
rcParams['font.size'] = 14
from IPython.core.display import HTML
from IPython.display import display
from matplotlib import animation

4.1. Structure simple#

4.1.1. Vecteurs, Matrices#

tableau numpy

accès avec un indice
dimension fixe
type uniforme

4.1.2. Liste d’objets non uniforme#

liste python

accès avec un indice
dimension variable
type différent

4.1.3. Dictionnaire#

liste avec un indicage par mot clés - accès avec une clé (key) - dimension variable - type différent

4.1.4. Boucle sur les élèments#

par indice
par valeur
par indice et valeur

# boucle classique sur les indices
X = np.linspace(0.,1.,6)
for i in range(X.size):
    print("X[{}]={}".format(i,X[i]))

X[0]=0.0
X[1]=0.2
X[2]=0.4
X[3]=0.6000000000000001
X[4]=0.8
X[5]=1.0

# boucle sur les valeurs
for x in X:
    print("X[]=",x)

X[]= 0.0
X[]= 0.2
X[]= 0.4
X[]= 0.6000000000000001
X[]= 0.8
X[]= 1.0

# boucle sur les valeurs et indices
for i,x in enumerate(X):
    print("X[{}]={}".format(i,x))

X[0]=0.0
X[1]=0.2
X[2]=0.4
X[3]=0.6000000000000001
X[4]=0.8
X[5]=1.0

4.1.5. boucle sur un dictionnaire#

clé : valeur
dico = { cle1:valeur1, cle2:valeur2, .. }

# dictionnaire
Dico={'mon':'my','personne':'nobody','nom':'name','est':'is'}
for mot in Dico:
    print("traduction de {} : {}".format(mot,Dico[mot]))

traduction de mon : my
traduction de personne : nobody
traduction de nom : name
traduction de est : is

# utilisation
phrase="mon nom est toto"
traduction=""
for mot in phrase.split():
    if mot in Dico:
        traduction += Dico[mot] + " "
    else:
        traduction += mot + " "
print(traduction)

my name is toto

4.2. Exemple#

on souhaite manipuler une liste d’étudiants avec leur nom (une chaine de caractère) et leur note (un nombre réel)

# version numpy
Noms  = np.array(['toto','bidule','machin'])
Notes = np.array([10.,16.0,13.])
print(Noms,Notes)
# recherche de la note d'un etudiant
etudiant='bidule'
for k in range(Noms.size):
    nom = Noms[k]
    if etudiant == nom :
        print("{} a pour note {}".format(nom,Notes[k]))

['toto' 'bidule' 'machin'] [10. 16. 13.]
bidule a pour note 16.0

# version avec liste
Listes = [['toto',10.],['bidule',16.],['machin',13.]]
print(Listes)
# recherche de la note d'un etudiant
nom='bidule'
for etudiant in Listes:
    if etudiant[0] == nom:
        print("{} a pour note {}".format(nom,etudiant[1]))

[['toto', 10.0], ['bidule', 16.0], ['machin', 13.0]]
bidule a pour note 16.0

# version avec dictionnaire
Etudiants = {'toto':10.,'bidule':16.,'machin':13.}
print(Etudiants)
# recherche de la note d'un etudiant
if nom in Etudiants:
    print("{} a pour note {}".format(nom,Etudiants[nom]))

{'toto': 10.0, 'bidule': 16.0, 'machin': 13.0}
bidule a pour note 16.0

4.3. Structure complexe#

On veut représenter un élève qui est caractérisé son nom, son prénom, son numéro d’étudiant, sa moyenne générale, etc. On voudrait qu’une seule variable conserve et donc donne accès à toutes ces informations.

En algorithmique, on définirait alors un type enregistrement Eleve regroupant ces informations.

Le type Eleve contiens alors une chaîne de caratère (le nom), une deuxième chaîne de caractère (le prénom), un entier (numero étudiant), un réel (moyenne générale)

# representation avec des listes
eleve=['machin','chouette',123456,12.5]
print(eleve)
print("eleve numero:{} moyenne:{}".format(eleve[2],eleve[3]))

['machin', 'chouette', 123456, 12.5]
eleve numero:123456 moyenne:12.5

Problème

accés aux données avec un indice (peu lisible)
complexification

solution - accès avec un mot clé - eleve.nom - eleve.note

4.3.1. Enregistrement (structure)#

Définition algorithmique : Un enregistrement est un type correspondant à un agrégat d’élément de types éventuellement différent auxquels on accède grâce à un nom.

en Python on peut l'implémenter avec la notion de classe

4.3.1.1. structure avec définition explicite#

à préférer !!!

# structure avec définition explicite
class Eleve():
    def __init__(self,name,forname,num,moy):
        self.nom     = name
        self.prenom  = forname
        self.numero  = num
        self.moyenne = moy
        return  

eleve = Eleve('machin','chouette',123456,12.5)
print("Eleve {} numero:{} moyenne:{}".
      format(eleve.nom,eleve.numero,eleve.moyenne))

Eleve machin numero:123456 moyenne:12.5

4.3.1.2. structure dynamique#

uniquement si nécéssaire !!!
préférer une définition explicite

class Eleve():
    pass

eleve = Eleve()
eleve.nom    = 'machin'
eleve.prenom = 'chose'
eleve.numero = 123456
eleve.moyenne= 12.5
print("nom {} numero:{} moyenne:{}".
      format(eleve.nom,eleve.numero,eleve.moyenne))

nom machin numero:123456 moyenne:12.5

4.4. TP: système solaire#

On veut manipuler les planétes du système solaire.

Une planéte est caractérisée par:

son nom
sa masse
sa distance au soleil
sa période de rotation

4.4.1. Définition d’une structure planete#

# unite de masse : terre en kg
masse_terre = 5.9736e24 
class Planete():
    def __init__(self,name,dist,diametre,density,period):
        self.nom   = name
        self.masse = np.pi/6.*(density*1.e12)*\
                    diametre**3/masse_terre
        self.rayon = diametre/2.
        self.distance = dist
        self.periode  = period
        return

4.4.2. Manipulation de la structure planete#

Terre = Planete("terre",150,12756,5.5,365.256)
Mars  = Planete("mars",228,6794,4.0,686.98)

# distance  terre/mars
dmin = -Terre.distance + Mars.distance
dmax =  Terre.distance + Mars.distance
print("distance terre mars: min {} max {} (10^6 km)".format(dmin,dmax))

distance terre mars: min 78 max 378 (10^6 km)

# durée du voyage (en jour) (vitesse du vaiseau en km/h)
V = 15000.0
tmin = (dmin*1e6/V)/24.
tmax = (dmax*1e6/V)/24.
print("duree min={:.2f}  max={:.2f} (jours)".format(tmin,tmax))

duree min=216.67  max=1050.00 (jours)

# liste de planetes
Jupiter=Planete("jupiter",778,143884,1.3,4332.6)
Venus  =Planete("venus",108,12104,5.3,224.701)
Saturne=Planete("saturne",1427,120536,0.7,10759.2)
SystemeSolaire=[Saturne,Terre,Mars,Jupiter,Venus]
#
def affiche(SSolaire):
    for planete in SSolaire:
        print("{:8s} masse {:6.2f} distance {:5.0f}mkm periode {:7.1f}j".format(
          planete.nom, planete.masse, planete.distance, 
          planete.periode))
    return
#
affiche(SystemeSolaire)

saturne  masse 107.45 distance  1427mkm periode 10759.2j
terre    masse   1.00 distance   150mkm periode   365.3j
mars     masse   0.11 distance   228mkm periode   687.0j
jupiter  masse 339.42 distance   778mkm periode  4332.6j
venus    masse   0.82 distance   108mkm periode   224.7j

4.4.3. Tri bulle (bubble sort)#

Le tri bulle est un algorithme classique de tri basé sur la comparaison répétitive d’éléments consécutifs du tableau. Il doit son nom au fait qu’il déplace rapidement les plus grands éléments en fin de tableau, comme des bulles d’air qui remonteraient rapidement à la surface d’un liquide Wikipedia. Cette technique est bien plus efficace que l’algorithme basique consistant à déterminer le maximum du tableau.

L’algorithme de tri bulle parcourt le tableau et compare les éléments consécutifs. Lorsque deux éléments consécutifs ne sont pas dans l’ordre, ils sont échangés. Après un premier parcours complet du tableau du dernier au premier, le plus grand élément est forcément en fin de tableau, à sa position définitive. Le reste du tableau est en revanche encore en désordre. Il faut donc le parcourir à nouveau jusqu’à l’avant-dernier élément. Après ce deuxième parcours, les deux plus grands éléments sont à leur position définitive. Il suffit de répéter cette opération N-1 fois, N étant la dimension du tableau.

Principe de l’algorithme de Tri bulle pour un tableau T de dimension n

Algorithm tri_à_bulles(Tableau T)
       pour n allant de taille(T) - 1 à 1
          "n=nbre d'elements à trier"
          pour j allant de 0 à n - 1
           si T[j+1] < T[j]
               échanger(T[j+1], T[j])

# Implémentation en Python

N = len(SystemeSolaire)
for i in range(N):
    n = N-i  # nbre d'elements à trier    
    for j in range(n-1):
        planete_j  = SystemeSolaire[j]
        planete_j1 = SystemeSolaire[j+1]
        if planete_j1.distance < planete_j.distance:
            # echange des planetes dans le tableau
            SystemeSolaire[j]  = planete_j1
            SystemeSolaire[j+1]= planete_j
# affiche les planetes pour vérifier
affiche(SystemeSolaire)

venus    masse   0.82 distance   108mkm periode   224.7j
terre    masse   1.00 distance   150mkm periode   365.3j
mars     masse   0.11 distance   228mkm periode   687.0j
jupiter  masse 339.42 distance   778mkm periode  4332.6j
saturne  masse 107.45 distance  1427mkm periode 10759.2j

4.4.4. Tracé du système solaire#

4.4.4.1. tracer des planetes#

# adimensionnalisation
dist_terre  = Terre.distance
rayon_terre = Terre.rayon
# couleur des planetes
Couleurs=['b','r','#c0fb2d','#aaa662','#ceb301']
#
plt.figure(figsize=(12,7))
ax = plt.axes(xlim=(-10,10),ylim=(-5,5))
for k,planete in enumerate(SystemeSolaire):
    col= Couleurs[k]
    r1 = planete.distance/dist_terre
    r2 = 0.1*planete.rayon/rayon_terre
    c2 = plt.Circle((r1,0),radius=r2,color=col)
    ax.add_patch(c2)
    plt.text(r1,0.5,planete.nom[0].upper(),fontsize=18)
plt.axis('equal')
plt.xlabel('distance soleil')

Text(0.5, 0, 'distance soleil')

_images/bead28dfef1642ee785dbf11eeaa6b3c4401a7897281cba130d8972009af941c.png

4.4.5. Animation des planetes#

dist_terre  = Terre.distance
rayon_terre = Terre.rayon
Couleurs=['b','r','#c0fb2d','#aaa662','#ceb301']
Cplanetes=[0]*len(SystemeSolaire)
# figure
ax = None
fig = None
#
def init_anim():
    global SystemeSolaire, Cplanetes, fig, ax
    fig=plt.figure(figsize=(6,6))
    ax = plt.axes(xlim=(-10,10),ylim=(-10,10))
    r0 = 0.1
    c0 = plt.Circle((0,0),radius=r0,color='k')
    ax.add_artist(c0)
    for planete in SystemeSolaire:
        r1 = planete.distance/dist_terre
        c1 = plt.Circle((0,0),radius=r1,lw=1,fill=False)
        ax.add_patch(c1)
    plt.axis('equal')
    plt.axis('off')
    return
def init():
    global SystemeSolaire,Cplanetes,ax
    for k,planete in enumerate(SystemeSolaire):
        col= Couleurs[k]
        c2 = plt.Circle((0,0),radius=0,color=col)
        ax.add_patch(c2)
        Cplanetes[k]=c2
    return (Cplanetes[k] for k in range(len(SystemeSolaire)))
#
def animate(i):
    global SystemeSolaire,Cplanetes
    t  = i*20.
    for k,planete in enumerate(SystemeSolaire):
        r1 = planete.distance/dist_terre
        w1 = 2*np.pi/planete.periode
        r2 = 0.12*planete.rayon/rayon_terre
        x  = r1*np.cos(w1*t)
        y  = r1*np.sin(w1*t)
        Cplanetes[k].center = (x,y)
        Cplanetes[k].radius = r2
    return (Cplanetes[k] for k in range(len(SystemeSolaire)))
#

import matplotlib.animation as animation
from matplotlib import rc
init_anim()
anim=animation.FuncAnimation(fig, animate, range(200),interval=100, init_func=init)

_images/869c588f027e9d93468794857751e28144ef174f46fc0e81774ecc55519bf4d5.png

rc('animation', html='jshtml')
anim

Cours Ateliers Numériques en Mécanique

Contenu

Cours Ateliers Numériques en Mécanique#

1. Introduction#

1.1. Objectif du cours#

1.1.1. Outils informatiques:#

1.1.2. Applications#

2. Histoire et enjeux de l’informatique scientifique#

2.1. Historique de l’informatique#

2.1.1. Premiers Algorithmes#

2.1.2. Origine du nom Algorithme#

2.1.3. Prémices de l’informatique#

2.1.4. Les pionniers: machine de Turing#

2.1.5. Premiers ordinateurs électronique#

2.1.6. Naissance de la micro-informatique ~ 1970#

2.1.7. L’ère internet (à partir 1990)#

2.1.8. L’ère actuelle: mobilité , données#

2.1.9. Conclusion#

2.2. Utilité d’un ordinateur en science#

2.2.1. Modélisation numérique#

2.2.2. Méthode#

2.3. Utilisation de l” informatique en science#

2.3.1. modélisation en mécanique de système complexe#

2.3.2. expérience numérique fondamentale#

2.3.3. CFD = Computational Fluid Dynamics#

2.3.4. CFD = Color Fluid Dynamics ?#

2.3.5. Attention au mirage de la simulation numérique#

2.4. FIN de la leçon#

3. Python pour les scientifiques#

3.1. Introduction au calcul scientifique avec Python#

3.1.1. Objectifs#

3.1.1.1. Apprendre:#

3.1.1.2. À la fin du cours, vous pourrez:#

3.1.2. Fonctionnement d’un ordinateur#

3.1.2.1. composants d’un ordinateur#

3.1.2.2. programmes / processus#

3.1.2.3. Système de fichiers (Unix)#

3.1.3. Execution d’un programme#

3.1.3.1. Calcul de la somme d’une série:#

3.1.3.2. Algorithme de base#

3.1.3.3. Execution sur un ordinateur#

3.1.3.4. Langage machine (binaire)#

3.1.4. Langages de programmation#

3.1.4.1. Langage assembleur#

3.1.4.2. Langage compilé: compilateur#

3.1.4.3. Langage interprété:#

3.1.4.3.1. Matlab (Matrix Laboratory)#

3.1.4.3.2. langage python#

3.1.5. Historique des langages de programmation#

3.1.5.1. Langages les plus utilisées par les scientifiques#

3.1.6. Exigences du calcul scientifique#

3.1.6.1. Démarche du calcul scientifique#

3.1.7. Documentation#

3.1.7.1. Installation (logiciel libre)#

3.1.8. Fin de la leçon#

3.2. Base de programmation en Python#

3.2.1. Questions préliminaires#

3.2.2. Historique#

3.2.3. Pourquoi Python#

3.2.3.1. Avantages du langage Python#

3.2.3.2. Défauts du langage Python#

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

3.2.4. Philosophie de Python (Zen of python)#

3.2.5. Concepts de base#

3.2.5.1. Algorithme#

3.2.5.2. Programme informatique#

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

3.2.6.1. exercice#

3.2.6.2. Indexation#

3.2.6.3. sous-chaînes#

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

3.2.6.4.1. commentaires#

3.2.6.4.2. application#

3.2.6.4.3. count()#

3.2.6.4.4. find() & index()#

3.2.6.4.5. index()#

3.2.6.4.6. exercices:#

3.2.6.4.7. split()#

3.2.7. Les listes en Python#

3.2.7.1. exercice:#

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

3.2.6.4.3. `count()`#

3.2.6.4.4. `find()` & `index()`#

3.2.6.4.5. `index()`#

3.2.6.4.7. `split()`#

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

3.2.7.3. `in` : test si dans la liste#

3.2.8.1. Itération avec `for`#

3.2.8.4. Test avec `if`#