las9 info for CNC

V 1.0

Hamza BA-MOHAMMED, ex-MP & AI student @ ENSIAS

if any mistakes are spotted, please contact me at: [email protected]

31 May 2022

Disclaimer
HADA MASHI COURS COMPLET DYAL INFO POUR PREPA, O HADSHI LI KAYN
HNA GHER BASH T7AREB ZERO ILA KNTI ZR9 F INFO, O Y9ED YNF3EK BASH
DIR "QUICK REVIEW" 9BL L’EPREUVE ILA KNTI DEJA SHAD INFO MZN. 7TIMAL
ANNA AU MOINS 1 POINT MN LES POINTS ABORDES ICI YT7ET F L’EPREUVE
KBIR, MAIS N’EMPECHE Y9D YKOUN DAKSHI F L’EPREUVE PLUS ELABORES.
THUS, USE THIS LAS9 ON YOUR OWN REPONSIBILITY
AND GOOD LUCK < 3.

Table des matières

1 Python 3 : les bases 2
1.1 A savoir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 les types in-built de variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 l’écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 La lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.5 Les opérations logiques et arithmétiques . . . . . . . . . . . . . . . . . . . . . 3
1.6 Les structures conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.7 Les structures itératives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.8 break et continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 Structures de données 5
2.1 lists (les listes) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 tuples (les n-uplets) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 sets (les ensembles) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.4 dictionaries (les dictionnaires) . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

3 Algorithmique 6
3.1 fonction et procédure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2 fonction récursive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.3 la complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.4 conversion de la base 10 à la base 2 O(log(n)) . . . . . . . . . . . . . . . . . . 8
3.5 recherche linéaire O(n) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.6 recherche binaire (dichotomie) O(log(n)) . . . . . . . . . . . . . . . . . . . . . 8
√
3.7 vérification de primalité d’un nombre O( n) . . . . . . . . . . . . . . . . . . 8
3.8 multiplication matricielle O(n3 ) . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.9 inversement d’une chaîne de caractère O(n) . . . . . . . . . . . . . . . . . . . 9
3.10 les algo de tri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.10.1 bulle O(n2 ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

1
 3.10.2 insertion O(n2 ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.10.3 selection O(n2 ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.10.4 fusion O(n.log(n)) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.11 calcul d’intégrales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.11.1 méthode des rectangles O(n) . . . . . . . . . . . . . . . . . . . . . . . 10
3.11.2 méthode des trapèzes O(n) . . . . . . . . . . . . . . . . . . . . . . . . 10
3.11.3 méthode de Monte Carlo O(n) . . . . . . . . . . . . . . . . . . . . . . 10
3.12 recherche de zéro d’une fonction analytique . . . . . . . . . . . . . . . . . . . 11
3.12.1 méthode dichotomie (principe du TVI) . . . . . . . . . . . . . . . . . . 11
3.12.2 méthode de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.13 méthode d’Euler O(T /h) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4 Python 3 : les librairies 12

4.1 numpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.2 scipy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.3 matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.4 math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.5 random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

5 SQL 14
5.1 A savoir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
5.2 Gestion de table SQL existante . . . . . . . . . . . . . . . . . . . . . . . . . . 14
5.3 Création et suppression de base de donnée SQL . . . . . . . . . . . . . . . . . 15

1 Python 3 : les bases

1.1 A savoir
Quelques points importants à propos de Python et la rédaction du code :
— Python est un langage de programmation interprété et non pas compilé comme
le langage C. Le code est "interprété" ligne par ligne, et donc le code crash sur la
première ligne présentant une erreur syntaxique ou sémantique.
— Python est en moyenne plus lent que les autres langages reconnus, mais il est riche
en librairies Open Source et il nécessite moins de lignes de code et de formalisme par
rapport aux autres.
— L’indentation (l’espace entre le début d’une ligne et la marge) est très importante en
Python : elle précise la structure logique du code (l’ordre des blocks, etc...). Comme
vous écrivez sur du papier sans carreaux le jour du concours, veillez à préciser
l’indentation avec des traits verticaux et étroits à l’aide d’une règle. (ma
t3gzsh sinon lprof aydir "3ino mizano" o atwli m7kom b la patience o la qualité de
vision du correcteur hh)
— dernière chose : PAS DE RATURES EN CODE. (Soit t3awedo kaml, soit blanco
ila 3ndk et s’il est permis)

1.2 les types in-built de variable

— int : pour les entiers relatifs (positifs ou négatifs). Le type int (integer) sur Python
3 n’a pas de limite et peut supporter des nombres très très grands (au delà de 50!).
— float : pour les nombres à virgules (les réels). Faites attention aux imprécisions de
calculs lors de la division des réels !
— str : pour les chaînes de caractères (même celles vides ou qui contient 1 seul caractère)

2
 1.3 l’écriture
Pour afficher un message :
 
1 print("mon texte entre guillemets")
2 print(variable) # la cas d’une variable
3 print(var1,var2) # plusieurs variables
4 print("text",var,42) # texts et nombres et variables..
 
la fonction print() effectue un retour à la ligne par défaut. Pour changer ce comportement,
on modifie le paramètre end dans la fonction :
 
1 print(1, end = " ") # espace a la fin
2 print(2, end = "") # rien a la fin
3 print(3) # retour a la ligne par defaut
4 print(4)
 
Output :
1 23
4

1.4 La lecture
Pour lire une variable depuis l’entrée de l’utilisateur :
 
1 x = input() # lit l’entree et le stock dans x
2 y = input("message") # affiche le message, lit l’entree
3 # et le stock dans y
 
la fonction input() renvoie une variable de type chaîne de caractères (string) par défaut.
Pour changer de type de données, on utilise les fonctions :
 
1 n = int(input()) # n un entier relatif
2 x = float(input()) # x un reel
 
On note que int(x) renvoie la partie avant la virgule de x. (e.i : int(3.6) renvoie 3)

1.5 Les opérations logiques et arithmétiques

comme en maths, on peut sommer, soustraire, diviser et multiplier les int et les float.
On ajoute 2 opérateurs pour la division des int : si a = b.k + r, alors r = a % b et
k = a // b. (notation mathématique)
Pour les str, on peut les concaténer avec +, et on peut doubler les occurences d’un str en
le multipliant par un entier.
 
1 s = "salut"
2 x = "etudiant"
3 d = s+x # d contient "salutetudiant"
4 e = s*3 # e contient "salutsalutsalut"
 
NB : les str sont immuables : ne peut pas être modifié après déclaration (ma t9edsh tbdl
le contenu dyal une case west dik string, par exemple "salut" tredha "palut", par contre
t9ed tzidliha other elements, f7al "salut" tredha "salut les amis"..).
Les opérateurs logiques sont and or xor not, leurs utilisation est assez intuitive : ils relient
des propositions logiques comme en logique mathématiques (p ET q , p OU q ...)

1.6 Les structures conditionnelles

3
  
1 if cond 1 :
2 # bloc 1
3 elif cond 2 :
4 # bloc 2
5 elif cond 3 :
6 # bloc 3
7 .....
8 else :
9 # bloc n
 

1.7 Les structures itératives

Il existe 2 type de boucles en Python, le for et le while.
Ci-dessous leurs syntaxes et comment passer d’une forme à l’autre :
 
1 for i in range(a, b, c): # i prend toutes les valeurs entieres
2 # des instructions.. dans [a,b[ en sautant par c
3 while condition : # tant que la condition est valide
4 # des instructions.. la boucle est executee
 
Dans le case de while, il faut toujours vérifier que la condition sera fausse après un certain
nombre d’itérations, sinon la boucle tournera à l’infini.
Pour le passage, les 2 boucles suivantes sont équivalentes :
 
1 for i in range(a,b,c):
2 # des instructions
3 ##########################
4 k = a
5 while k < b :
6 # des instructions
7 k = k + c # ou k += c
 

1.8 break et continue

Il est parfois utile de savoir les 2 commandes break et continue dans les boucles :
— break : sert à arrêter la boucle en cours
— continue : sert à sauter le reste d’une itération sans arrêter la boucle
 
1 for i in range(6):
2 if i == 3 : break
3 print(i)
 
output :
0
1
2
 
1 for i in range(6):
2 if i == 3 : continue
3 print(i)
 
output :
0
1
2
4
5

4
 2 Structures de données
Ici, on se limitera aux 4 structures principales en python (listes, ensemble, tuple et
dictionnaire) avec pour chacun : ses caractéristiques et cas d’utilisation, ses méthodes prin-
cipales (initialisation, ajout/suppression élément, taille, accès et parcours).

2.1 lists (les listes)

— nature : muable (peut être modifiée)
— accès aux élements : par index (de 0 a la taille de la liste - 1)
— cas d’utilisation : outil standard de stockage d’un grand nombre de variables. Utilisé
dans les concours le contexte de matrices.
 
1 # initialisation
2 L = list() # ou L = []
3 # ajouter element x
4 L.append(x) # ou L += x
5 # supprimer l’element d’index i
6 del(L[i])
7 # acces element d’index i
8 print(L[i])
9 # parcours d’elements
10 for i in range(len(L)): # par index
11 # blabla L[i]
12 for e in L: # par valeurs
13 # blabla e
 
NB : si A est une liste, A contient seulement l’adresse de A dans la mémoire de
stockage. le faite de faire B = A ne fait que créer une copie de référence : A et B pointent
à la même liste. Pour créer une copie de A, il suffit de faire comme suit :
 
1 B = list(A)
 
NB 2 : la méthode de "slicing" consiste à prendre une sous-partie [a:b:c] d’une liste L,
avec a l’index de départ, b − 1 l’index de fin et c le pas (comme dans range()..). Elle est
applicable aussi pour les string.
NB 3 : il existe certaines fonctions utiles pour les listes comme max(L) min(L) sum(L) qui
renvoient respectivement le max, le min et la somme d’une listes sans utilisation de boucle
(juste pour alléger le code, en matière de vitesse d’exécution ça revient au même)

2.2 tuples (les n-uplets)

En bref, ce n’est qu’une liste immuable (qui ne peut être modifiée après initialisation).
Rarement utilisé, sauf lorsqu’on traite des éléments statiques (par exemple, coordonnées
(x, y, z) d’un point fixe dans l’espace..). Il contient au moins 1 élément, mais en général il
est initialisé par 2 éléments.
 
1 # initialisation
2 t = (3,4)
3 # ajouter/supprimer/acceder element : impossible
4 # acces element
5 print(t[i])
6 # parcours d’elements : comme les listes..
 

2.3 sets (les ensembles)

— nature : muable (peut être modifiée)

5
 — accès aux éléments : par parcours complet sur tous les éléments
— cas d’utilisation : utile pour l’implémentation des ensemble mathématiques en in-
formatique. Souvent utilisé pour l’élimination d’élément dupliqué dans une autre
structure (un ensemble n’admet pas de répétition)
 
1 #initialisation
2 s = set() # ensemble vide
3 s = {5,2,6,"rdt",2.68}
4 #ajouter element x
5 s.add(x)
6 #supprimer element x
7 s.discard(x) # si x n’existe pas elle ne fait rien
8 #acces element : impossible
9 #parcours d’elements
10 for e in s: # par element
11 # blabla
 
NB : ils existent des méthodes pour simuler les opérations sur les ensembles qui sont assez
intuitives.
 
1 s1.union(s2) # equivalent a s1 | s2
2 s1.intersection(s2) # equivalent a s1 & s2
3 s1.difference(s2) # equivalent a s1 - s2
4 s1.symmetric_difference(s2) # equivalent a s1 ^ s2
5 s1.isdisjoint(s2) # renvoie True ou False
 

2.4 dictionaries (les dictionnaires)

— nature : muable (peut être modifiée)
— accès aux éléments : par clé
— cas d’utilisation : lorsque les éléments sont indexés avec des clés autres que 0,1,2,...
 
1 #initialisation
2 d = dict() # ou d = { }
3 #ajouter element de cle "c" et de valeur k ou changer la valeur de la cle "c"
4 d[c] = k
5 #supprimer element de cle "c"
6 d.pop(c) # si "c" n’existe pas dans d, pop() renvoie une erreur
7 #acces element : par cle
8 print(d[c])
9 #parcours d’elements
10 for c in d.keys(): # par cle
11 # blabla
12 for k in d.values(): # par valeur
13 # blabla
14 for c,k in d.items() # par cle et valeur
15 # blabla
 
NB : les éléments d.items(), d.values() et d.keys() sont des méthodes qui renvoient
respectivement une liste des paires (clé,valeur), une liste des valeurs, et une liste des clés.
NB générale : pour toutes les structures vues, et aussi pour les string, on utilise len(S)
pour avoir la taille de la structure S.

3 Algorithmique
Un algorithme est une succession d’instructions que suit la machine (ou même l’homme..)
pour arriver à des données de sortie (output) en partant de certains données d’entrée (input).

6
 Kayn bzaf d les algo f prepa, ci-dessous on en cite les plus "classiques", et avant, on passe
rapidement sur les notions : fonction, procédure, récursivité et complexité temporelle.

3.1 fonction et procédure

Comme en maths, une fonction est une méthode qui pour un input elle réalise des
instructions puis renvoie un output. Une procédure par contre, réalise des instructions mais
ne renvoie aucun output. Il peut exister des procédures sans input aussi (ex : une procédure
qui affiche un message constant quand elle est appelée n’a pas besoin d’input). Ci-dessous
la syntaxe générale :
 
1 def fonction(param1, param2, param3, ...., paramN):
2 #blabla
3 return resulat1, resultat2,...,resultatM
4
5 def procedure(param1,...paramN):
6 #blabla
 

3.2 fonction récursive

C’est tout simplement une fonction (ou procédure) qui s’appelle soit-même lors de sont
exécution. Ce type de fonction contient nécessairement 2 éléments :
 
1 def fct_iterative(N):
2 if cond : return "X" # condition d’arret
3 #bla bla
4 return fct_iterative(N-1) #appel recursif
 
NB 1 : la fonction récursive peut contenir plusieurs appels récursifs. En général, il est
commun de demande d’exprimer une fonction récursive itérativement (avec des boucles) ou
l’inverse. Sans la condition d’arrêt, la fonction récursive ne s’arrêtera jamais (boucle infinie).
NB 2 : si on vous demande de comparer la version itérative et celle récursive d’une fonction,
la version itérative est en général plus performante (en matière de temps et de mémoire)
que celle récursive, avec un décalage relativement faible.

3.3 la complexité
Cette notion reflète la performance d’un algorithme et elle est divisée en 2 catégories :
temporelle et spatiale. Pour des raisons de "las9", on peut se rappeler que la complexité
temporelle d’un algorithme est le nombre d’opérations effectuées au pire des cas en fonction
de la taille de l’input, tandis que celle spatiale est l’espace mémoire utilisée au pire des
cas en fonction de la taille de l’input. On utilise la notation mathématique grand O pour
exprimer le type de complexité qui peut être :
1. constante O(1) : la vitesse est indépendante de la taille de l’input
2. logarithmique O(log(n)) : en général, c’est la complexité des algo qui procèdent
par la division de la taille de l’input par 2 à chaque itération (ex : la dichotomie)
3. linéaire O(n) : effectue N opérations pour un input de taille N (ex : recherche
linéaire)
√ √
4. racine carrée O( n) : effectue ∼ n opérations (ex : vérification (optimale) si un
nombre est premier)
5. quasi-linéaire O(n.log(n)) : mélange des 2 derniers algorithmes (ex : tri fusion)
6. polynomiale O(nk ) : contient en général des boucles imbriquées (ex : produit ma-
triciel n × n (O(n3 )) ou somme matricielle n × n (O(n2 )))

7
 7. exponentielle O(k n ) : contient en général une récursivité (ex : génération de tous
les sous ensembles d’un ensemble de taille n (il existe exactement 2n ensembles))
8. factorielle O(n!) : rarement affronté.. (ex : génération de toutes les permutations
d’un ensemble de taille n)
Les complexités spatiales sont exprimées de la même façon, mais dépendent plutôt de l’espace
occupé par les variables de l’algo et non de sa vitesse d’exécution. En général, la complexité
spatiale et celle temporelle sont inversement proportionnelle (car on a tendance à uti-
liser plus d’espace pour réduire les calculs et donc le temps d’exécution en réutilisant les
résultats stockés..)

Encore, pour des raisons de "las9", le "background mathématique" de la plupart des al-
gorithmes présentés par la suite a été omis. Toutefois, des commentaires "light" ont été
introduit au sein des codes afin d’éclaircir un peu l’image..

3.4 conversion de la base 10 à la base 2 O(log(n))

 
1 def base2(n): # base sur la division euclidienne
2 q = -1
3 res = str()
4 while q != 0:
5 q = n // 2
6 r = n % 2
7 res = str(r) + res
8 n = q
9 return res
 

3.5 recherche linéaire O(n)

 
1 def search(L, k):
2 for i in range(len(L)):
3 if L[i] == k: return i
4 return -1 # cad element introuvable
 

3.6 recherche binaire (dichotomie) O(log(n))

 
1 def BS(tab, target):
2 left = 0
3 right = len(tab) - 1
4 while right >= left :
5 mid = int((right+left)/2)
6 if tab[mid] == target : return mid
7 elif tab[mid] > target :
8 right = mid + 1
9 BS(tab[left : right], target)
10 else :
11 left = mid - 1
12 BS(tab[left : right], target)
13 return -1 # element introuvable
 

√
3.7 vérification de primalité d’un nombre O( n)

8
  
1 import math
2 def isprime(n):
3 if abs(n) < 2 : return False # si |n| < 2, n’est pas premier
4 for i in range(2,int(math.sqrt(n)) + 1):
5 if n % 2 : return False # si un nombre <= sqrt(n) divise n, n n’est pas premier
6 return True
 

3.8 multiplication matricielle O(n3 )

 
1 def produitMat(A,B): # retourne A.B si possible
2 n = len(A) # nbr lignes A
3 p = len(A[O]) # nbr colonnes A
4 m = len(B) # nbr lignes B
5 q = len(B[0]) # nbr colonnes B
6 if p != m : return False # incompatibilite des tailles de matrices
7 C = list()
8 for i in range(n):
9 ligne = list()
10 for j in range(q):
11 case = 0
12 for k in range(p):
13 case += A[i][k] * B[k][j]
14 ligne.append(case)
15 C.append(ligne)
16 return C
 

3.9 inversement d’une chaîne de caractère O(n)

 
1 def inverser(s):
2 return s[::-1] # le pas -1 parcourt la chaine dans le sens inverse..
 

3.10 les algo de tri

3.10.1 bulle O(n2 )
 
1 def bulle(T):
2 for i in range(len(T) - 1, 0, -1):
3 for j in range(i):
4 if T[j] > T[j + 1]:
5 T[j + 1], T[j] = T[j], T[j + 1] # cette ligne effectue un "swap" de T[j + 1] et T[j]
sans utilisation explicite d’une 3eme variable
6 return T
 

3.10.2 insertion O(n2 )

 
1 def tri_insertion(L):
2 N = len(L)
3 for n in range(1,N):
4 cle = L[n]
5 j = n-1
6 while j>=0 and L[j] > cle:
7 L[j+1] = L[j] # decalage
8 j = j-1
9 L[j+1] = cle
 

9
 3.10.3 selection O(n2 )
 
1 def selection(tab):
2 for i in range(0,len(tab)-1):
3 min = i
4 for j in range(i+1,len(tab)):
5 if tab[j] < tab[min]: min = j
6 if (min != i):
7 tab[i], tab[min] = tab[min], tab[i]
 

3.10.4 fusion O(n.log(n))

 
1 def fusion(A,B):
2 if len(A) == 0:
3 return B
4 elif len(B) == 0:
5 return A
6 elif A[0] <= B[0]:
7 return [A[0]] + fusion(A[1:], B)
8 else:
9 return [B[0]] + fusion(A, B[1:])
10
11 def triFusion(L):
12 if len(L) == 1:
13 return L
14 else:
15 return fusion(triFusion(L[:len(L)//2]), triFusion(L[len(L)//2:]) )
 

3.11 calcul d’intégrales

3.11.1 méthode des rectangles O(n)
 
1 def integrale(f, a, b, n): # l integrale In de f sur [a, b] avec n rectangles
2 somme = 0
3 h = float(b-a) / n
4 x = a
5 for i in range(0, n + 1):
6 somme += f(x) * h
7 x += h
8 return somme
 

3.11.2 méthode des trapèzes O(n)

 
1 def trapeze(f, a, b, n): # l integrale In de f sur [a, b] avec n trapezes
2 h = ( b - a ) / n
3 s = 0.5 * ( f( a ) + f( b ) )
4 for i in range( 1, n ):
5 s += f(a + h*i)
6 return s * h
 

3.11.3 méthode de Monte Carlo O(n)

10
  
1 import random
2 def integrale_MC(f, a, b, n): # l integrale In de f sur [a, b] avec n echantillons
3 somme = 0
4 for i in range(0, n):
5 x = random.uniform(a, b)
6 somme += f(x)
7 return somme / n
 

3.12 recherche de zéro d’une fonction analytique

3.12.1 méthode dichotomie (principe du TVI)
 
1 def dicho(f, a, b, eps=0.000001):
2 # Recherche un zero d’une fonction f sur un intervalle [a,b]. eps est la precision souhaitee (par
defaut, 1/1000000)
3 # f(a) et f(b) doivent etre de signes contraires
4 if f(a)*f(b) > 0:
5 return None # aucun zero dans l’intervalle
6 while abs(b-a) > eps:
7 c = (a+b)/2
8 if f(a)*f(c) > 0:
9 a=c
10 else:
11 b=c
12 return a, b
 

3.12.2 méthode de Newton

 
1 def Newton(f, fp, x, epsilon = 0.000001): # fp est la derivee de f, x est un point de depart
quelconque
2 n = 0
3 dif = 2 * epsilon
4 while dif > epsilon : # epsilon est la precision de recherche
5 x1 = x - (f(x) / fp(x))
6 dif = abs(x1 - x)
7 x = x1
8 n = n+1
9 return x # le zero de f a epsilon pres
 
NB : la complexité de la méthode de Newton dépend de la vitesse de convergence de la
f (xn )
suite (xn − )n .
f p(xn )

3.13 méthode d’Euler O(T /h)

Un système différentiel est défini dans une fonction python de la forme systeme(Y,t)
où Y est un tableau contenant les variables. La fonction euler(systeme,Yi,T,h) effectue
l’intégration numérique sur l’intervalle [0, T ]. La condition initiale est Yi. Le pas de temps
est h. La fonction stocke les valeurs de Y sous forme d’une liste (construite comme une pile).
Une liste contenant le temps est aussi générée.
 
1 def euler(systeme,Yi,T,h):
2 Y = Yi
3 t = 0.0
4 liste_y = [Y]
5 liste_t = [t]

11
6 while t < T:
7 Y = Yn + h*systeme(Y,t)
8 t += h
9 liste_y.append(Y)
10 liste_t.append(t)
11 return liste_y,liste_t # renvoit 2 listes: les yi et les ti
 

4 Python 3 : les librairies

En ingénierie numérique, on fait appel à 5 librairies :
— numpy : pour l’implémentation et la gestion rapide des matrices
— scipy : pour l’intégration et d’autres opérations scientifiques optimisées en temps
— matplotlib : pour le tracée des graphes
— math : pour les fonctions mathématiques usuelles (trigonométrie, exponentiel, loga-
rithme, racine carrée, partie fractionnelle...)
— random : pour la génération d’éléments pseudo-aléatoires
On verra par la suite les plus importantes méthodes de chacune et un exemple de code
basique pour le tracé d’une courbe.

4.1 numpy
 
1 import numpy as np # appel de la librairie
2
3 A = np.array([3,4,1][5,7,2][9,6,8]) # A est une matrice 3 x 3
4 print(A.shape()) # renvoie les dimensions de A = (2,3)
5 O = np.zeros((13,7)) # O est une matrice nulle de taille 13 x 7
6 I = np.ones((5,8)) # I est une matrice remplie de 1 de taille 5 x 8
7 B = A.T # B est la transposee de A
8 C = A + B # la somme matricielle
9 D = dot(A,B) # D est le produit matriciel de A et B
10 E = A * 3 # pour tt i,j , E[i][j] = 3 * A[i][j]
11 G = A**2 # pour tt i,j , G[i][j] = A[i][j] * A[i][j] (ce n’est pas le produit matriciel A.A !)
12 print( np.linalg.norm(A) ) # renvoie la norme standard de A (scalaire)
13 f = np.linalg.det(A) # renvoie le determinant de A (scalaire)
14 T = np.linspace(a,b,n) # renvoie une liste de n reels uniformement distribues entre a et b (inclus)
 

4.2 scipy
ci dessous un exemple de résolution du système différentiel de second ordre :
θ′ (t) = ω(t)
ω ′ (t) = −b ∗ ω(t) − c ∗ sin(θ(t))
 
1 import numpy as np
2 import scipy as sp # appel des librairies
3 #ci-dessous un exemple depuis le site de scipy
4

5 def f(y, t): # y est un vecteur de 2 elements (liste)

6 theta, omega = y
7 dydt = [omega, -0.25*omega - 5.0*np.sin(theta)]
8 return dydt
9
10 y0 = [np.pi - 0.1, 0.0] # vecteur condition initiale
11 t = np.linspace(0, 10, 101) # liste de 101 moments ti entre 0 et 10
12
13 sol = sp.integrate.odeint(f, y0, t) # renvoie une liste de vecteurs (omega_i, theta_i) solution du
systeme d’equations differentiel de fonction f et de condition initiale y0 pour les ti dan t
 

12
 4.3 matplotlib
 
1 import numpy as np
2 import matplotlib.pyplot as plt # importation des librairies
3
4 def carre(x): # fonction x^2
5 return x**2
6 X = np.linspace(0,100,100) # listes de 100 x entre 0 et 100
7 Y = f(X) # listes des f(x)
8
9 plt.plot(X,Y) # trace la fonction avec l’aide des points (x_i,y_i)
10 plt.show() # affiche le resultat en dessous
 

4.4 math
Rien de spécial dans cette librairie, la plupart des fonctions sont intuitives. Toutefois, on
en cite quelques unes :
 
1 import math # appel de la librairie
2

3 x = math.cos(4) # en radian
4 y = math.sin(34)
5 z = math.atan(8) # fonction arctan
6 u = math.log(2) # fonction logarithme Neperien (ln)
7 u2 = math.log2(4) # fonction logarithme a base 2
8 u10 = math.log10(739) # fonction logarithme a base 10
9 v = math.exp(49) # fonction exponentiel
10 w = math.sqrt(7) # fonction racine carree
11 a = math.ceil(3.4) # renvoie la partie entiere avec exces (4 dans ce cas)
12 b = math.floor(3.4) # renvoie la partie entiere avec defaut (3 dans ce cas)

13
  

4.5 random
 
1 import random as rd # appel de librairie
2
3 A = [2,6,1,9,4]
4 print( rd.choice(A) ) # renvoie une valeur aleatoire d’une liste, ensemble ou chaine de caracteres
5 print( rd.randint(5,15) ) # renvoie un entier aleatoire entre 5 et 15
6 print( rd.uniform(3,7) ) # renvoie un reel aleatoire entre 3 et 7 (inclus)
7 print( rd.random() ) # renvoie un reel aleatoire entre 0 et 1
 

5 SQL
Bon, SQL mashi mon point fort mais an7awl n3ti fih quelques trucs..

5.1 A savoir
— SQL est un langage de gestion des bases de données relationnelles. Il est basé sur
l’algèbre relationnelle.
— chaque commande SQL se termine par un " ;"
— une base de données peut être composée de plusieurs tables. Chaque table est un
tableau de certains colonnes et certaines lignes. Chaque table possède une clé pri-
maire qui est la colonne par laquelle on peut distinguer entre les lignes (en général,
c’est la colonne qui n’admet pas de duplicata, comme la colonne ID)
— certaines tables possèdent une clé primaire composée de plusieurs colonnes, et cer-
taines tables possèdent une ou des clés étrangères (c-à-d des colonnes qui appar-
tiennent à d’autres tables)

5.2 Gestion de table SQL existante

On considère dans ce qui suit une table "cpgeX" composée de 4 colonnes : ID (un
entier unique auto incrémenté), nomEleve (chaine de caractères), moyenne (un réel entre
0 et 20) et filiere. On suppose qu’elle contient 200 lignes, chaque ligne représente un élève.
Nous allons effectuer quelques requêtes SQL sur cette base de données :
 
1 SELECT nomEleve FROM cpgeX; -- affiche la colonne nomEleve
2 SELECT nomEleve, filiere FROM cpgeX; -- affiche les colonnes nomEleve et filiere
3 SELECT * FROM cpgeX; -- affiche toutes les colonnes
4 SELECT DISTINCT nomEleve FROM cpgeX; -- affiche la colonne nomEleve sans duplicata
5 SELECT COUNT(DISTINCT filiere) FROM cpgeX; -- renvoie le nombre de filieres distinctes dans la table
6 SELECT nomEleve FROM cpgeX WHERE filiere = "TSI"; -- affiche les noms d’eleves dans la filiere TSI
7 SELECT nomEleve FROM cpgeX WHERE (filiere = "TSI" OR filiere = "MP"); -- affiche les noms d’eleves
dans les filieres TSI et MP
8 SELECT nomEleve FROM cpgeX WHERE moyenne BETWEEN 10 AND 12; -- affiche les eleves dont la moyenne
est entre 10 et 12
9 SELECT nomEleve FROM cpgeX WHERE NOT (filiere = "MP"); -- affiche les noms d’eleves hors de la
filiere MP
10 SELECT * FROM cpgeX ORDER BY moyenne; -- affiche toutes les colonnes et lignes ordonnees par moyenne
11 SELECT * FROM cpgeX ORDER BY moyenne DESC; -- affiche toutes les colonnes et lignes ordonnees par
moyenne en ordre decroissant
12 SELECT * FROM cpgeX ORDER BY moyenne, nomEleve; -- affiche toutes les colonnes et lignes ordonnees
par moyenne, puis par nom en cas d’egalite de moyennes
13 SELECT * FROM cpgeX WHERE moyenne IS NULL; -- affiche les eleves qui n’ont pas une moyenne dans la
table (champs vide)

14
14
15 INSERT INTO cpgeX(nomEleve, moyenne, filiere) VALUES ("adil", 16.38, PSI); -- insert une nouvelle
ligne a la table
16
17 UPDATE cpgeX SET moyenne = 9.34 WHERE ID = 78; -- change la moyenne de l’eleve numero 78 dans la
table
18 UPDATE cpgeX SET moyenne = 10; -- change la moyenne de chaque eleve a 10
19
20 DELETE FROM cpgeX WHERE nomEleve = ’Hamza’; -- supprime tous les eleves dont le nom est "Hamza"
21 DELETE FROM cpgeX; -- supprime toutes les lignes sans supprimer la table
22
23 SELECT MAX(moyenne), MIN(moyenne), AVG(moyenne) FROM cpgeX WHERE filiere = ’MP’; -- renvoie la plus
grande moyenne, la plus petite moyenne, et la moyenne des moyennes obtenue par les eleves MP
24 SELECT COUNT(*) FROM cpgeX WHERE filiere = ’PSI’; -- renvoie le nombre d’eleve en filiere PSI
25 SELECT nomEleve FROM cpgeX WHERE nomEleve LIKE ’Abd%’; -- renvoie tous les noms d’eleves qui
commencent par "Abd" (Abdellah, Abdelhamid..)
26 SELECT nomEleve FROM cpgeX WHERE nomEleve LIKE ’S____’; -- renvoie tous les noms d’eleves qui
commencent par S et contiennent exactement 4 lettres apres (comme Samir..)
27 SELECT moyenne AS m FROM cpgeX AS c WHERE m > 4; -- des alias comme dans Python pour alleger le code
, la requete afiche toutes les moyennes superieures a 4 strictement
 

5.3 Création et suppression de base de donnée SQL

Maintenant, on suppose que la base de données n’est pas encore crée et qu’elle contient
2 tables : cpgeX et cpgeY. Nous allons voir comment créer cette BD, puis ajouter et enlever
certaines colonnes :
 
1 CREATE DATABASE ma_base; -- cree une BD vide
2 CREATE TABLE cpgeX( -- creation de table cpgeX
3 ID int AUTO_INCREMENT, -- colonne type entier et auto incrementee
4 nomEleve varchar(50), -- colonne de type chaine de caractere de longueur 50
5 moyenne float, -- colonne de type nombre reel
6 filiere varchar(4),
7 PRIMARY KEY (ID) -- la colonne ID est definie comme cle primaire de cpgeX
8 );
9 CREATE TABLE cpgeY( -- creation de table cpgeY
10 ID int AUTO_INCREMENT,
11 nomEleve varchar(50),
12 moyenne float,
13 filiere varchar(4),
14 PRIMARY KEY (ID) -- remarquez qu il n y a pas de virgule apres la derniere colonne
15 );
16
17 ALTER TABLE cpgeX ADD absence int; -- ajout d une colonne absence a la table cpgeX de type entier
18 ALTER TABLE cpgeY DROP COLUMN moyenne; -- suppression de la moyenne de la table cpgeY
19
20 DROP TABLE cpgeX; -- suppression de la table cpgeX
21 DROP DATABASE ma_base; -- suppression de la base de donnee avec toutes ses tables
 

15