MEGA MEMO PYTHON

Variables:
-association entre un identificateur et une valeur stockée dans l'ordinateur
-peut être composée de lettres majuscules, minuscules, chiffres, du symbole "_" (underscore)
-Attention: peut pas commercer par un chiffre; variable en minuscule ≠ variables minuscules (age ≠ AGE)
-écriture en pseudo-code: x←7 en python: x=7
Variables GLOBALES: définies EN DEHORS de toute fonction; existe durant l'exécution du programme
Variable LOCALES: définies DANS une fonction, masque toute autre variable de même nom; existe durant
l'exécution de la fonction

→ différents types de données car:

Python a besoin de connaître quels types de données sont utilisées pour savoir quelles opération il faut faire
avec: chaine1='rien'
-Entiers: int chaine2="rien"
-Flottant (nombre à virgule): float print('chaine=',chaine1,'ou =',chaine2)
-Chaine de caractère = succession de caractère:
\" ou \' pour ecrire des guillements sans fermer >>>
<< chaine= rien ou = rien
la chaine de caractère
\n retour à la ligne (retour chariot)
\t faire une tabulation \\ ecrire un antislash

affectation d'une variable

par l'utilisateur: a=imput

incrémentation d'une variable: variable = variable +1 ou variable +=1

opération:
addition: + ; multiplication: * ; soustraction: - ; exposant: ** ;
division: / ; division entière: // ; modulo: %

print() avec
retour à la ligne :

la fonction type()
renvoie le type de
la variable passée
en paramètre

Booléens: en python, la classe des booléens content uniquement les éléments True et False.
opérations de bases entre les booléens
Structures Conditionnelles:
→ permettent d'exécuter une ou plusieurs instructions dans un cas, d'autres instructions dans un autre cas.
formes complètes:
→ if : "si..." opérateur de comparaison
→ else : "sinon..." différend de: !=
→ elif : "sinon si...." égal à: ==
supérieur ou égal à: >=
inférieur ou égal à: =<

Boucles: permettent de répéter une

certaine opération autant de fois que
nécessaire
→while
permet de répéter une instruction
tant qu’une condition reste vraie
break → peut interrompre une boucle
continue → continuer une boucle,
en repartant directement à la ligne du
while ou for (ex: pour supprimer les éléments d'une liste)

→for
spécialisée dans le parcours d'une séquence de plusieurs
données
Liste & Chaînes de caractères:
.La classe str:
Mettre une chaine de majuscule: upper()
Mettre une chaine en minuscule: lower()
Retirer les espaces au début et à la fin de
la chaîne: strip()
Mettre le premier caractère en majuscule:
capitalize()
Centrer la chaîne dans un espace de n
caractères: center(n)
la chaîne est renvoyée sans être modifiée

Convertir une chaîne de caractère en liste:

→ list(): séparation faite à chaque caractère
→ split(): séparation se fait sur le(s) caractère(s) choisi(s)
L’accès à un caractère de la chaîne se fait par l’intermédiaire
des indices mis à l’intérieur de crochets.

→max(), min() retournent le caractère maximal (resp. minimal)

selon l’ordre alphabétique, de la chaîne (attention les majuscules
ne sont pas retenues par cette fonction),
→len() donne le nombre de caractère de la chaîne (espaces inclus),
→in donne l'existence d'un caractère dans une chaîne de caractère,
→count("str", beg,end) donne le nombre de fois où l’occurrence
"str" apparait dans la chaîne de caractère, il faut préciser l’index
de départ, beg, et de fin, end, de la recherche (attention les
majuscules ne sont pas retenues par cette fonction)

Il est possible de concaténer deux chaînes de caractères en une seule

→str() retourne une chaîne vide
→replace('old','new',n) remplace
n fois dans une chaîne un caractère
('old') par un autre caractère ('new')

l’opérateur %. s’applique sur les

chaînes de caractères et permet de
définir le format lors d’un print()
 Listes: Ensemble ordonné d'éléments entouré par des crochets. Chaque élément d’une liste est
associé à un nombre, sa position ou son index. Le premier index est 0, le second 1 …
max(list) retourne la valeur maximale des éléments d’une
liste,
min(list) retourne la valeur minimale des éléments d’une
liste
index("val") permet d’obtenir la position du premier
élément égal à la valeur "val" dans la liste
count("val") permet d’obtenir le nombre d’occurrence
de l’élément égal à la valeur "val" dans la liste

Il est possible de modifier un ou plusieurs éléments

d’une liste à partir de son index ou de sa position

→ append():modifie un ou plusieurs éléments d’une liste

Deux listes peuvent être concaténées à l’aide de
→ extend(liste) qui prend un seul argument qui est toujours
une liste et ajoute chacun des éléments de cette liste
à la liste originelle.

→ reverse() « renverser » les

positions des valeurs dans une liste

→pop(index) permet d’enlever

l’élément d’index connu de la liste et
Supprimer un élément d'une liste: de retourner la valeur qui a été
→ del() si on connaît sa positon enlevée
→ remove() si on connaît sa valeur → pop() c'est
(enlève sa première occurrence si la le dernier
valeur est plusieurs fois dans la liste) élément qui
est supprimé
→insert(index,val) ajouter un élément
à une liste
→sum(List) retourne la somme des
éléments de List, si List comporte des
éléments de type int, float, ou complex

→range(entier1,entier2,pas) retourne la liste d’entiers [entier1,......,entier2 -1]

Range dans l'ordre

décroissant:
Tuples: liste non-mutable (elle ne peut, en aucune
manière, être modifiée) est défini de la même manière
qu'une liste sauf que l'ensemble d'éléments est entouré
de parenthèses plutôt que de crochets
→impossible d'enlever ou d'ajouter un élément
→sont d’accès plus rapide que les listes. Si vous définissez
un ensemble de valeurs constantes et que tout ce que vous
allez faire est le lire sans le modifier → utiliser tuple
→ code plus sûr si vous « protégez en écriture » les données qui n'ont pas besoin d'être modifiées. Utiliser
un tuple à la place d'une liste assure que les données sont constantes et le resteront.

Dictionnaire: Permet de définir une relation sous forme de tables entre des clés et des valeurs
forme: { "clé1" : "valeur1" , "clé2" : "valeur2" , … }
→obtenir les clés de l’ensemble des éléments du dictionnaire d.keys(),
→obtenir les valeurs de l’ensemble des éléments du dictionnaire d.values(),
→obtenir les couples clé : valeur de l’ensemble des éléments du dictionnaires d.items()

→possible d’assigner une nouvelle valeur

à une clé existante
→ possible d’ajouter de nouvelles paires
clé:valeur à tout moment
→un dictionnaire n'est pas
ordonné !!
→ les clés ou les valeurs
peuvent aussi être des float, int,...
→ del() permet d'effacer un élément
d'un dictionnaire à partir de sa clé
→clear() efface tout
Fichiers:
→fichiers binaires: nécessitent de connaître le format binaire d'écriture pour être lus
(ex: PDF, JPEG, un exécutable, mp3,mp4)
→fichiers textes: contiennent des caractères uniquement, ouvrables avec un éditeur de texte, contenu
(texte, ponctuation, nombres,...) souvent divisé en lignes.(ex: fichier csv, page web HTML, etc...)

Un fichier fait parti d'une ressource nécessaire d'acquérir avant de s'en servir puis la libérer après usage
(pour un ficher cela se fait en l'ouvrant puis en le fermant)

→ouvrir un fichier: fichier = open("chemin d’accès", [mode]) [mode] peut valoir:

- ’r’ : ouverture en lecture (Read) ;
- ’w’ : ouverture en écriture (Write). Le contenu du fichier est écrasé. Si le fichier n’existe pas, il est créé,
- ’a’ : ouverture en écriture en mode ajout (Append). On écrit à la fin du fichier sans écraser l’ancien
contenu du fichier. Si le fichier n’existe pas, il est créé.
- 'r+' : ouverture en lecture et écriture

→fichier.write("texte") : écrit la chaine de

caractère "texte" dans le fichier,( pour aller à la
ligne il faut que la chaîne se termine par '\n')
→ fichier.writelines(liste): écrit tous les
éléments d'une liste dans le fichier
→fichier.close(): ferme le fichier
→fichier.read(n) :lit n caractères (lit tout
si read() )
→fichier.readline(): lit la ligne suivante
→fichier.readlines(): lit tout le fichier dans
une liste de ligne
→ligne.replace('a','b'): remplace tous les
'a' de la ligne par 'b'
→ligne.replace('a','b',n): remplace les n
premiers 'a' de la
ligne par 'b'

Python fonctionne avec un "curseur" qui se déplace dans le

fichier, les fonctions read commencent la ou se trouve le curseur
→fichier.tell(): donne la position du curseur
position initiale du curseur: fichier.tell() retourne 0
→fichier.seek(): change la position
du curseur

→ligne.split('caractère'): permet de séparer en

plusieurs morceaux une chaine de caractère.
Les chaines obtenues sont mises dans une liste
→ligne.rstrip('str') : recommandée pour supprimer le (ou les) caractère(s) de
fin de ligne situés au bout de chaque ligne (le fichier origine n’est pas modifié)
Problèmes stationnaires (invariant au cours du temps) à 1 dimension (une seule variable)
→ Résolution approchée d’une équation algébrique du type f(x) = 0 (toute équation peut être mise sous la
forme f(x) = 0)
→ Sur un intervalle [a , b], il est impossible de trouver exactement c tel que f(c) =0 ( précision limitée du
codage des nombres en IEE754; erreurs d’arrondis liées aux calculs (avec cumulation des erreurs !))
→ Nécessaire de définir un critère de convergence: une valeur ε telle que |f (c )| < ε (en pratique ε ≈ 10-8)
→ La plupart des méthodes de recherche de racines d’une fonction, se comportent bien si une seule racine
est présente dans l’intervalle d’étude. S’il y en a plusieurs, il convient de restreindre la fonction.
→Séparer la racine ri revient à trouver l'intervalle ]ai ; ai+1[ où cette racine est unique !

Méthode de dichotomie:
1) Diviser l’intervalle [a,b] en deux parts
égales [a,c] et [c,b] avec c milieu de [a,b]
2) Conserver l’intervalle [a,c] ou [c,b]
contenant la racine (phase de test)
3) Y reproduire l’opération, jusqu’à ce que
le critère de convergence soit satisfait.
Le test « tant que ite < itemax » sur le nombre d’itérations ite assure l’arrêt de la méthode même si celle-ci
ne converge pas.

Si la fonction f est définie et continue sur l’intervalle [a, b] et n’admet qu’une seule racine sur l’intervalle
[a, b], alors la méthode de dichotomie converge.

Méthode de Lagrange:
1) Diviser l’intervalle [a,b] en deux parts
[a,c] et [c,b] avec c point d'intersection entre
l'axe des abscisses et la droite passant par
(a,f(a)) et (b,f(b))
2) Conserver l’intervalle [a,c] ou [c,b]
contenant la racine (phase de test)
3) Y reproduire l’opération, jusqu’à ce que
le critère de convergence soit satisfait.

→Equation de la corde:
𝑓(𝑏)−𝑓(𝑎)
f(x) = 𝑦 = 𝑓(𝑎) + (𝑥 − 𝑎) 𝑓(𝑏)−𝑓(𝑎) 𝑎𝑓(𝑏)−𝑏𝑓(𝑎)
𝑏−𝑎 𝑓(𝑎) + (𝑐 − 𝑎) = 0 c = 
𝑏−𝑎 𝑓(𝑏)−𝑓(𝑎)
comme f(c)=0 on a donc:

Convergence non assurée pour cette méthode.

Elle permet cependant dans bien des cas une résolution plus
rapide que la Dichotomie.
 Méthode de Newton:
Si la fonction C1 sur l’intervalle [a,b]:

f(b)=f(a) + f '(a).(b-a) + o(b-a)

donc pour x1 racine:

f(x1) = f(x0) + f '(x0).(x0-x1) = 0 x1 = x0 - f(x0) / f '(x0)

Selon le gradient de la courbe et le choix de x0, la méthode

sera plus ou moins efficace.
La méthode de Newton lorsqu’elle converge est souvent plus
rapide que les méthodes précédentes.

Méthode du Point Fixe:

→ Consiste a transformer f(x) = 0 en une équation équivalente g(x) = x ou g est une fonction auxiliaire
"bien" choisie. c tel que f(c) = 0 est le point fixe de g, tel que g(c) = c. Approcher les zéros de f revient a
approcher les points fixes de g.
→Pour que ça converge, g doit être contractante au voisinage I de c: │g'(x)│ 1, xI , I voisinage de c,
→Dans ce cas on définit la suite xntelle que:
Intégration Numérique:

Interpolation → déterminer une fonction (dans un ensemble donné), passant par un certain nombre de
points imposés. Utile lorsqu’une loi est donnée à partir d’une liste de points et qu’il est nécessaire d’évaluer
le résultat en des points intermédiaires.
Approximation → déterminer une fonction passant "au mieux" à proximité des points donnés. Utile
lorsqu’une loi théorique est recherchée à partir de points de mesure (nombreux, mais entachés de bruits de
mesure).
Interpolation Polynomiale: On cherche, dans une expression du polynôme de degré ≤ n prenant les mêmes
valeurs qu’une fonction donnée en n + 1 points deux à deux distincts donnés.
Soit (x0 ,.... ,xn) n+1 complexes distincts 2 à 2 on cherche la famille de polynômes (L0 ,..., Ln ) tel que:

∀(i, j) ∈ [0,.., n]2 , Li(xj)= δi,j ( 0 si i ≠ j ou 1 si i = j ) ainsi:

(x−xj)
∀(i, j) ∈ [0,.., n]2 , Li(x) = 𝜆 ∏𝑛𝑗≠𝑖(x − xj) et ∀(i, j) ∈ [0,.., n]2 Li(x) = ∏𝑛
𝑗≠𝑖 (xi−xj)
Li(xi) = 1 donc λ = 1⁄∏𝑛 (xi − xj)
𝑗≠𝑖
On a (L0 ,...., Ln) qui constitue une base de Cn[x] (x−xj)
ainsi et au final: P(x) = ∑𝑛𝑖=0 𝑦𝑖 ∏𝑛𝑗≠𝑖 (xi−xj)
P(x) = ∑𝑛𝑖=0 𝜆𝑖 𝐿𝑖(𝑥) P(xi) = yi = λi

Pour 3 points {(x1, y1), (x2, y2), (x3, y3)}

→Pas idéale dès que le nombre de points augmente : le polynôme interpolant peut alors présenter des
oscillations entre les points (phénomène de Runge). L’interpolation peut alors être localement très éloignée
des points. Pour éviter les oscillations sur certaines fonctions: réaliser une interpolation polynomiale de
faible degré mais par morceaux.

→ Interpolation par morceaux de degrés 0:

Entre deux points, la valeur de la fonction vaut une constante égale à
la valeur du point précédent, du point suivant ou encore égale à la moyenne
des valeurs des points encadrant (fonction interpolante non-continue).

→ Interpolation par morceaux de degrés 1:

Loi affine (ax + b) entre deux points successifs, passant par les deux points
(fonction interpolante continue mais pas sa dérivée)

→ Interpolation par morceaux de degrés 2:

Loi parabolique (ax2+ bx+c) est adoptée sur chaque intervalle
regroupant 3 points successifs, passant par les 3 points.
(fonction est continue mais sa dérivée ne l’est pas car elle
présente des discontinuités de la pente entre chaque portion de parabole)

Intégration numérique → intégrer (de façon approchée) une fonction sur un

intervalle borné [a,b ], à partir d’un calcul ou d’une mesure en un nombre fini
de points (avec un pas d'échantillonnage h généralement constant).
L’intégration des polynômes étant très simple, l’opération consiste généralement à construire une
interpolation polynomiale par morceaux (de degré plus ou moins élevé) puis d’intégrer le polynôme sur
chaque morceau. La précision de l’intégration numérique peut s’améliorer en augmentant le nombre de
points n (en diminuant h) ou en augmentant le degré de l’interpolation polynomiale (sous réserve de bonnes
propriétés de continuité de la courbe).
Méthode des rectangles :
→ La fonction à intégrer est interpolée par un polynôme
de degré 0 (à savoir une fonction constante)
σ0 =a < σ1 < ...... < σn-1 < σn =b

→Point d’insertion du rectangles à

gauche:

→Point d’insertion du rectangles à

droite:
→Point d’insertion du rectangles à
droite:

→Point d’insertion du rectangles au

milieu:

Méthode des trapèzes :

→ La fonction à intégrer est interpolée par un polynôme
de degré 1, ce qui conduit à considérer l’aire de trapèzes.
Méthode de Simpson :
→ La fonction à intégrer est interpolée par un polynôme
de degré 2
On peut interpoler f à l’aide des valeurs en:

On a alors localement des paraboles proches de f.

Calcul de l’erreur pour la méthode des rectangles avec point d’insertion à gauche :
Sur l’intervalle élémentaire:
Dérivation Numérique : f définie et continue sur I
un intervalle réel compact
→Equation différentielle ordinaire (ode) d'ordre 1 : (fermé et borné)

Méthode d'Euler:
→ Résoudre le problème de Cauchy:

→ Discrétiser l’espace temps en intervalles: t0 ,t1 ,....., tn-1 , tn = tMAX tk+1 = tk +h

avec h, le pas de temps
→Taylor à l'ordre 1 donne:

→Problème de Cauchy approché:

Euler Explicite:

on prend comme exemple l'ode 1 d'un moteur à cc (réponse à un échelon unitaire)

donc
τ.ω'(t) + ω(t) = ωc ω'(t) = f(ω,t)= (ωc - ω(t))/τ
on pose ωc = 530rad/s et τ = 0.2s

solution exacte:

Il est judicieux de prendre un pas de temps h petit

devant le temps caractéristique τ du problème ... quand
on le connait à l'avance !
→ L'erreur commise à chaque pas
(erreur locale) dépend de la concavité de la
solution car on a négligé dans Taylor :
→Si la dérivée seconde est positive, la méthode numérique
donnera une erreur locale négative. L'erreur est à chaque pas
proportionnelle à h² mais d'amplitude et de signe variable
→ L'erreur cumulée au bout de N pas est la somme des
erreurs algébriques commises à chaque pas, On peut dire
qu'elle est majorée par la somme des valeurs absolues des
erreurs locales

Euler Implicite:
cas pour l'ex du moteur

Le schéma implicite est plus stable que le schéma

explicite au détriment de la rapidité (car il
implique souvent la résolution numérique d’une
équation de type f(x) = 0 par méthode itérative)

ODE d'ordre 2: →Ramener à la résolution d'un système

de deux ODE d'ordre 1

→Il est nécessaire de connaitre les conditions initiales y(0) et v(0)!

exemple du pendule simple:
on pose:

donc:
avec numpy :

Euler Explicite avec Numpy:

Création de tableaux & calcul matriciel:
→ Un tableau est la liste des listes de lignes,
→ Pour atteindre un terme de la matrice A: A[N°ligne][N°colonne]

a et b désignent le même tableau (ce sont des alias). Si on modifie un terme de a, b sera
aussi modifié. Si on affecte à a un nouveau tableau, b ne sera pas modifié. Utiliser: b=a.copy()

Recherche par balayage dans un tableau

Attention au partage de tableau en mémoire ! ex
On peut construire un tableau v = [0, 1, 2],
puis l’utiliser trois fois pour chacune des
lignes de la matrice : m = [v, v, v]
ça donne une matrice (3, 3) mais montre un partage du tableau v
entre les lignes ex: si on affecte un nouvel élément à m[0][1],
c'est toute la colonne qui est modifiée (m[0][1],m[1][1],m[2][1])

Créer une matrice de grande taille:

→ Dimension d'une matrice:

Vérifie qu’un tableau de tableaux m représente bien une matrice de dimensions (n, p)

→ Transposition: →Multiplication de Matrices:

Tableaux Numpy:

→ Tableaux numpy homogènes (constitués d’éléments du même type).

→ Taille des tableaux numpy fixée à la création. On ne peut donc augmenter ou diminuer la taille d’un
tableau comme on le ferait pour une liste. L’empreinte du tableau en mémoire est invariable

→ np.array() former un tableau à partir de listes

→ np.arange(val_initiale, val_finale, pas) retourne un tableau
→ np.zero((m, n)) tableau de 0 de dimensions (m,n)
→ np.ones((m, n)) tableau de 1 de dimensions (m,n)
→ np.eye(n) matrice identité

→ shape : indique le format du tableau, sous la forme du

tuple du nombre d’éléments dans chaque direction
→ alen : donne la première dimension d’un tableau (la taille pour un
vecteur, le nombre de lignes pour une matrice)
→ size : donne le nombre total d’éléments
→ ndim : renvoie le nombre d’indices nécessaires au parcours
du tableau (1 pour un vecteur, 2 pour une matrice)

Lire les valeurs d'une matrice

Si on écrit un entier x dans un tableau de flottants, no problèmo (x est converti en le flottant correspondant).
Mais si on écrit un flottant x dans un tableau d’entiers, alors x est converti en un entier (par troncature, pas
par arrondi !!!) Les tableaux Numpy ont leur « data type » et leur taille (le nombre total d’éléments) sont
fixés lors de leur création. Pour créer la copie d'un tableau d'un data type: astype

Ecrire dans une matrice:

Si a est un tableau numpy, a.reshape(n,p) renvoie

une copie redimensionnée
Suppression de la ligne n → delete(a,n,1)
Suppression de la colonne p→delete(a,p,0)
Ajout d'une ligne → append(a,[[..,...,]],1)
Ajout d'une colonne → append(a,[[..],..[..]],0)

Transposer une matrice → a.transpose() ou a.T

Produit Matriciel → dot(a,b) Calcul produit m.mt :

Calculer pour une matrice carrée: - l'inverse → linalg.inv(a)

- le déterminant → linalg.det(a)
Résoudre le système ax=b → linalg.solve(a,b)
Déterminer le degré de mobilité ou d'hyperstatisme → np.rank(a)
add(a,b) additionne terme à terme les éléments de a et b (autre syntaxe possible : a + b)
subtract(a,b) soustrait terme à terme les éléments de b à ceux de a (autre syntaxe possible : a - b)
multiply(a,b) multiplie terme à terme les éléments de a et b (autre syntaxe possible : a * b)
divide(a,b) quotients (flottants) terme à terme des éléments de a par ceux de b (autre syntaxe : a/b)
Pivot de Gauss:
Le problème de ce programme
c'est que dès qu'une ligne s'annule,
ça plante ! Du coup ça marche que
pour les systèmes ayant autant
de solutions que d'inconnues!
Tris:

● On sélectionne arbitrairement un élément clé de la

Tri Rapide (Quicksort): liste L à trier.

● On crée deux tableaux L1 et L2 qui contiennent

respectivement les éléments de L inférieurs et
supérieurs à clé.

● Par un appel récursif, on trie les tableaux L1 et L2.

On fusionne alors L1, [clé] et L2.

Tri Fusion

Tri Sélection:
Tri par Insertion Dichotomique:

→ But: dans une liste

TRIEE, retourne la
positon d'un terme e (pas
forcement dans la liste)
de sorte que lorsque l'on
injecte e dans cette liste,
elle reste triée !!

Tri à Bulles:

→ consiste à comparer deux à deux et successivement tous les couples consécutifs d'éléments d'une liste
donnée et à les permuter dans le cas où le deuxième est plus petit que le premier. On répète l'opération
jusqu'à ce que la liste soit triée
Graphes G = (S,A) → donnée d'un ensemble fini S de points (= ensemble des sommets)
et d'un ensemble A de liens entre ces points (= ensemble des arêtes)
.Si {u,v} ∈ A est une arête de G (souvent noté u – v), les sommets u et v sont adjacents.
.Ordre d'un graphe → cardinal de son ensemble de sommets.
.Graphe complet d'ordre n (noté Kn) → l'unique graphe non orienté tel que toute paire de sommets
(distincts) soit reliée.

.Graphe pondéré (ou valué) → graphe (orienté ou non) où les arêtes

sont affectées d'un poids qui est un nombre réel. On considérera
pour certains algorithmes le seul cas où le poids affecté est strictement
positif. ( exemple des situations de distances dans un réseau routier)

.Chemin → suite consécutive d'arcs dans un graphe orienté.

(Dans le cas d'un graphe non orienté on parle de chaîne.)
.Cycle → chemin (ou chaîne) pour lequel le sommet de départ et le sommet d'arrivé sont identiques.
.Pour un graphe non pondéré: -Longueur d'une chaîne = son nombre d'arêtes (si graphe non orienté)
-Longueur d'un chemin = son nombre d'arcs (si graphe orienté)
.Pour un graphe pondéré: -Longueur d'une chaîne = somme du poids de ses arêtes (si graphe non orienté)
-Longueur d'un chemin = somme du poids de ses arcs (si graphe orienté)
.Un graphe est connexe s'il existe un chemin entre tout couple de sommets.
.Algorithme de parcours en profondeur = consiste à déterminer
s'il existe un chemin d'un sommet à un autre et donc tester s'il est
connexe ou non. Principe = partir d'un sommet s et de le marquer puis
d'appeler récursivement la fonction sur tous les sommets non marqués
qui sont reliés à s. Nous utiliserons une liste L, initialement vide, qui
correspond aux sommets marqués (déjà visités).
.Un graphe est Hamiltonien s'il a au moins un cycle passant par tous
les sommets exactement une fois (cycle Hamiltonien).

Soit G=(S,A) un graphe non pondéré. Matrice d'adjacence M = la matrice carrée d'ordre card(S), dont
chaque élément Mij est égal à 0 s’il n'y a pas de d'arête liant i à j et 1 s’il existe une arête reliant i à j.
Si G est non orienté, sa matrice d'adjacence est symétrique.
Dans le cas d'un graphe pondéré, Mij est égal au poids de l'arête liant i à j.
Piles:
-Un objet = concept, idée ou toute entité du monde physique ou virtuel.
-Un conteneur = objet permettant de stocker d'autres objets (non forcément distincts).
-Une structure de données = conteneur dynamique (i.e. de longueur modifiable) destinée à organiser des
données informatiques pour maximiser l'efficacité de certaines opérations
Un conteneur S peut être étudié selon trois points de vue :
- l'accès, c'est-à-dire la manière d'accéder aux éléments du conteneur.
- le stockage, c'est-à-dire la manière de stocker les éléments du conteneur ;
- le parcours, c'est-à-dire la manière de parcourir les éléments du conteneur.

Soit E un ensemble non vide. Une pile p d'éléments de E est une structure de données qui met en œuvre le
principe : dernier entré, premier sorti ou LIFO (Last - In - First - Out)
Une pile P est :
- soit vide (de profondeur 0) ;
- soit une pile de profondeur n > 1, de la forme p = (q,s) où s est un élément de E, appelé sommet de p
et q une pile de profondeur n-1, appelé queue de p.

Opérations primitives :