TP1 : Prise en main de Python

But : se familiariser avec l’usage de python. Python est un langage de programmation orienté
objet gratuit, utilisé dans de nombreux domaines d’application. Le but de ce TP est d’introduire
les commandes les plus courantes qui serviront de base pour les autres TPs.

I. Installation de Python
Deux choix s'offrent à vous pour les utilisateurs de Windows :
1) Pour la version basique de Python (la moins lourde), connectez-vous à
python.org/download/ et téléchargez la dernière version appropriée de l’installeur
Python 3 pour Windows et pour votre architecture (32 ou 64 bits). Suivez la procédure
d'installation en laissant les paramètres par défaut
2) Pour la version contenant la plupart des modules utiles à la "data science", connectez-
vous à https://www.anaconda.com/distribution/ et téléchargez la dernière version
d'Anaconda.

Dans la suite de ce TP, les commandes suggérées sont adéquates pour ceux qui ont choisi la
version basique (1). Ceux qui ont choisi la version (2) devront adapter les commandes en
supprimant dans la plupart des cas toutes les commandes d'installation de modules.
II. Environnement d'exécution de commandes :
Lancer IDLE
1) Vous avez une console qui s'ouvre permettant de faire directement des calculs.
2) Ouvrez un nouveau fichier. Ce sera un script, ce qui permettra d'exécuter plusieurs
lignes de codes les unes après les autres.
3) Enregistrer le script dans le dossier Documents
III. Opérations arithmétiques :

Attention !!! Dans Python, le code n'est pas délimité par des accolades ; ceux-ci sont
remplacés pat l'indentation du code. La vidéo ci-dessous vous montre que le résultat est
complétement différent si le codé est mal indenté.
https://www.youtube.com/watch?v=GcJTEbotA-0
Dans la partie console tapez:
5+8 (enter)
Pour conserver le résultat, il faut l’assigner à un objet, à une variable :
A=5+8 (enter)
B= -5+5 ; (enter)
C= -a+b ; (enter)
C (enter)
IV. Commandes élémentaires :
Pour voir l'historique des commandes en du plus récent au plus ancien : Alt+P
Pour voir l'historique des commandes passées du plus ancien au plus récent : Alt+N
Les commentaires débutent par #. Par exemple, on peut écrire
# ceci est un commentaire
Les fonctions de Python sont organisées dans des fichiers appelés modules. Un module est un
fichier contenant des définitions et des instructions. Son nom de fichier est le nom du module
suffixé de .py.
Pour connaître le répertoire de travail courant nous allons utiliser l'un de ces modules.
# importation du module os
import os
# Appel de la fonction qui donne le répertoire de travail courant
os.getcwd()
# changement du répertoire courant
os.chdir('D:\\Users\\Guepie\\Documents')

# Afficher fichier du répertoire courant

os.listdir()

V. Fonctions élémentaires :

L'interpréteur Python propose quelques fonctions et types natifs qui sont toujours disponibles.
Par exemple : abs(), complex().
Beaucoup d'autres fonctions mathématiques sont déjà prédéfinies dans Python ; d’où l'intérêt
d'utiliser ce logiciel. Elles sont contenues dans le module math. Ce module est toujours
disponible. Il fournit l’accès aux fonctions mathématiques définies par le standard C. Ces
fonctions ne peuvent être utilisées avec les nombres complexes. Pour les nombres complexes,
utilisez les fonctions du même nom du module cmath. La distinction entre les fonctions
supportant les nombres complexes et celles ne les supportant pas est née du fait que tous les
utilisateurs ne désirent pas acquérir le niveau mathématique suffisant pour comprendre les
nombres complexes. Recevoir une exception à la place d’un nombre complexe permet de
détecter un nombre complexe non désiré en paramètre, ainsi le programmeur peut déterminer
comment et pourquoi il a été généré. Les fonctions suivantes sont fournies dans ce module. Sauf
mention contraire explicite, toutes les valeurs de retour sont des flottants.

import math # importation du module

math.sqrt(1) # utilisation de la fonction
math.sqrt(-1)
 ou encore
from cmath import sqrt # importation directe de la fonction
sqrt(-1)
Pour connaitre la syntaxe d'une fonction il faudra chercher de l'aide en tapant :
help(nom_module.nom_fonction); # par exemple help(math.sqrt)
- Pour connaitre la syntaxe d'une fonction native il faudra chercher de l'aide en tapant :
help(nom_fonction) # par exemple help(abs)

I. Les types de données

Python est un langage à typage dynamique, ce qui signifie qu’il n’est pas nécessaire de déclarer
les variables avant de pouvoir leur affecter une valeur. La valeur que l’on affecte possède un
type qui dépend de la nature des données (int : nombre entier, float : nombre à virgule, str :
chaîne de caractères, bool : booléen, list : liste, complx : complexe etc). Le type du contenu
d’une variable peut donc changer si on change sa valeur. Pour connaître le type d’une donnée
ou le type de la valeur d’une variable, il suffit d’utiliser la fonction type().
a = 15
type(a)
a = "toto"
type(a)
a = 2 + 3j
type(a)
II. Les ensembles de données

1) Tuples
A partir des types de base (int, float, etc.), il est possible d’en élaborer de nouveaux. On les
appelle des types construits. Un exemple de type construit est le tuple. Il permet de créer une
collection ordonnée de plusieurs éléments. En mathématiques, on parle de p-uplet. Par exemple,
un quadruplet est constitué de 4 éléments. Les tuples ressemblent aux listes, mais on ne peut
pas les modifier une fois qu’ils ont été créés. On dit qu’un tuple n’est pas mutable. On le définit
avec des parenthèses.
a = (3, 4, 7)
type(a)
a[0]
(b, c) = (5, 6)
 2) Les listes
Une liste (ou list / array ) en python est une variable dans laquelle on peut mettre plusieurs
variables.
Pour créer une liste vide, rien de plus simple:
liste = []
Vous pouvez voir le contenu de la liste en l'appelant comme ceci:
liste
Vous pouvez ajouter les valeurs que vous voulez lors de la création de la liste python :
liste = [1,2,3]
Ou les ajouter après la création de la liste avec la méthode append
liste = []
liste.append(1)
liste.append("ok")
On voit qu'il est possible de mélanger dans une même liste des variables de type différent. On
peut d'ailleurs mettre une liste dans une liste.
Afficher et modifier un item d'une liste
Pour lire une liste, on peut demander à voir l'index de la valeur qui nous intéresse:
liste = ["a","d","m"]
liste[0]
Le premier item commence toujours avec l'index 0. Pour lire le premier item on utilise la valeur
0, le deuxième on utilise la valeur 1, etc.
Il est d'ailleurs possible de modifier une valeur avec son index
liste[2] = "z"
Supprimer une entrée avec un index
Il est parfois nécessaire de supprimer une entrée de la liste. Pour cela vous pouvez utiliser la
fonction del .
liste = ["a", "b", "c"]
del liste[1]
Supprimer une entrée avec sa valeur
Il est possible de supprimer une entrée d'une liste avec sa valeur avec la méthode remove .
liste = ["a", "b", "c"]
liste.remove("a")
Inverser les valeurs d'une liste
Vous pouvez inverser les items d'une liste avec la méthode reverse.
liste = ["a", "b", "c"]
liste.reverse()
Compter le nombre d'items d'une liste
Il est possible de compter le nombre d'items d'une liste avec la fonction len .
liste = [1,2,3,5,10]
len(liste)
Compter le nombre d'occurrences d'une valeur
Pour connaitre le nombre d'occurrences d'une valeur dans une liste, vous pouvez utiliser la
méthode count .
liste = ["a","a","a","b","c","c"]
liste.count("a")
liste.count("c")
Trouver l'index d'une valeur
La méthode index vous permet de connaitre la position de l'item cherché.
liste = ["a","a","a","b","c","c"]
liste.index("b")
Manipuler une liste
Voici quelques astuces pour manipuler des listes:
liste[-1] # Cherche la dernière occurrence
liste[-4:] # Affiche les 4 dernières occurrences
liste[2:4] = [69, 70]# les éléments de 2 à 4 par pas de 1 avec 4 exclu (c’est-à-dire le 3 et 4 ème)
sont remplacés par 69 et 70
liste[:] = [] # vide la liste
Boucler sur une liste
Pour afficher les valeurs d'une liste, on peut utiliser une boucle:
liste = ["a","d","m"]
for lettre in liste:
print(lettre)
Si vous voulez en plus récupérer l'index, vous pouvez utiliser la fonction enumerate .
for lettre in enumerate(liste):
print (lettre)
Les valeurs retournées par la boucle sont des tuples.
Copier une liste
Beaucoup de débutants font l'erreur de copier une liste de cette manière
x = [1,2,3]
y=x
Or si vous changez une valeur de la liste y, la liste x sera elle aussi affectée par cette
modification:
y[0] = 4
x
En fait cette syntaxe permet de travailler sur un même élément nommé différemment
Alors comment copier une liste qui sera indépendante?
y = x[:]
y[0] = 9
x
Pour des données plus complexes, vous pouvez utiliser la fonction deepcopy du module copy

import copy
x = [[1,2], 2]
y = copy.deepcopy(x)
y[0] = [1,2,3]
y
Transformer un string en liste
Parfois il peut être utile de transformer une chaine de caractère en liste. Cela est possible avec
la méthode split .
ma_chaine = "Olivier:ENGEL:Strasbourg"
ma_chaine.split(":")
L'inverse est possible avec la méthode " join ".
liste = ["Olivier","ENGEL","Strasbourg"]
":".join(liste)
Trouver un item dans une liste
Pour savoir si un élément est dans une liste, vous pouvez utiliser le mot clé in de cette manière:
liste = [1,2,3,5,10]
3 in liste
11 in liste
Ranger une suite d'éléments
La fonction range génère une liste composée d'une simple suite arithmétique.
range(10)
Agrandir une liste par une liste
Pour mettre bout à bout deux listes, vous pouvez utiliser la méthode extend
x = [1, 2, 3, 4]
y = [4, 5, 1, 0]
x.extend(y)
Permutations
La permutation d'un ensemble d'éléments est une liste de tous les cas possibles. Si vous avez
besoin de cette fonctionnalité, inutile de réinventer la roue, itertools s'en occupe pour vous.
from itertools import permutations
list(permutations(['a', 'b', 'c']))
Permutation d'une liste de liste
Comment afficher tous les cas possibles d'une liste elle-même composée de liste? Avec l'outil
product de itertools :
from itertools import product
list(product(['a', 'b'], ['c', 'd']))
[('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd')]
Afficher les 2 premiers éléments d'une liste
liste = [1,2,3,4,5]
liste[:2]
Vous pouvez concaténer deux listes pour les combiner ensemble en utilisant l'opérateur + :
x = [1, 2, 3]
y = [4, 5, 6]
x+y
Vous pouvez même répéter une liste:
x = [1, 2]
x*5
Ce qui peut être utile pour initialiser une liste:
[0] * 5
3) Ensembles
Un ensemble est une structure permettant de stocker des éléments hétérogènes au sens
mathématique de la théorie des ensembles:
set0 = {0, 5.4, "chaine", True}
Il est possible de tester si un élément appartient à un ensemble:
if "chaine" in set0:
print("dedans")
4) Dictionnaires
Un dictionnaire est une structure permettant de stocker des éléments hétérogènes indexés par
des clefs (elles aussi hétérogènes):
dict0 = {"pommes": 0, "poires": 4, 12: 2}
Les éléments d'un dictionnaire sont accessibles par les clefs:
dict0["pommes"]
dict0[12]
Un dictionnaire peut être vu comme un tableau associatif associant à chaque clef une valeur.
La liste des clefs et des valeurs sont accessibles respectivement avec dict0.keys() et
dict0.values(). Les dictionnaires sont mutables, il est donc possible de modifier une association
clef-valeur et d'en rajouter ou supprimer une:
 5) Vecteurs de chaîne de caractères :
Une valeur de mode caractère est entrée entre des guillemets doubles " ". Il est possible d'inclure
ce caractère dans la valeur s'il suit un antislash \.
Une autre possibilité est de délimiter les variables de mode caractère avec des guillemets
simples (') ; dans ce cas il n'est pas nécessaire d'échapper les guillemets doubles avec des
antislash (mais les guillemets simples doivent l'être)
"+" permet de concaténer deux chaines de caractères et " string.split(separator,
maxsplit)" permet de les séparer
6) Tableaux et calcul matriciel avec NumPy
Premièrement, nous allons installer le module numpy. En python 3.8, l'utilitaire pip est déjà
installé. En version antérieure, commence par installer pip. Dans une fenêtre cmd "invite de
commande", mettez vous le répertoire Documents
cd Documents
et tapez:
py -m pip install numpy
il faut une connexion internet car pip va chercher tout seul numpy et fait l'installation. Ensuite
import numpy as np# numpy est abrégé en np
Dans la syntaxe « standard », on importe la totalité du module numpy et on lui donne un alias
pour alléger ensuite l’écriture de l’appel des fonctions. L’alias qui est le plus couramment utilisé
est np
a) Tableaux monodimensionnels (1D)
Pour créer un tableau 1D, il suffit de passer une liste de nombres en argument de numpy.array().
Un liste est constituée de nombres séparés par des virgules et entourés de crochets ([ et ]).
a = np.array([4,7,9])
Pour connaître le type du résultat de numpy.array(), on peut utiliser la fonction type().
type(a)
On constate que ce type est issu du package numpy. Ce type est différent de celui d’une liste.
b) Tableaux bidimensionnels (2D)
Pour créer un tableau 2D, il faut transmettre à numpy.array() une liste de listes grâce à des
crochets imbriqués.
a = np.array([[1, 2, 3], [4, 5, 6]])
La fonction numpy.size() renvoie le nombre d’éléments du tableau.
np.size(a)
La fonction numpy.shape() (forme, en anglais) renvoie la taille du tableau.
np.shape(a)

Changement de la taille d’un tableau

Il est possible de changer la taille d’un tableau en utilisant l’attribut shape de ce tableau.
u = np.arange(1, 16)
np.shape(u)
u.shape = (3, 5)
np.shape(u)
Obtention d’un tableau 2D ligne ou colonne
a = np.arange(1, 6)
a.shape = (1, np.size(a))
a.shape = (np.size(a), 1)
Trouver l'index d 'un élémént
Index=np.where(A = = 0)
Tableaux et slicing
Lors de la manipulation des tableaux, on a souvent besoin de récupérer une partie d’un tableau.
Pour cela, Python permet d’extraire des tranches d’un tableau grâce une technique appelée
slicing (tranchage, en français). Elle consiste à indiquer entre crochets des indices pour définir
le début et la fin de la tranche et à les séparer par deux points :.
a = np.array([12, 25, 34, 56, 87])
Il est aussi possible de ne pas mettre de début ou de fin.
a[1:]
a[:3]
a[:]
Slicing des tableaux 2D
a = np.array([[1, 2, 3],[4, 5, 6]])
a[0,1]
a[:,1:3]
Avertissement
a[:,n] donne un tableau 1D correspondant à la colonne d’indice n de a. Si on veut obtenir un
tableau 2D correspondant à la colonne d’indice n, il faut faire du slicing en utilisant a[:,n:n+1].
a[:,1:2]
Tableaux de 0 - numpy.zeros()
zeros(n) renvoie un tableau 1D de n zéros.
np.zeros(3)
zeros((m,n)) renvoie tableau 2D de taille m x n, c’est-à-dire de shape (m,n).
np.zeros((2,3))
Tableaux de 1 - numpy.ones()
np.ones(3)
Matrice identité - numpy.eye()¶
eye(n) renvoie tableau 2D carré de taille n x n, avec des uns sur la diagonale et des zéros partout
ailleurs.
np.eye(3)
Algèbre linéaire
Produit terme à terme
Il est possible de réaliser un produit terme à terme grâce à l’opérateur *. Il faut dans ce cas que
les deux tableaux aient la même taille.
a = np.array([[1, 2, 3],[4, 5, 6]])
b = np.array([[2, 1, 3],[3, 2, 1]])
a*b
Produit matriciel - numpy.dot()
Un tableau peut jouer le rôle d’une matrice si on lui applique une opération de calcul matriciel.
Par exemple, la fonction numpy.dot() permet de réaliser le produit matriciel.
a = np.array([[1, 2, 3],[4, 5, 6]])
b = np.array([[4],[2],[1]])
np.dot(a,b)
Le produit d’une matrice de taille n x m par une matrice m x p donne une matrice n x p.
Transposé : a.T
Complexe conjugué - numpy.conj()
u= np.array([[ 2j, 4+3j],
[2+5j, 5 ],
[ 3, 6+2j]])
np.conj(u)
Déterminant - numpy.linalg.det()
from numpy.linalg import det
a = np.array([[1, 2], [3, 4]])
det(a)
Inverse - numpy.linalg.inv()
from numpy.linalg import inv
inv(a)
Résolution d’un système d’équations linéaires - numpy.linalg.solve()
Pour résoudre le système d’équations linéaires 3 * x0 + x1 = 9 et x0 + 2 * x1 = 8 :
a = np.array([[3,1], [1,2]])
b = np.array([9,8])
x = np.linalg.solve(a, b)
Pour vérifier que la solution est correcte :
np.allclose(np.dot(a, x), b)

Valeurs propres et vecteurs propres - numpy.linalg.eig()

from numpy.linalg import eig
A = np.array([[ 1, 1, -2 ], [-1, 2, 1], [0, 1, -1]])
D, V = eig(A)
Les colonnes de V sont les vecteurs propres de A associés aux valeurs propres qui apparaissent
dans D.
Fonctions vectorielles :
 max(x) maximum du vecteur x
 min(x) minimum
 sorted(x) tri par ordre croissant
 sum(x) retourne la somme des éléments de x
 numpy.mean(x) moyenne des éléments de x
Liste des opérateurs :
 + : addition ; < : inférieur à ; not : NON logique
 - : soustraction ; > : supérieur à; & : ET logique
 * : multiplication; <=: inférieur ou égal à; & : ET logique
 / : division; >= supérieur ou égal à; | OU logique
 ** : puissance; == : égal à ; % : modulo; != différent;
 // division entière
VI. Commandes structurées :

1) L’instruction for :
for element in sequence:
instruction

2) Les instructions conditionnelles : if…else…end :

if condition:
instruction
else :
instruction

if condition:
instruction
elif condition:
instruction
else:
instruction

Exercice 1: écrire le code qui renvoie le signe d'un nombre : 1 pour les positifs
et -1 pour les négatifs
3) L’instruction While :
while condition:
instruction

Exercice 2 créer une variable X contenant le tableau de données 2D suivant :

prenom taille poids 'QI sexe
Paul 185 82 110 M
'Matthieu 178 81 108 M
Camille 165 55 125 F

VII. Ecrire et lire un fichier txt

1) Lecture :
On peut lire avec la fonction loadtxt de numpy
2) Ecriture :
On peut écrire avec la fonction savetxt de numpy
Exercice 3 : Ecrire le tableau précédent X dans un fichier nommé "poids.txt" en utilisant savetxt
 Exercice 4 : Charger le fichier ' vehicule_Saporta_2006.txt' dans une matrice 2D de caractères
nommée vehicule et affichez le contenu de vehicule.
VIII. Syntaxe d'une fonction dans un module personnel
En Python, la création d'un module est très simple. Il suffit d'écrire un ensemble de fonctions
(et/ou de constantes) dans un fichier, puis d'enregistrer ce dernier avec une extension .py
(comme n'importe quel script Python).
Pour créer une fonction simple
def nom_fonction( input_parameter):
return output_parameter
Exercice 5 : écrire une fonction nommée factoriel qui calcule le factoriel d'un nombre n.
Vérifier pour n=7 : résultat=5040; pour n=10 résultat=3628800.

IX. Affichage d'une courbe e

1) En 2D

# On commence par installer le package matplotlib

# Puis on l'importe le package
import matplotlib
# Puis on importe le module pyplot de matplotlib
import matplotlib.pyplot as plt
# Tracer la figure
a=np.arange(10)
plt.plot(a,a)
Afficher la figure à l'écran
plt.show()

2) En 3D
# Importation de mplot3d qui permet d'utiliser projection='3d'
from mpl_toolkits import mplot3d
# on prepare la figure
fig = plt.figure()
ax = plt.axes(projection='3d')
# Data for a three-dimensional line
zline = np.linspace(0, 15, 1000)
xline = np.sin(zline)
yline = np.cos(zline)
ax.plot3D(xline, yline, zline, 'gray')
# angle
ax.view_init(60, 35)
#affichage
fig.show()

Exercice:6
= sin ( )
Tracer la courbe d’équation ou -2π≤t≤2π
= cos(t) − ( )