Premiers pas avec la bibliothèque de traitement de données Python pandas-Tutoriel Python-php.cn

Pandas est un progiciel en langage Python Lorsque nous utilisons le langage Python pour la programmation d'apprentissage automatique, il s'agit d'une bibliothèque de programmation de base très couramment utilisée. Cet article est un tutoriel d'introduction à la bibliothèque de traitement de données Python pandas. Il est très bien. Les amis intéressés devraient y jeter un œil ensemble

pandas est un progiciel en langage Python lorsque nous utilisons le langage Python. programmation d'apprentissage automatique, il s'agit d'une bibliothèque de programmation de base très couramment utilisée. Cet article en est un tutoriel d’introduction.

pandas fournit des structures de données rapides, flexibles et expressives conçues pour rendre le travail avec des données « relationnelles » ou « balisées » facile et intuitif. Il est destiné à être un élément de base de haut niveau pour l’analyse pratique des données en Python.

Démarrer

pandas convient à de nombreux types de données différents, notamment :

Données tabulaires avec des types de colonnes hétérogènes, telles que des tableaux SQL ou des données Excel
Données de séries chronologiques ordonnées et non ordonnées (pas nécessairement à fréquence fixe).
Données matricielles arbitraires (de type uniforme ou de types différents) avec des étiquettes de lignes et de colonnes
Toute autre forme d'ensemble de données d'observation/statistiques.

Puisqu'il s'agit d'un progiciel en langage Python, vous devez d'abord disposer d'un environnement de langage Python sur votre machine. À ce sujet, veuillez rechercher sur Internet comment l'obtenir vous-même.

Pour savoir comment obtenir des pandas, veuillez vous référer aux instructions sur le site officiel : Installation des pandas.

Normalement, nous pouvons effectuer l'installation via pip :

sudo pip3 install pandas

Copier après la connexion

ou via conda pour installer pandas :

conda install pandas

Copier après la connexion

Actuellement (février 2018), la dernière version de pandas est la v0.22.0 (publiée : décembre 29, 2017).

J'ai mis le code source et les données de test de cet article sur Github : pandas_tutorial, les lecteurs peuvent aller le chercher.

De plus, pandas est souvent utilisé avec NumPy, et NumPy est également utilisé dans le code source de cet article.

Il est recommandé aux lecteurs de se familiariser avec NumPy avant d'apprendre les pandas. J'ai également écrit un tutoriel de base sur NumPy auparavant, voir ici : Tutoriel NumPy de la bibliothèque d'apprentissage automatique Python

<. 🎜 >Structure de données de base

Les structures de données de base des pandas sont les deux structures de données

et Series. DataFrame

La comparaison de ces deux types de structures de données est la suivante :

DataFrame peut être considéré comme un conteneur de Series, c'est-à-dire : un DataFrame peut contiennent plusieurs séries.

Remarque : Avant la version 0.20.0, il existait une structure de données tridimensionnelle nommée Panel. C'est aussi la raison pour laquelle la bibliothèque pandas s'appelle : pan-da-s. Cependant, cette structure de données a été abandonnée car rarement utilisée.

Séries

Étant donné que les séries sont des données structurées unidimensionnelles, nous pouvons créer ce type de données directement via un tableau, comme ceci :

# data_structure.py
import pandas as pd
import numpy as np
series1 = pd.Series([1, 2, 3, 4])
print("series1:\n{}\n".format(series1))

Copier après la connexion

La sortie de ce code est la suivante :

series1:
0 1
1 2
2 3
3 4
dtype: int64

Copier après la connexion

La description de cette sortie est la suivante :

La dernière ligne de sortie est le type de données en série, et les données ici sont toutes de type int64.
Les données sont affichées dans la deuxième colonne, et la première colonne est l'index des données, qui est appelé Index chez les pandas.

Nous pouvons imprimer les données et l'index de la série séparément :

# data_structure.py
print("series1.values: {}\n".format(series1.values))
print("series1.index: {}\n".format(series1.index))

Copier après la connexion

La sortie de ces deux lignes de code est la suivante :

series1.values: [1 2 3 4]
series1.index: RangeIndex(start=0, stop=4, step=1)

Copier après la connexion

Si non spécifié (comme ci-dessus ), l'index est sous la forme [ 1, N-1]. Cependant, nous pouvons également spécifier l'index lors de la création de la série. L'index ne doit pas nécessairement être un entier, il peut s'agir de n'importe quel type de données, comme une chaîne. Par exemple, nous utilisons sept lettres pour cartographier sept notes de musique. Le but de l'index est d'obtenir les données correspondantes, telles que les suivantes :

# data_structure.py
series2 = pd.Series([1, 2, 3, 4, 5, 6, 7],
 index=["C", "D", "E", "F", "G", "A", "B"])
print("series2:\n{}\n".format(series2))
print("E is {}\n".format(series2["E"]))

Copier après la connexion

La sortie de ce code est la suivante :

series2:
C 1
D 2
E 3
F 4
G 5
A 6
B 7
dtype: int64
E is 3
DataFrame

Copier après la connexion

Jetons un coup d'œil à la création de DataFrame. Nous pouvons créer une matrice 4x4 via l'interface NumPy pour créer un DataFrame, comme ceci :

# data_structure.py
df1 = pd.DataFrame(np.arange(16).reshape(4,4))
print("df1:\n{}\n".format(df1))

Copier après la connexion

La sortie de ce code est la suivante :

df1:
 0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
3 12 13 14 15

Copier après la connexion

À partir de cette sortie, nous pouvons voir que les noms d'index et de colonne par défaut sont sous la forme [0, N-1].

Nous pouvons spécifier des noms de colonnes et des index lors de la création d'un DataFrame, comme ceci :

# data_structure.py
df2 = pd.DataFrame(np.arange(16).reshape(4,4),
 columns=["column1", "column2", "column3", "column4"],
 index=["a", "b", "c", "d"])
print("df2:\n{}\n".format(df2))

Copier après la connexion

La sortie de ce code est la suivante :

df2:
 column1 column2 column3 column4
a 0 1 2 3
b 4 5 6 7
c 8 9 10 11
d 12 13 14 15

Copier après la connexion

Nous pouvons également spécifier directement les données des colonnes pour créer un DataFrame :

# data_structure.py

df3 = pd.DataFrme({"note" : ["C", "D", "E", "F", "G", "A", "B"],
 "weekday": ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]})
print("df3:\n{}\n".format(df3))

Copier après la connexion

Le résultat de ce code est le suivant :

df3:
 note weekday
0 C Mon
1 D Tue
2 E Wed
3 F Thu
4 G Fri
5 A Sat
6 B Sun

Copier après la connexion

Veuillez noter :

Les différentes colonnes du DataFrame peuvent être de différents types de données

Si vous créez un DataFrame avec un tableau Series, chaque Series deviendra une ligne au lieu d'une colonne

Par exemple :

# data_structure.py
noteSeries = pd.Series(["C", "D", "E", "F", "G", "A", "B"],
 index=[1, 2, 3, 4, 5, 6, 7])
weekdaySeries = pd.Series(["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
 index=[1, 2, 3, 4, 5, 6, 7])
df4 = pd.DataFrame([noteSeries, weekdaySeries])
print("df4:\n{}\n".format(df4))

Copier après la connexion

df4的输出如下：

df4:
 1 2 3 4 5 6 7
0 C D E F G A B
1 Mon Tue Wed Thu Fri Sat Sun

Copier après la connexion

我们可以通过下面的形式给DataFrame添加或者删除列数据：

# data_structure.py
df3["No."] = pd.Series([1, 2, 3, 4, 5, 6, 7])
print("df3:\n{}\n".format(df3))
del df3["weekday"]
print("df3:\n{}\n".format(df3))

Copier après la connexion

这段代码输出如下：

df3:
 note weekday No.
0 C Mon 1
1 D Tue 2
2 E Wed 3
3 F Thu 4
4 G Fri 5
5 A Sat 6
6 B Sun 7
df3:
 note No.
0 C 1
1 D 2
2 E 3
3 F 4
4 G 5
5 A 6
6 B 7

Copier après la connexion

Index对象与数据访问

pandas的Index对象包含了描述轴的元数据信息。当创建Series或者DataFrame的时候，标签的数组或者序列会被转换成Index。可以通过下面的方式获取到DataFrame的列和行的Index对象：

# data_structure.py
print("df3.columns\n{}\n".format(df3.columns))
print("df3.index\n{}\n".format(df3.index))

Copier après la connexion

这两行代码输出如下：

df3.columns
Index([&#39;note&#39;, &#39;No.&#39;], dtype=&#39;object&#39;)
df3.index
RangeIndex(start=0, stop=7, step=1)

Copier après la connexion

请注意：

Index并非集合，因此其中可以包含重复的数据
Index对象的值是不可以改变，因此可以通过它安全的访问数据

DataFrame提供了下面两个操作符来访问其中的数据：

loc：通过行和列的索引来访问数据
iloc：通过行和列的下标来访问数据

例如这样：

# data_structure.py
print("Note C, D is:\n{}\n".format(df3.loc[[0, 1], "note"]))
print("Note C, D is:\n{}\n".format(df3.iloc[[0, 1], 0]))

Copier après la connexion

第一行代码访问了行索引为0和1，列索引为“note”的元素。第二行代码访问了行下标为0和1（对于df3来说，行索引和行下标刚好是一样的，所以这里都是0和1，但它们却是不同的含义），列下标为0的元素。

这两行代码输出如下：

Note C, D is:
0 C
1 D
Name: note, dtype: object

Note C, D is:
0 C
1 D
Name: note, dtype: object

Copier après la connexion

文件操作

pandas库提供了一系列的read_函数来读取各种格式的文件，它们如下所示：

read_csv
read_table
read_fwf
read_clipboard
read_excel
read_hdf
read_html
read_json
read_msgpack
read_pickle
read_sas
read_sql
read_stata
read_feather

读取Excel文件

注：要读取Excel文件，还需要安装另外一个库：xlrd

通过pip可以这样完成安装：

sudo pip3 install xlrd

Copier après la connexion

安装完之后可以通过pip查看这个库的信息：

$ pip3 show xlrd
Name: xlrd
Version: 1.1.0
Summary: Library for developers to extract data from Microsoft Excel (tm) spreadsheet files
Home-page: http://www.python-excel.org/
Author: John Machin
Author-email: sjmachin@lexicon.net
License: BSD
Location: /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages
Requires:

Copier après la connexion

接下来我们看一个读取Excel的简单的例子：

# file_operation.py
import pandas as pd
import numpy as np
df1 = pd.read_excel("data/test.xlsx")
print("df1:\n{}\n".format(df1))

Copier après la connexion

这个Excel的内容如下：

df1:
 C Mon
0 D Tue
1 E Wed
2 F Thu
3 G Fri
4 A Sat
5 B Sun

Copier après la connexion

注：本文的代码和数据文件可以通过文章开头提到的Github仓库获取。

读取CSV文件

下面，我们再来看读取CSV文件的例子。

第一个CSV文件内容如下：

$ cat test1.csv 
C,Mon
D,Tue
E,Wed
F,Thu
G,Fri
A,Sat

Copier après la connexion

读取的方式也很简单：

# file_operation.py
df2 = pd.read_csv("data/test1.csv")
print("df2:\n{}\n".format(df2))

Copier après la connexion

我们再来看第2个例子，这个文件的内容如下：

$ cat test2.csv 
C|Mon
D|Tue
E|Wed
F|Thu
G|Fri
A|Sat

Copier après la connexion

严格的来说，这并不是一个CSV文件了，因为它的数据并不是通过逗号分隔的。在这种情况下，我们可以通过指定分隔符的方式来读取这个文件，像这样：

# file_operation.py
df3 = pd.read_csv("data/test2.csv", sep="|")
print("df3:\n{}\n".format(df3))

Copier après la connexion

实际上，read_csv支持非常多的参数用来调整读取的参数，如下表所示：

Paramètre	Description
chemin	Chemin du fichier
sep ou délimiteur	Délimiteur de champ
en-tête	Le nombre de lignes dans le nom de la colonne, la valeur par défaut est 0 (Première ligne)
index_col	Le numéro ou le nom de la colonne est utilisé comme index de ligne dans le résultat
noms	Liste des noms de colonnes du résultat
skiprows	Nombre de lignes à sauter depuis la position de départ
na_values	Une séquence de valeurs qui remplace `NA`
comment	Le caractère qui sépare les commentaires par des fins de ligne
parse_dates	tente d'analyser les données dans `datetime`. La valeur par défaut est `False`
keep_date_col	Si vous concaténez une colonne à une date analysée, conservez la colonne concaténée. La valeur par défaut est `False`.
convertisseurs	Convertisseurs pour les colonnes
dayfirst	Lors de l'analyse des dates pouvant provoquer une ambiguïté, stockées sous forme interne.La valeur par défaut est `False`
data_parser	Fonction utilisée pour analyser les dates
nrows	de Le nombre de lignes à commencer la lecture dans le fichier
itérateur	Renvoie un objet TextParser pour lire une partie du contenu
chunksize	Spécifiez la taille du bloc de lecture
skip_footer	Le nombre de lignes à ignorer à la fin du fichier
verbeux	Sortie de diverses informations de sortie d'analyse
encodage	Encodage de fichiers
squeeze	Si les données analysées ne contiennent qu'une seule colonne, renvoie un `Series`
milliers	délimiteur de milliers

详细的read_csv函数说明请参见这里：pandas.read_csv

处理无效值

现实世界并非完美，我们读取到的数据常常会带有一些无效值。如果没有处理好这些无效值，将对程序造成很大的干扰。

对待无效值，主要有两种处理方法：直接忽略这些无效值；或者将无效值替换成有效值。

下面我先创建一个包含无效值的数据结构。然后通过pandas.isna函数来确认哪些值是无效的：

# process_na.py
import pandas as pd
import numpy as np
df = pd.DataFrame([[1.0, np.nan, 3.0, 4.0],
   [5.0, np.nan, np.nan, 8.0],
   [9.0, np.nan, np.nan, 12.0],
   [13.0, np.nan, 15.0, 16.0]])
print("df:\n{}\n".format(df));
print("df:\n{}\n".format(pd.isna(df)));****

Copier après la connexion

这段代码输出如下：

df:
 0 1 2 3
0 1.0 NaN 3.0 4.0
1 5.0 NaN NaN 8.0
2 9.0 NaN NaN 12.0
3 13.0 NaN 15.0 16.0
df:
 0 1 2 3
0 False True False False
1 False True True False
2 False True True False
3 False True False False

Copier après la connexion

忽略无效值

我们可以通过pandas.DataFrame.dropna函数抛弃无效值：

# process_na.py
print("df.dropna():\n{}\n".format(df.dropna()));

Copier après la connexion

注：dropna默认不会改变原先的数据结构，而是返回了一个新的数据结构。如果想要直接更改数据本身，可以在调用这个函数的时候传递参数 inplace = True。

对于原先的结构，当无效值全部被抛弃之后，将不再是一个有效的DataFrame，因此这行代码输出如下：

df.dropna():
Empty DataFrame
Columns: [0, 1, 2, 3]
Index: []

Copier après la connexion

我们也可以选择抛弃整列都是无效值的那一列：

# process_na.py
print("df.dropna(axis=1, how=&#39;all&#39;):\n{}\n".format(df.dropna(axis=1, how=&#39;all&#39;)));

Copier après la connexion

注：axis=1表示列的轴。how可以取值'any'或者'all'，默认是前者。

这行代码输出如下：

df.dropna(axis=1, how=&#39;all&#39;):
 0 2 3
0 1.0 3.0 4.0
1 5.0 NaN 8.0
2 9.0 NaN 12.0
3 13.0 15.0 16.0

Copier après la connexion

替换无效值

我们也可以通过fillna函数将无效值替换成为有效值。像这样：

# process_na.py
print("df.fillna(1):\n{}\n".format(df.fillna(1)));

Copier après la connexion

这段代码输出如下：

df.fillna(1):
  0 1  2  3
0 1.0 1.0 3.0 4.0
1 5.0 1.0 1.0 8.0
2 9.0 1.0 1.0 12.0
3 13.0 1.0 15.0 16.0

Copier après la connexion

将无效值全部替换成同样的数据可能意义不大，因此我们可以指定不同的数据来进行填充。为了便于操作，在填充之前，我们可以先通过rename方法修改行和列的名称：

# process_na.py

df.rename(index={0: &#39;index1&#39;, 1: &#39;index2&#39;, 2: &#39;index3&#39;, 3: &#39;index4&#39;},
   columns={0: &#39;col1&#39;, 1: &#39;col2&#39;, 2: &#39;col3&#39;, 3: &#39;col4&#39;},
   inplace=True);
df.fillna(value={&#39;col2&#39;: 2}, inplace=True)
df.fillna(value={&#39;col3&#39;: 7}, inplace=True)
print("df:\n{}\n".format(df));

Copier après la connexion

这段代码输出如下：

df:
  col1 col2 col3 col4
index1 1.0 2.0 3.0 4.0
index2 5.0 2.0 7.0 8.0
index3 9.0 2.0 7.0 12.0
index4 13.0 2.0 15.0 16.0

Copier après la connexion

处理字符串

数据中常常牵涉到字符串的处理，接下来我们就看看pandas对于字符串操作。

Series的str字段包含了一系列的函数用来处理字符串。并且，这些函数会自动处理无效值。

下面是一些实例，在第一组数据中，我们故意设置了一些包含空格字符串：

# process_string.py
import pandas as pd
s1 = pd.Series([&#39; 1&#39;, &#39;2 &#39;, &#39; 3 &#39;, &#39;4&#39;, &#39;5&#39;]);
print("s1.str.rstrip():\n{}\n".format(s1.str.lstrip()))
print("s1.str.strip():\n{}\n".format(s1.str.strip()))
print("s1.str.isdigit():\n{}\n".format(s1.str.isdigit()))

Copier après la connexion

在这个实例中我们看到了对于字符串strip的处理以及判断字符串本身是否是数字，这段代码输出如下：

s1.str.rstrip():
0  1
1 2 
2 3 
3  4
4  5
dtype: object
s1.str.strip():
0 1
1 2
2 3
3 4
4 5
dtype: object
s1.str.isdigit():
0 False
1 False
2 False
3  True
4  True
dtype: bool

Copier après la connexion

下面是另外一些示例，展示了对于字符串大写，小写以及字符串长度的处理：

# process_string.py
s2 = pd.Series([&#39;Stairway to Heaven&#39;, &#39;Eruption&#39;, &#39;Freebird&#39;,
     &#39;Comfortably Numb&#39;, &#39;All Along the Watchtower&#39;])
print("s2.str.lower():\n{}\n".format(s2.str.lower()))
print("s2.str.upper():\n{}\n".format(s2.str.upper()))
print("s2.str.len():\n{}\n".format(s2.str.len()))

Copier après la connexion

该段代码输出如下：

s2.str.lower():
0   stairway to heaven
1     eruption
2     freebird
3   comfortably numb
4 all along the watchtower
dtype: object

s2.str.upper():
0   STAIRWAY TO HEAVEN
1     ERUPTION
2     FREEBIRD
3   COMFORTABLY NUMB
4 ALL ALONG THE WATCHTOWER
dtype: object

s2.str.len():
0 18
1  8
2  8
3 16
4 24
dtype: int64

Copier après la connexion