Le langage Python est un langage généraliste, disposant de bibliothèques puissantes en calcul numérique (scipy, numpy et matplotlib) permettant de l'utiliser dans le cadre du calcul scientifique. Plusieurs interfaces graphiques (Pyzo, Spyder, Eric, etc) permettent de travailler dans un environnement Python. Le livre d'informatique Vuibert s'appuie sur Pyzo.
Scilab est d'abord un logiciel, proposant une interface graphique de travail et un langage de programmation. Semblable au logiciel Matlab, le logiciel Scilab est dédié au calcul scientifique pour la recherche et l'industrie. Il est moins généraliste que Python, mais dispose d'un outil de modélisation graphique (Xcos) permettant de manipuler des modèles numériques complexes, ce qui manque à Python.
Le C et ses variantes est, de très loin, le langage le plus répandu en informatique. Il est presque certain que ce langage sera abordé en école d'ingénieurs. Il est néanmoins un peu plus rigide et complexe à manipuler pour l'apprentissage de la programmation (il n'est pas interactif par exemple).
Le langage C est un langage compilé. Il est beaucoup plus rapide à l'execution que les langages interprétés.
Pour la programmation des micro-contrôleurs (utilisés en TP de SI), il est incontournable. C'est pourquoi le formulaire ci-dessous propose, pour un petit nombre de fonctionnalités, les expressions équivalentes en C.
Le formulaire tente de couvrir en une page l'essentiel des commandes utiles dans le cadre du programme de CPGE. Chaque commande est illustrée en une ligne, permettant de se remémorer rapidement la syntaxe des fonctions dans chaque langage. Seules les commandes présentant le symbole 
sont raisonnablement à connaitre pour les concours.
Le symbole 
redirige vers une page proposant plus d'explications et d'exemples pour certaines commandes lorsque c'est utile. Le symbole 
renvoie vers une documentation officielle de la commande.
| Description | Python | Scilab | C |
|---|---|---|---|
| Importer un fichier |
import file
|
exec("fichier.sce")
exec fichier.sce
|
|
| Lancer l'aide interactive |
help()
|
help
|
|
| Afficher l'aide associée à la commande cosinus |
help(cos)
|
help cos
apropos cos
|
|
Afficher x sur la console interactive
|
print(x)
|
disp(x)
|
printf("%f",x)
|
| Demander une entrée en console |
x=input("Entrer une chaine : ")
x=float(input("Entrer une valeur : "))
|
x=input("Entrer une chaine : ","string")
x=input("Entrer une valeur : ")
|
printf("Entrer une chaine : ")
gets(str)
|
| Importer une bibliothèque |
import bibliotheque as nom
from bibliotheque import *
|
Menu > Applications
> Gestionnaire de module - Atoms
|
|
| Interruption d'un programme pour débug |
import pdb
pdb.set_trace()
|
pause
|
|
Les variables sont dans les 3 langages, systématiquement associées à un type (et donc un espace mémoire alloué). Néanmoins, le typage est "dynamique" en Python et Scilab, c'est-à-dire que le type peut changer en fonction des besoins du calcul, tandis qu'il est statique en C (le type est choisi avant l'initialisation de la variable et ne peut plus être modifié par la suite, ce qui s'avère beaucoup plus simple et efficace pour la gestion de la mémoire).
| Description | Python | Scilab | C |
|---|---|---|---|
| Obtenir le type d'une variable a |
type(a)
|
type(a)
typeof(a)
inttype(a)
|
explicite dans le programme...
|
| Changement de type |
int(a)
float(a)
str(a)
|
int(a)
int8(a)
int16(a)
float32(a)
float64(a)
|
(int)a
(int8_t)a
(float)a
|
Nous passons sur les opérateurs classiques + - * / qui sont identiques dans les 3 langages (attention toutefois à la division de deux entiers qui est réalisée dans les entiers en C et en python 2.7, et dans les flottants en Scilab et en Python 3.3...). Il est nécessaire d'importer la bibliothèque math.h en C.
| Description | Python | Scilab | C |
|---|---|---|---|
|
Puissance ab
|
a**b
|
a^b
|
pow(a,b)
|
|
Reste ou modulo
|
a%b
|
modulo(a,b)
|
a%b
|
|
Division entière
|
a//b
|
floor(a/b)
|
a/b avec a et b entiers
|
|
Test égalité
|
a == b
|
a == b
|
a == b
|
|
Inférieur (ou égal)
|
a < b ; a <= b
|
a < b ; a <= b
|
a < b ; a <= b
|
|
Supérieur (ou égal)
|
a > b ; a >= b
|
a > b ; a > =b
|
a>b ; a>=b
|
|
Différent
|
a != b
|
a ~= b
|
a != b
|
|
ET
|
a and b
|
a & b
|
a && b
|
| ET bitwise |
a & b
|
bitand(a,b)
|
a & b
|
|
OU
|
a or b
|
a | b
|
a || b
|
| OU bitwise |
a | b
|
bitor(a,b)
|
a | b
|
|
NON
|
not a
|
~a
|
!a
|
| NON bitwise |
~a
|
bitcmp(a,8)
|
~a
|
| OU exclusif |
a ^ b
|
~(a == b)
|
!(a == b)
|
| OU exclusif bitwise |
a ^ b
|
bitxor(a,b)
|
a ^ b
|
|
décalage de 3 bits à gauche et à droite
|
a << 3 ; a >> 3
|
a*2^3 ; floor(a/2^3)
|
a << 3 ; a >> 3
|
|
Affichage d'un nombre en binaire
|
bin(a)
|
dec2bin(a)
|
|
| Affichage d'un nombre en hexadécimal |
hex(a)
|
dec2hex(a)
|
|
Les fonctions mathématiques standards en python peuvent provenir de différents paquets. Le chargement du module pylab (
| Description | Python | Scilab | C |
|---|---|---|---|
|
Racine carrée
|
sqrt(a)
|
sqrt(a)
|
sqrt(a)
|
|
cosinus
sinus
tangente
|
cos(a)
sin(a)
tan(a)
|
cos(a)
sin(a)
tan(a)
|
cos(a)
sin(a)
tan(a)
|
| arcos arcsin |
acos(a)
asin(a)
|
acos(a)
asin(a)
|
|
| arctangente sur ]-π/2, π/2[ |
atan(a)
|
atan(a)
|
atan(a)
|
| arctangente sur ]-π, π] |
atan2(y,x)
|
atan(y,x)
|
atan2(x,y)
|
| ch, sh, th |
cosh(x)
sinh(x)
tanh(x)
|
cosh(x)
sinh(x)
tanh(x)
|
cosh(x)
sinh(x)
tanh(x)
|
| Logarithme Néperien (ln) |
log(a)
|
log(a)
|
log(a)
|
| Logarithme en base 10 (log) |
log10(a)
|
log10(a)
|
log10(a)
|
| Logarithme en base n quelconque |
log(a,n)
|
log(a)/log(n)
|
|
| Exponentielle ea |
exp(a)
|
exp(a)
|
exp(a)
|
| Arrondi entier |
around(a)
fix(a)
|
round(a)
fix(a)
|
round(a)
|
| Arrondi à l'entier supérieur |
ceil(a)
|
ceil(a)
|
ceil(a)
|
| Arrondi à l'entier inférieur |
floor(a)
|
floor(a)
|
floor(a)
|
| Générer un nombre ou une liste aléatoire |
random.random()
numpy.random.sample(10)
|
rand()
rand(1,10)
|
random()
|
| Constantes |
pi
e
|
%pi
%e
|
|
Le calcul en complexes est possible dans les langages Python et Scilab.
| Description | Python | Scilab | C |
|---|---|---|---|
| imaginaire i |
1j
|
%i
|
|
| Nombre complexes 3+4i |
3+4j
complex(3,4)
|
3+4*%i
complex(3,4)
|
|
| Partie réelle de a |
a.real
|
real(a)
|
|
| Partie imaginaire de a |
a.imag
|
imag(a)
|
|
| Module |
abs(a)
absolute(a)
|
abs(a)
|
|
| Argument |
angle(a)
phase(a)
|
atan(imag(a),real(a))
|
|
| Conjugué de a |
a.conj()
|
conj(a)
|
|
La séquence la plus courante sous Python est la liste. Il s'agit d'un des types fondamentaux du langage. Pour le calcul numérique, nécessitant des opérations de calcul sur des tableaux de flottants par exemple, le module NumPy est mieux approprié.
Au contraire, la séquence la plus courante en Scilab est le tableau. La liste n'est utilisée que lorsque la séquence doit contenir des données de types différents.
| Description | Python | Scilab | C |
|---|---|---|---|
|
Définir une liste
|
liste1 = [M,v]
|
liste1 = list(M,v)
|
|
|
Sélectionner par position
|
liste1[i]
|
liste1(i)
|
|
| Supprimer un élément |
del liste1[i]
|
L(i)=null()
|
|
| Concaténation |
liste1 + liste2
|
lstcat(liste1,liste2)
|
|
|
Longueur de la liste
|
len(liste1)
|
size(liste1)
length(liste1)
|
|
|
Ajouter un élément en fin de liste
|
liste1.append(a)
|
liste1($+1)=a
|
|
| Ajouter un élément en tête de liste |
liste1=[a]+liste1
|
liste1(0)=a
|
|
Le calcul numérique s'appuie intensivement sur des tableaux de valeurs, soit pour représenter des signaux, soit pour représenter des vecteurs et des matrices. Les tableaux peuvent avoir une ou plusieurs dimensions.
La syntaxe de Scilab est fortement orienté vers la manipulation de tableau. Elle est en ce sens très pratique et lisible.
Python propose quant à lui trois types possibles pour manipuler des données sous forme de tableaux : les listes (à une ou plusieurs dimensions), le type "array", et le type "matrix". Des conversions sont possibles entre ces types. Il est conseillé dans le cadre du calcul numérique (pour des raisons pratiques et d'efficacité des calculs) d'utiliser le type "array". C'est ce qui est considéré par la suite.
Attention, en Python et en C, les indices des tableaux commencent à 0 tandis qu'en Scilab, ils commencent à 1.
| Description | Python | Scilab | C |
|---|---|---|---|
|
Vecteur ligne
|
v=array([1, 2, 3])
|
v=[1, 2, 3] ou
[1 2 3]
|
int v[3]={1, 2, 3}
|
|
Vecteur colonne
|
v=array([[1],[2],[3]])
v=array([1, 2, 3])[:,newaxis]
v=array([1, 2, 3]).reshape(-1,1)
|
v=[1; 2; 3]
|
|
|
Tableau à 2 dimensions
|
M=array([[1,2,3],[4,5,6]])
|
M=[1, 2, 3; 4, 5, 6]
|
int v[2][3]={{1, 2, 3}, {4, 5, 6}}
|
|
Accéder à un élément
|
v[0], M[0,1]
|
v(1), M(1,2)
|
v[0], M[0][1]
|
|
Accéder au dernier élément, et l'avant dernier
|
v[-1], v[-2]
|
v($), v($-1)
|
|
|
Dimensions d'un tableau
|
M.shape
|
size(M)
|
|
|
Extraire la 2ème ligne ou 2ème colonne
|
M[1,:] ou M[:,1]
|
M(2,:) ou M(:,2)
|
|
|
Extraire une portion de tableau (2 premières colonnes)
|
M[:,0:2]
|
M(:,1:2)
|
|
|
Extraire des éléments d'un tableau par leurs indices
|
M[0,(2,1)]
|
M([1],[3,2])
|
|
|
Séquence équirépartie d'entiers
|
range(1,11)
|
1:10
|
|
|
Séquence équirépartie quelconque (101 points, 100 intervalles sur [0, 10])
|
arange(0,10.1,0.1)
linspace(0,10,101)
|
0:0.1:10
linspace(0,10,101)
|
|
|
Tableau de zéros
|
zeros((2,3),float)
|
zeros(2,3)
|
|
|
Tableau de uns
|
ones((2,3),float)
|
ones(2,3)
|
|
|
Copier un tableau dans une autre variable
|
w=v.copy()
|
w=v
|
|
|
Opérations élément par élément (multiplication, division, exposant)
|
v*w, v/w, v**w
|
v.*w, v./w, v.^w
|
|
| Maximum et minimum d'un tableau |
v.max(0), v.min(0)
|
max(v), min(v)
|
|
| Indice i du maximum |
v.argmax(0)
|
[m,i] = max(v)
|
|
| Description | Python | Scilab | C |
|---|---|---|---|
|
Produit matriciel
|
dot(v,w)
|
v*w
|
|
|
Transposée
|
M.transpose()
|
M'
|
|
|
Résolution de système matriciel M.X=Y
|
linalg.solve(M,Y)
|
X=linsolve(M,-Y)
X=M\Y
|
|
| Produit scalaire de deux vecteurs (colonne) |
vdot(v,w)
|
v'*w
|
|
| Produit vectoriel |
cross(v,w)
|
cross(v,w)
|
|
| Déterminant |
linalg.det(M)
|
det(M)
|
|
| Inverse |
linalg.inv(M)
|
inv(M)
|
|
| Valeurs propres |
linalg.eig(M)[0]
|
spec(M)
|
|
| Vecteurs propres |
linalg.eig(M)[1]
|
[v,l] = spec(M)
|
|
| Rang |
linalg.matrix_rank(M)
|
rank(M)
|
|
Ce sont des listes un peu plus complexes en ce que chacun des éléments qui le compose est au moins composé de 2 membres, l'un étant la clé, l'autre la valeur.
En python, le dictionnaire est embrassé par des accolades { }.
Scilab propose aussi des structures indicées (cell()) qui ne seront pas développées ci-dessous (car plus ou moins équivalentes à une liste).
| Description | Python | Scilab | C |
|---|---|---|---|
| Définir un dictionnaire |
D1 = {'Scal': 5, 'Vect': array([1,2,3])}
|
S1=struct('Scal', 5, 'Vect', [1,2,3])
|
|
| Obtenir ou changer un élément |
D1['Scal'] = 1 + D1['Vect'][2]
|
S1.Scal = 1 + S1.Vect(3)
|
|
| Supprimer un élément |
del D1['Scal']
clear()
pop(cle)
popitem()
|
S1.Scal=null()
|
|
En C il faut utiliser la bibliothèque string.h.
| Description | Python | Scilab | C |
|---|---|---|---|
|
Définir une chaîne de caractères
|
mot="Python et Scilab"
|
mot="Python et Scilab"
|
mot="Python et Scilab"
|
|
Construire une chaîne de caractères formatée
|
"il fait {:3.0f} degres.".format(10)
|
msprintf("il fait %3.0f degres.",10)
|
printf("il fait %3.0f degres.",10)
|
|
Longueur d'une chaîne
|
len(mot)
|
length(mot)
|
strlen(mot)
|
|
Extraire des caractères
|
mot[2:7]
|
part(mot,[1,2,11:16])
|
|
|
Concaténation
|
mot="python" + "/" + "Scilab"
|
mot="python" + "/" + "Scilab"
|
strcat(mot1,mot2)
|
| Replacer une portion de chaîne |
mot.replace("Scilab","C")
|
strsubst(mot,"Scilab","C")
|
|
| Découper une chaîne de caractères |
mot.split(" ")
|
strsplit(mot," ")
|
|
| Supprimer des caractères de retour à la ligne |
mot.rstrip("\n\r")
|
|
|
| Description | Python | Scilab | C |
|---|---|---|---|
|
Boucle FOR
|
for i in range(10):
print(i)
|
for i=1:10
disp(i);
end
|
for (i=1;i<=10;i++){
printf("%d",i);
}
|
|
Boucle WHILE
|
i=0
while (i<10):
i+=1
print(i)
|
i=0
while (i<10)
i=i+1;
disp(i)
end
|
int i=0;
while (i<10){
i++;
printf("%d",i);
}
|
| Interruption d'une boucle |
break
|
break
|
break
|
| Description | Python | Scilab | C |
|---|---|---|---|
|
Condition IF
|
if (i>3):
print(i)
else
print("hello")
|
if (i>3) then
disp(i)
else
disp("hello")
end
|
if (i>3){
printf("%d",i);
}
else{
printf("hello");
}
|
| Condition CASE |
if i == 1:
print("Egal à 1")
elif i == 2:
print("Egal à 2")
else:
print("Aucun des deux")
|
select i,
case 1 then
disp("Egal à 1");
case 2 then
disp("Egal à 2");
else
disp("Aucun des deux");
end
|
switch(i) {
case 2:
b=b+1;
break;
case 3:
b=b+5;
break;
default:
b=0;
}
|
| Description | Python | Scilab | C |
|---|---|---|---|
|
Définir une fonction
|
def nomdelafonction(paramètres):
bloc d'instructions
return resultat
|
function resultat=nomdelafonction(paramètres)
bloc d'instructions
endfunction
|
<type> nom_de_la_fonction(paramètres)
{
bloc d'instructions
}
|
En Python, il est parfois nécessaire d'exécuter la commande show() pour afficher le graphique après l'appel à la commande plot().
| Description | Python | Scilab | C |
|---|---|---|---|
|
Tracé d'une courbe y ou (x,y)
|
plot(y) ou plot(x,y)
|
plot(y) ou plot(x,y)
|
|
| Tracé de points (o) rouges (r) reliés par des lignes (-) |
plot(x,y,"-or")
|
plot(x,y,"-or")
|
|
|
Effacer le graphique
|
clf()
|
clf
|
|
| Ouvrir une nouvelle figure |
figure(3)
|
figure(3)
|
|
| Échelle logarithmique en X |
semilogx(x,y)
|
plot2d("ln",x,y)
|
|
| Échelle logarithmique en X et Y |
loglog(x,y)
|
plot2d("ll",x,y)
|
|
| Description | Python | Scilab | C |
|---|---|---|---|
|
Ouvrir un fichier texte en lecture/écriture
|
fic=open("fichier.txt","r")
fic=open("fichier.txt","w")
|
fic=mopen("fichier.txt","r")
fic=mopen("fichier.txt","w")
|
FILE *fic;
fic=fopen("fichier.txt","r");
fic=fopen("fichier.txt","w");
|
|
Fermer un fichier
|
fic.close()
|
close(fic)
|
fclose(fic)
|
|
Lire une ou plusieurs lignes
|
ligne=fic.readline()
lignes=fic.readlines()
|
ligne=mgetl(f,1)
lignes=mgetl(f)
|
char ligne[20];
fgets(ligne,20,fic);
|
| Lire un tableau formaté |
a,b=loadtxt("Fichier.txt",
usecols = (0,2),
dtype={
'names': ('numero', 'consigne'),
'formats': ('i2', 'f4')},
delimiter=',',
unpack=True)
|
Tableau=mfscanf(-1,fic,"%d,%f,%f")
|
fscanf(fic,"%d,%f,%f",i,a,b)
|
|
Écrire une ligne
|
fic.write("il fait {:f} degres.\n"\
.format(10))
|
mfprintf(fic,"il fait %f degres.\n",10)
|
fprintf(fic,"il fait %f degres.\n",10)
|
| Écrire un tableau formaté |
for i in range(len(x)):
fic.write("{:d},{:f},{:f}\n"\
.format(i,x[i],y[i]))
|
mfprintf(fic,"%d,%f,%f",1:100,x,y)
|
|
| Description | Python | Scilab | C |
|---|---|---|---|
| Sauver des variables dans un fichier binaire |
import pickle
fic=open("fichier.pick","wb")
pickle.dump(a,fic)
pickle.dump(b,fic)
fic.close()
|
save("fichier.dat",a,b)
|
|
| Recharger des variables du fichier binaire |
import pickle
fic=open("fichier.pick","rb")
pickle.load(a,fic)
pickle.load(b,fic)
fic.close()
|
load("fichier.dat","a","b")
|
|
| Ouvrir un fichier binaire en lecture/écriture |
fic=open("fichier.txt","rb")
fic=open("fichier.txt","wb")
|
fic=mopen("fichier.txt","rb")
fic=mopen("fichier.txt","wb")
|
|
| Lire 3 octets dans un fichier binaire |
octets=fic.read(3)
|
octets=mget(3,"c",fic)
|
|
| Écrire des octets dans un fichier binaire |
fic.write("PCSI")
fic.write(int8(83))
fic.write(float32(2.3))
|
mput(ascii("PCSI"),"c",fic)
mput(83,"i",fic)
mput(2.3,"f",fic)
|
|
La lecture et l'écriture d'image sous python 3.x n'est pas forcement simple : la bibliothèque scipy.misc (chargée par pylab) supporte la plupart des formats d'images sous 2.x mais pas sous 3.x. Matplotlib permet néanmoins de lire le format png (et fournit un tableau de niveaux de couleurs entre 0 et 1, type float). Sous Pyzo, la bibliothèque
La lecture et l'écriture d'image sous Scilab nécessite l'installation par Atoms du module SIVP (image and vidéo processing). La plupart des formats sont supportés.
Les images sont ensuite manipulées dans le programme sous forme de tableaux.
| Description | Python | Scilab | C |
|---|---|---|---|
| Ouvrir une image |
im=imread("image.png")
|
im=imread("image.png")
|
|
| Enregistrer une image |
imsave("image.png",im)
|
imwrite(im,"image.png")
|
|
| Afficher une image |
imshow(im)
|
imshow(im)
|
|
| Taille de l'image |
im.shape
|
size(im)
|
|
| Description | Python | Scilab | C |
|---|---|---|---|
| Interpolation linéaire d'une courbe (X,Y) en x (où x peut être un tableau) |
fct_interp = interp1d(X,Y)
y=fct_interp(x)
|
y=interpln([X;Y],x)
|
|
| Intégration numérique d'une fonction de à |
quad(sin,x0,x1)
|
integrate("sin(x)","x",x0,x1)
|
|
| Intégration par la méthode des trapèzes |
trapz(y[, x, dx, axis])
|
inttrap(x,y)
|
|
| Dérivation numérique d'une fonction |
derivative(f, 1.0, dx=1e-6)
|
derivative(f,x)
|
|
| Différences finies |
diff(a[, n, axis])
|
numdiff(y,x)
|
|
| Solution d'une équation non linéaire |
fsolve(f,x0)
|
fsolve(x0,f)
|
|
| Minimisation d'une fonction |
minimize(f,x0)
|
optim(f,x0)
|
|
| Intégration numérique d'une équation différentielle ordinaire (ODE) |
odeint(f,x0,t)
|
ode(x0,t0,t,f)
|
|
| Intégration numérique d'une équation différentielle algébrique (DAE) |
|
dae(x0,t0,t,f)
|
|
|
Alain CAIGNOT, Marc DERUMAUX Damien ICETA, Johann LABASQUE Lionel MOISAN, Xavier PESSOLES |
| Ce formulaire a été inspiré par le document mathesaurus (http://mathesaurus.sourceforge.net/), dans un format adapté aux classes préparatoires. |