Introduction au Python

Ce document introduit la syntaxe de base du Python ainsi que les étapes à suivre pour
l'installation et la configuration d'un environnement de développement pour le Python.

Avant-propos
Le Python est un langage de programmation interprété ou compilé, multi-paradigmes et
multiplateformes. Il a été conçu en 1991 par Guido van Rossum et développé depuis par la
Python Software Foundation.

C'est un langage puissant qui connaît un engouement et un intérêt en croissance continue

de la part des développeurs, surtout depuis les 10 dernières années.

Bien que le Python soit utilisé dans des projets de natures de plus en plus disparates
(applications Web, applications mobiles, applications de bureau, etc.), il existe un type de
projets particulier où le Python reste incontournable. Il s'agit des projets intégrants l'intelligence
artificielle. Ceci pour diverses raisons :

● il est facile à apprendre et à utiliser ;

● il possède une communauté mature et diversifiée (notamment sur [Link]) ;
● plusieurs grands noms de l'informatique tels que Google, Facebook, Amazon ou encore
Google, investissent et soutiennent activement le langage ;
● il possède des milliers de bibliothèques logicielles couvrant différents domaines et
applications (notamment, pour tout ce qui se rapport à l'intelligence artificielle) ;

IA - Licence 3 - UMMTO 1
L. Lazib et S. Sadi
 ● il est versatile, efficient, fiable et performant ;
● Il peut être interprété, ou compilé (avec cython, jython, pypy, etc.) ;
● c'est un langage multi-paradigmes (intègre l'impératif, le fonctionnel, l'orienté objet, etc.).

Installation de l'environnement de développement

Plusieurs choix s'offrent au développeur pour commencer à utiliser Python.

Une solution simple et rapide consiste à utiliser des plateformes en ligne telles que
Jupyter ([Link] ou Google Colab ([Link] L'avantage
est que le code écrit s'exécute sur le Cloud (sur des machines distantes) et il n'y a rien à
configurer. Toutes les bibliothèques sont disponibles et prêtes à l'emploi. L'inconvénient est qu'il
faut disposer d'une connexion internet.

Une alternative consiste à installer un environnement de développement complet. C'est

celle que nous adoptons.

L'environnement de développement choisi est PyCharm. Pour son installation, il suffit de

suivre les instructions suivantes :

● Sur windows :
○ installer Python depuis [Link] :
S'assurer d'utiliser un interpréteur python avec une version supérieure à 3.7:
[Link]
○ installer la version “community” de pycharm:
[Link]
● Sur ubuntu, exécuter dans un terminal les deux commandes :
○ sudo apt-get install python
○ sudo snap install pycharm-community --classic
● Il est préférable d'installer PyCharm en anglais.

Prise en main de PyCharm

1. Créer un nouveau projet, avec le menu "File -> New Project".
a. Ceci va aussi créer un "environnement" python. Celui-ci va contenir toutes les
bibliothèques qu'on va installer après.
b. Si l'on ne souhaite pas re-télécharger les bibliothèques pour chaque nouveau
projet, il convient d'utiliser un environnement global (système) ou partagé.
c. Bien côcher "Create a [Link] welcome script".

IA - Licence 3 - UMMTO 2
L. Lazib et S. Sadi
 2. Pour exécuter le projet, il suffit d’utiliser le menu “Run -> Run ‘main’”
a. Sur la console s’affiche alors: “Hi, PyCharm”

Installation de bibliothèques sous PyCharm

Pour installer des bibliothèques sous PyCharm, il faut disposer d’une connexion internet.
Ensuite, l’installation se fait à travers l’interface de PyCharm de façon intuitive.

Par exemple, pour installer la bibliothèque Numpy, il faut suivre les étapes suivantes :

1. aller dans “File -> Settings ...” ;

2. dans le panneau de gauche, cliquer sur “Projet: ...“, puis sur “Python Interpreter” ;
3. cliquer sur le bouton avec l’icon “+” ;
4. dans la barre de recherche, taper “numpy” (sans les guillemets) ;
5. cliquer sur “Install Package” et attendre la fin de l’installation.

Pour les besoins immédiats du TP, nous aurons besoin des bibliothèques :

● numpy, pandas, matplotlib, scikit-learn.

● Il se peut qu’on ait besoin d’autres bibliothèques que nous installerons plus tard.

Introduction à la syntaxe de Python

Ce document résume la syntaxe de Python. Il existe des concepts qui ne sont pas
présentés (par exemple: le typage, l'héritage de classes, etc.).

Pour aller plus loin, voir : [Link]

Notions de base
● Le Python est un langage sensible à la casse (ma_variable != Ma_Variable).
○ Préférer le style snake_case (ma_variable) au style camelCase (maVariable),
pour nommer les variables.
○ Les termes commençant par une majuscule doivent être réservés pour les noms
de classes.
● Les commentaires en Python commencent avec le caractère # sur une ligne, ou sont
délimités avec """ (trois guillemets) sur plusieurs lignes.

IA - Licence 3 - UMMTO 3
L. Lazib et S. Sadi
 ● Le Python utilise l’indentation pour séparer les instructions et non pas des points
virgules. Il faut donc mettre une instruction par ligne. Les blocs de codes ne sont pas
délimités par begin et end (comme en pascal), ou par des accolades, mais par
l’indentation du texte. Exemple :

if university == 'ummto':
print('Bienvenue')
print('à l\'UMMTO')
print('fin.')

Dans cet exemple, nous testons si la variable “university” contient la chaîne de

caractères 'ummto'. Si c’est le cas, nous affichons les deux messages ('Bienvenu' et 'à
l\'UMMTO') à l’écran. Le message 'fin.' est affiché dans tous les cas.

Les deux points après la condition annoncent le début d’un bloc de code. Ensuite, toutes
les instructions qui doivent être exécutées si la condition est vraie, sont précédées par 4
espaces ou une tabulation. Le nombre d’espaces (4 ici), peut être différent, mais doit être le
même pour chaque instruction. Le dernier “print” n’est pas inclus dans la condition, car il n’est
pas indenté.

Déclarer une variable

Python est un langage fortement typé. Ainsi, contrairement à des langages faiblement
typés (comme le javascript), il ne permet pas les opérations ayant peu de sens (par exemple,
additionner un nombre à une chaîne de caractères). Par contre, le typage est dynamique ce qui
permet de mettre différents types de valeurs dans les variables à différents moments de
l'exécution du code.

Exemple :
a = 55 # déclare a comme une étant un int
print(a) # affiche 55
a = False # change le type de a pour contenir le booléen False
print(a) # affiche False
a = 'Hello' # change le type de a pour contenir une chaîne de caractères
print(a) # affiche 'Hello'

IA - Licence 3 - UMMTO 4
L. Lazib et S. Sadi
 Chaînes de caractères
Les chaînes de caractères en Python sont délimitées avec les caractères " ou '
(guillemets simples ou doubles).

L’exemple suivant illustre quelques opérations sur les chaînes de caractères :

a = 'Hello' # déclare a comme une étant une chaîne de caractères
print(a) # affiche 'Hello'

a = a + ' World' # a vaut 'Hello World'

a = a + str(42) # a vaut 'Hello World42'

# extraire tout à partir du premier caractère

a = a[1:] # similaire aux opérateurs sur les listes et set (voir plus loin)
print(a) # affiche 'ello World42'

print(len(a)) # affiche 12

print([Link]()) # affiche 'ELLO WORLD42'

Listes
Les listes en Python sont des tableaux dynamiques à ne pas confondre avec les Set (bien
que les opérations permises restent très similaires). Contrairement à certains langages, une
liste peut avoir des éléments de différents types.

Python offre une possibilité d’accéder aux listes facilement et de façon optimale. Si a est
une liste, alors:

● a[i] retourne le i ème élément de la liste (en commençant à 0).

● a[-i] retourne le i ème élément en commençant de la fin de la liste.
● a[i:] retourne une nouvelle liste contenant tous les éléments de a en commençant par
le i ème. En particulier, a[:] retourne une copie de la liste.
● a[i:k] retourne une nouvelle liste contenant tous les éléments de a en commençant
par le i ème jusqu'au k ème non inclus. Si i est omis, alors c’est comme si i vallait 0.

L’exemple suivant illustre quelques opérations sur les listes :

a = ['a', 'b', 'c'] # déclare a comme étant une liste
print(a) # affiche ['a', 'b', 'c']

IA - Licence 3 - UMMTO 5
L. Lazib et S. Sadi
 a = ['d', 'e'] + a
print(a) # affiche ['d', 'e', 'a', 'b', 'c']

[Link]() # trie la liste

print(a) # affiche ['a', 'b', 'c', 'd', 'e']
print(len(a)) # affiche 5

print(a[3]) # affiche 'd'

print(a[-3]) # affiche 'c'
print(a[1:3]) # affiche ['b', 'c']
print(a[:3]) # affiche ['a', 'b', 'c']

[Link]('f') # ajoute 'f' à la fin de la liste

print(a) # affiche ['a', 'b', 'c', 'd', 'e', 'f']

b = a # b fait référence à a, mais ce n'est pas une copie

b[0] = 'X' # toutes les modifications sur b, se font aussi sur a
print(a[0]) # affiche 'X'

print('z' in a) # affiche False, car 'z' n'est pas dans a

print('e' in a) # affiche True, car 'e' est dans a

# afficher tous les éléments de la liste

for v in a:
print(v)

# afficher tous les éléments de la liste (en utilisant des indexes)

for i in range(len(a)):
print(a[i])

Sets (ensembles)
Les sets (ou ensembles) sont similaires aux listes et ont beaucoup d’opérations en
commun. Toutefois, ils sont implémentés à l’aide de tables de hachage. Ainsi, les sets ne
tolèrent pas de doublons et ses éléments ne sont pas ordonnés.

L’exemple suivant illustre quelques opérations sur les sets :

a = ('a', 'b', 'c') # déclare a comme étant un set
print(a) # affiche ('a', 'b', 'c')

IA - Licence 3 - UMMTO 6
L. Lazib et S. Sadi
 a = ('d', 'e') + a
print(a) # affiche ('d', 'e', 'a', 'b', 'c')

print(len(a)) # affiche 5

print('z' in a) # affiche False, car 'z' n'est pas dans a

print('e' in a) # affiche True, car 'e' est dans a

l = list(a) # convertit a en une liste dans l

[Link]('c')
print(l) # affiche ['d', 'e', 'a', 'b', 'c', 'c']

s = set(l) # convertit la liste l en set

print(s) # affiche ('d', 'e', 'a', 'b', 'c'), le 'c' dupliqué est enlevé

# set avec un élément

s = ('a', ) # remarquer la virgule additionnelle

# afficher tous les éléments du set

for v in a:
print(v)

Dictionnaires
Les dictionnaires sont des structures de données permettant d’accéder à des données
avec des clés.

L’exemple suivant illustre quelques opérations sur les dictionnaires :

# déclare le dictionnaire
d = {
'prenom': 'John',
'nom': 'Doe',
'age': 22,
}

print(d['prenom']) # affiche 'John'

print(len(d)) # affiche 3

IA - Licence 3 - UMMTO 7
L. Lazib et S. Sadi
 print([Link]()) # affiche ['prenom', 'nom', 'age']
print([Link]()) # affiche ['John', 'Doe', 22]

d['university'] = 'Ummto' # ajoute une valeur dans le dictionnaire

print(d['university']) # affiche 'Ummto'

del d['age'] # supprime la clé 'age' (et sa valeur) depuis le dictionnaire

print('age' in d) # retourne False
print('university' in d) # retourne True
print('University' in d) # retourne False

# Pour boucler sur d:

for k in d:
print('cle ' + k)
print('valeur ' + d[k])

Opérateurs
Python fournit différents opérateurs (similairement à d’autres langages) :
● Opérateurs arithmétiques : +, -, *, /, %
● Opérateurs puissance (x puissance y): x ** y
● Opérateurs de comparaison : >, <, <=, >=, ==, !=
● Opérateurs de logiques : and, or, not. Noter que le vrai et le faux sont
respectivement True et False (respecter la casse).

En plus de ces opérateurs, Python définit l’opérateur is, à ne pas confondre avec l’égalité
(==). En effet, pour Python (a == False) vaut True si :
● a est False ;
● a est 0 ;
● a est None (None étant une valeur spéciale dans Python qui indique “rien”).

Ainsi, pour tester si a est exactement False, il faut utiliser (a is False).

Il existe aussi d’autres opérateurs et fonctions utiles, listés ci-après :

● Valeur absolue : abs(x)
● Opérateurs de conversion : int(x), float(x), str(x)
● min / max d’une liste : min(l), max(l), min(a, b), etc.

IA - Licence 3 - UMMTO 8
L. Lazib et S. Sadi
 Conditions
Les conditions en Python sont formulées comme suite :
if condition1:
pass # mettre les instructions ici, pass = ne rien faire
elif booléen2:
pass
else:
pass

Boucles
Les boucles en Python sont formulées comme suite :
# boucler de 0 à 9
# affiche: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
i = 0
while i < 10:
print(i)
i = i + 1

Nous pouvons aussi utiliser des boucles for, comme suite :

# boucler de 10 à 15 (15 n'est pas inclus) avec un pas de 1
# affiche: 10, 11, 12, 13, 14
for i in range(10, 15):
print(i)

# boucler de 10 à 50 (50 n'est pas inclus) avec un pas de 5

# affiche: 10, 15, 20, 25, 30, 35, 40, 45
for i in range(10, 50, 5):
print(i)

Fonctions
Le Python offre des outils très puissants pour définir et appeler des fonctions, que l’on ne
retrouve pas dans tous les langages. Ainsi, il est notamment possible de :

● définir des paramètres optionnels pour une fonction ;

● appeler une fonction avec des paramètres nommés.

IA - Licence 3 - UMMTO 9
L. Lazib et S. Sadi
Exemple :
# Définit une fonction, avec 5 paramètres.
# Les paramètres 3, 4 et 5 sont optionnels et peuvent être omis lors de l'appel de
la fonction.
# Les paramètres omis prennent la valeur par défaut (0 pour param3, 'hello' pour
param4 et False pour param5)

def ma_fonction(param1, param2, param3=0, param4='hello', param5=False):

return None

# Le code suivant appelle la fonction ma_fonction avec :

# param1='a', param2='b', param3=99 et param5=True
# param4, étant omis va prendre la valeur par défaut ('hello')
ma_fonction('a', 'b', 99, param5=True)

Bibliothèques
Pour utiliser une bibliothèque en Python, il faut déjà l’installer (si ce n’est pas une
bibliothèque déjà existante), et ensuite l’importer. Voici un exemple :
# importer la bibliothèque random
import random as rd

# génère une valeur aléatoire entre 15 et 45

a = [Link](15, 45)

# affiche le nombre
print(a)

Voici un autre exemple :

# importer uniquement la fonction randrange depuis la bibliothèque random
from random import randrange

# génère une valeur aléatoire entre 15 et 45

a = randrange(15, 45)

# affiche le nombre
print(a)

IA - Licence 3 - UMMTO 10
L. Lazib et S. Sadi
 Objets et classes
Python est un langage de programmation orienté objet. Presque tout en Python est un
objet, avec ses propriétés et ses méthodes. Une classe est comme un constructeur d'objet, ou
un "plan" pour créer des objets.

Exemple :
class Person:
def __init__(self, name, age):
# définit les propriétés de la classe
[Link] = name
[Link] = age

# ceci est une méthode de classe

def myfunc(self):
print("Hello my name is " + [Link])

# crée une instance de la classe

p1 = Person("John", 36)

# appelle une méthode de la classe

[Link]()

IA - Licence 3 - UMMTO 11
L. Lazib et S. Sadi