Liste chaînée

Bonsoir, tout cela n'a aucun sens. Enfin je ne comprends pas le but de l'exercice.

Pourquoi une fonction pour créer une liste ? Est-ce une obligation de ton enseignant ? (si oui, hum...). En plus tu ne crées pas une liste mais un tuple dans cette fonction creer_liste, un tuple est une liste non mutable, donc user de tuple ne va pas, également, dans l'appel de cette fonction, tu n'en utilises pas le retour (liste_vide).

Que sont censées faire ces lignes dans ton code ?

dernier_element, liste_avant = liste

Si on tente de faire cela, on obtient forcément une erreur :

>>> a = [1, 2, 3]
>>> b, c = a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

Logique, puisque python ne peut savoir combien d'éléments on veut dans b et c, cela ne fonctionnera uniquement que s'il y a autant de variables que d'éléments dans la liste. Je suppose que ton enseignant a abordé les indices et slices d'itérables afin d'accéder à tel ou tels éléments de la liste. Ici tu en auras besoin.

La fonction elements_liste, idem, je n'en comprends pas l'utilité, puisqu'elle reçoit une liste, construit une liste et retourne cette nouvelle liste, en gros, elle fait une copie de la liste d'origine.

La fonction est_liste_vide, celle-là au moins peut avoir une petite utilité, même chose que précédemment concernant tuple et list. Pour savoir si une liste est vide, on préférera au mieux regarder combien d'éléments contient cette liste:

len(liste) == 0

Et encore bien mieux on utilisera le mot clé not, car, une liste vide est évaluée à False par python, ce qui fait qu'on arrive alors à

def est_liste_vide(liste):
    """retourne Vrai si la liste est vide"""
    return not liste

La fonction inserer, alors celle-là hormis que tu utilises encore des tuples n'est pas très logique puisque tu insères dans ta nouvelle liste, certes un élément nouveau, mais aussi l'ancienne liste, donc on va obtenir des choses comme ['a', ['b', ['c', 'd']]].

Dans cette fonction, tu dois d'abord créer une nouvelle liste, insérer le nouvel élément, puis parcourir les éléments de l'ancienne liste (boucle for), les insérer dans la nouvelle liste, et enfin la retourner.

La fonction tete doit retourner le 1er élément de la liste, ici encore nécessité d'user d'indice.

La fonction queue hormis qu'elle est en incohérence au regard de ce que fait la fonction tete, devrait construire une nouvelle liste en omettant d'y insérer le 1er élément, donc un petit for ... range pourrait convenir.

Bon courage.

Bonjour,

Je me demande quel est l'intérêt des listes chainées en Python ..

En C, ok, avec structures et pointeurs, mais en Python, avec toutes les possibilités du langage ...

Bonjour,

Comme le soulignent Phil et cpamafote, l'exercice est un peu idiot car les listes existent déjà nativement en python. Je passe aussi sur le fait que l'énoncé est mal rédigé (c'est à peine français).

Enfin, il n'est pas très clair si l'exercice appelle tableau les listes ou les tuples de pythons. Est-ce que la question c'est comment convertir un tuple en liste ? Si oui ça s'écrit comme ça :

t = (1, 2, 3)
l = [x for x in t]

print(t, type(t))  #(1, 2, 3) <class 'tuple'>
print(l, type(l))  #[1, 2, 3] <class 'list'>

Ceci dit, même si l'exercice est idiot, tu peux imiter une structure de liste chaînée en python, c'est à dire avoir une classe qui permet de stocker un maillon de la liste, et une classe qui permet d'envelopper le tout. Il faudrait demander à ton enseignant si c'est ce qu'il attend.

class Maillon:
    def __init__(self, value, next=None):
        self.value = value
        self.next = next

class Liste:
    def __init__(self, iter=None):
        self.head = None
        self.tail = None
        self.cur = None
        if iter is not None:
            for x in iter:
                self.append(x)

    def append(self, value):
        maillon = Maillon(value)
        if self.tail is None:
            self.head = self.tail = maillon
        else:
            self.tail.next = maillon
            self.tail = maillon

    def __iter__(self):
         self.cur = self.head
         return self
 
    def __next__(self):
         if self.cur is None:
             raise StopIteration
         ret = self.cur.value
         self.cur = self.cur.next
         return ret

    def __str__(self):
        return f"Liste<{[x for x in self]}>"

l = Liste()
for x in range(5):    # x itère de 0 à 4
    l.append(x)
print(l)              # Liste<[0, 1, 2, 3, 4]>
print([x for x in l]) # [0, 1, 2, 3, 4]

Ce qui est sûr c'est que le code que tu proposes ne réalise pas une liste chaînée au sens où on l'entend habituellement (contrairement à l'extrait de code ci-dessus).

Bonne chance