Full Circle Magazine FR

Outils pour utilisateurs

Outils du site

Piste : • python • python • python
issue140:python

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
issue140:python [2019/01/07 08:40] – d52frissue140:python [2019/01/08 16:16] (Version actuelle) – auntiee
Ligne 12: Ligne 12:
 • pytz** • pytz**
  
-Pandas et Python et Code ... Oh ! Mon D... !+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. **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.
Ligne 22: Ligne 33:
  
 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.** 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. **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.
Ligne 30: Ligne 50:
  
 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'.** 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 **Series Data Structures
Ligne 54: Ligne 82:
 8    19 8    19
 9    98** 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. **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.
Ligne 67: Ligne 119:
 3    73 3    73
 4    90** 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. **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... If we want to simply see one item out of our list, we can use the index...
- 
  
 >>> print(sd[4]) >>> print(sd[4])
Ligne 82: Ligne 146:
 5    18 5    18
 6    37** 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... **While this command looks somewhat strange, I'll break it down so it makes more sense...
Ligne 106: Ligne 184:
 Nine     19 Nine     19
 Ten      98** 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... **One of the things that I really like about Pandas, is the built-in Data Analysis Helper functions.  Here is a quick sample...
Ligne 126: Ligne 228:
 75%      65.250000 75%      65.250000
 max      98.000000** 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 **DataFrame Data Structures
Ligne 137: Ligne 259:
  
 The easiest way to show you a DataFrame in action, let’s create a small dictionary (shown below).** 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). **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).
Ligne 152: Ligne 285:
 3  Lois   27      F      Development 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.
 +
 +>>> df
 +   Nom  Age     Sexe   Service
 +0  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. **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.
Ligne 166: Ligne 313:
 >>> age.sum() >>> age.sum()
 167** 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. **It’s SO easy to deal with data this way.
Ligne 181: Ligne 342:
  
 >>> df.set_index('Name',inplace=True)** >>> 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... **Now we can see our data structure after the change...
Ligne 200: Ligne 376:
 Department    Management Department    Management
 Name: Greg, dtype: object** 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. **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.
Ligne 215: Ligne 408:
  
 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!** 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 !
  
issue140/python.1546846826.txt.gz · Dernière modification : 2019/01/07 08:40 de d52fr