Pandas DataFrame DataFrame.transpose() Función

Usa DataFrame.transpose() para intercambiar las filas y las columnas de un DataFrame de pandas. El DataFrame devuelto usa las etiquetas de las filas originales como etiquetas de columna y las etiquetas de las columnas originales como etiquetas de fila. Los ejemplos de esta guía se ejecutan con pandas 3.1 y también cubren el atajo T, lo que ocurre con los tipos de datos cuando un DataFrame mezcla números y texto, y cómo el resultado comparte memoria con el original.

Sintaxis de DataFrame.transpose()

Llama al método en el objeto que quieras transponer: df.transpose(). Devuelve un DataFrame transpuesto; el objeto original sigue disponible como df.

import pandas as pd

transposed = dataframe.transpose()

La firma también acepta *args y una palabra clave copy, ambos conservados por compatibilidad con la API de NumPy y con código antiguo de pandas. Ninguno de los dos ayuda en una llamada normal: pandas no acepta posiciones de ejes (la sección de errores muestra qué ocurre si pasas una), y pandas 3 marca copy como obsoleto porque la copia al escribir (Copy-on-Write) ya decide cuándo se duplican los datos.

Ejemplo: transponer un DataFrame con DataFrame.transpose()

Este ejemplo crea una tabla pequeña con nombres de estudiantes, asistencia y calificaciones. Después de llamar al método, cada columna original se convierte en una fila y cada etiqueta del índice original se convierte en una columna.

import pandas as pd

dataframe = pd.DataFrame(
    {
        "Attendance": [60, 100, 80, 78, 95],
        "Name": ["Olivia", "John", "Laura", "Ben", "Kevin"],
        "Obtained Marks": [90, 75, 82, 64, 45],
    }
)

transposed = dataframe.transpose()
print(transposed)

Salida:

                     0     1      2    3      4
Attendance          60   100     80   78     95
Name            Olivia  John  Laura  Ben  Kevin
Obtained Marks      90    75     82   64     45

Las etiquetas permiten comprobar con más facilidad el sentido del intercambio: Attendance, Name y Obtained Marks identifican las filas del resultado, mientras que 0 a 4 identifican sus columnas.

Transponer un DataFrame con tipos de datos homogéneos

Cuando todas las columnas contienen enteros, los valores de entrada son de un tipo homogéneo. Transpón el DataFrame y consulta los tipos dtype de las columnas antes y después para ver cómo se representa este ejemplo en tu entorno de pandas.

import pandas as pd

dataframe = pd.DataFrame(
    {
        "A": [6, 20, 80, 78, 95],
        "B": [60, 50, 7, 67, 54],
    }
)

transposed = dataframe.transpose()
print("Original values:")
print(dataframe)
print("Transposed values:")
print(transposed)
print("Original dtypes:")
print(dataframe.dtypes)
print("Transposed dtypes:")
print(transposed.dtypes)

Salida:

Original values:
    A   B
0   6  60
1  20  50
2  80   7
3  78  67
4  95  54
Transposed values:
    0   1   2   3   4
A   6  20  80  78  95
B  60  50   7  67  54
Original dtypes:
A    int64
B    int64
dtype: object
Transposed dtypes:
0    int64
1    int64
2    int64
3    int64
4    int64
dtype: object

Esta entrada tiene cinco filas, etiquetadas de 0 a 4, y dos columnas, A y B, por lo que el resultado tiene dos filas y cinco columnas. Como todas las columnas de entrada contienen enteros, las columnas transpuestas conservan el tipo int64: cuando todas las columnas de un DataFrame comparten un mismo tipo, las columnas del DataFrame transpuesto conservan ese tipo. El siguiente ejemplo muestra qué cambia cuando no lo comparten.

Transponer un DataFrame con tipos de datos mixtos

Un DataFrame puede tener columnas de distintos tipos. En este caso, dos columnas contienen números y una contiene nombres. El código muestra los valores y los tipos dtype antes y después de la operación para que puedas inspeccionar el resultado de esta entrada.

import pandas as pd

dataframe = pd.DataFrame(
    {
        "Attendance": [60, 100, 80, 78, 95],
        "Name": ["Olivia", "John", "Laura", "Ben", "Kevin"],
        "Obtained Marks": [90, 75, 82, 64, 45],
    }
)

transposed = dataframe.transpose()
print("Original values:")
print(dataframe)
print("Transposed values:")
print(transposed)
print("Original dtypes:")
print(dataframe.dtypes)
print("Transposed dtypes:")
print(transposed.dtypes)

Salida:

Original values:
   Attendance    Name  Obtained Marks
0          60  Olivia              90
1         100    John              75
2          80   Laura              82
3          78     Ben              64
4          95   Kevin              45
Transposed values:
                     0     1      2    3      4
Attendance          60   100     80   78     95
Name            Olivia  John  Laura  Ben  Kevin
Obtained Marks      90    75     82   64     45
Original dtypes:
Attendance        int64
Name                str
Obtained Marks    int64
dtype: object
Transposed dtypes:
0    object
1    object
2    object
3    object
4    object
dtype: object

Los valores se trasladan sin cambios, pero compara los tipos: todas las columnas del DataFrame transpuesto tienen el tipo object, incluso las que solo contienen números. Cada una de esas columnas combina ahora valores de las dos columnas de enteros y de la columna Name, y object es el único tipo que puede contenerlos todos: los números siguen ahí, almacenados como objetos genéricos de Python en lugar de valores int64.

Cuando una transposición mixta convierte los números en objetos

Esa pérdida de tipo es más que estética. Las operaciones aritméticas sobre todo el DataFrame transpuesto llegan ahora a las cadenas de la fila Name y fallan:

import pandas as pd

dataframe = pd.DataFrame(
    {
        "Attendance": [60, 100, 80, 78, 95],
        "Name": ["Olivia", "John", "Laura", "Ben", "Kevin"],
        "Obtained Marks": [90, 75, 82, 64, 45],
    }
)

transposed = dataframe.transpose()
print(transposed + 1)

Salida:

TypeError: can only concatenate str (not "int") to str

Volver a transponer restaura la disposición original, pero no los tipos originales: el DataFrame restaurado conserva object en todas las columnas. Para volver a trabajar con números reales, convierte con astype() las filas que deben ser numéricas:

import pandas as pd

dataframe = pd.DataFrame(
    {
        "Attendance": [60, 100, 80, 78, 95],
        "Name": ["Olivia", "John", "Laura", "Ben", "Kevin"],
        "Obtained Marks": [90, 75, 82, 64, 45],
    }
)

transposed = dataframe.transpose()
restored = transposed.transpose()
print("Dtypes after transposing back:")
print(restored.dtypes)

numeric_rows = transposed.loc[["Attendance", "Obtained Marks"]].astype(int)
print("Dtypes of the recovered numeric rows:")
print(numeric_rows.dtypes)

Salida:

Dtypes after transposing back:
Attendance        object
Name              object
Obtained Marks    object
dtype: object
Dtypes of the recovered numeric rows:
0    int64
1    int64
2    int64
3    int64
4    int64
dtype: object

La conversión selecciona solo las dos filas numéricas. Incluir la fila Name haría que astype(int) fallara con los nombres, así que deja las filas de texto fuera de la selección.

Transponer con el atajo T

La propiedad T es el atajo de la llamada sin argumentos y devuelve el mismo DataFrame. En un DataFrame no cuadrado, la forma muestra el intercambio de un vistazo: cinco filas y dos columnas se convierten en dos filas y cinco columnas. Transponer dos veces restaura el original, y en esta entrada homogénea equals() confirma que tanto los valores como los tipos sobreviven al viaje de ida y vuelta, a diferencia del ejemplo mixto anterior.

import pandas as pd

dataframe = pd.DataFrame(
    {
        "A": [6, 20, 80, 78, 95],
        "B": [60, 50, 7, 67, 54],
    }
)

print("Original shape:", dataframe.shape)
print("Transposed shape:", dataframe.T.shape)
print("T matches transpose():", dataframe.T.equals(dataframe.transpose()))
print("Transposing twice restores the original:", dataframe.T.T.equals(dataframe))

Salida:

Original shape: (5, 2)
Transposed shape: (2, 5)
T matches transpose(): True
Transposing twice restores the original: True

Cómo el DataFrame transpuesto comparte memoria con el original

Un DataFrame transpuesto no es una copia independiente de los datos. Por defecto es una vista que comparte memoria con el original, como confirma numpy.shares_memory():

import numpy as np
import pandas as pd

dataframe = pd.DataFrame(
    {
        "A": [6, 20, 80, 78, 95],
        "B": [60, 50, 7, 67, 54],
    }
)

transposed = dataframe.transpose()
print("Shares memory with the original:", np.shares_memory(transposed, dataframe))

transposed.iloc[0, 0] = 999
print("Value in the transposed frame:", transposed.loc["A", 0])
print("Value in the original frame:", dataframe.loc[0, "A"])

Salida:

Shares memory with the original: True
Value in the transposed frame: 999
Value in the original frame: 6

Compartir memoria no significa que los cambios se propaguen al original. La copia al escribir, siempre activa desde pandas 3.0, copia los datos afectados en la primera escritura, de modo que la asignación solo cambia el DataFrame transpuesto y el original conserva su valor. Llama a .copy() sobre el resultado cuando necesites un DataFrame totalmente independiente desde el principio.

Errores y casos límite

El *args de la firma invita a un hábito de NumPy, pero pandas siempre intercambia los dos ejes de un DataFrame y no acepta ninguna permutación de ejes:

import pandas as pd

dataframe = pd.DataFrame({"A": [1, 2], "B": [3, 4]})
print(dataframe.transpose(1))

Salida:

ValueError: the 'axes' parameter is not supported in the pandas implementation of transpose()

Una tupla como (1, 0) falla con el mismo ValueError. Las formas degeneradas, en cambio, son entradas válidas y no errores:

import pandas as pd

empty = pd.DataFrame(columns=["A", "B"])
print("Original shape:", empty.shape)
print("Transposed shape:", empty.transpose().shape)

single_row = pd.DataFrame({"A": [1], "B": [2], "C": [3]})
print(single_row.transpose())

Salida:

Original shape: (0, 2)
Transposed shape: (2, 0)
   0
A  1
B  2
C  3

Un DataFrame con columnas pero sin filas cambia la forma (0, 2) por (2, 0), y una sola fila se convierte en una sola columna cuyo índice contiene las etiquetas de las columnas originales.