Create a DataFrame object - MaxCompute - Centre de documentation Alibaba Cloud

PyODPS fournit une API DataFrame pour le traitement des données structurées dans MaxCompute. Un objet DataFrame peut référencer quatre types de sources de données — tables MaxCompute, partitions MaxCompute, DataFrames Pandas et tables SQLAlchemy — via la même interface. Il suffit de modifier l'entrée pour basculer d'une source à l'autre, sans réécrire votre logique de traitement. Vous pouvez ainsi développer et tester votre code localement avec Pandas, puis exécuter la même logique à grande échelle sur MaxCompute.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

La table exemple pyodps_iris disponible dans votre projet MaxCompute. Pour les instructions de configuration, consultez la rubrique Utiliser DataFrame pour traiter les données

Concepts clés

Un objet DataFrame PyODPS est le seul objet Collection que vous devez créer manuellement. Les trois principaux types d'objets sont les suivants :

Objet	Structure	Description
`Collection` (`DataFrame`)	Bidimensionnelle	Représente une table complète
`Sequence`	Unidimensionnelle	Représente une colonne unique
`Scalar`	Valeur unique	Représente un objet scalaire

Évaluation différée : un DataFrame construit à partir d'une table MaxCompute ne charge pas les données réelles ; il conserve une représentation des opérations à effectuer. MaxCompute exécute ces opérations et stocke les résultats uniquement lorsque vous déclenchez le calcul. En revanche, un DataFrame créé à partir d'un DataFrame Pandas contient les données réelles en mémoire.

Récapitulatif des sources de données

Les quatre méthodes de création utilisent le même constructeur DataFrame(source). La seule différence réside dans la valeur passée en tant que source.

Source de données	Méthode	Cas d'utilisation typique
Table MaxCompute	`DataFrame(o.get_table(...))` ou `.to_df()`	Traitement des données de production
Partition MaxCompute	`DataFrame(o.get_table(...).get_partition(...))` ou `.to_df()`	Traitement limité à une partition
DataFrame Pandas	`DataFrame(pandas_df)`	Tests et développement locaux
Table SQLAlchemy	`DataFrame(sqlalchemy_table)`	Accès aux tables de base de données

Créer un objet DataFrame à partir d'une table MaxCompute

Transmettez l'objet table directement à DataFrame, ou appelez to_df() sur la table.

from odps.df import DataFrame

# Method 1: Pass the table object to DataFrame
iris = DataFrame(o.get_table('pyodps_iris'))

# Method 2: Use the to_df method on the table
iris2 = o.get_table('pyodps_iris').to_df()

Ces deux méthodes produisent des objets DataFrame équivalents dotés du même schéma.

Créer un objet DataFrame à partir d'une partition MaxCompute

Transmettez un objet partition à DataFrame, ou appelez to_df() sur la partition.

from odps.df import DataFrame

# Create a partitioned table if one does not already exist
o.create_table('partitioned_table', ('num bigint, num2 double', 'pt string'), if_not_exists=True)

# Method 1: Pass the partition object to DataFrame
pt_df = DataFrame(o.get_table('partitioned_table').get_partition('pt=20171111'))

# Method 2: Use the to_df method on the partition
pt_df2 = o.get_table('partitioned_table').get_partition('pt=20171111').to_df()

Créer un objet DataFrame à partir d'un DataFrame Pandas

Transmettez le DataFrame Pandas au constructeur DataFrame.

from odps.df import DataFrame
import pandas as pd
import numpy as np

df = DataFrame(pd.DataFrame(np.arange(9).reshape(3, 3), columns=list('abc')))

Inférence des types de données

Lors de la conversion d'un DataFrame Pandas, PyODPS déduit automatiquement les types de données. Utilisez les paramètres suivants pour contrôler la résolution des types lorsque l'inférence échoue ou produit des résultats incorrects :

Paramètre	Type	Description
`unknown_as_string`	bool	Lorsque ce paramètre est défini sur `True`, convertit les colonnes dont les types ne sont pas reconnaissables (y compris les colonnes vides) en `string` au lieu de générer une erreur
`as_type`	dict	Définit explicitement le type de données pour une ou plusieurs colonnes ; requis pour les colonnes `list` et `dict`, dont PyODPS ne peut pas déduire automatiquement le type

Exemple 1 : Résoudre une colonne vide et remplacer un type de données

df2 = DataFrame(df, unknown_as_string=True, as_type={'null_col2': 'float'})
print(df2.dtypes)

Résultat :

odps.Schema {
  sepallength           float64
  sepalwidth            float64
  petallength           float64
  petalwidth            float64
  name                  string
  null_col1             string   # unknown_as_string=True converted this to string
  null_col2             float64  # as_type forced this to float
}

Exemple 2 : Définir le type pour une colonne de liste

PyODPS ne déduit pas les types pour les colonnes list ou dict. Définissez as_type sur un dictionnaire associant les noms de colonnes à leurs types.

df4 = DataFrame(df3, as_type={'list_col': 'list<int64>'})
print(df4.dtypes)

Résultat :

odps.Schema {
  id        int64
  list_col  list<int64>  # as_type is required for list and dict columns
}

PyODPS ne prend pas en charge le chargement des tables externes Object Storage Service (OSS) ou Tablestore vers MaxCompute.

Créer un objet DataFrame à partir d'une table SQLAlchemy

Connectez SQLAlchemy à votre projet MaxCompute, puis transmettez l'objet table à DataFrame. Pour connaître les paramètres de connexion, consultez la rubrique Connecter SQLAlchemy à un projet MaxCompute.

import os
from odps.df import DataFrame
import sqlalchemy

# Build the connection string using environment variables for your AccessKey credentials.
# Set ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET before running this code.
conn_string = 'odps://%s:%s@<project>/?endpoint=<endpoint>' % (
    os.getenv('ALIBABA_CLOUD_ACCESS_KEY_ID'),
    os.getenv('ALIBABA_CLOUD_ACCESS_KEY_SECRET')
)

engine = sqlalchemy.create_engine(conn_string)
metadata = sqlalchemy.MetaData(bind=engine)  # Bind metadata to the engine
table = sqlalchemy.Table('pyodps_iris', metadata, extend_existing=True, autoload=True)

iris = DataFrame(table)

Étapes suivantes

Une fois l'objet DataFrame créé, vous pouvez effectuer des opérations sur les données à l'aide de l'API DataFrame PyODPS. Pour consulter les opérations disponibles, reportez-vous à la rubrique Utiliser DataFrame pour traiter les données.