Le type liste standard de Python peut représenter un tableau à deux dimensions par une liste de listes.
Cette section explique comment échanger les lignes et les colonnes de ce tableau à deux dimensions.
- Convertir en tableau NumPy
.TTransposez avec ceci.
pandas.DataFrameConvertir en ceci.TTransposez avec ceci.
- Transposition avec la fonction intégrée zip()
Il est plus facile d'utiliser NumPy ou pandas, mais si vous ne voulez pas importer NumPy ou pandas juste pour la transposition, vous pouvez utiliser la fonction zip() pour transposer.
Le tableau bidimensionnel original est défini comme suit
import numpy as np
import pandas as pd
l_2d = [[0, 1, 2], [3, 4, 5]]
Converti en tableau NumPy ndarray et transposé avec .T
Génère un tableau NumPy ndarray à partir du tableau bidimensionnel d'origine et obtient l'objet transposé avec l'attribut .T.
Si vous voulez un objet de type liste Python à la fin, convertissez-le en liste avec la méthode tolist().
arr_t = np.array(l_2d).T
print(arr_t)
print(type(arr_t))
# [[0 3]
# [1 4]
# [2 5]]
# <class 'numpy.ndarray'>
l_2d_t = np.array(l_2d).T.tolist()
print(l_2d_t)
print(type(l_2d_t))
# [[0, 3], [1, 4], [2, 5]]
# <class 'list'>
En plus de l'attribut .T, la méthode ndarray transpose() et la fonction numpy.transpose() peuvent également être utilisées.
Converti en pandas.DataFrame et transposé avec .T
Générez un pandas.DataFrame à partir du tableau bidimensionnel d'origine et obtenez l'objet transposé avec l'attribut .T.
Si vous voulez un objet de type liste Python à la fin, récupérez numpy.ndarray avec l'attribut values, puis convertissez-le en liste avec la méthode tolist().
df_t = pd.DataFrame(l_2d).T
print(df_t)
print(type(df_t))
# 0 1
# 0 0 3
# 1 1 4
# 2 2 5
# <class 'pandas.core.frame.DataFrame'>
l_2d_t = pd.DataFrame(l_2d).T.values.tolist()
print(l_2d_t)
print(type(l_2d_t))
# [[0, 3], [1, 4], [2, 5]]
# <class 'list'>
Transposition avec la fonction intégrée zip()
Transpose un tableau à deux dimensions en utilisant la fonction intégrée zip().
zip() est une fonction qui renvoie un itérateur qui résume les éléments de plusieurs itérables (listes, tuples, etc.). Elle est utilisée pour exécuter plusieurs listes dans une boucle for, par exemple.
En outre, la fonction utilise un mécanisme par lequel la liste peut être développée et transmise si l'argument de la fonction est marqué d'un astérisque.
- RELATED :Expansion et passage de listes, tuples et dictionnaires comme arguments de fonction en Python
Les transpositions peuvent être effectuées comme suit.
l_2d_t_tuple = list(zip(*l_2d))
print(l_2d_t_tuple)
print(type(l_2d_t_tuple))
# [(0, 3), (1, 4), (2, 5)]
# <class 'list'>
print(l_2d_t_tuple[0])
print(type(l_2d_t_tuple[0]))
# (0, 3)
# <class 'tuple'>
En l'état, les éléments qu'il contient sont des tuples. Par conséquent, si vous voulez en faire une liste, utilisez list(), qui convertit un tuple en une liste en notation de compréhension de liste.
- RELATED :Comment utiliser les compréhensions de listes en Python ?
- RELATED :Conversion de listes et de tuples en Python : list(), tuple()
l_2d_t = [list(x) for x in zip(*l_2d)]
print(l_2d_t)
print(type(l_2d_t))
# [[0, 3], [1, 4], [2, 5]]
# <class 'list'>
print(l_2d_t[0])
print(type(l_2d_t[0]))
# [0, 3]
# <class 'list'>
Voici une description détaillée de la procédure, étape par étape.
Les éléments de la liste sont développés avec un astérisque, les éléments développés sont regroupés avec la fonction zip(), puis le tuple est converti en liste avec la notation de compréhension de liste.
print(*l_2d)
# [0, 1, 2] [3, 4, 5]
print(list(zip([0, 1, 2], [3, 4, 5])))
# [(0, 3), (1, 4), (2, 5)]
print([list(x) for x in [(0, 3), (1, 4), (2, 5)]])
# [[0, 3], [1, 4], [2, 5]]