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 1.1 A savoir . . . . . . . . . . . . . . . . . . 1.2 les types in-built de variable . . . . . . . 1.3 l’écriture . . . . . . . . . . . . . . . . . . 1.4 La lecture . . . . . . . . . . . . . . . . . 1.5 Les opérations logiques et arithmétiques 1.6 Les structures conditionnelles . . . . . . 1.7 Les structures itératives . . . . . . . . . 1.8 break et continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 2 2 3 3 3 3 4 4 2 Structures de données 2.1 lists (les listes) . . . . . . . . 2.2 tuples (les n-uplets) . . . . . . 2.3 sets (les ensembles) . . . . . . 2.4 dictionaries (les dictionnaires) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 5 5 5 6 . . . . . . . . . . . 6 7 7 7 8 8 8 8 9 9 9 9 . . . . . . . . . . . . . . . . . . . . . . . . 3 Algorithmique 3.1 fonction et procédure . . . . . . . . . . . . . . 3.2 fonction récursive . . . . . . . . . . . . . . . . 3.3 la complexité . . . . . . . . . . . . . . . . . . 3.4 conversion de la base 10 à la base 2 O(log(n)) 3.5 recherche linéaire O(n) . . . . . . . . . . . . . 3.6 recherche binaire (dichotomie) O(log(n)) . . . √ 3.7 vérification de primalité d’un nombre O( n) 3.8 multiplication matricielle O(n3 ) . . . . . . . . 3.9 inversement d’une chaîne de caractère O(n) . 3.10 les algo de tri . . . . . . . . . . . . . . . . . . 3.10.1 bulle O(n2 ) . . . . . . . . . . . . . . . 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.10.2 insertion O(n2 ) . . . . . . . . . . . . . 3.10.3 selection O(n2 ) . . . . . . . . . . . . . 3.10.4 fusion O(n.log(n)) . . . . . . . . . . . 3.11 calcul d’intégrales . . . . . . . . . . . . . . . . 3.11.1 méthode des rectangles O(n) . . . . . 3.11.2 méthode des trapèzes O(n) . . . . . . 3.11.3 méthode de Monte Carlo O(n) . . . . 3.12 recherche de zéro d’une fonction analytique . 3.12.1 méthode dichotomie (principe du TVI) 3.12.2 méthode de Newton . . . . . . . . . . 3.13 méthode d’Euler O(T /h) . . . . . . . . . . . . 4 Python 3 : les 4.1 numpy . . 4.2 scipy . . . 4.3 matplotlib 4.4 math . . . 4.5 random . librairies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 10 10 10 10 10 10 11 11 11 11 . . . . . 12 12 12 13 13 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 Pour afficher un message : 1 2 3 4 2 3 4 print("mon texte entre guillemets") print(variable) # la cas d’une variable print(var1,var2) # plusieurs variables 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 l’écriture print(1, end = " ") # espace a la fin print(2, end = "") # rien a la fin print(3) # retour a la ligne par defaut print(4) Output : 1 23 4 1.4 Pour lire une variable depuis l’entrée de l’utilisateur : 1 2 3 x = input() # lit l’entree et le stock dans x y = input("message") # affiche le message, lit l’entree # 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 2 La lecture n = int(input()) # n un entier relatif 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 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 2 3 4 Les opérations logiques et arithmétiques s x d e = = = = "salut" "etudiant" s+x # d contient "salutetudiant" 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 2 3 4 5 6 7 8 9 if cond 1 : # bloc 1 elif cond 2 : # bloc 2 elif cond 3 : # bloc 3 ..... else : # bloc n 1.7 2 3 4 1 2 3 4 5 6 7 for i # while # in range(a, b, c): # i prend toutes les valeurs entieres des instructions.. dans [a,b[ en sautant par c condition : # tant que la condition est valide 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 : for i in range(a,b,c): # des instructions ########################## k = a while k < b : # des instructions k = k + c # ou k += c 1.8 1 2 3 1 2 3 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 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 for i in range(6): if i == 3 : break print(i) output : 0 1 2 for i in range(6): if i == 3 : continue 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 principales (initialisation, ajout/suppression élément, taille, accès et parcours). 2.1 1 2 3 4 5 6 7 8 9 10 11 12 13 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. # initialisation L = list() # ou L = [] # ajouter element x L.append(x) # ou L += x # supprimer l’element d’index i del(L[i]) # acces element d’index i print(L[i]) # parcours d’elements for i in range(len(L)): # par index # blabla L[i] for e in L: # par valeurs # 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 : 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 1 2 3 4 5 6 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. # initialisation t = (3,4) # ajouter/supprimer/acceder element : impossible # acces element print(t[i]) # 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 informatique. Souvent utilisé pour l’élimination d’élément dupliqué dans une autre structure (un ensemble n’admet pas de répétition) 1 2 3 4 5 6 7 8 9 10 11 1 2 3 4 5 #initialisation s = set() # ensemble vide s = {5,2,6,"rdt",2.68} #ajouter element x s.add(x) #supprimer element x s.discard(x) # si x n’existe pas elle ne fait rien #acces element : impossible #parcours d’elements for e in s: # par element # blabla NB : ils existent des méthodes pour simuler les opérations sur les ensembles qui sont assez intuitives. s1.union(s2) # equivalent a s1 | s2 s1.intersection(s2) # equivalent a s1 & s2 s1.difference(s2) # equivalent a s1 - s2 s1.symmetric_difference(s2) # equivalent a s1 ^ s2 s1.isdisjoint(s2) # renvoie True ou False 2.4 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #initialisation d = dict() # ou d = { } #ajouter element de cle "c" et de valeur k ou changer la valeur de la cle "c" d[c] = k #supprimer element de cle "c" d.pop(c) # si "c" n’existe pas dans d, pop() renvoie une erreur #acces element : par cle print(d[c]) #parcours d’elements for c in d.keys(): # par cle # blabla for k in d.values(): # par valeur # blabla for c,k in d.items() # par cle et valeur # 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 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 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 : def fonction(param1, param2, param3, ...., paramN): #blabla return resulat1, resultat2,...,resultatM 1 2 3 4 5 6 def procedure(param1,...paramN): #blabla 3.2 1 2 3 4 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 : def fct_iterative(N): if cond : return "X" # condition d’arret #bla bla 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 matriciel 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 à utiliser 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 algorithmes 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 2 3 4 5 6 7 8 9 def base2(n): # base sur la division euclidienne q = -1 res = str() while q != 0: q = n // 2 r = n % 2 res = str(r) + res n = q return res 3.5 recherche linéaire O(n) 1 2 3 4 def search(L, k): for i in range(len(L)): if L[i] == k: return i return -1 # cad element introuvable 3.6 recherche binaire (dichotomie) O(log(n)) 1 2 3 4 5 6 7 8 9 10 11 12 13 def BS(tab, target): left = 0 right = len(tab) - 1 while right >= left : mid = int((right+left)/2) if tab[mid] == target : return mid elif tab[mid] > target : right = mid + 1 BS(tab[left : right], target) else : left = mid - 1 BS(tab[left : right], target) return -1 # element introuvable 3.7 √ vérification de primalité d’un nombre O( n) 8 1 2 3 4 5 6 import math def isprime(n): if abs(n) < 2 : return False # si |n| < 2, n’est pas premier for i in range(2,int(math.sqrt(n)) + 1): if n % 2 : return False # si un nombre <= sqrt(n) divise n, n n’est pas premier return True 3.8 multiplication matricielle O(n3 ) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 def produitMat(A,B): # retourne A.B si possible n = len(A) # nbr lignes A p = len(A[O]) # nbr colonnes A m = len(B) # nbr lignes B q = len(B[0]) # nbr colonnes B if p != m : return False # incompatibilite des tailles de matrices C = list() for i in range(n): ligne = list() for j in range(q): case = 0 for k in range(p): case += A[i][k] * B[k][j] ligne.append(case) C.append(ligne) return C 3.9 2 def inverser(s): return s[::-1] # le pas -1 parcourt la chaine dans le sens inverse.. 3.10 3.10.1 2 3 4 5 6 bulle O(n2 ) def bulle(T): for i in range(len(T) - 1, 0, -1): for j in range(i): if T[j] > T[j + 1]: 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 return T 3.10.2 2 3 4 5 6 7 8 9 insertion O(n2 ) 1 les algo de tri 1 inversement d’une chaîne de caractère O(n) 1 def tri_insertion(L): N = len(L) for n in range(1,N): cle = L[n] j = n-1 while j>=0 and L[j] > cle: L[j+1] = L[j] # decalage j = j-1 L[j+1] = cle 9 3.10.3 selection O(n2 ) 1 2 3 4 5 6 7 def selection(tab): for i in range(0,len(tab)-1): min = i for j in range(i+1,len(tab)): if tab[j] < tab[min]: min = j if (min != i): tab[i], tab[min] = tab[min], tab[i] 3.10.4 fusion O(n.log(n)) def fusion(A,B): if len(A) == 0: return B elif len(B) == 0: return A elif A[0] <= B[0]: return [A[0]] + fusion(A[1:], B) else: return [B[0]] + fusion(A, B[1:]) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 def triFusion(L): if len(L) == 1: return L else: return fusion(triFusion(L[:len(L)//2]), triFusion(L[len(L)//2:]) ) 3.11 3.11.1 calcul d’intégrales méthode des rectangles O(n) 1 2 3 4 5 6 7 8 def integrale(f, a, b, n): # l integrale In de f sur [a, b] avec n rectangles somme = 0 h = float(b-a) / n x = a for i in range(0, n + 1): somme += f(x) * h x += h return somme 3.11.2 2 3 4 5 6 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 h = ( b - a ) / n s = 0.5 * ( f( a ) + f( b ) ) for i in range( 1, n ): s += f(a + h*i) return s * h 3.11.3 méthode de Monte Carlo O(n) 10 1 2 3 4 5 6 7 import random def integrale_MC(f, a, b, n): # l integrale In de f sur [a, b] avec n echantillons somme = 0 for i in range(0, n): x = random.uniform(a, b) somme += f(x) return somme / n 3.12 3.12.1 recherche de zéro d’une fonction analytique méthode dichotomie (principe du TVI) 1 2 3 4 5 6 7 8 9 10 11 12 def dicho(f, a, b, eps=0.000001): # Recherche un zero d’une fonction f sur un intervalle [a,b]. eps est la precision souhaitee (par defaut, 1/1000000) # f(a) et f(b) doivent etre de signes contraires if f(a)*f(b) > 0: return None # aucun zero dans l’intervalle while abs(b-a) > eps: c = (a+b)/2 if f(a)*f(c) > 0: a=c else: b=c return a, b 3.12.2 2 3 4 5 6 7 8 9 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 n = 0 dif = 2 * epsilon while dif > epsilon : # epsilon est la precision de recherche x1 = x - (f(x) / fp(x)) dif = abs(x1 - x) x = x1 n = n+1 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 1 2 3 4 5 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. def euler(systeme,Yi,T,h): Y = Yi t = 0.0 liste_y = [Y] liste_t = [t] 11 6 7 8 9 10 11 while t < T: Y = Yn + h*systeme(Y,t) t += h liste_y.append(Y) liste_t.append(t) 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, logarithme, 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 import numpy as np # appel de la librairie 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A = np.array([3,4,1][5,7,2][9,6,8]) # A est une matrice 3 x 3 print(A.shape()) # renvoie les dimensions de A = (2,3) O = np.zeros((13,7)) # O est une matrice nulle de taille 13 x 7 I = np.ones((5,8)) # I est une matrice remplie de 1 de taille 5 x 8 B = A.T # B est la transposee de A C = A + B # la somme matricielle D = dot(A,B) # D est le produit matriciel de A et B E = A * 3 # pour tt i,j , E[i][j] = 3 * A[i][j] 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 !) print( np.linalg.norm(A) ) # renvoie la norme standard de A (scalaire) f = np.linalg.det(A) # renvoie le determinant de A (scalaire) 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) = −b ∗ ω(t) − c ∗ sin(θ(t)) θ′ (t) import numpy as np import scipy as sp # appel des librairies #ci-dessous un exemple depuis le site de scipy 1 2 3 4 def f(y, t): # y est un vecteur de 2 elements (liste) theta, omega = y dydt = [omega, -0.25*omega - 5.0*np.sin(theta)] return dydt 5 6 7 8 9 y0 = [np.pi - 0.1, 0.0] # vecteur condition initiale t = np.linspace(0, 10, 101) # liste de 101 moments ti entre 0 et 10 10 11 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 import numpy as np import matplotlib.pyplot as plt # importation des librairies 1 2 3 def carre(x): # fonction x^2 return x**2 X = np.linspace(0,100,100) # listes de 100 x entre 0 et 100 Y = f(X) # listes des f(x) 4 5 6 7 8 9 10 plt.plot(X,Y) # trace la fonction avec l’aide des points (x_i,y_i) plt.show() # affiche le resultat en dessous 4.4 1 math Rien de spécial dans cette librairie, la plupart des fonctions sont intuitives. Toutefois, on en cite quelques unes : import math # appel de la librairie 2 3 4 5 6 7 8 9 10 11 12 x = math.cos(4) # en radian y = math.sin(34) z = math.atan(8) # fonction arctan u = math.log(2) # fonction logarithme Neperien (ln) u2 = math.log2(4) # fonction logarithme a base 2 u10 = math.log10(739) # fonction logarithme a base 10 v = math.exp(49) # fonction exponentiel w = math.sqrt(7) # fonction racine carree a = math.ceil(3.4) # renvoie la partie entiere avec exces (4 dans ce cas) b = math.floor(3.4) # renvoie la partie entiere avec defaut (3 dans ce cas) 13 4.5 random import random as rd # appel de librairie 1 2 3 4 5 6 7 A = [2,6,1,9,4] print( rd.choice(A) ) # renvoie une valeur aleatoire d’une liste, ensemble ou chaine de caracteres print( rd.randint(5,15) ) # renvoie un entier aleatoire entre 5 et 15 print( rd.uniform(3,7) ) # renvoie un reel aleatoire entre 3 et 7 (inclus) 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é primaire 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 certaines tables possèdent une ou des clés étrangères (c-à-d des colonnes qui appartiennent à 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 2 3 4 5 6 7 8 9 10 11 12 13 SELECT nomEleve FROM cpgeX; -- affiche la colonne nomEleve SELECT nomEleve, filiere FROM cpgeX; -- affiche les colonnes nomEleve et filiere SELECT * FROM cpgeX; -- affiche toutes les colonnes SELECT DISTINCT nomEleve FROM cpgeX; -- affiche la colonne nomEleve sans duplicata SELECT COUNT(DISTINCT filiere) FROM cpgeX; -- renvoie le nombre de filieres distinctes dans la table SELECT nomEleve FROM cpgeX WHERE filiere = "TSI"; -- affiche les noms d’eleves dans la filiere TSI SELECT nomEleve FROM cpgeX WHERE (filiere = "TSI" OR filiere = "MP"); -- affiche les noms d’eleves dans les filieres TSI et MP SELECT nomEleve FROM cpgeX WHERE moyenne BETWEEN 10 AND 12; -- affiche les eleves dont la moyenne est entre 10 et 12 SELECT nomEleve FROM cpgeX WHERE NOT (filiere = "MP"); -- affiche les noms d’eleves hors de la filiere MP SELECT * FROM cpgeX ORDER BY moyenne; -- affiche toutes les colonnes et lignes ordonnees par moyenne SELECT * FROM cpgeX ORDER BY moyenne DESC; -- affiche toutes les colonnes et lignes ordonnees par moyenne en ordre decroissant 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 SELECT * FROM cpgeX WHERE moyenne IS NULL; -- affiche les eleves qui n’ont pas une moyenne dans la table (champs vide) 14 14 INSERT INTO cpgeX(nomEleve, moyenne, filiere) VALUES ("adil", 16.38, PSI); -- insert une nouvelle ligne a la table 15 16 UPDATE cpgeX SET moyenne = 9.34 WHERE ID = 78; -- change la moyenne de l’eleve numero 78 dans la table UPDATE cpgeX SET moyenne = 10; -- change la moyenne de chaque eleve a 10 17 18 19 DELETE FROM cpgeX WHERE nomEleve = ’Hamza’; -- supprime tous les eleves dont le nom est "Hamza" DELETE FROM cpgeX; -- supprime toutes les lignes sans supprimer la table 20 21 22 23 24 25 26 27 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 SELECT COUNT(*) FROM cpgeX WHERE filiere = ’PSI’; -- renvoie le nombre d’eleve en filiere PSI SELECT nomEleve FROM cpgeX WHERE nomEleve LIKE ’Abd%’; -- renvoie tous les noms d’eleves qui commencent par "Abd" (Abdellah, Abdelhamid..) 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..) 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 : CREATE DATABASE ma_base; -- cree une BD vide CREATE TABLE cpgeX( -- creation de table cpgeX ID int AUTO_INCREMENT, -- colonne type entier et auto incrementee nomEleve varchar(50), -- colonne de type chaine de caractere de longueur 50 moyenne float, -- colonne de type nombre reel filiere varchar(4), PRIMARY KEY (ID) -- la colonne ID est definie comme cle primaire de cpgeX ); CREATE TABLE cpgeY( -- creation de table cpgeY ID int AUTO_INCREMENT, nomEleve varchar(50), moyenne float, filiere varchar(4), PRIMARY KEY (ID) -- remarquez qu il n y a pas de virgule apres la derniere colonne ); 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ALTER TABLE cpgeX ADD absence int; -- ajout d une colonne absence a la table cpgeX de type entier ALTER TABLE cpgeY DROP COLUMN moyenne; -- suppression de la moyenne de la table cpgeY 17 18 19 20 21 DROP TABLE cpgeX; -- suppression de la table cpgeX DROP DATABASE ma_base; -- suppression de la base de donnee avec toutes ses tables 15
