I - Programmation

Python

Tarek SBOUI

Etapes de la programmation
• Écrire un algorithme
• Écrire un programme dans un langage (e.g. Java,
C++, python)
• Compiler le programme
– Traduire le programme dans un langage de bas
niveau (machine)
– [éventuellement optimisation]
– Produire un programme (code) exécutable
• Exécuter le programme
– Charger le programme en mémoire
– Exécuter le programme pour avoir le résultat

1
 Termes
• Syntaxe d’un langage
– Comment formuler une instruction correcte
(grammaire)
• Sémantique
– Ce que l’instruction réalise
• Erreur
– de compilation: typiquement reliée à la syntaxe
– d’exécution: sémantique (souvent plus difficile à
détecter et corriger)

Python
• Open-source : son utilisation est gratuite et les fichiers
sources sont disponibles et modifiables;
• Facile à apprendre, à lire et à écrire ;
• Portable (fonctionne sous de plusieurs systèmes
d'exploitation) ;
• Doté d’une communauté active (plusieurs bibliothèques
disponibles);
• Orienté objet ;
• Typage dynamique

2
 Python : Compilation et Executuon

La compilation et l’exécution sont effectuées par l'environnement de

développement de Python.

Il suffit d'entrer des commandes, de taper <Enter>,

et Python se charge de les compiler et de les exécuter.

Pour savoir si vous avez Python sur votre machine :

- Ouvrir l'invite de commande> Taper py> Appuyez sur
Entrée Si Python est installé, il affichera les détails de
la version. Sinon, il ouvrira le Microsoft Edge

Savoir l’emplqcement de Python

- import sys

locate_python = sys.exec_prefix
print(locate_python)

3
Premiers pas : Calculer avec Python

>>> 5+3
>>> 2 - 9 # les espaces sont optionnels
>>> 7 + 3 * 4 # la hiérarchie des opérations
mathématiques
# est-elle respectée ?
>>> (7+3)*4
>>> 20 / 3

Noms de variables et mots réservés

Les noms de variables sont des noms qu’on choisit assez librement.

Quelques règles pour les noms de variables sous Python :

1. Un nom de variable est une séquence de lettres (a à z , A à Z) et de chiffres (0 à 9), qui

doit toujours commencer par une lettre.

2. Seules les lettres ordinaires sont autorisées. Les lettres accentuées, les cédilles, les
espaces, les caractères spéciaux tels que $, #, @, etc. sont interdits, à l'exception du
caractère _ (souligné).

3. La casse est significative (les caractères majuscules et minuscules sont distingués).

4
 En plus de ces règles, il faut encore ajouter que vous ne pouvez pas utiliser
comme noms de variables les 29 « mots réservés » au langage ci-dessous :

and assert break class continue def

del elif else except exec finally
for from global if import in
is lambda not or pass print
raise return try while yield

Affectation
Nous savons désormais comment choisir judicieusement un nom de variable.
Voyons à présent comment nous pouvons en définir et affecter une valeur.

En Python comme dans de nombreux autres langages, l'opération d'affectation

est représentée par le signe égal :

>>> n = 7 # donner à n la valeur 7

Print (n)

>>> msg = "Quoi de neuf ?" # affecter la valeur "Quoi de neuf ?" à msg

>>> pi = 3.14159 # assigner sa valeur à la variable pi

Mémoire
@
n 7 en binaire
@
msg « quoi de neuf »
en binaire…
@
Pi 3,14159
en binaire
.
.
.

5
 Afficher la valeur d’une variable
Pour afficher la valeur à l'écran, il existe deux possibilités. :

1. La première consiste à entrer au clavier le nom de la variable, puis

<Enter>.

>>> n
7
>>> msg
"Quoi de neuf ? "
>>> pi
3.14159

2. A l'intérieur d'un programme, vous utiliserez toujours l'instruction print :

>>> print (msg)

Quoi de neuf ?

Affectations multiples
Sous Python, on peut assigner une valeur à plusieurs variables simultanément.
Exemple :
>>> x = y = 7
>>> x
7
>>> y
7

On peut aussi effectuer des affectations parallèles à l'aide d'un seul opérateur :
>>> a, b = 4, 8.33
>>> a
4
>>> b
8.33

Dans cet exemple, les variables a et b prennent simultanément les nouvelles

valeurs 4 et 8,33.

6
 Exercice
1. Décrivez le plus clairement possible ce qui se passe à chacune des trois
lignes de l'exemple ci-dessous :

>>> largeur = 20
>>> hauteur = 5 * 9.3
>>> largeur * hauteur
(?)

2. Assignez les valeurs respectives 3, 5, 7 à trois variables a, b, c.

Effectuez l'opération a - b/c.

Opérateurs et expressions
On manipule les valeurs et les variables qui les référencent, en les
combinant avec des opérateurs pour former des expressions.
Exemple :
a, b = 7.3, 12
y = 3*a + b/5

Exercice
Décrivez ce qui se passe à l’exécution des lignes suivantes :

>>> r , pi = 12, 3.14159

>>> s = pi * r**2
>>> s
>>> type(r), type(pi), type(s)
>>>

Quelle est, à votre avis, l'utilité de la fonction type() ?

7
 Structures de contrôle

Structures de contrôle
Les structures de contrôle sont les groupes d'instructions
qui déterminent l'ordre dans lequel les actions sont
effectuées dans le programme.

En programmation moderne, il en existe seulement trois : la

séquence, la sélection que nous allons décrire dans ce
qui suit, et la répétition.

8
Séquence d’instructions :
Sauf mention explicite, les instructions d'un programme s'exécutent les unes
après les autres, dans l'ordre où elles ont été écrites à l'intérieur du programme.
Le « chemin » d’exécution est appelé un flux d'instructions, et les constructions
qui le modifient sont appelées des instructions de contrôle de flux.
Python exécute normalement les instructions de la première à la dernière, sauf
lorsqu'il rencontre une instruction conditionnelle comme l'instruction «if». Une
telle instruction va permettre au programme de suivre différents chemins
suivant les circonstances.

début d’exécution

Instruction de contrôle du flux

if
circonstance1 circonstance2

fin d’exécution

Sélection ou exécution conditionnelle

• C’est une technique permettant d'aiguiller le déroulement du programme dans
différentes directions, en fonction des circonstances rencontrées.
• Disposer d'instructions capables de tester une certaine condition et de modifier le
comportement du programme en conséquence.

L'instruction if.
>>> a = 150
>>> if (a > 100):
... "a dépasse la centaine"
...
Indentation obligatoire

En interactif :
Frappez encore une fois <Enter>. Le programme s'exécute, et vous obtenez :
a dépasse la centaine.
Recommencez le même exercice, mais avec a = 20 en guise de première ligne : cette fois Python
n'affiche plus rien du tout.

9
 >>> a = 20
>>> if (a > 100):
print ("a dépasse la centaine")
else:
print ("a ne dépasse pas cent")

En interactif :
Frappez <Enter> encore une fois. Le programme s'exécute, et affiche cette fois :
a ne dépasse pas cent.

On peut faire mieux encore en utilisant aussi l'instruction elif (contraction

de « else if ») :

a=0
if a > 0 :
print (" a est positif ")
elif a < 0 :
print ("a est négatif")
else:
print ("a est nul")

10
 Exercice

Ecrire une fonction qui demande a l’utilisateur de saisir un

entier («Introduire un entier») jusqu’à ce que cet entier
soit entre 10 et 30.
Afficher l’entier.

>>> a = input('Entrez la première valeur : ')

>>> b = input('Entrez la deuxième valeur : ')
>>> if (a<b):
print (a)
else:
print (b)

11
 >>> nom = input(" Introduire votre nom : ")

nom :

>>> note = int(input("Quelle est votre note ? : "))

>>> if note >= 10:

print("Vous avez la moyenne")
else:
print("Vous n'avez pas la moyenne")

Opérateurs de comparaison
La condition évaluée après l'instruction «if» peut contenir les opérateurs de
comparaison suivants :
x == y # x est égal à y (deux signes « égale » et non d'un seul)
x != y # x est différent de y
x>y # x est plus grand que y
x<y # x est plus petit que y
x >= y # x est plus grand que, ou égal à y
x <= y # x est plus petit que, ou égal à y

Exemple :
>>> a = 7
>>> if (a % 2 == 0):
print ("a est pair")
print ("parce que le reste de sa division par 2 est
nul")
else:
print ("a est impair")

12
 Répétitions en boucle
L'instruction while

L'une des tâches que les machines font le mieux est la répétition sans
erreur de tâches identiques !

Une des méthodes pour programmer ces tâches

répétitives est construite autour de l'instruction while.

1. Entrer les commandes ci-dessous

>>> a = 0
>>> while (a < 7): # (n'oubliez pas le double point !)
a = a + 1 # (n'oubliez pas l'indentation /alignement!)
a

2. Frappez sur <Enter>

3. Que se passe-t-il ?

>>> a = 0
>>> while (a < 7): # (n'oubliez pas le double point !)
... a = a + 1 # (n'oubliez pas l'indentation !)
...a

Commentaires
1. Dans notre exemple, si la condition a < 7 est encore vraie, le corps de la boucle est exécuté une
nouvelle fois et le bouclage se poursuit.
2. La variable évaluée dans la condition doit exister au préalable (Il faut qu'on lui ait déjà affecté au
moins une valeur)
3. Si la condition est fausse au départ, le corps de la boucle n'est jamais exécuté
4. Si la condition reste toujours vraie, alors le corps de la boucle est répété indéfiniment.

>>> n = 3
>>> while n < 5:
"hello !"

13
 Répétitions en boucle
L'instruction for

entête
for <variable> in range(<nombre de repetitions>):
<instruction1>
< instruction2>
… corps
< instructionn>

>>> for x in range(3):

print('Hello!')
Compter n print('goodbye')
fois
Hello!
goodbye
Hello!
Instructions goodbye
Hello!
goodbye

>>> for x in range(0,3):

print('Hello!')
print (x)

x=0
While (x<3):
print('Hello!')
print (x)
x=x+1

14
 >>> for i in range(0,10):
print (i)

>>> liste = [1,5,10,15,20,25]

>>> for i in liste:
if i > 15:
print ("On stoppe la boucle")
break
print (i)

>>> v = "Bonjour toi"

>>> for lettre in v:

print (lettre)

Exercice
Écrire un programme qui affiche les 3 premiers termes de la table
de multiplication par 7.

15
 Les fonctions en
Python

Les fonctions en Python

Il arrivera souvent qu'une même séquence d'instructions doive être utilisée à
plusieurs reprises dans un programme, et on souhaitera bien évidemment ne
pas avoir à la reproduire systématiquement.

La syntaxe Python pour la définition d'une fonction est la suivante:

def nomDeLaFonction(liste de paramètres):

...
bloc d'instructions
...

16
 Fonctions sans paramètre
>>> def table7():
n=1
while n <11 :
print (n * 7)
n = n+1

Pour utiliser la fonction que nous venons de définir, il suffit de l'appeler par
son nom. Ainsi :

>>> table7()

Provoque l'affichage de :

7 14 21 28 35 42 49 56 63 70

Fonctions avec paramètres

La fonction table() telle que définie ci-dessous utilise le paramètre base
pour calculer les dix premiers termes de la table de multiplication de base.

>>> def table(base):

n=1
while n <11 :
print (n, 'x', base, '=', n * base)
n = n +1

Pour tester cette nouvelle fonction, il nous suffit de l'appeler avec un

argument.
>>> table(13)
13 26 39 52 65 78 91 104 117 130
>>> table(9)
9 18 27 36 45 54 63 72 81 90

17
 Exercice
Écrivez un programme qui contient une fonction carre qui calcule
le carré d’un nombre envoyé comme paramètre.

Une fonction peut avoir plusieurs paramètres.

Exemple : Ajouter des paramètres supplémentaires, dans une nouvelle version que nous
appellerons cette fois tableMulti() :

>>> def tableMulti(base, debut, fin):

print ('Fragment de la table de multiplication par', base, ':')
n = debut
while n <= fin :
print (n, 'x', base, '=', n * base)
n = n +1
Cette nouvelle fonction utilise donc trois paramètres : la base de la table comme dans
l'exemple précédent, l'indice du premier terme à afficher, et l'indice du dernier terme à
afficher.

Essayons cette fonction en entrant par exemple :

>>> tableMulti(8, 13, 17)
Fragment de la table de multiplication par 8 :
13 x 8 = 104
14 x 8 = 112
15 x 8 = 120
16 x 8 = 128
17 x 8 = 136

18
 Exercice
Écrivez un programme qui contient une fonction addition qui
calcule la somme de deux nombres envoyés comme paramètre.

Appel/utilisation d’une fonction à

partir d’une autre
Les fonctions peuvent aussi s'utiliser dans d’autres fonctions.
Exemple : Ecrire une programme qui calcule le volume d'une sphère à
l'aide de la formule :

Ecrire le programme en quatre parties :

- Fonction cube() : calcule le cube du rayon r.
- Fonction volumeSphere(). Calcule le vlume de la sphere. A l'intérieur
de la fonction volumeSphere(), il y a un appel de la fonction cube().
- Une invitation a l’utilisateur pour introduire une valeur dans r
- Un appel de la fonction volumeSphere() (avec la valeur introduite par
l’utilisateur), et un affichage du résultat avec la commande print ().

19
>>> def cube(n):
return n**3
>>> def volumeSphere(r):
return 4 * 3.1416 * cube(r) / 3

>>> r = input('Entrez la valeur du rayon : ')

>>> intr = int(r)

>>> print ('Le volume de cette sphère vaut',

volumeSphere(intr))

Listes et dictionnaires

20
 Listes
Une liste : une collection d'éléments séparés par des virgules, l'ensemble étant
enfermé dans des crochets.

Exemple :
>>> jour = ['lundi', 'mardi', 'mercredi', 100, 20.3]
>>> print (jour)
['lundi', 'mardi', 'mercredi', 100, 20.3]

On peut accéder à chacun d'entre eux individuellement si l'on connaît son

index dans la liste

Exemple :
>>> jour = ['lundi', 'mardi', 'mercredi', 100, 20.3]
>>> print (jour[2])
mercredi
>>> print (jour[4])
20.3

Remplacer certains éléments d'une liste par d'autres, comme ci-dessous :

>>> jour[3] = ‘jeudi'
>>> print (jour)

La fonction prédéfinie len(liste) renvoie le nombre d'éléments présents dans la

liste :
>>> len(jour)
5

La fonction prédéfinie del(elements de liste) permet de supprimer d'une liste

un élément quelconque (à partir de son index).
>>> del(jour[4])

La fonction prédéfinie append(element) permet d'ajouter un élément à une liste.

>>> jour.append(‘Jeudi')

21
 Exercice
Analyser le script ci-dessous et commenter son fonctionnement :

>>>jour =
['dimanche','lundi','mardi','mercredi','jeudi','vendredi','samedi']

>>> a = 0
while a<7:
print (a , jour[a])
a=a+1

Exercice
Définissez une fonction listeMax(liste) qui renvoie
l'élément ayant la valeur la plus élevée dans la liste
transmise en argument.

Exemple d'utilisation :
serie = [5, 8, 2, 1, 9, 3, 6, 7]

listeMax(serie )
renvoie
9

22
 Exercice
Définissez une fonction remplirListe(liste, n) qui
reçoit une liste vide et un entier n, et renvoie cette
liste remplie avec n entiers introduits par l’utilisateur.

Exemple d'utilisation :
>>> serie = []
>>> remplirListe(serie, 3)
renvoie
[3, 5, 7]

>>> def remplirlister(liste, n):

for i in range(0, n):
x = int(input('introduire une valeur : '))
liste.append(x)
return liste
>>> serie4 = []
>>> remplirlister(serie4, 4)
introduire une valeur : 3
introduire une valeur : 3
introduire une valeur : 9
[3, 3, 9]
>>>

23
 Exercice
Définissez une fonction indiceMax(liste) qui
renvoie l’indice de l'élément ayant la valeur la plus
élevée dans la liste remplie par l’utilisateur.

Exemple d'utilisation :
serie = [5, 8, 2, 1, 9, 3, 6, 7]

indexMax(serie )
renvoie
4

Dictionnaire
• Un dictionnaire permet de stocker des
paires appelées éléments.
{ 'Cle1' : 'valeur1', 'Cle2' : 'valeur2'}
• Chaque paire d'entrées contient : une clé
et une valeur
• La clé doit être unique dans le
dictionnaire.

24
my_dict = {'nom':'Mariem', 'age': 26}
my_dict ['nom'] est 'Mariem' . my_dict
['age'] est 26
• voiture= {
“marque": "Ford",
"modele": "Mustang",
“annee": 1964
}

# mise a jour d'une valeur

my_dict['age'] = 27

# Ajout d'un element

my_dict['address'] = 'Tunis‘

# supprimer un element
del my_dict ['address']

25
my_dict.items() # renvoyer les elements
my_dict.keys() # renvoyer les cles
my_dict.values() # renvoyer les valeur

my_dict['name'] = my_dict.pop('nom') # mise a

jour d'une cle // dict[new_key] = dict.pop(old_key)

Exercise
• Créez trois dictionnaires contenant chacun
deux clés nom, annee. Puis créez un
dictionnaire qui contient les trois autres
dictionnaires.

26
 Solution

• child1 = {"nom":"Sarra","annee":2004 }
child2 = {"nom":"Ali","annee":2002 }
child3 = {"nom":"Fatma","annee":2000 }
myfamily = {
"ch1" : child1,
"ch2" : child2,
"ch3" : child3
}

La programmation
Orientée Objet dans
Python

27
 La programmation Orientée
Objet (POO) dans Python
• Il y plusieurs types de base en Python (int, float, str,
etc.).
• La notion de classe permet d’entendre la notion de «
type » en créant de nouvelles structures/types de
données (les classes).
• Une classe contient des attributs et des méthodes.
– Exemple, une classe voiture peut être caractérisée par
un attribut couleur, un attribut vitesse, etc. La classe
Voiture pourra également définir une méthode rouler().

POO - Définition d’une classe

Définition d’une classe en Python
• class Point:

• Création d’un objet (ou instance) de type Point

Point ()
• Mettons la référence à cet objet dans la variable p :
p = Point ()

28
 POO - Définition des attributs
>>> class Point:
"c’est une classe"

>>> p = Point()
>>> p.x = 1
>>> p.y = 2
>>> print("p : x =", p.x, "y =", p.y)

• la variable p contient la reference

indiquant l’emplacement
memoire du nouvel objet (objet X 1
Point), qui contient lui-meme les p
deux attributs x et y. Ceux-ci Y 2
contiennent les references des
valeurs 1 et 2, memorisees
ailleurs.

29
 POO - Définition des methodes
class Point:
def deplace(self, dx, dy):
self.x = self.x + dx
self.y = self.y + dy

>>> class Point:

def deplace(self, dx, dy):
self.x = self.x + dx
self.y = self.y + dy
>>> a = Point()
>>> a.x = 1
>>> a.y = 2
>>> print("a : x =", a.x, "y =", a.y)
>>> a.deplace(3, 5)
>>> print("a : x =", a.x, "y =", a.y)

30
POO- La notion de constructeur
>>> class Point:
def __init__(self):
self.x = 0
self.y = 0
>>> a = Point()
>>> print("a : x =", a.x, "y =", a.y)
>>> a.x = 1
>>> a.y = 2
>>> print("a : x =", a.x, "y =", a.y)

class Point:
def __init__(self, abs, ord):
self.x = abs
self.y = ord

a = Point(1, 2)
print("a : x =", a.x, "y =", a.y)

31
class Point:
def __init__(self, x, y):
self.x = x
self.y = y

a = Point(1, 2)
print("a : x =", a.x, "y =", a.y)

POO - exemple
>>> class Point:
def __init__(self, abs, ord):
self.x = abs
self.y = ord
def deplace(self, dx, dy):
self.x = self.x + dx
self.y = self.y + dy

32
>>> a = Point(1, 2)
>>> b = Point(3, 4)
>>> print("a : x =", a.x, "y =", a.y)
>>> print("b : x =", b.x, "y =", b.y)
>>> a.deplace(3, 5)
>>> b.deplace(-1, -2)
>>> print("a : x =", a.x, "y =", a.y)
>>> print("b : x =", b.x, "y =", b.y)

Methode statique
Une méthode statique peut être appelée sans créer d’objet/instance.
class Music:
@staticmethod
def play():
print("*playing music*")

def stop(self):
print("stop playing")

m = Music()
Music.play()
Music.stop() # Erreur. On doit creer un objet
# -------------------------- solution :
m.stop()

33
 II- Programmation
SIG - Python

Python et SIG – pourquoi ?

• Effectuer des traitements répétitifs
• Etendre un SIG avec un programme Python
– Exemples : Python et QGIS, Python et ArcGIS

1
 Les packages/modules Python
• Packages liés à un SIG
– ArcPy pour ArcGIS
– PyQGIS pour QGIS
• Packages indépendants des SIG (exemples :
Geopandas, pyproj, Rasterio)

Quelques packages/modules
• GDAL : Geospatial Data Abstraction Library (GDAL) / OGR combine deux modules
distinctes qui sont généralement téléchargées ensemble en tant que GDAL.
– GDAL est largement utilisée pour les données raster. Elle permet la lecture et l'écriture de nombreux formats de
fichiers raster.

– La bibliothèque OGR est utilisée pour lire et écrire des données vectorielles ( plusieurs formats tel que le .shp).

• Geopandas : Facilite le traitement de données vectorielle. Il combine deux modules :

pandas et shapely. Basé sur GDAL et NumPy

• NumPy est un package analytique basé sur des vecteurs (tableaux) et des matrices.

• Pyproj : Effectue des transformations cartographiques et des calculs géodésiques.

• Rasterio : Facilite le traitement de données raster avec Python.

• Le module pyplot de la bibliothèque matplotlib qui permet de créer des graphiques.

2
 Installation des packages
• Python bénéficie d’une communauté active d'intervenants qui développent des
programmes/modules qui peuvent être réutilisés par d’autres développeurs Python.
• pip est l’outil d’installation. À partir de Python 3.4, il est inclus par défaut avec
l’installateur de Python.
• La commande suivante installe la dernière version d’un module et ses dépendances (en
principe) :
• python -m pip install unPackage

• Normalement, si un module approprié est déjà installé, l’installer à nouveau n’aura

aucun effet.
• Mise à jour de modules existants :
• python -m pip install --upgrade SomePackage

Traitement de données
vectorielles
Sections :
1. Le package Geopandas
2. Lire des données vectorielles
3.Sélecter et itérer sur des données vectorielles
4.Créer une nouvelle colonne
5. Créer un shapefile à partir d’un autre
6. Autres traitements sur les données vectorielles :
- regrouper les données vectorielles.
- établir une zone tampon (Buffer).

3
 Traitement de données vectorielles
Geopandas
1- le package Geopandas
• Geopandas est un package Python construit au-dessus du package Pandas (package
d'analyse de données non-spatiales).
• Geopandas permet de traiter des données géospatiales stockées par exemple dans un
Shapefile ou dans une base de données PostGIS.
• Geopandas possède plusieurs fonctionnalités de traitement/analyse spatiale telles que
l'analyse de superposition (overlay), le géocodage, l'agrégation spatiale et les jointures
attributaires/spatiales.

• Nous utilisons des données que vous pouvez télécharger à partir de :

https://github.com/Automating-GIS-processes/Lesson-2-Geo-DataFrames/raw/master/data/Data.zip.

• Décompresser le fichier Data.zip. Le dossier Data contient un Shapefile appelé

DAMSELFISH_distribution.shp.

Traitement de données vectorielles

2- Lire des données vectorielles
• Les données spatiales peuvent être lues en utilisant la fonction read_file () de geopandas :

# Importer les modules necessaries

import geopandas as gpd
import matplotlib.pyplot as plt

# Definir le chemin du fichier

fp = "./Data_geopandas_L2Git_DAMSELFISH/DAMSELFISH_distributions.shp"
bochra est de type etudient
c a d etudient c la classe de bochra # Lire le fichier en utilisant gpd.read_file()
data = gpd.read_file(fp)

# Aficher le type de data on a associer le fichier par un objet qui est data
print (type(data))

Résultat : geopandas.geodataframe.GeoDataFrame

4
Traitement de données vectorielles
• Geopandas peut également charger des données directement à partir d'un URL :
import geopandas
url = "http://d2ad6b4ur7yvpq.cloudfront.net/naturalearth-3.3.0/ne_110m_land.geojson"
df = geopandas.read_file(url)

• Ou à partir d’un fichier .zip

zipfile = "zip://C:/Users/……/cb_2017_us_state_500k.zip"
states = geopandas.read_file(zipfile)

Traitement de données vectorielles

• Si les données se trouvent dans un dossier (ex. data) dans le .zip, vous devez ajouter son
nom:
zipfiledd = "zip://C:/Users/……/cb_2017_us_state_500k-2.zip!data"
statesd = geopandas.read_file(zipfiledd)

• S'il y a plusieurs données dans un dossier du fichier ZIP, vous devez également spécifier
le nom du fichier:
zipfilefd = "zip://C:/Users/……../cb_2017_us_state_500k-
2.zip!data/cb_2017_us_state_500k.shp"
statesfd = geopandas.read_file(zipfilefd)

# si plusieurs donnees directement dans le .zip (et pas dans un dossier dans le .zip)
zipfilef =
"zip://C:/Users/……./cb_2017_us_state_500k.zip/cb_2017_us_state_500k.shp"
statesf = geopandas.read_file(zipfilef)

5
comment cree un objet:
objet nom de l objet
nom de la classe() parametre init

Traitement de données vectorielles

 Visualiser les données sur une carte.

• La fonction .plot () de geopandas crée une carte simple à partir des données :

# afficher les donnees

data.plot ()
plt.show()

plot cree une carte

Traitement de données vectorielles

• GeoDataFrame (la classe de l'objet data) étend les fonctionnalités de
pandas.DataFrame pour gérer les données géospatiales (d'où le nom geopandas).
• Explorer les données data et afficher les 5 premières lignes à l'aide de la fonction head
() (affiche les 5 premières lignes par défaut).

print (data.head())

Résultat :
ID_NO ... geometry
0 183963.0 ... POLYGON ((-115.64375 29.71392, -115.61585 29.6...
1 183963.0 ... POLYGON ((-105.58995 21.89340, -105.56483 21.8...
2 183963.0 ... POLYGON ((-111.15962 19.01536, -111.15948 18.9...
3 183793.0 ... POLYGON ((-80.86500 -0.77894, -80.75930 -0.833...
4 183793.0 ... POLYGON ((-67.33922 -55.67610, -67.33755 -55.6...

6
Traitement de données vectorielles
 Afficher le système de coordonnées (CRS)

• GeoDataFrame contient des informations sur le système de coordonnées.

• Utiliser l'attribut crs pour afficher sur le système de coordonnées :

print(data.crs)

Résultat :
epsg:4326 ….

• Le code EPSG 4326 fait référence au système de coordonnées WGS84.

Traitement de données vectorielles

 Géométries dans Geopandas

• Les géométries sont stockées dans une colonne appelée geometry qui est un nom de la
colonne par défaut pour stocker les données géométriques dans geopandas.

• Imprimer les 5 premières lignes de la colonne 'geometry' :

# Il est possible de spécifier uniquement des colonnes spécifiques en indiquant le nom de la colonne
entre crochets []
print (data['geometry'].head())

Résultat :
0 POLYGON ((-115.6437454219999 29.71392059300007...
1 POLYGON ((-105.589950704 21.89339825500002, -1...
2 POLYGON ((-111.159618439 19.01535626700007, -1...
3 POLYGON ((-80.86500229899997 -0.77894492099994...
4 POLYGON ((-67.33922225599997 -55.6761029239999...
Name: geometry, dtype: object