Pandas and Python and Code … Oh My! I try to keep abreast of new happenings in the Python and programming worlds in general. Lately, I have been seeing a number of Python articles having to do with Data Science or Machine Learning that involve a Python library called Pandas. I'd heard of it before, but never took the time to find out more about it. Recently, I learned about it, and I am glad I did! Pandas, to quote from their web page, “is an open source, BSD-licensed library providing high-performance, easy-to-use data structures and data analysis tools for the Python programming language.” You can find out a lot more about it at https://pandas.pydata.org/. There is a wealth of information on the Internet about it. To install it, you can do a pip install pandas. There are, of course some dependencies for Pandas. They are: • Python 2.7 or higher (as of January 1, 2019 it will only work under Python 3.5 or higher) • setuptools 24.2.0 or higher • NumPy 1.9.0 or higher • python-dateutil 2.5.0 or higher • pytz
Pandas et Python et Code … Oh mon D… !
En général, j'essaie de me tenir au courant des nouveautés dans les mondes de Python et de la programmation. Récemment, j'ai vu bon nombre d'articles sur Python au sujet de la Science des données et l'apprentissage des machines, qui utilisaient une bibliothèque Python appelée Pandas. J'en avais entendu parlé avant, mais je n'avais jamais pris le temps d'en savoir plus à son sujet. Récemment, je me suis renseigné et je suis content de l'avoir fait !
Pandas, pour citer leur propre page Web, « est une bibliothèque Open Source, sous licence BSD, fournissant des outils pour les structures de données et leur analyse, à haute performance et faciles à utiliser, pour le langage de programmation Python. »
Vous pouvez en découvrir beaucoup plus à son sujet sur https://pandas.pydata.org/. Il y a une quantité d'informations sur Internet à son sujet. Pour l'installer, vous pouvez faire un pip install pandas. Il y a, bien sûr, des dépendances pour Pandas. Ce sont : • Python 2.7 ou + (au 1er janvier 2019, elle ne marchera que sous Python 3.5 ou +) • setuptools 24.2.0 ou + • NumPy 1.9.0 ou + • python-dateutil 2.5.0 ou + • pytz
So, given that Pandas is such an important library for Data Science, I plan to spend a few articles on it. Now, I am not going to try to teach you a large amount about Pandas in this quick article. I'm only going to try to show you some of the neat things that Pandas can do. We'll go into Pandas in depth in later articles. Pandas can deal with three different types of data structures - • Series • DataFrame • Panel A Series data structure is a 1D labeled array which is size-immutable and contains homogeneous data (same data type). A DataFrame structure is a 2D labeled tabular structure which is size-mutable, which contains heterogeneous data (data of different types) and is a container for a Series structure. A Panel is a 3D labeled size-mutable array which contains heterogeneous data and is a container for a DataFrame structure. All Pandas data structures are value mutable (can be changed). Size-mutable is only available to DataFrames and Panel structures.
Ainsi, étant donné que Pandas est une bibliothèque aussi importante pour la Science des données, je prévois de faire quelques articles dessus. Et je ne vais pas essayer de vous apprendre une part étendue de Pandas dans ce court article. Je vais juste essayer de vous montrer quelques-uns des trucs chouettes que Pandas peut faire. Nous approfondirons Pandas dans les prochains articles.
Pandas peut gérer trois types de structures de données : • Series • DataFrame • Panel
Une structure de données « Series » est un tableau étiqueté à une dimension de taille non modifiable et qui contient des données homogènes (des données de même type). Une structure « Dataframe » est une structure tabulaire étiquetée à deux dimensions de taille modifiable, qui contient des données hétérogènes (des données de types différents) et qui est un conteneur pour une structure Series. Un « Panel » est un tableau étiqueté en trois dimensions de taille modifiable qui contient des données hétérogènes et qui est un conteneur pour une structure Dataframe. Toutes les structures de données de Pandas sont mutables en valeur (elles peuvent être modifiées). Les modifications de taille ne sont possibles que pour les structures Dataframe et Panel.
All of that dry information is nice, but to really appreciate how easy Pandas makes dealing with data, let's play a little bit. One of the best things about Pandas is that many times, you can do much of the work in a Python shell. So, assuming you've gotten the Pandas library, open up a Python3 shell. The first thing you need to do is import the Pandas library. »> import pandas as pd Just for those who haven't been doing Python for a while, like most of you, we use the 'as pd' to create an alias to the library so we don't have to refer to all the commands by typing 'pandas.command'. We can just type 'pd.command'.
C'est bien, toute cette information brute, mais pour apprécier réellement comment Pandas facilite la gestion des données, jouons un peu avec. Une des meilleures choses à propos de Pandas est que, souvent, vous pouvez faire la plupart de votre travail dans un shell Python.
Aussi, en présumant que vous avez récupéré la bibliothèque Pandas, ouvrons un shell Python3. La première chose que vous devez faire est d'importer la bibliothèque Pandas.
import pandas as pd
Juste pour ceux qui n'auraient rien fait avec Python depuis un moment, comme la plupart d'entre vous, nous utilisons « as pd » pour créer un alias pour la bibliothèque ; ainsi, nous n'avons pas à taper la référence « pandas.command » dans toutes les commandes. Nous n'avons qu'à saisir « pd.command ».
Series Data Structures Now let's create a simple list of random ten integers and name it 'data'. »> data = [20,10,42,73,90,18,37,26,19,98] Now we can create a Pandas series data structure by the .Series() command. »> sd = pd.Series(data) That's all there is to it. Now let's see what it looks like.. »> print(sd) 0 20 1 10 2 42 3 73 4 90 5 18 6 37 7 26 8 19 9 98
Structure de données Series
Maintenant, créons une liste simple de dix entiers aléatoires et appelons-la « data ».
data = [20,10,42,73,90,18,37,26,19,98]
Ensuite, nous pouvons créer une structure de données Series de Pandas avec la commande .Series().
sd = pd.Series(data)
C'est tout ce qu'il y a à faire. Maintenant, regardons à quoi ça ressemble.
print(sd)
0 20 1 10 2 42 3 73 4 90 5 18 6 37 7 26 8 19 9 98
Notice our list of integers is exactly as we entered it and that there is an index added for us as well. This is the DEFAULT index. We can make it different if we wish, which we'll see later. Also, you might notice that at the end of the output from almost all of the Pandas code we will be doing, you will see something like dtype: int64. That is there to show you what the data type is. I’ve taken it out of the output listings to save space in the article. Now, if we just want a quick peek at the data, we could use the .head() or .tail() command. Here is an example of the .head command showing the first five items. »> sd.head(5) 0 20 1 10 2 42 3 73 4 90
Notez que notre liste d'entiers est exactement comme nous l'avons saisie et qu'il y a aussi un index qui a été ajouté. C'est l'index PAR DÉFAUT. Nous pouvons le faire autrement si nous le souhaitons, ce que nous verrons plus tard.
Vous pouvez noter aussi qu'à la fin des sorties de presque tous les codes de Pandas que nous ferons, vous verrez quelque chose comme dtype: int64. C'est là pour vous montrer quel est le type des données. Je l'ai retiré des listings imprimés dans cet article pour gagner de la place.
Maintenant, si vous voulez simplement un extrait rapide des données, nous pouvons utiliser la commande .head() ou .tail(). Voici un exemple de la commande .head() montrant les cinq premiers éléments.
sd.head(5)
0 20 1 10 2 42 3 73 4 90
The .tail() command works the same way, showing the end of the data list. If we want to simply see one item out of our list, we can use the index… »> print(sd[4]) 90 Now assume we want to see items 4, 5 and 6. We do it this way… »> print(sd.loc[4:6,]) 4 90 5 18 6 37
La commande .tail() fonctionne de la même façon, en montrant la fin de la liste.
Si vous ne voulez voir qu'un des éléments de la liste, vous pouvez utiliser l'index…
print(sd[4])
90
Maintenant, disons que nous voulons voir les éléments 4,5 et 6. Nous le faisons ainsi…
print(sd.loc[4:6,])
4 90 5 18 6 37
While this command looks somewhat strange, I'll break it down so it makes more sense… sd.loc[] is an indexer command. It works with both the Series and Dataframe data structures. It can be very powerful. The command works like this… .loc[rowslice,columnslice] Since we are using a Series structure, we have only one column, so we only work with the row indexer portion of the command. We'll look at the .loc command some more when we deal with Dataframes. Now getting back to custom indexes. We can create the index as a second parameter to the Series command like this… »> sd = pd.Series(data,index=['One','Two','Three','Four','Five','Six','Seven','Eight','Nine','Ten']) »> print(sd) One 20 Two 10 Three 42 Four 73 Five 90 Six 18 Seven 37 Eight 26 Nine 19 Ten 98
Comme cette commande paraît un peu étrange, je la détaillerai pour lui donner plus du sens…
sd.loc[] est une commande d'indexeur. Elle fonctionne avec les deux structures de données Series et Dataframe. Elle peut être vraiment puissante. La commande fonctionne ainsi…
.loc[rowslice,columnslice]
Comme nous utilisons une structure Series, nous n'avons qu'une colonne ; aussi, nous ne travaillons qu'avec la portion d'indexeur « ligne » de la commande. Nous en verrons plus de la commande .loc quand nous traiterons les Dataframes.
Maintenant, revenons aux index personnalisés. Nous pouvons créer l'index comme deuxième paramètre de la commande Series comme ceci…
sd = pd.Series(data,index=['One','Two','Three','Four','Five','Six','Seven','Eight','Nine','Ten'])
print(sd)
One 20 Two 10 Three 42 Four 73 Five 90 Six 18 Seven 37 Eight 26 Nine 19 Ten 98
One of the things that I really like about Pandas, is the built-in Data Analysis Helper functions. Here is a quick sample… »> sd.sum() 433 »> sd.count() 10 »> sd.min() 10 »> sd.max() 98 »> sd.describe() count 10.000000 mean 43.300000 std 32.107631 min 10.000000 25% 19.250000 50% 31.500000 75% 65.250000 max 98.000000
Une des choses que j'apprécie vraiment dans Pandas, c'est les fonctions intégrées du Data Analysis Helper (Aide à l'analyse des données). Voici un exemple rapide…
sd.sum()
433
sd.count()
10
sd.min()
10
sd.max()
98
sd.describe()
count 10.000000 mean 43.300000 std 32.107631 min 10.000000 25% 19.250000 50% 31.500000 75% 65.250000 max 98.000000
DataFrame Data Structures Now that I’ve shown you some of the things that can be done with a simple Series data structure, let’s look at the DataFrame. I stated earlier that a DataFrame is a 2D tabular structure. Think of a spreadsheet or database table and that is pretty much what a DataFrame looks like. We can create a DataFrame from any of the following: • Lists • Dictionaries • Series • Numpy ndarrays • Other DataFrames The easiest way to show you a DataFrame in action, let’s create a small dictionary (shown below).
Structure de données Dataframe
Maintenant que je vous ai montré certaines des choses qui peuvent être faites avec une simple structure de données Series, regardons les Dataframes. J'ai indiqué précédemment qu'une Dataframe était une structure tabulaire en deux dimensions. Pensez à un tableur ou à une table de base de données et c'est à peu près à quoi ressemble une Dataframe. Nous pouvons créer une Dataframe à partir de n'importe lequel de ceux-ci : • Listes • Dictionnaires • Séries • Numpy ndarrays • Autres DataFrames
La façon la plus simple de vous montrer une Dataframe en action sera de créer un petit dictionnaire (montré ci-dessous).
As you can see, there will be four rows and four columns. And you can also see that the data types are mixed. Just as we did when we created the Series data structure, we simply call the .DataFrame command with our data (there are other parameter options that we’ll discuss another time). »> df = pd.DataFrame(data2) Now to see what the structure looks like to Pandas, we just call the structure. »> df Name Age Gender Department 0 Greg 65 M Management 1 Sam 34 M Development 2 Mary 41 F Human Resources 3 Lois 27 F Development »>
Comme vous pouvez le voir, il y a quatre lignes et quatre colonnes. Et vous pouvez voir aussi que les types de données sont variés. Comme nous l'avons fait quand nous avons créé la structure de données Series, nous appelons simplement la commande .Dataframe avec nos données (il y a d'autres paramètres dont nous parlerons une autre fois).
df = pd.DataFrame(data2)
Maintenant, pour voir à quoi ressemble la structure à Pandas, nous appelons simplement la structure.
dfNom Age Sexe Service0 Greg 65 M Management
1 Sam 34 M Development 2 Mary 41 F Human Resources 3 Lois 27 F Development
Like I said earlier, it resembles a spreadsheet. Pretty much everything we did with the Serial structure, we can do with the DataFrame. Let’s do something useful with the data. We’ll create a Serial structure based on the Age column. »> age = df['Age'] »> age 0 65 1 34 2 41 3 27 Now that we have our age Serial structure, let’s get the sum of the values… »> age.sum() 167
Comme je l'ai déjà dit, cela ressemble à un tableur. À peu près tout ce que nous avons fait avec la structure Series peut être fait avec la Dataframe. Faisons quelque chose d'utile avec les données. Nous créerons une structure Series basée sur la colonne Age.
age = df['Age']
age
0 65 1 34 2 41 3 27
Maintenant que nous avons notre structure Series age, additionnons les valeurs…
age.sum()
167
It’s SO easy to deal with data this way. As we did with the Serial structure, we can get the data for just one row by using the .loc command. »> df.loc[0] Name Greg Age 65 Gender M Department Management Name: 0, dtype: object Notice we have to use the index that was created for us automatically. We can’t do something like df.loc[‘Greg’] since ‘Greg’ is not an index item. HOWEVER, there is a cool way to fix that. We can use the .set_index(ColumnName,inplace=True) command to remove the default index and replace it with a column of our choice. In this case, we’ll use the ‘Name’ column… »> df.set_index('Name',inplace=True)
C'est TELLEMENT facile de gérer les données de cette façon.
Comme nous l'avons fait avec la structure Series, nous obtenons les données d'une seule ligne avec la commande .loc.
df.loc[0]
Nom Greg Age 65 Sexe M Service Management Name: 0, dtype: object
Notez que nous avons utilisé l'index qui a été créé automatiquement pour nous. Nous ne pouvons pas faire quelque chose comme df.loc[‘Greg’] car ‘Greg’ n'est pas un élément indexable. CEPENDANT, il y a une façon sympa de résoudre cela. Nous pouvons utiliser la commande .set_index(ColumnName,inplace=True) pour enlever l'index par défaut et le remplacer par une colonne de notre choix. Dans ce cas, nous utiliserons la colonne « Nom »…
df.set_index('Nom',inplace=True)
Now we can see our data structure after the change… »> df Age Gender Department Name Greg 65 M Management Sam 34 M Development Mary 41 F Human Resources Lois 27 F Development Now our index has been replaced by the Name column. NOW we can get the information on just Greg… »> df.loc['Greg'] Age 65 Gender M Department Management Name: Greg, dtype: object
Maintenant, vous pouvez voir notre structure de données après la modification…
df
Nom Age Sexe Service Greg 65 M Management Sam 34 M Development Mary 41 F Human Resources Lois 27 F Development
Maintenant, notre index est remplacé par la colonne Nom. MAINTENANT, nous pouvons obtenir uniquement l'information sur Greg…
df.loc['Greg']
Age 65 Sexe M Service Management Name: Greg, dtype: object
One of the things we can do with a DataFrame that we can’t with a Serial structure, is get extended information using the .info() command. »> df.info() <class 'pandas.core.frame.DataFrame'> RangeIndex: 4 entries, 0 to 3 Data columns (total 4 columns): Name 4 non-null object Age 4 non-null int64 Gender 4 non-null object Department 4 non-null object dtypes: int64(1), object(3) memory usage: 208.0+ bytes I hope that I have generated some interest about Pandas. Next time, we’ll look deeper at the DataFrames in Pandas. Until then, keep coding!
Une des choses que nous pouvons faire avec une Dataframe, que nous ne pouvons pas faire avec une structure Series, c'est d'obtenir une information étendue en utilisant la commande .info().
df.info()
<class 'pandas.core.frame.DataFrame'> RangeIndex: 4 entries, 0 to 3 Data columns (total 4 columns): Nom 4 non-null object Age 4 non-null int64 Sexe 4 non-null object Service 4 non-null object dtypes: int64(1), object(3) memory usage: 208.0+ bytes
J'espère que j'ai généré quelque intérêt pour Pandas. La prochaine fois, nous regarderons plus en détail les Dataframes dans Pandas. Jusque-là, continuez à coder !