Obtenir la forme de la liste en Python

1. Utilisez la fonction “len()” pour obtenir la forme d’une liste unidimensionnelle en Python
2. Utilisez les listes en compréhension et la fonction “len()” pour obtenir la forme des listes emboîtées en Python
3. Utilisez NumPy pour obtenir la forme des listes multi-dimensionnelles en Python
4. Utilisez la récursivité pour obtenir la forme des listes emboîtées de manière irrégulière en Python
5. Conclusion

En Python, comprendre la forme d’une liste est crucial lors de la manipulation des structures de données, en particulier dans les scénarios impliquant des listes multi-dimensionnelles ou emboîtées. Cet article explore diverses méthodes pour déterminer la forme d’une liste en Python, allant des simples listes unidimensionnelles aux listes multi-dimensionnelles complexes ou emboîtées de manière irrégulière.

Utilisez la fonction “len()” pour obtenir la forme d’une liste unidimensionnelle en Python

La méthode la plus simple pour obtenir la forme d’une liste en Python est d’utiliser la fonction “len()” qui fournit la longueur (nombre d’éléments) d’une liste, donnant ainsi la taille de la première dimension.

La fonction “len()” a une syntaxe simple et concise:

len(object)

L’“objet” est l’objet pour lequel vous voulez déterminer la longueur. Il peut s’agir d’une séquence (comme une liste, un tuple ou une chaîne de caractères) ou d’une collection (comme un dictionnaire ou un ensemble).

L’exemple de code suivant montre comment utiliser la méthode “len()” pour obtenir la forme d’une liste en Python.

my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print("Length of the list:", length)

Résultat:

Length of the list: 5

Dans cet exemple, la longueur de la liste “my_list” est calculée et affichée dans la console.

Utilisez les listes en compréhension et la fonction “len()” pour obtenir la forme des listes emboîtées en Python

En plus de déterminer la longueur d’une liste plate (1D), nous pouvons également utiliser la fonction “len()” pour déterminer la forme de listes emboîtées (2D ou de dimension supérieure).

Dans l’exemple ci-dessous, nous déterminons le nombre de lignes et de colonnes dans une liste emboîtée 2D.

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
num_rows = len(nested_list)
# Assuming all sublists have the same number of columns
num_cols = len(nested_list[0])
print(f"Number of rows: {num_rows}, Number of columns: {num_cols}")

Résultat:

Number of rows: 3, Number of columns: 3

Ici, “num_rows” représente le nombre de lignes (sous-listes) et “num_cols” représente le nombre de colonnes (éléments dans chaque sous-liste) dans la liste emboîtée.

Utilisez NumPy pour obtenir la forme des listes multi-dimensionnelles en Python

Si nous voulons que notre code fonctionne avec n’importe quelle liste multidimensionnelle, nous pouvons utiliser l’attribut “.shape” de NumPy. Il renvoie un tuple qui contient le nombre d’éléments dans chaque dimension d’un tableau.

Le package NumPy a été initialement conçu pour être utilisé avec des tableaux mais peut également fonctionner avec des listes. NumPy est un package externe et n’est pas préinstallé avec Python, il est donc nécessaire de l’installer avant de l’utiliser.

La commande pour installer le package “NumPy” est donnée ci-dessous.

pip install numpy

L’exemple de code suivant montre comment obtenir la forme d’une liste multi-dimensionnelle en utilisant NumPy.

import numpy as np

my_array = np.array([[1, 2, 3], [4, 5, 6]])
num_rows, num_cols = my_array.shape
print(f"Number of rows: {num_rows}, Number of columns: {num_cols}")

Résultat:

Number of rows: 2, Number of columns: 3

Ici, on crée un tableau NumPy “my_array” et on récupère ensuite sa forme à l’aide de l’attribut “.shape”. Cette méthode fonctionne parfaitement pour les tableaux multidimensionnels, fournissant à la fois le nombre de lignes et de colonnes.

Utilisez la récursivité pour obtenir la forme des listes emboîtées de manière irrégulière en Python

Dans certains cas, nous pouvons rencontrer des listes emboîtées de manière irrégulière, où la profondeur de l’emboîtement varie et les sous-listes ont des longueurs différentes. Pour gérer de tels scénarios, nous pouvons utiliser une fonction récursive.

def get_shape(data):
    if isinstance(data, list):
        return [len(data)] + get_shape(data[0])
    else:
        return []  # Assuming leaf elements are considered as a single column


nested_list = [[1, 2], [3, 4, 5], [6, [7, 8]]]
shape = get_shape(nested_list)
num_rows, num_cols = shape
print(f"Number of rows: {num_rows}, Number of columns: {num_cols}")

Résultat:

Number of rows: 3, Number of columns: 2

La fonction “get_shape()” navigue de manière récursive à travers la liste emboîtée, en comptant le nombre de lignes dans chaque dimension et en supposant que les éléments feuilles sont considérés comme une seule colonne. Cette approche fournit à la fois le nombre de lignes et de colonnes pour les listes emboîtées de manière irrégulière.

Conclusion

L’approche la plus simple pour obtenir la forme d’une liste unidimensionnelle en Python consiste à utiliser la fonction “len()”. Pour les listes emboîtées, les listes en compréhension avec la fonction “len()” peuvent aider à déterminer le nombre de lignes et de colonnes de manière efficace.

Pour des scénarios plus avancés impliquant des tableaux multidimensionnels, l’attribut “.shape” de NumPy offre un moyen pratique d’obtenir le nombre de lignes et de colonnes. Enfin, lorsqu’il s’agit de listes emboîtées de manière irrégulière où les sous-listes ont des profondeurs et des longueurs variables, une fonction récursive peut être utilisée pour déterminer la forme avec précision.