Quick start - MaxCompute - Centro de documentación de Alibaba Cloud

DataFrame proporciona una API de datos estructurados para MaxCompute. Este tema le guía en la creación de objetos DataFrame y en la ejecución de operaciones comunes con datos, como filtrado, agregación y uniones.

Preparación de datos

Los ejemplos utilizan los archivos u.user, u.item y u.data, que contienen datos de usuarios, películas y calificaciones, respectivamente.

Cree las tablas:

La tabla pyodps_ml_100k_users para los datos de usuarios.

CREATE TABLE IF NOT EXISTS pyodps_ml_100k_users
(
  user_id    BIGINT COMMENT 'User ID',
  age        BIGINT COMMENT 'Age',
  sex        STRING COMMENT 'Gender',
  occupation STRING COMMENT 'Occupation',
  zip_code   STRING COMMENT 'Zip code'
);

La tabla pyodps_ml_100k_movies para los datos de películas.

CREATE TABLE IF NOT EXISTS pyodps_ml_100k_movies
(
    movie_id            BIGINT COMMENT 'Movie ID',
    title              STRING COMMENT 'Movie title',
    release_date       STRING COMMENT 'Release date',
    video_release_date STRING COMMENT 'Video release date',
    IMDb_URL           STRING COMMENT 'IMDb URL',
    unknown            TINYINT COMMENT 'Unknown',
    Action             TINYINT COMMENT 'Action',
    Adventure          TINYINT COMMENT 'Adventure',
    Animation          TINYINT COMMENT 'Animation',
    Children           TINYINT COMMENT 'Children',
    Comedy             TINYINT COMMENT 'Comedy',
    Crime              TINYINT COMMENT 'Crime',
    Documentary        TINYINT COMMENT 'Documentary',
    Drama              TINYINT COMMENT 'Drama',
    Fantasy            TINYINT COMMENT 'Fantasy',
    FilmNoir           TINYINT COMMENT 'Film Noir',
    Horror             TINYINT COMMENT 'Horror',
    Musical            TINYINT COMMENT 'Musical',
    Mystery            TINYINT COMMENT 'Mystery',
    Romance            TINYINT COMMENT 'Romance',
    SciFi              TINYINT COMMENT 'Sci-Fi',
    Thriller           TINYINT COMMENT 'Thriller',
    War                TINYINT COMMENT 'War',
    Western            TINYINT COMMENT 'Western'
);

La tabla pyodps_ml_100k_ratings para los datos de calificaciones.

CREATE TABLE IF NOT EXISTS pyodps_ml_100k_ratings
(
    user_id    BIGINT COMMENT 'User ID',
    movie_id  BIGINT COMMENT 'Movie ID',
    rating    BIGINT COMMENT 'Rating',
    timestamp BIGINT COMMENT 'Timestamp'
)

Use Tunnel Upload to import local data files into MaxCompute tables. For more information about Tunnel operations, see Tunnel Commands.

Tunnel upload -fd | path_to_file/u.user pyodps_ml_100k_users;
Tunnel upload -fd | path_to_file/u.item pyodps_ml_100k_movies;
Tunnel upload -fd | path_to_file/u.data pyodps_ml_100k_ratings;

Operaciones con DataFrame

Una vez que las tres tablas estén listas (pyodps_ml_100k_movies, pyodps_ml_100k_users y pyodps_ml_100k_ratings), podrá explorar las operaciones de DataFrame en IPython.

Nota

IPython requiere Python. Ejecute pip install IPython para instalarlo y luego ejecute ipython para iniciar el entorno interactivo.

Cree un objeto ODPS.

import os
from odps import ODPS
# Make sure that the ALIBABA_CLOUD_ACCESS_KEY_ID environment variable is set to your Access Key ID,
# and the ALIBABA_CLOUD_ACCESS_KEY_SECRET environment variable is set to your Access Key Secret.
# We recommend that you avoid hardcoding the Access Key ID and Access Key Secret in your code.
o = ODPS(
    os.getenv('ALIBABA_CLOUD_ACCESS_KEY_ID'),
    os.getenv('ALIBABA_CLOUD_ACCESS_KEY_SECRET'),
    project='your-default-project',
    endpoint='your-end-point',
)

Cree un objeto DataFrame a partir de una tabla.

from odps.df import DataFrame
users = DataFrame(o.get_table('pyodps_ml_100k_users'));

Consulte los nombres de columna y los tipos de datos mediante la propiedad dtypes.

print(users.dtypes)

Salida:

odps.Schema {
  user_id             int64
  age                 int64
  sex                 string
  occupation          string
  zip_code            string
}

Visualice las primeras N filas con el método head.

print(users.head(10))

Salida:

   user_id  age  sex     occupation  zip_code
0        1   24    M     technician     85711
1        2   53    F          other     94043
2        3   23    M         writer     32067
3        4   24    M     technician     43537
4        5   33    F          other     15213
5        6   42    M      executive     98101
6        7   57    M  administrator     91344
7        8   36    M  administrator     05201
8        9   29    M        student     01002
9       10   53    M         lawyer     90703

Para trabajar con columnas específicas, utilice uno de los siguientes métodos:

Seleccione un subconjunto de columnas.

print(users[['user_id', 'age']].head(5))

Salida:

   user_id  age
0        1   24
1        2   53
2        3   23
3        4   24
4        5   33

Excluya columnas específicas.

print(users.exclude('zip_code', 'age').head(5))

Salida:

   user_id  sex  occupation
0        1    M  technician
1        2    F       other
2        3    M      writer
3        4    M  technician
4        5    F       other

Excluya columnas y añada otras calculadas. Por ejemplo, cree una columna booleana llamada sex_bool que sea True si sex es M y False en caso contrario.

print(users.select(users.exclude('zip_code', 'sex'), sex_bool=users.sex == 'M').head(5))

Salida:

   user_id  age  occupation  sex_bool
0        1   24  technician      True
1        2   53       other     False
2        3   23      writer      True
3        4   24  technician      True
4        5   33       other     False

Cuente los usuarios masculinos y femeninos.

print(users.groupby(users.sex).agg(count=users.count()))

Salida:

   sex  count
0    F    273
1    M    670

Agrupe los usuarios por ocupación, ordénelos de forma descendente y consulte las 10 principales ocupaciones por cantidad.

df = users.groupby('occupation').agg(count=users['occupation'].count())
df1 = df.sort(df['count'], ascending=False)
print(df1.head(10))

Salida:

      occupation  count
0        student    196
1          other    105
2       educator     95
3  administrator     79
4       engineer     67
5     programmer     66
6      librarian     51
7         writer     45
8      executive     32
9      scientist     31

También puede usar el método value_counts para lograr una sintaxis más breve. El número de filas devueltas está limitado por options.df.odps.sort.limit. Para obtener más información, consulte Configuration.

df = users.occupation.value_counts()[:10]
print(df.head(10))

Salida:

      occupation  count
0        student    196
1          other    105
2       educator     95
3  administrator     79
4       engineer     67
5     programmer     66
6      librarian     51
7         writer     45
8      executive     32
9      scientist     31

Una las tres tablas con join y guarde el resultado en una nueva tabla llamada pyodps_ml_100k_lens.

movies = DataFrame(o.get_table('pyodps_ml_100k_movies'))
ratings = DataFrame(o.get_table('pyodps_ml_100k_ratings'))
o.delete_table('pyodps_ml_100k_lens', if_exists=True)
lens = movies.join(ratings).join(users).persist('pyodps_ml_100k_lens')
print(lens.dtypes)

Salida:

odps.Schema {
  movie_id                          int64       
  title                             string      
  release_date                      string      
  ideo_release_date                 string      
  imdb_url                          string      
  unknown                           int64       
  action                            int64       
  adventure                         int64       
  animation                         int64       
  children                          int64       
  comedy                            int64       
  crime                             int64       
  documentary                       int64       
  drama                             int64       
  fantasy                           int64       
  filmnoir                          int64       
  horror                            int64       
  musical                           int64       
  mystery                           int64       
  romance                           int64       
  scifi                             int64       
  thriller                          int64       
  war                               int64       
  western                           int64       
  user_id                           int64       
  rating                            int64       
  timestamp                         int64       
  age                               int64       
  sex                               string      
  occupation                        string      
  zip_code                          string      
}

Procesamiento de datos con DataFrame

Primero, descargue el conjunto de datos Iris. Los siguientes pasos utilizan un nodo PyODPS en DataWorks. Para obtener más información, consulte Develop a PyODPS 3 task.

Cree una tabla de datos de prueba.
Cree una tabla en DataWorks:
1. En el panel Business Flow, haga clic derecho en MaxCompute y seleccione Create Table. En el cuadro de diálogo Create Table, seleccione una Path, introduzca un Name y haga clic en Create para ir al editor de tablas.
2. Haga clic en DDL en la esquina superior izquierda de la página de edición.
3. Introduzca la siguiente sentencia DDL y luego ejecútela para crear la tabla.
```
CREATE TABLE pyodps_iris (
    sepallength double COMMENT 'sepal length (cm)',
    sepalwidth double COMMENT 'sepal width (cm)',
    petallength double COMMENT 'petal length (cm)',
    petalwidth double COMMENT 'petal width (cm)',
    name string COMMENT 'name'
) ;
```
Cargue los datos de prueba.
1. Haga clic derecho en la nueva tabla, seleccione Import Data y haga clic en Next para cargar el conjunto de datos que descargó.
  
  En el cuadro de diálogo Import Data, establezca Data Import Method en Upload Local File y File Format en CSV. Seleccione el archivo iris.csv descargado. Establezca Delimiter en Comma, Source Charset en GBK y Start Row en 1. Seleccione Yes para First Row Is Header. Tras confirmar que la vista previa de los datos es correcta, haga clic en Next.
2. Haga clic en Match by Position para importar los datos.
En el panel Business Flow, haga clic derecho en MaxCompute, seleccione Create Node y luego seleccione PyODPS 3 para crear un nodo PyODPS donde almacenar y ejecutar su código.

Introduzca el código y haga clic en el icono de ejecución . Una vez ejecutado el código, podrá consultar los resultados en la pestaña Run log que se encuentra abajo. El código es el siguiente:

from odps import ODPS
from odps.df import DataFrame, output
import os
# Make sure that the ALIBABA_CLOUD_ACCESS_KEY_ID environment variable is set to your Access Key ID,
# and the ALIBABA_CLOUD_ACCESS_KEY_SECRET environment variable is set to your Access Key Secret.
# We recommend that you avoid hardcoding the Access Key ID and Access Key Secret in your code.
o = ODPS(
    os.getenv('ALIBABA_CLOUD_ACCESS_KEY_ID'),
    os.getenv('ALIBABA_CLOUD_ACCESS_KEY_SECRET'),
    project='your-default-project',
    endpoint='your-end-point',
)
# Create a DataFrame object named iris from the MaxCompute table.
iris = DataFrame(o.get_table('pyodps_iris'))
print(iris.head(10))
# Print part of the iris DataFrame.
print(iris.sepallength.head(5))
# Use a custom function to calculate the sum of two columns in the iris DataFrame.
print(iris.apply(lambda row: row.sepallength + row.sepalwidth, axis=1, reduce=True, types='float').rename('sepaladd').head(3))
# Specify the output names and types for the function.
@output(['iris_add', 'iris_sub'], ['float', 'float'])
def handle(row):
    # Use the yield keyword to return multiple output rows.
    yield row.sepallength - row.sepalwidth, row.sepallength + row.sepalwidth
    yield row.petallength - row.petalwidth, row.petallength + row.petalwidth
# Print the first 5 rows of the result. axis=1 indicates a row-by-row operation.
  print(iris.apply(handle, axis=1).head(5))

Resultados:

# print(iris.head(10))
   sepallength  sepalwidth  petallength  petalwidth         name
0          4.9         3.0          1.4         0.2  Iris-setosa
1          4.7         3.2          1.3         0.2  Iris-setosa
2          4.6         3.1          1.5         0.2  Iris-setosa
3          5.0         3.6          1.4         0.2  Iris-setosa
4          5.4         3.9          1.7         0.4  Iris-setosa
5          4.6         3.4          1.4         0.3  Iris-setosa
6          5.0         3.4          1.5         0.2  Iris-setosa
7          4.4         2.9          1.4         0.2  Iris-setosa
8          4.9         3.1          1.5         0.1  Iris-setosa
9          5.4         3.7          1.5         0.2  Iris-setosa
# print(iris.sepallength.head(5))
   sepallength
0          4.9
1          4.7
2          4.6
3          5.0
4          5.4
# print(iris.apply(lambda row: row.sepallength + row.sepalwidth, axis=1, reduce=True, types='float').rename('sepaladd').head(3))
   sepaladd
0       7.9
1       7.9
2       7.7
# print(iris.apply(handle,axis=1).head(5))
   iris_add  iris_sub
0       1.9       7.9
1       1.2       1.6
2       1.5       7.9
3       1.1       1.5
4       1.5       7.7