Pourquoi Python n’a-t-il pas une fonction «aplatie» pour les listes?

Erlang et Ruby sont tous deux dotés de fonctions permettant d'aplatir les tableaux. Cela semble être un outil simple et utile à ajouter à une langue. On pourrait faire ceci:

>>> mess = [[1, [2]], 3, [[[4, 5]], 6]]
>>> mess.flatten()
[1, 2, 3, 4, 5, 6]

Ou même:

>>> import itertools
>>> mess = [[1, [2]], 3, [[[4, 5]], 6]]
>>> list(itertools.flatten(mess))
[1, 2, 3, 4, 5, 6]

Au lieu de cela, en Python, il faut passer par le problème d'écrire une fonction pour aplatir les tableaux. Cela me semble ridicule, l’aplanissement des tableaux est une chose si courante à faire. C'est comme avoir à écrire une fonction personnalisée pour concaténer deux tableaux.

J'ai googlé cela sans résultat, alors je demande ici; Y a-t-il une raison particulière pour laquelle un langage mature comme Python 3, qui contient cent mille piles différentes, ne fournit pas une méthode simple pour aplatir les tableaux? L'idée d'inclure une telle fonction a-t-elle été discutée et rejetée à un moment donné?

Les propositions d’ flattenajout d’ une fonction à la bibliothèque standard apparaissent de temps en temps sur les listes de diffusion python-dev et python-ideas . Les développeurs Python répondent généralement avec les points suivants:

1. Une mise à niveau à un niveau (transformant un itérable d'iterables en un unique itérable) est une expression triviale d'une ligne (x for y in z for x in y)et, dans tous les cas, se trouve déjà dans la bibliothèque standard sous le nom itertools.chain.from_iterable.

2. Quels sont les cas d'utilisation pour un aplatissement multiniveau à usage général? Sont-ils vraiment assez convaincants pour que la fonction soit ajoutée à la bibliothèque standard?

3. Comment un utilisateur multiniveau polyvalent déciderait-il à quel moment l'aplatir et le moment de son départ? Vous pourriez penser qu’une règle du type "tout ce qui prend en charge l’interface itérable" fonctionnerait, mais cela entraînerait une boucle infinie flatten('a').

Voir par exemple Raymond Hettinger :

Il a été discuté ad nauseam sur comp.lang.python. Les gens semblent aimer écrire leurs propres versions de flatten plutôt que de trouver des cas d'utilisation légitimes pour lesquels il n'existe pas de solutions triviales.

Un aplatissement général a besoin de savoir comment on peut dire ce qui est atomique et ce qui peut être subdivisé davantage. En outre, il n'est pas évident d'étendre comment l'algorithme devrait être étendu pour couvrir les entrées avec des structures de données en forme d'arborescence avec des données aux nœuds ainsi que les feuilles (pré-ordre, post-commande, parcours en ordre, etc.)

Cela vient avec une telle méthode mais ça ne s'appelle pas aplatir. Cela s'appelle " chaîne ". Il retourne un itérateur sur lequel vous auriez alors besoin d'utiliser la fonction list () pour le transformer en liste. Si vous ne souhaitez pas utiliser de *, vous pouvez utiliser la deuxième version "from_iterator". Cela fonctionne de la même manière en Python 3. Il échouera si l'entrée de liste n'est pas une liste de listes.

[[1], [2, 3], [3, 4, 5]] #yes
[1, 2, [5, 6]] #no

Il y avait à une époque une méthode d' aplatissement dans le module compiler.ast, mais elle était déconseillée dans la version 2.6 puis supprimée dans la version 3.0. La récursion de profondeur arbitraire, nécessaire pour les listes imbriquées de manière arbitraire, ne fonctionne pas bien avec la profondeur de récursivité maximale conservatrice de Python. Le raisonnement en faveur de la suppression du compilateur était en grande partie dû au fait que c'était un désordre . Le compilateur a été transformé en ast mais aplati a été laissé derrière.

Une profondeur arbitraire peut être obtenue avec les tableaux de Numpy et l'aplatissement de cette bibliothèque.

... peut-être parce que ce n'est pas si difficile d'en écrire un toi-même

def flatten(l): return flatten(l[0]) + (flatten(l[1:]) if len(l) > 1 else []) if type(l) is list else [l]

... et ensuite aplatissez tout ce que vous voulez :)

>>> flatten([1,[2,3],4])
[1, 2, 3, 4]
>>> flatten([1, [2, 3], 4, [5, [6, {'name': 'some_name', 'age':30}, 7]], [8, 9, [10, [11, [12, [13, {'some', 'set'}, 14, [15, 'some_string'], 16], 17, 18], 19], 20], 21, 22, [23, 24], 25], 26, 27, 28, 29, 30])
[1, 2, 3, 4, 5, 6, {'age': 30, 'name': 'some_name'}, 7, 8, 9, 10, 11, 12, 13, set(['set', 'some']), 14, 15, 'some_string', 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
>>>