03/12/2024 13:30 03_numpy_pandas_bases

Chapitre 3 - Python et les données

(NumPy et Pandas)
Les deux packages principaux pour manipuler des données sont NumPy et Pandas, nous
allons ici détailler l'utilisation des trois structures de base de ces packages que sont les
ndarray de NumPy et les Series et DataFrame de Pandas.

3.2 NumPy et ses ndarray

3.2.1 Les ndarray de NumPy
Ces structures sont des structures multidimensionnelles dans lequelles on va
généralement avoir un seul type de données.

Un array à une dimension est un vecteur, un array à deux dimensions est une matrice.

On commence par importer NumPy

In [1]: import numpy as np

3.2.2 Construction des ndarray

A partir d'une liste

In [89]: array_de_liste=[Link]([[1,4,7,9],[1,4,7,9],[1,4,7,9]])
print(array_de_liste)

[[1 4 7 9]
[1 4 7 9]
[1 4 7 9]]

[Link] ITC A/Python/03_numpy_pandas_bases.html 1/17

03/12/2024 13:30 03_numpy_pandas_bases

à partir d'une suite d'entiers

In [91]: array_range=[Link](0,10,0.1)
print(array_range)

[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. 1.1 1.2 1.3 1.4 1.5 1.6 1.7
1.8 1.9 2. 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3. 3.1 3.2 3.3 3.4 3.5
3.6 3.7 3.8 3.9 4. 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 5. 5.1 5.2 5.3
5.4 5.5 5.6 5.7 5.8 5.9 6. 6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9 7. 7.1
7.2 7.3 7.4 7.5 7.6 7.7 7.8 7.9 8. 8.1 8.2 8.3 8.4 8.5 8.6 8.7 8.8 8.9
9. 9.1 9.2 9.3 9.4 9.5 9.6 9.7 9.8 9.9]

en découpant un intervalle

In [94]: array_linspace=[Link](0,9,10)
print(array_linspace)

[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

en utilisant des fonctions génératrices d'arrays

In [95]: array_ones=[Link]((4,4))
print(array_ones)

[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]

In [96]: array_ones=[Link](4)
print(array_ones)

[1. 1. 1. 1.]

3.2.3 Les types de données dans les ndarrays

On peut fixer le type des ndarrays en utilisant le paramètre dtype.

Le dtype peut être un des types de base mais aussi d'autres types comme
np.complex128 si nécessaire.

In [97]: arr1=[Link]([1,4,7,9], dtype=int)

arr1

Out[97]: array([1, 4, 7, 9])

In [106… arr2=[Link]([1,4,7,9], dtype=float)

print(arr2)

[1. 4. 7. 9.]

3.2.4 Les propriétés d'un ndarray

In [105… # on génère un array de nombres aléatoires tirés d'une
# loi normale centrée réduite
arr_norm =[Link](100000)

[Link] ITC A/Python/03_numpy_pandas_bases.html 2/17

03/12/2024 13:30 03_numpy_pandas_bases

np.set_printoptions(threshold=[Link])
arr_norm

On peut donc extraite des informations sur notre array, ce sont ses propriétés

In [108… [Link](10,50, size=(5,3))

Out[108… array([[44, 17, 29],

[31, 44, 40],
[23, 35, 29],
[11, 18, 22],
[49, 42, 27]])

In [8]: print(arr_norm.shape, arr_norm.dtype, arr_norm.ndim, arr_norm.size,

arr_norm.itemsize, sep=" - ")

(100000,) - float64 - 1 - 100000 - 8

3.2.5 Accéder aux éléments d'un array

Pour passer à deux dimensions, on utilise :

In [121… arr_mult=[Link](109).reshape(20,5)
# on affiche la forme d'une sous-matrice
arr_mult[:,[0,4]].shape

Out[121… (20, 2)

In [10]: # on peut extraite plusieurs lignes

list_ind=[2,5,7,9,14,18]
arr_mult[list_ind, :].shape

Out[10]: (6, 5)

3.2.6 La manipulation des arrays avec NumPy

Les opérations sur les arrays sont des opérations terme à terme.

La notion de broadcasting permet d'appliquer des opérations entre des arrays de tailles
différentes.

In [11]: arr1=[Link]([1,4,7,9])
arr2=[Link](3)
# on ne peut pas faire la somme de ces arrays car ils n'ont pas de dimensions co
try:
arr1+arr2
except Exception as e:
print("Erreur:",e)

Erreur: operands could not be broadcast together with shapes (4,) (3,)

In [12]: arr3=[Link]((3,4))
# par contre, on peut faire cette somme
arr1+arr3

[Link] ITC A/Python/03_numpy_pandas_bases.html 3/17

03/12/2024 13:30 03_numpy_pandas_bases

Out[12]: array([[ 2., 5., 8., 10.],

[ 2., 5., 8., 10.],
[ 2., 5., 8., 10.]])

Exercice
Je suis ligoté sur les rails en gare d’Arras. Écrire un programme qui affiche un tableau me
permettant de connaître l’heure à laquelle je serai déchiqueté par le train parti de la gare
du Nord à 9h (il y a 170 km entre la gare du Nord et Arras). Le tableau prédira les
différentes heures possibles pour toutes les vitesses de 100 km/h à 300 km/h, par pas de
50 km/h, les résultats étant arrondis à la minute inférieure. Vous pourrez utiliser les
fonctions linspace or [Link]. Par exemple les 4 commandes ci-dessous donnent le
même résultat

In [123… x = [Link]([0.1, 0.3, 0.5, 0.7, 0.9, 1.1])

y1 = [Link](0.1, 1.1, 6)
y2 = [Link](0.1, 1.1, 0.2)
y3 = [Link](0.1, 1.11, 0.2)

In [124… vitesse = [Link](100.0, 300.0, 6)

heure = 9 + 170/vitesse
print(heure)

[10.7 10.21428571 9.94444444 9.77272727 9.65384615 9.56666667]

In [126… # Autre méthode

# Paramètres
distance_km = 170 # Distance entre la gare du Nord et Arras
depart_heure = 9 # Heure de départ (9h00)
depart_minute = 0 # Minutes de départ

# Vitesse en km/h de 100 à 300 par pas de 50

vitesses = [Link](100, 301, 50)

# Calcul du temps de trajet en heures pour chaque vitesse

temps_heures = distance_km / vitesses

# Convertir le temps de trajet en minutes

temps_minutes = temps_heures * 60

# Calculer l'heure d'arrivée pour chaque vitesse

heures_arrivee = []
for t in temps_minutes:
total_minutes = depart_heure * 60 + depart_minute + t
heure_arrivee = total_minutes // 60 # Heure entière
minute_arrivee = total_minutes % 60 # Minutes restantes
heures_arrivee.append(f"{int(heure_arrivee):02}:{int(minute_arrivee):02}")

print(vitesses,heures_arrivee)

[100 150 200 250 300] ['10:42', '10:08', '09:51', '09:40', '09:34']

In [127… import pandas as pd

# Créer un tableau avec les résultats
tableau = [Link]({
'Vitesse (km/h)': vitesses,
'Heure d\'arrivée': heures_arrivee

[Link] ITC A/Python/03_numpy_pandas_bases.html 4/17

03/12/2024 13:30 03_numpy_pandas_bases

})

# Afficher le tableau
print(tableau)

Vitesse (km/h) Heure d'arrivée

0 100 10:42
1 150 10:08
2 200 09:51
3 250 09:40
4 300 09:34

Cas d'application du broadcasting sur une image

On génère un array équivalent à une image de 1000 par 2000 pixels :

In [ ]:

In [13]: image=[Link](0,255,(1000,2000,3))
[Link]

Out[13]: (1000, 2000, 3)

On génère un array qui va nous permettre de transformer tous les pixels de notre image.

In [14]: transf = [Link]([100, 255, 34])

[Link]

Out[14]: (3,)

On peut appliquer la transformation en divisant la valeur de la couleur de chaque pixel

par notre vecteur de transformation

In [15]: new_image = image/transf

new_image.shape

Out[15]: (1000, 2000, 3)

Manipulation d’arrays
On travaille sur une nouvelle structure à 3 dimensions.

In [16]: array_image=[Link](1,255,(500,1000,3))
print(array_image.dtype, array_image.shape)

int32 (500, 1000, 3)

On peut extraire un rectangle à partir de notre image (100 premiers pixels

horizontalement et 200 derniers pixels verticalement)

In [17]: array_image_rect=array_image[:100,-200:]
array_image_rect.shape

Out[17]: (100, 200, 3)

[Link] ITC A/Python/03_numpy_pandas_bases.html 5/17

03/12/2024 13:30 03_numpy_pandas_bases

On peut passer notre image au format 2 dimensions (on empile les pixels). Le -1 est
automatiquement remplacé par sa valeur par NumPy (500000)

In [18]: array_image_empile = array_image.reshape(-1,3)

array_image_empile.shape

Out[18]: (500000, 3)

On peut ausi changer la forme d'un array en utilisant .shape :

In [19]: array_vec=[Link](10)
array_vec.shape=(5,2)
array_vec

Out[19]: array([[0, 1],

[2, 3],
[4, 5],
[6, 7],
[8, 9]])

Les fonctions universelles de NumPy

On va comparer trois approches pour calculer une somme sur les éléments d'un array

1ère approche avec Python

In [20]: %%timeit
somme=0
for elem in arr_mult :
somme+= elem

23 µs ± 4.52 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

2ème approche avec les fonctions universelles de Python

In [21]: %timeit sum(arr_mult)

23.4 µs ± 2.7 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

3ème approche avec les fonctions universelles de NumPy

In [22]: %timeit [Link](arr_mult)

5.32 µs ± 578 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

Les fonctions de génération de nombres aléatoires

NumPy possède un module spécifique pour ce type de fonctions, il s'agit de random.

Pour générer des nombres aléatoires issus d'une loi normale centrée réduite, on utilise :

In [23]: [Link](4)

Out[23]: array([-0.30674376, 0.33259702, -0.41886299, -0.9632654 ])

[Link] ITC A/Python/03_numpy_pandas_bases.html 6/17

03/12/2024 13:30 03_numpy_pandas_bases

Pour générer des nombres aléatoires entre 0 et 1 issus d'une loi uniforme, on utilise :

In [24]: [Link](size=(2,2))

Out[24]: array([[0.44772397, 0.72128319],

[0.28748153, 0.07862287]])

Pour générer des entiers entre 0 et 4, on utilise :

In [25]: [Link](0,5,size=10)

Out[25]: array([3, 0, 4, 1, 0, 1, 4, 3, 3, 0])

Fixer la graine (seed)

Lorsqu'on veut pouvoir reproduire une analyse, on peut fixer la graine qui permet de
générer les nombres pseudo-aléatoires.

In [26]: # on crée un objet avec une graine fixée

rand_gen=[Link](seed=12345)

In [27]: # on crée un autre objet avec une graine fixée

rand_gen2=[Link](seed=12345)

In [28]: print(rand_gen.randn(2))
print(rand_gen2.randn(2))
rand_gen.randn(2)==rand_gen2.randn(2)

[-0.20470766 0.47894334]
[-0.20470766 0.47894334]
Out[28]: array([ True, True])

3.2.7 Copies et vues d'array

Dans le cas classique, on fait référence au même objet (il s'agit d'un pointeur)

In [29]: a=[Link](10)
b=a
b[3]=33
print(a[3])

33

In [30]: [Link] = (2,5)

[Link]

Out[30]: (2, 5)

Si on crée une vue, on a :

In [31]: a=[Link](10)
b=[Link]()
b[3]=33
print(a[3])

[Link] ITC A/Python/03_numpy_pandas_bases.html 7/17

03/12/2024 13:30 03_numpy_pandas_bases

33

In [32]: [Link] = (2,5)

[Link]

Out[32]: (10,)

Si on crée une copie, on a :

In [33]: a=[Link](10)
b=[Link]()
b[1]=33
print(a[1])

In [34]: [Link] = (5,2)

[Link]

Out[34]: (10,)

Les arrays structurés

Il s'agit d'un type d'array moins utilisé mais qui permet d'avoir plusieurs types dans le
même array

In [35]: array_struct = [Link]([('Client A', 900, 'Paris'),

('Client B', 1200, 'Lyon')],
dtype=[('Clients', 'U10'),
('CA', 'int'),
('Ville', 'U10')])
array_struct

Out[35]: array([('Client A', 900, 'Paris'), ('Client B', 1200, 'Lyon')],

dtype=[('Clients', '<U10'), ('CA', '<i4'), ('Ville', '<U10')])

In [36]: array_struct['Clients']

Out[36]: array(['Client A', 'Client B'], dtype='<U10')

In [37]: array_struct['CA'][0]

Out[37]: 900

Exportation et importation d'arrays

pickle permet de sauver n'importe quel type d'objet Python mais NumPy a ses propres
approches pour cela.

In [38]: # on construit un array

array_grand=[Link]((100000,100))

In [39]: # on exporte avec save au format .npy

%time [Link]("grand_array.npy", array_grand)

[Link] ITC A/Python/03_numpy_pandas_bases.html 8/17

03/12/2024 13:30 03_numpy_pandas_bases

CPU times: total: 62.5 ms

Wall time: 1.54 s

In [40]: # on exporte en texte avec savetxt

%time [Link]("grand_array.txt", array_grand)

CPU times: total: 14.9 s

Wall time: 19.9 s

In [41]: import os

In [42]: print("Taille du fichier .npy :",[Link]("grand_array.npy").st_size)

Taille du fichier .npy : 80000128

In [43]: print("Taille du fichier .txt :", [Link]("grand_array.txt").st_size)

Taille du fichier .txt : 250100000

In [44]: # on supprime l'array

del array_grand

In [45]: # on recharge array_grand à partir du fichier .npy

%time array_grand=[Link]("grand_array.npy")

CPU times: total: 109 ms

Wall time: 113 ms

In [46]: del array_grand

In [47]: # on recharge array_grand à partir du fichier .txt

%time array_grand=[Link]("grand_array.txt")

CPU times: total: 7.05 s

Wall time: 7.52 s

3.3 Les objets de Pandas

3.3.1 Les objets Series de Pandas
La première structure de Pandas est l'objet Series.

In [48]: from pandas import Series

On peut créer une Series à partir d'une liste avec des index

In [145… ma_serie = Series([8.,70,320, 1200],index=["Suisse","France","USA","Chine"])

ma_serie

Out[145… Suisse 8.0

France 70.0
USA 320.0
Chine 1200.0
dtype: float64

On peut créer un objet Series à partir d'un dictionnaire

[Link] ITC A/Python/03_numpy_pandas_bases.html 9/17

03/12/2024 13:30 03_numpy_pandas_bases

In [50]: ma_serie2= Series({"Suisse" :8,"France" :70,"USA" :320,"Chine" :1200})

ma_serie2

Out[50]: Suisse 8
France 70
USA 320
Chine 1200
dtype: int64

On peut créer un objet Series à partir d'une fonction de NumPy

In [51]: ma_serie3= Series([Link](5), index=["A","B","C","D","E"])

ma_serie3

Out[51]: A 0.006410
B -1.215372
C -0.281820
D -0.600510
E 0.720283
dtype: float64

Extraire des éléments d'un objet Series

On peut extraire des éléments directement à partir de l'objet Series

In [52]: ma_serie.iloc[:3] # équivalent à ma_serie[:3]

Out[52]: Suisse 8
France 70
USA 320
dtype: int64

on peut extraire des éléments par leur index

In [53]: ma_serie[["Suisse","France","USA"]]

Out[53]: Suisse 8
France 70
USA 320
dtype: int64

on peut appliquer des conditions simples

In [54]: ma_serie[ma_serie>50]

Out[54]: France 70
USA 320
Chine 1200
dtype: int64

et des conditions plus complexes avec les opérateurs | et &

In [55]: ma_serie[(ma_serie>500)|(ma_serie<50)]

Out[55]: Suisse 8
Chine 1200
dtype: int64

[Link] ITC A/Python/03_numpy_pandas_bases.html 10/17

03/12/2024 13:30 03_numpy_pandas_bases

Calculs sur les objets Series

On peut utiliser l'opérateur + pour faire une somme

In [56]: ma_serie3= Series([Link](5),index=["A","B","C","D","E"])

ma_serie4=Series([Link](4), index=["A","B","C","F"])
ma_serie3+ma_serie4

Out[56]: A -1.682827
B -1.659241
C -1.268362
D NaN
E NaN
F NaN
dtype: float64

In [146… ma_serie3

Out[146… A -1.039411
B -0.955525
C -0.657389
D 0.624117
E -1.591925
dtype: float64

In [147… ma_serie4

Out[147… A -0.643416
B -0.703716
C -0.610973
F 0.763070
dtype: float64

Si on veut faire en sorte de ne pas avoir de données manquantes, on utilise :

In [57]: ma_serie3.add(ma_serie4, fill_value=0)

Out[57]: A -1.682827
B -1.659241
C -1.268362
D 0.624117
E -1.591925
F 0.763070
dtype: float64

3.3.2 Les objets DataFrame de Pandas

Il s'agit de la structure principale de Pandas

In [58]: import pandas as pd

On peut créer un DataFrame à partir d'une liste :

In [59]: frame_list=[Link]([[2,4,6,7],[3,5,5,9]])
frame_list

[Link] ITC A/Python/03_numpy_pandas_bases.html 11/17

03/12/2024 13:30 03_numpy_pandas_bases

Out[59]: 0 1 2 3

0 2 4 6 7

1 3 5 5 9

On peut construire un DataFrame à partir d'un dictionnaire :

In [60]: dico1={"RS" :["Facebook","Twitter","Instagram","Linkedin","Snapchat"],

"Budget" :[100,50,20,100,50],"Audience" :[1000,300,400,50,200]}
frame_dico=[Link](dico1)
frame_dico

Out[60]: RS Budget Audience

0 Facebook 100 1000

1 Twitter 50 300

2 Instagram 20 400

3 Linkedin 100 50

4 Snapchat 50 200

On peut construire un DataFrame à partir d'un array :

In [150… frame_mult=[Link](arr_mult[:5,:],columns=["A","B","C","D","E"],
index=["Obs_" + str(i+1) for i in range(1,6)])
frame_mult

Out[150… A B C D E

Obs_2 9 10 11 12 13

Obs_3 14 15 16 17 18

Obs_4 19 20 21 22 23

Obs_5 24 25 26 27 28

Obs_6 29 30 31 32 33

In [163… arr_mult

[Link] ITC A/Python/03_numpy_pandas_bases.html 12/17

03/12/2024 13:30 03_numpy_pandas_bases

Out[163… array([[ 9, 10, 11, 12, 13],

[ 14, 15, 16, 17, 18],
[ 19, 20, 21, 22, 23],
[ 24, 25, 26, 27, 28],
[ 29, 30, 31, 32, 33],
[ 34, 35, 36, 37, 38],
[ 39, 40, 41, 42, 43],
[ 44, 45, 46, 47, 48],
[ 49, 50, 51, 52, 53],
[ 54, 55, 56, 57, 58],
[ 59, 60, 61, 62, 63],
[ 64, 65, 66, 67, 68],
[ 69, 70, 71, 72, 73],
[ 74, 75, 76, 77, 78],
[ 79, 80, 81, 82, 83],
[ 84, 85, 86, 87, 88],
[ 89, 90, 91, 92, 93],
[ 94, 95, 96, 97, 98],
[ 99, 100, 101, 102, 103],
[104, 105, 106, 107, 108]])

On peut extraire une colonne avec :

In [151… frame_mult["A"]

Out[151… Obs_2 9
Obs_3 14
Obs_4 19
Obs_5 24
Obs_6 29
Name: A, dtype: int32

On peut construire de nouvelles colonnes facilement

In [154… frame_mult["F"]=frame_mult["A"]*2
frame_mult

Out[154… A B C D E F

Obs_2 9 10 11 12 13 18

Obs_3 14 15 16 17 18 28

Obs_4 19 20 21 22 23 38

Obs_5 24 25 26 27 28 48

Obs_6 29 30 31 32 33 58

In [155… col = [12,13,14,15,16]

frame_mult["G"]=col
frame_mult

[Link] ITC A/Python/03_numpy_pandas_bases.html 13/17

03/12/2024 13:30 03_numpy_pandas_bases

Out[155… A B C D E F G

Obs_2 9 10 11 12 13 18 12

Obs_3 14 15 16 17 18 28 13

Obs_4 19 20 21 22 23 38 14

Obs_5 24 25 26 27 28 48 15

Obs_6 29 30 31 32 33 58 16

In [156… # on supprime la colonne

del frame_mult["F"]

In [160… # on peut insérer une colonne à un point précis dans le DataFrame

frame_mult.insert(1,"X",frame_mult["A"]*2)

In [161… frame_mult

Out[161… F X A B C D E G

Obs_2 18 18 9 10 11 12 13 12

Obs_3 28 28 14 15 16 17 18 13

Obs_4 38 38 19 20 21 22 23 14

Obs_5 48 48 24 25 26 27 28 15

Obs_6 58 58 29 30 31 32 33 16

In [162… # on supprime la colonne

del frame_mult["F"]
del frame_mult["X"]
frame_mult

Out[162… A B C D E G

Obs_2 9 10 11 12 13 12

Obs_3 14 15 16 17 18 13

Obs_4 19 20 21 22 23 14

Obs_5 24 25 26 27 28 15

Obs_6 29 30 31 32 33 16

Accéder et manipuler les lignes du DataFrame

On extrait une ligne par son index en utilisant :

In [67]: frame_mult.loc["Obs_4"]

[Link] ITC A/Python/03_numpy_pandas_bases.html 14/17

03/12/2024 13:30 03_numpy_pandas_bases

Out[67]: A 10
B 11
C 12
D 13
E 14
Name: Obs_4, dtype: int32

On extrait une ligne par sa position en utilisant

In [68]: frame_mult.iloc[3]

Out[68]: A 15
B 16
C 17
D 18
E 19
Name: Obs_5, dtype: int32

On extrait des valeurs à partir de listes :

In [69]: frame_mult.loc[["Obs_2","Obs_3"],["A","B"]]

Out[69]: A B

Obs_2 0 1

Obs_3 5 6

On peut extraire une sous-partie du DataFrame

In [70]: frame_mult.iloc[1:3,:2]

Out[70]: A B

Obs_3 5 6

Obs_4 10 11

Réindexation d'un DataFrame

In [164… frame_vec =[Link](array_vec,index=["a","b","c","d","e"],columns=["A","B"])

frame_vec

Out[164… A B

a 0 1

b 2 3

c 4 5

d 6 7

e 8 9

In [72]: frame_vec.reindex(index=["e","c","d"], columns=["B","A"])

[Link] ITC A/Python/03_numpy_pandas_bases.html 15/17

03/12/2024 13:30 03_numpy_pandas_bases

Out[72]: B A

e 9 8

c 5 4

d 7 6

On peut réindexer le DataFrame en utilisant des fonctions lambda :

In [73]: frame_vec2=frame_vec.rename(mapper=lambda x : "Obs. "+[Link](),axis=0)

frame_vec2=frame_vec2.rename(mapper=lambda x : "Var. "+[Link](), axis=1)

In [74]: frame_vec2

Out[74]: Var. A Var. B

Obs. A 0 1

Obs. B 2 3

Obs. C 4 5

Obs. D 6 7

Obs. E 8 9

On peut aussi renommer les colonnes et les index avec des dictionnaires

In [75]: frame_vec.rename(columns={"A" :"nouveau_A"}, index={"a" :"nouveau_a"})

Out[75]: nouveau_A B

nouveau_a 0 1

b 2 3

c 4 5

d 6 7

e 8 9

3.3.3 Copie et vue d'objets de Pandas

Les objets DataFrame de Pandas sont liés aux objets qui ont été utilisé pour les définir :

In [174… arr1=[Link](6).reshape(3,2) #on crée un array

frame1=[Link](arr1) # on crée un DataFrame à partir de l’array
[Link][1,1]=22 # on modifie une valeur du DataFrame

[[0 1]
[2 3]
[4 5]]
Out[174… array([[ 0, 1],
[ 2, 22],
[ 4, 5]])

[Link] ITC A/Python/03_numpy_pandas_bases.html 16/17

03/12/2024 13:30 03_numpy_pandas_bases

In [170… L = list(range(5))
X = L
[Link]()
print(L)

[0, 1, 2, 3]

In [77]: # l'array générateur est modifié

arr1

Out[77]: array([[ 0, 1],

[ 2, 22],
[ 4, 5]])

Accélérer vos calculs avec Pandas en utilisant PyArrow

Depuis la version 2.0, il est possible d’utiliser PyArrow plutôt que NumPy comme outil de
stockage des colonnes d’un DataFrame. Cette approche comporte un avantage énorme,
le temps de calcul nécessaire.

On peut l'utiliser pour charger des fichiers plus rapidement :

In [165… df = pd.read_csv("D:/COURS INP-HB/ESCAE/M2/SOURCES/data/[Link]", engine='pyar

On peut aussi définir des types avec cette fonctionnalité :

In [166… ser = [Link]([1.3, 2.2, None], dtype="float32[pyarrow]")

Le développement de l'utilisation de Arrow en tant que backend pour Pandas avance

rapidement afin d'accélérer les temps de calcul et de se rapprocher d'un package comme
polars.

Nous allons dans le prochain Notebook, manipuler des données grâce à Python, NumPy
et Pandas.

[Link] ITC A/Python/03_numpy_pandas_bases.html 17/17