Share
C’est la deuxième partie d’un didacticiel en deux parties sur Pandas, l’étonnant kit d’analyses de données Python..
Dans la première partie, nous avons abordé les types de données de base des pandas: la série et la trame de données. Nous avons importé et exporté des données, sélectionné des sous-ensembles de données, travaillé avec des métadonnées et trié les données..
Dans cette partie, nous poursuivrons notre cheminement et traiterons des données manquantes, de la manipulation des données, de la fusion des données, du regroupement des données, de la série chronologique et du traçage..
L'un des points forts des pandas est le traitement des valeurs manquantes. Cela ne fera pas que planter et graver en présence de données manquantes. Lorsque des données sont manquantes, pandas les remplace par np.nan (pas un nombre), et ne participe à aucun calcul..
Réindexons notre cadre de données en ajoutant plus de lignes et de colonnes, mais sans nouvelles données. Pour le rendre intéressant, nous allons renseigner quelques valeurs.
>>> df = pd.DataFrame (np.random.randn (5,2), index = index, colonnes = ['a', 'b']) >>> new_index = df.index.append (pd.Index (['six'])) >>> new_columns = liste (df.columns) + ['c'] >>> df = df.reindex (index = nouvel_index, colonnes = nouvelles_colonnes) >>> df.loc [' trois ']. c = 3 >>> df.loc [' quatre ']. c = 4 >>> df abc un -0.042172 0.374922 NaN deux -0.689523 1.411403 NaN trois 0.332707 0.307561 3.0 quatre 0.426519 -0.425181 4.0 cinq -0.161095 - 0,849932 NaN six NaN NaN NaN
Notez que df.index.append () renvoie un Nouveau index et ne modifie pas l'index existant. Également, df.reindex () renvoie un Nouveau trame de données que j'attribue à la df variable.
À ce stade, notre cadre de données comporte six lignes. La dernière ligne contient tous les NaN et toutes les autres lignes sauf la troisième et la quatrième ont NaN dans la colonne "c". Que pouvez-vous faire avec les données manquantes? Voici les options:
Conserver les données manquantes --------------------- >>> df * = 2 >>> df abc one -0.084345 0.749845 NaN deux -1.379046 2.822806 NaN trois 0.665414 0.615123 6.0 quatre 0.853037 -0.850362 8.0 cinq -0.322190 -1.699864 NaN six NaN NaN NaN Supprime les lignes avec les données manquantes --------------------------- >> > df.dropna () abc three 0.665414 0.615123 6.0 four 0.853037 -0.850362 8.0 Remplacer par la valeur par défaut -------------------------- >>> df .fillna (5) abc one -0.084345 0.749845 5.0 deux -1.379046 2.822806 5.0 trois 0.665414 0.615123 6.0 quatre 0.853037 -0.850362 8.0 cinq -0.322190 -1.699864 5.0 six 5.000000 5.000000 5.0
Si vous voulez juste vérifier s’il vous manque des données dans votre bloc de données, utilisez le isnull () méthode. Ceci retourne un masque booléen de votre dataframe, qui est Vrai pour les valeurs manquantes et Faux autre part.
>>> df.isnull () a b c un Faux Faux Vrai Faux Vrai Faux Vrai Faux Faux Faux Faux Faux Faux Faux Faux Faux Faux Faux Faux Vrai Faux
Lorsque vous avez un cadre de données, vous devez souvent effectuer des opérations sur les données. Commençons par un nouveau cadre de données comportant quatre lignes et trois colonnes d'entiers aléatoires compris entre 1 et 9 (inclus)..
>>> df = pd.DataFrame (np.random.randint (1, 10, taille = (4, 3)), colonnes = ['a', 'b', 'c']) >>> df abc 0 1 3 3 1 8 9 2 2 8 1 5 3 4 6 1
Maintenant, vous pouvez commencer à travailler sur les données. Résumons toutes les colonnes et affectons le résultat à la dernière ligne, puis additionnons toutes les lignes (dimension 1) et assignons à la dernière colonne:
>>> df.loc [3] = df.sum () >>> df abc 0 1 3 3 1 8 9 2 2 8 1 5 3 21 19 11 >>> df.c = df.sum (1)> >> df abc 0 1 3 7 1 8 9 19 2 8 1 14 3 21 19 51
Vous pouvez également effectuer des opérations sur l’ensemble du bloc de données. Voici un exemple de soustraction 3 de chaque cellule:
>>> df - = 3 >>> df a b c 0 -2 0 4 1 5 6 16 2 5 -2 11 3 18 16 48
Pour un contrôle total, vous pouvez appliquer des fonctions arbitraires:
>>> df.apply (lambda x: x ** 2 + 5 * x - 4) a b c 0 -10 -4 32 1 46 62 332 2 46 -10 172 3 410 332 2540
Un autre scénario courant lors de l'utilisation de trames de données consiste à combiner et à fusionner des trames de données (et des séries). Les pandas, comme d’habitude, vous offrent différentes options. Créons un autre bloc de données et explorons les différentes options.
>>> df2 = df // 3 >>> df2 a b c 0 -1 0 1 1 2 5 2 1 -1 3 3 6 6 5 16
Lors de l'utilisation de pd.concat, les pandas concaténent simplement toutes les lignes des pièces fournies dans l'ordre. Il n'y a pas d'alignement des index. Voir dans l'exemple suivant comment les valeurs d'index dupliquées sont créées:
>>> pd.concat ([df, df2]) a b c 0 -2 0 4 1 5 6 16 2 5 -2 11 3 18 16 48 0 -1 0 1 1 2 5 2 1 -1 3 3 6 6 5 16
Vous pouvez également concaténer des colonnes à l'aide de la commande axe = 1 argument:
>>> pd.concat ([df [: 2], df2], axe = 1) abcabc 0 -2.0 0.0 4.0 -1 0 1 1 5.0 6.0 16.0 1 2 5 2 NaN NaN NaN 1 -1 3 3 NaN NaN NaN 6 5 16
Notez que comme le premier bloc de données (j’avais utilisé seulement deux lignes) ne comportait pas autant de lignes, les valeurs manquantes ont été automatiquement renseignées avec des NaN, ce qui a modifié les types de colonne de int à float..
Il est possible de concaténer un nombre illimité de trames de données en un seul appel..
La fonction de fusion se comporte de manière similaire à la jointure SQL. Il fusionne toutes les colonnes des lignes qui ont des clés similaires. Notez qu'il ne fonctionne que sur deux trames de données:
>>> df = pd.DataFrame (dict (clé = ['début', 'fin'], x = [4, 8])) >>> clé df x 0 début 4 1 arrivée 8 >>> df2 = pd .DataFrame (dict (clé = ['début', 'fin'], y = [2, 18])) >>> clé df2 y 0 début 2 1 arrivée 18 >>> pd.merge (df, df2, on = "clé") clé xy 0 début 4 2 1 arrivée 8 18
Le cadre de données ajouter() La méthode est un petit raccourci. Il se comporte fonctionnellement comme concat (), mais enregistre quelques coups clés.
>>> clé df x 0 début 4 1 fin 8 Ajout d'une ligne à l'aide de la méthode append () ----------------------------- -------------- >>> df.append (dict (clé = 'milieu', x = 9), ignore_index = True) clé x 0 début 4 1 arrivée 8 2 milieu 9 Ajout une ligne en utilisant le concat () ------------------------------------------- >>> pd.concat ([df, pd.DataFrame (dict (clé = 'milieu', x = [9]))], ignore_index = True) clé x 0 début 4 1 fin 8 2 moyen 9
Voici un bloc de données contenant les membres et les âges de deux familles: les Smith et les Jones. Vous pouvez utiliser le par groupe() méthode pour regrouper les données par nom de famille et trouver des informations au niveau de la famille, telles que la somme des âges et l’âge moyen:
Accentsconagua
df = pd.DataFrame (dict (premier = 'John Jim Jenny et Jill Jack'.split (), dernier = "Smith Jones Jones Smith Smith" .split (), age = [11, 13, 22, 44, 65]) ) >>> df.groupby ('last'). sum () âge dernier Jones 35 Smith 120 >>> df.groupby ('last'). moyenne () âge dernier Jones 17.5 Smith 40.0 Un grand nombre de données importantes sont des séries chronologiques. Les pandas prennent fortement en charge les données de série chronologique, en commençant par les plages de données, en passant par la localisation et la conversion de l'heure, ainsi que par un rééchantillonnage sophistiqué basé sur la fréquence..
le date_range () La fonction peut générer des séquences de dates-heures. Voici un exemple de génération d'une période de six semaines à compter du 1er janvier 2017 à l'aide du fuseau horaire UTC..
>>> semaines = pd.date_range (début = '01/01/2017', périodes = 6, freq = "W", tz = "UTC") >>> weeks DatetimeIndex (['2017-01-01', '2017-01-08', '2017-01-15', '2017-01-22', '2017-01-29', '2017-02-05'], dtype = "datetime64 [ns, UTC] ", freq =" W-SUN ")
L'ajout d'un horodatage à vos cadres de données, sous forme de colonne de données ou d'index, est idéal pour organiser et regrouper vos données par heure. Il permet également le ré-échantillonnage. Voici un exemple de rééchantillonnage de données minute en agrégations de cinq minutes.
>>> minutes = pd.date_range (début = '01/01/2017', périodes = 10, freq = "1Min", tz = "UTC") >>> ts = pd.Series (np.random.randn ( len (minutes)), minutes) >>> ts 2017-01-01 00: 00: 00 + 00: 00 1.866913 2017-01-01 00: 01: 00 + 00: 00 2.157201 2017-01-01 00:02 : 00 + 00: 00 -0,439932 2017-01-01 00: 03: 00 + 00: 00 0.777944 2017-01-01 00: 04: 00 + 00: 00 0.755624 2017-01-01 00: 05: 00 + 00 : 00 -2.150276 2017-01-01 00: 06: 00 + 00: 00 3.352880 2017-01-01 00: 07: 00 + 00: 00 -1.657432 2017-01-01 00: 08: 00 + 00: 00 - 0.144666 2017-01-01 00: 09: 00 + 00: 00 -0.667059 Fréq: T, type: float64 >>> ts.resample ('5Min'). Mean () 2017-01-01 00: 00: 00+ 00:00 1.023550 2017-01-01 00: 05: 00 + 00: 00 -0.253311Les pandas sont compatibles avec matplotlib. Assurez-vous qu'il est installé: pip installer matplotlib. Pour générer un tracé, vous pouvez appeler le terrain() d'une série ou d'une trame de données. Il existe de nombreuses options pour contrôler le tracé, mais les valeurs par défaut fonctionnent à des fins de visualisation simples. Voici comment générer un graphique linéaire et l'enregistrer dans un fichier PDF.
ts = pd.Series (np.random.randn (1000), index = pd.date_range ('1/1/2017', périodes = 1000)) ts = ts.cumsum () ax = ts.plot () fig = ax.get_figure () fig.savefig ('plot.pdf')Notez que sur macOS, Python doit être installé en tant que cadre pour le traçage avec Pandas..
Pandas est un cadre d'analyse de données très large. Il présente un modèle d'objet simple avec les concepts de série et de trame de données et une richesse de fonctionnalités intégrées. Vous pouvez composer et mixer des fonctions de pandas et vos propres algorithmes.
De plus, n'hésitez pas à voir ce que nous avons disponible à la vente et à étudier sur le marché, et n'hésitez pas à poser des questions et à fournir vos précieux commentaires en utilisant le flux ci-dessous.
Les importations et exportations de données dans les pandas sont également très étendues et vous permettent de les intégrer facilement aux systèmes existants. Si vous faites un traitement de données en Python, les pandas appartiennent à votre boîte à outils.
