Trier, dédupliquer, échantillonner et transformer des données - MaxCompute

Cette rubrique décrit les opérations que vous pouvez effectuer sur un DataFrame. Vous pouvez trier, dédupliquer, échantillonner et mettre à l'échelle des données. Vous pouvez également traiter les valeurs nulles.

Prérequis

Assurez-vous que les conditions suivantes sont remplies :

Une table nommée pyodps_iris est préparée. Pour plus d'informations, consultez la section « Traitement des données DataFrame » dans Prise en main.

Un DataFrame est créé.

from odps.df import DataFrame
iris = DataFrame(o.get_table('pyodps_iris'))

Trier des données

Vous ne pouvez trier des données que dans une collection.

Appelez la méthode sort ou sort_values pour trier les données.

>>> iris.sort('sepalwidth').head(5)
   sepallength  sepalwidth  petallength  petalwidth             name
0          5.0         2.0          3.5         1.0  Iris-versicolor
1          6.2         2.2          4.5         1.5  Iris-versicolor
2          6.0         2.2          5.0         1.5   Iris-virginica
3          6.0         2.2          4.0         1.0  Iris-versicolor
4          5.5         2.3          4.0         1.3  Iris-versicolor

Ajoutez la configuration ascending=False; pour trier les données par ordre décroissant.

>>> iris.sort('sepalwidth', ascending=False).head(5)
   sepallength  sepalwidth  petallength  petalwidth         name
0          5.7         4.4          1.5         0.4  Iris-setosa
1          5.5         4.2          1.4         0.2  Iris-setosa
2          5.2         4.1          1.5         0.1  Iris-setosa
3          5.8         4.0          1.2         0.2  Iris-setosa
4          5.4         3.9          1.3         0.4  Iris-setosa

Utilisez - pour trier les données par ordre décroissant.

>>> iris.sort(-iris.sepalwidth).head(5)
   sepallength  sepalwidth  petallength  petalwidth         name
0          5.7         4.4          1.5         0.4  Iris-setosa
1          5.5         4.2          1.4         0.2  Iris-setosa
2          5.2         4.1          1.5         0.1  Iris-setosa
3          5.8         4.0          1.2         0.2  Iris-setosa
4          5.4         3.9          1.3         0.4  Iris-setosa

Triez les données selon plusieurs champs.

>>> iris.sort(['sepalwidth', 'petallength']).head(5)
   sepallength  sepalwidth  petallength  petalwidth             name
0          5.0         2.0          3.5         1.0  Iris-versicolor
1          6.0         2.2          4.0         1.0  Iris-versicolor
2          6.2         2.2          4.5         1.5  Iris-versicolor
3          6.0         2.2          5.0         1.5   Iris-virginica
4          4.5         2.3          1.3         0.3      Iris-setosa

Si vous triez les données selon plusieurs champs avec des ordres différents, utilisez le paramètre ascending pour afficher une liste des données à trier. Le nombre de colonnes doit correspondre au nombre de champs. Les valeurs des champs doivent être de type BOOLEAN.

>>> iris.sort(['sepalwidth', 'petallength'], ascending=[True, False]).head(5)
   sepallength  sepalwidth  petallength  petalwidth             name
0          5.0         2.0          3.5         1.0  Iris-versicolor
1          6.0         2.2          5.0         1.5   Iris-virginica
2          6.2         2.2          4.5         1.5  Iris-versicolor
3          6.0         2.2          4.0         1.0  Iris-versicolor
4          6.3         2.3          4.4         1.3  Iris-versicolor

L'exemple de code suivant illustre un autre cas de tri des données basé sur plusieurs champs.

>>> iris.sort(['sepalwidth', -iris.petallength]).head(5)
   sepallength  sepalwidth  petallength  petalwidth             name
0          5.0         2.0          3.5         1.0  Iris-versicolor
1          6.0         2.2          5.0         1.5   Iris-virginica
2          6.2         2.2          4.5         1.5  Iris-versicolor
3          6.0         2.2          4.0         1.0  Iris-versicolor
4          6.3         2.3          4.4         1.3  Iris-versicolor

Remarque

Pour trier des données en Python sur MaxCompute (PyODPS), vous devez configurer le paramètre options.df.odps.sort.limit afin de spécifier le nombre de lignes à trier. La valeur par défaut du paramètre options.df.odps.sort.limit est 10000. Vous pouvez définir ce paramètre sur une valeur supérieure à 10000. Toutefois, ce réglage peut provoquer une erreur d'épuisement de la mémoire (OOM).

Dédupliquer des données

Pour dédupliquer des données dans une collection, appelez la méthode distinct pour dédupliquer les données de la manière suivante :

>>> iris[['name']].distinct()
              name
0      Iris-setosa
1  Iris-versicolor
2   Iris-virginica

>>> iris.distinct('name')
              name
0      Iris-setosa
1  Iris-versicolor
2   Iris-virginica

>>> iris.distinct('name', 'sepallength').head(3)
          name  sepallength
0  Iris-setosa          4.3
1  Iris-setosa          4.4
2  Iris-setosa          4.5

Appelez la méthode unique pour dédupliquer une séquence de données. Cependant, la séquence qui appelle la méthode unique ne peut pas être utilisée pour sélectionner des colonnes.
```
>>> iris.name.unique()
              name
0      Iris-setosa
1  Iris-versicolor
2   Iris-virginica
```
Exemple de code incorrect :
```
>>> iris[iris.name, iris.name.unique()]
```

Échantillonner des données

Pour échantillonner des données à partir d'une collection, vous pouvez appeler la méthode sample . PyODPS prend en charge les méthodes d'échantillonnage suivantes :

Remarque

MaxCompute DataFrame doit prendre en charge XFlow dans les projets pour exécuter les méthodes d'échantillonnage suivantes, à l'exception de l'échantillonnage par partie. Si MaxCompute DataFrame ne prend pas en charge XFlow, vous ne pouvez exécuter les méthodes d'échantillonnage qu'en arrière-plan via Pandas DataFrame.

Échantillonnage par partie

Les données sont divisées en parts à l'aide de cette méthode d'échantillonnage. Vous pouvez sélectionner la partie par son numéro.

>>> iris.sample(parts=10)  # Split data into 10 parts and sample data of the part numbered 0 by default. 
>>> iris.sample(parts=10, i=0)  # Split data into 10 parts and manually sample data of the part numbered 0. 
>>> iris.sample(parts=10, i=[2, 5])   # Split data into 10 parts and sample data of the parts numbered 2 and 5. 
>>> iris.sample(parts=10, columns=['name', 'sepalwidth'])  # Sample the data by name and sepalwidth.

Échantillonnage pondéré
Lorsque vous utilisez cette méthode, vous pouvez spécifier la colonne de pondération, le nombre d'enregistrements et la proportion d'enregistrements que vous souhaitez échantillonner. Pour activer l'échantillonnage avec remise, définissez le paramètre replace sur True.
```
>>> iris.sample(n=100, weights='sepal_length')
>>> iris.sample(n=100, weights='sepal_width', replace=True)
```
Échantillonnage stratifié
Pour utiliser cette méthode d'échantillonnage, vous pouvez spécifier la colonne d'étiquette pour la stratification, ainsi que la proportion d'échantillonnage ou le nombre d'enregistrements que vous souhaitez échantillonner. Configurez le paramètre frac pour spécifier la proportion d'échantillonnage et configurez le paramètre n pour spécifier le nombre d'enregistrements à échantillonner. Cette méthode d'échantillonnage ne prend pas en charge l'échantillonnage avec remise.
```
>>> iris.sample(strata='category', n={'Iris Setosa': 10, 'Iris Versicolour': 10})
>>> iris.sample(strata='category', frac={'Iris Setosa': 0.5, 'Iris Versicolour': 0.4})
```

Mettre à l'échelle des données

Un DataFrame prend en charge la mise à l'échelle des données basée sur la valeur maximale, la valeur minimale, la valeur moyenne ou l'écart type. Les données suivantes présentent un exemple.

name  id  fid
0  name1   4  5.3
1  name2   2  3.5
2  name2   3  1.5
3  name1   4  4.2
4  name1   3  2.2
5  name1   3  4.1

Utilisez la méthode min_max_scale pour normaliser les données.

df.min_max_scale(columns=['fid'])
    name  id       fid
0  name1   4  1.000000
1  name2   2  0.526316
2  name2   3  0.000000
3  name1   4  0.710526
4  name1   3  0.184211
5  name1   3  0.684211

Utilisez la méthode min_max_scale avec le paramètre feature_range pour spécifier la plage de valeurs de sortie. L'exemple suivant montre comment conserver les valeurs de sortie dans la plage (-1, 1) :

df.min_max_scale(columns=['fid'], feature_range=(-1, 1))
    name  id       fid
0  name1   4  1.000000
1  name2   2  0.052632
2  name2   3 -1.000000
3  name1   4  0.421053
4  name1   3 -0.631579
5  name1   3  0.368421

Si vous devez conserver les valeurs d'origine, utilisez le paramètre preserve . Les données mises à l'échelle sont ajoutées sous forme de nouvelle colonne. Par défaut, la nouvelle colonne est nommée en ajoutant le suffixe _scaled au nom de la colonne d'origine. Vous pouvez utiliser le paramètre suffix pour modifier le nom du suffixe.
```
df.min_max_scale(columns=['fid'], preserve=True)
    name  id  fid  fid_scaled
0  name1   4  5.3    1.000000
1  name2   2  3.5    0.526316
2  name2   3  1.5    0.000000
3  name1   4  4.2    0.710526
4  name1   3  2.2    0.184211
5  name1   3  4.1    0.684211
```
Utilisez la méthode min_max_scale avec le paramètre group pour spécifier une ou plusieurs colonnes de regroupement et récupérer les valeurs minimales et maximales de la colonne spécifiée afin de mettre les données à l'échelle.
```
df.min_max_scale(columns=['fid'], group=['name'])
    name  id       fid
0  name1   4  1.000000
1  name1   4  0.645161
2  name1   3  0.000000
3  name1   3  0.612903
4  name2   2  1.000000
5  name2   3  0.000000
```
L'exemple précédent montre que les données dans name1 et name2 sont mises à l'échelle en fonction des valeurs minimales et maximales des deux groupes.
Utilisez la méthode std_scale pour mettre les données à l'échelle selon la loi normale centrée réduite. Dans la méthode std_scale , vous pouvez configurer le paramètre preserve pour conserver la colonne d'origine, et configurer le paramètre group pour regrouper les données.
```
df.std_scale(columns=['fid'])
    name  id       fid
0  name1   4  1.436467
1  name2   2  0.026118
2  name2   3 -1.540938
3  name1   4  0.574587
4  name1   3 -0.992468
5  name1   3  0.496234
```

Traiter les valeurs nulles

Un DataFrame vous permet de supprimer les lignes contenant des valeurs nulles et de remplir les valeurs nulles. Données d'exemple :

id   name   f1   f2   f3   f4
0   0  name1  1.0  NaN  3.0  4.0
1   1  name1  2.0  NaN  NaN  1.0
2   2  name1  3.0  4.0  1.0  NaN
3   3  name1  NaN  1.0  2.0  3.0
4   4  name1  1.0  NaN  3.0  4.0
5   5  name1  1.0  2.0  3.0  4.0
6   6  name1  NaN  NaN  NaN  NaN

Utilisez la méthode dropna pour supprimer les lignes qui contiennent des valeurs nulles dans l'objet subset .

df.dropna(subset=['f1', 'f2', 'f3', 'f4'])
   id   name   f1   f2   f3   f4
0   5  name1  1.0  2.0  3.0  4.0

Pour conserver les lignes contenant des valeurs non nulles, ajoutez la configuration how='all' .

df.dropna(how='all', subset=['f1', 'f2', 'f3', 'f4'])
   id   name   f1   f2   f3   f4
0   0  name1  1.0  NaN  3.0  4.0
1   1  name1  2.0  NaN  NaN  1.0
2   2  name1  3.0  4.0  1.0  NaN
3   3  name1  NaN  1.0  2.0  3.0
4   4  name1  1.0  NaN  3.0  4.0
5   5  name1  1.0  2.0  3.0  4.0

Utilisez le paramètre thresh pour spécifier le nombre minimal de valeurs non nulles dans une ligne.

df.dropna(thresh=3, subset=['f1', 'f2', 'f3', 'f4'])
   id   name   f1   f2   f3   f4
0   0  name1  1.0  NaN  3.0  4.0
2   2  name1  3.0  4.0  1.0  NaN
3   3  name1  NaN  1.0  2.0  3.0
4   4  name1  1.0  NaN  3.0  4.0
5   5  name1  1.0  2.0  3.0  4.0

Appelez la méthode fillna pour remplacer les valeurs nulles par des constantes ou par des valeurs provenant d'une colonne existante.

L'exemple suivant montre comment remplacer les valeurs nulles par des constantes :

df.fillna(100, subset=['f1', 'f2', 'f3', 'f4'])
   id   name     f1     f2     f3     f4
0   0  name1    1.0  100.0    3.0    4.0
1   1  name1    2.0  100.0  100.0    1.0
2   2  name1    3.0    4.0    1.0  100.0
3   3  name1  100.0    1.0    2.0    3.0
4   4  name1    1.0  100.0    3.0    4.0
5   5  name1    1.0    2.0    3.0    4.0
6   6  name1  100.0  100.0  100.0  100.0

L'exemple suivant montre comment remplacer les valeurs nulles par des valeurs issues d'une colonne existante :

df.fillna(df.f2, subset=['f1', 'f2', 'f3', 'f4'])
   id   name   f1   f2   f3   f4
0   0  name1  1.0  NaN  3.0  4.0
1   1  name1  2.0  NaN  NaN  1.0
2   2  name1  3.0  4.0  1.0  4.0
3   3  name1  1.0  1.0  2.0  3.0
4   4  name1  1.0  NaN  3.0  4.0
5   5  name1  1.0  2.0  3.0  4.0
6   6  name1  NaN  NaN  NaN  NaN

Un DataFrame prend en charge le remplissage vers l'arrière et le remplissage vers l'avant pour combler les valeurs nulles. Le tableau suivant définit les valeurs valides du paramètre method .

Valeur	Description
bfill ou backfill	Remplissage vers l'arrière
ffill ou pad	Remplissage vers l'avant

Exemple

df.fillna(method='bfill', subset=['f1', 'f2', 'f3', 'f4'])
   id   name   f1   f2   f3   f4
0   0  name1  1.0  3.0  3.0  4.0
1   1  name1  2.0  1.0  1.0  1.0
2   2  name1  3.0  4.0  1.0  NaN
3   3  name1  1.0  1.0  2.0  3.0
4   4  name1  1.0  3.0  3.0  4.0
5   5  name1  1.0  2.0  3.0  4.0
6   6  name1  NaN  NaN  NaN  NaN
df.fillna(method='ffill', subset=['f1', 'f2', 'f3', 'f4'])
   id   name   f1   f2   f3   f4
0   0  name1  1.0  1.0  3.0  4.0
1   1  name1  2.0  2.0  2.0  1.0
2   2  name1  3.0  4.0  1.0  1.0
3   3  name1  NaN  1.0  2.0  3.0
4   4  name1  1.0  1.0  3.0  4.0
5   5  name1  1.0  2.0  3.0  4.0
6   6  name1  NaN  NaN  NaN  NaN

Vous pouvez également utiliser la fonction ffill ou bfill pour simplifier le code. La fonction ffill équivaut à fillna(method='ffill') . La fonction bfill équivaut à fillna(method='bfill') .