Les listes :
Création d'une liste vide : L=[]
On peut accéder au dernier élément d'une liste en utilisant L[-1] ou
L[len(L)-1]
Pour connaitre la longueur d'une liste on utilise len(L)
On peut ajouter un élément à la fin de la liste en utilisant la méthode
L.append([‘’])
Pour ajouter un élément dans une position précise dans la liste, on
utilise la méthode L.insert(position,l'élément à rajouter)
Sélectionner une partie d'une liste en utilisant un indiçage construit sur
la liste[m:n+1]
Pour supprimer un élément de la liste, on utilise del L[k] ou
L.remove(‘e’)
La méthode index recherche la première occurrence d'un élément de
liste et renvoie son index. Si l'élément ne figure pas dans la liste, il
génère ValueError. : L.index(e)
max (list) : Renvoie l'élément de liste avec la valeur maximale
min (list) : Renvoie l'élément de liste avec la valeur minimale
list.count (obj) : Retourne le nombre de fois qu'un élément apparaît
dans une liste
list.remove (obj) : Supprime un objet d'une liste
list.reverse () : Inverse les objets d'une liste
Les tuples :
Un tuple correspend à une liste non mutable (non modifiable) dans
laquelle on utilise les parenthèses au lieu des crochets.
Un tuple vide : t=()
Les dictionnaires:
mon_dictionnaire ={"name": "Mohamed", "age": 45, "adresse": "Tunisie"}
On peut récupérer toutes les clés d'un dictionnaire grâce à la
fonction keys : mon_dictionnaire.keys()
On peut récupérer toutes les clés d'un dictionnaire grâce à la
fonction items :mon_dictionnaire.items()
Pour ajouter des valeurs à un dictionnaire il faut indiquer une clé ainsi
qu'une valeur : dic["nom"] = "Mohamed"
La méthode get vous permet de récupérer une valeur dans un
dictionnaire dic.get("nom")
Il est possible de supprimer une entrée en indiquant sa clé, comme pour
les listes: del dic["age"]
La méthode update permet de fusionner deux dictionaires :
d1.update(d2)
Les fonctions:
def nom_de_la_fonction (les entrées):
⟶⟶ Le coprs de la fonction
⟶⟶ ⋮⋮
⟶⟶ return le_résultat
nom_de_la_fonction = lambda les entrées : instruction demandée
(mathématique) exp : somme=lambda a,b:a+b
Les boucles:
la commande range(n)
range(n,m) permet d’obtenir un tableau 1D de la valer de départ n à la
valeur de fin m-1 avec un pas 1.
range(m) permet d’obtenir un tableau 1D de la valer de départ 0 à la
valeur de fin m-1 avec un pas 1.
range(n,m,p) permet d’obtenir un tableau 1D de la valer de départ n à
la valeur de fin m-1 avec un pas p.
Les Matrices:
import numpy as np
Pour déclarer la matrice A, on utilise np.array(liste[listes]) exp :
A=np.array([[4,3,3,3],[2, 4, 3, 3],[2,2,4,np.pi]])
Afficher la dimension de A en utilsiant la commande A.shape()
A[L1:Ln,C1:Cn] est une sous matrice
B=A.copy() entraine la création d'une nouvelle matrice B et laisser la
matrice A intact.
B=A entraine que toute modification sur B enjendre la même
modification sur A.
Afficher la diagonale de 𝐴 np.diag(A)
Afficher la première sous diagonale de 𝐴 np.diag(A,-1)
Afficher la première sur diagonale de 𝐴 np.diag(A,1)
Afficher la matrice triangulaire inférieure associée à 𝐴 np.tril(A)
Afficher la matrice triangulaire supérieure associée à 𝐴 np.triu(A)
Calculer les produits matriciels A.dot(B)
transposée de 𝐴 A.T ou A.transpose()
Construire une matrice diagonale C=np.diagflat(U)
Matrice identité : np.identity(n) ou np.eye(n)
Les fonctions zeros et ones permettent de créer des matrices remplies
de 0 ou de 1.
Pour calculer un déterminant, inverser une matrice, résoudre un
système d'équations linéaires, etc nous faisons appel au sous
module .linalg de numpy
Déterminant : np.linalg.det(A)
Résoudre un système de cramer : np.linalg.solve(A,b)ou
np.linalg.inv(A).dot(b)
np.arange(n,m,p) permet d’obtenir un tableau 1D de la valeur de
départ n à la valeur de fin m-1 avec un pas p
np.linspace(n,m,p) permet d’obtenir un tableau 1D contenant p
coefficient allant d’une valeur de départ n à une valeur de fin m
Représentation graphique :
import matplotlib.pyplot as plt
exp :
x=np.arange(0,2*np.pi,0.1)#abcisses
y=np.sin(x) #ordonnées
plt.figure(figsize=(10,10)) #dimensions de la figure
plt.xlabel('observations',fontsize=30) # lengende sur l'axe des
abcisses
plt.ylabel('mesures',fontsize=30) # lengende sur l'axe des
abcisses
plt.legend(('sin(x)'),fontsize=30,loc = 0) # lengende sur l'axe
des ordonnées
plt.xticks(fontsize=30)#taille de police sur les abcisses
plt.yticks(fontsize=20)#taille de police sur les ordonnées
plt.title('Ma première figure', fontsize=30)
plt.grid(True)
plt.plot(x,y,'go-', linewidth=5,ms=5) # tracer y en fonction de x
Les paramètres de l'habillage des points les plus courants sont :
- couleurs : 'r' rouge, 'b' bleu, 'c' cyan, 'g' vert, 'k' noir ;
- formes : 'o' point, '+' plus, 'x' croix ;
- ligne entre les points : '-' ligne continue, '--' pointillés, ':' petits points.
Matrice à diagonale strictement dominante :
def matrice_diag_dominante(A):
n=A.shape[0]
etat=True
i=0;
while i<n and etat==True :
etat=abs(A[i,i])>sum(abs(A[i,:]))-abs(A[i,i])
i+=1
return etat
A=np.array([[3,2,-1],[1,5,-3],[2,1,4]])
print(matrice_diag_dominante(A))
Méthode de Jacobi :
def jacobi(A, b, X, epsilon):
etat=matrice_diag_dominante(A)
if etat==False:
return ('A n\'est pas à diagonale strictement dominante')
else:
M=np.diagflat(np.diag(A))
N=M-A
k=0
while np.linalg.norm(A.dot(X)-b,1)>epsilon:
X=np.linalg.inv(M).dot(N).dot(X)+np.linalg.inv(M).dot(b)
k+=1
return X,k
Méthode de gauss seidel :
def gauss_seidel(A, b, X, epsilon):
M = np.tril(A)
N=M-A
invM=np.linalg.inv(M)
k=0
while np.linalg.norm(A.dot(X)-b,1)>epsilon:
X=(invM.dot(N)).dot(X)+invM.dot(b)
k+=1
return X,k
Les polynome:
from numpy.polynomial import Polynomial
exp : P=Polynomial([1,0,6,1])
#P(X)=1+6*X^2+1*X^3=1+0*X+6*X^2+1*X^3.
Les coefficients : P.coef
coef[i] affiche le coefficient 𝑎𝑖ai de 𝑅R.
pandas :
import pandas as pd
Charger la base de donnée :df = pd.read_csv('cons_veh.csv')
Nbr ligne colone :df.shape
df.head() # la méthpde head() affiche les 5 premières lignes
par defaut
#Pour voir n derniere ligne: df.head(10)
afficher les noms de colonnes :df.columns
pd.plotting.scatter_matrix(df,alpha=1, figsize=(15,12));
