Implémentation de liste avec liste chaîne

Bonjour vous pouvez m’aidez pour cette fonction svp je n’y arrive pas je dois faire une fonction longueur(lst) qui renvoie la longueur de la liste lst sans utiliser len et de façon itérative puis de façon récursive merci voici ce que j’ai fais

Def longueur(lst):
    l=0
    for i in range(len(lst)):
           l+=1
    return l

Sauf que là, tu utilises len. Essais de traduire en français ce que tu veux faire.

Pour l’instant, c’est « pour chaque i allant de 0 (inclus) au nombre d’élément de la liste (exclus), augmente de 1 un compteur ». L’idée est bonne, il suffit de la reformuler sans utiliser le nombre d’élément de la liste.

Tu peux par exemple utiliser l’instruction del pour supprimer les éléments de la liste un par un.
Il faut s’arrêter quand on obtient une liste vide [], et bien sûr compter combien de fois on l’a fait..
Procédé utilisable aussi bin en itération qu’en récursion.

Comme ceci pour la façon itérative ?

def longueur(lst):
   a = 0
   for i in lst:
      a= a + 1 
   return a

Oui, par exemple.

de facon recursive j’ai réussi c bon maintenant je dois faire une fonction spprime(lst) qui renvoie une tuple contenant comme 1er élément, l’élément supprimé, et comme second élément, la liste à laquelle on a supprimé le 1er élément pour cette fonction je n’ai pas réussi du tout si vous pouvez m’aidez please

Édit entre temps du message auquel je répond.

Pour "découper" une liste, tu peux utiliser la syntaxe en [a:b], qui prend tous les éléments du a-ième inclut au b-ième exclut (en comptant à partir de 0), en les prenant tous si a ou b est vide. Exemples :

l = [0, 1, 2, 3, 4, 5]
l[:1] # [0]
l[1:] # [1, 2, 3, 4, 5]
l[1:3] # [1, 2]
l[:-1] # [0, 1, 2, 3, 4]

Attention, si tu débordes (l[2:] sur une liste avec un seul élément), ça marche, mais ce n’est souvent pas souhaitable.

Pour extraire le premier élément d’un côté et le reste de l’autre, il est aussi possible de faire directement :

>>> values = [0, 1, 2, 3, 4, 5]
>>> head, *tail = values
>>> head
0
>>> tail
[1, 2, 3, 4, 5]

je n’ai pas compris du coup dans mon énoncé il y a Une liste prendra alors la forme : l = (1, (2, (3, None))). Une liste vide sera constituée du seule élément None. et moi je veux faire une fonction supprime(lst) qui renvoie une tuple contenant comme 1er élément, l’élément supprimé, et comme second élément, la liste à laquelle on a supprimé le 1er élément pour cette fonction donc je fais

def supprime(lst):
  lst=None

et donc après svp

je n’ai pas compris du coup dans mon énoncé il y a Une liste prendra alors la forme : l = (1, (2, (3, None))). Une liste vide sera constituée du seule élément None.

Une liste en Python est déjà quelque chose de particulier qui n’est pas défini comme pleins de tuples emboîtés. Si ce que tu dois manipuler sont des "listes" définies autrement, il faut nous dire précisément ce que ton énoncé contient. Sinon on ne pourra pas t’aider.

et moi je veux faire une fonction supprime(lst) qui renvoie une tuple contenant comme 1er élément, l’élément supprimé, et comme second élément, la liste à laquelle on a supprimé le 1er élément pour cette fonction donc je fais

Si ta liste est définie comme (1, (2, (3, (..., None)))), c’est déjà un tuple contenant le premier élément et le reste de la liste. Du coup, ce que tu dois faire et quelle est la structure de données que tu manipules effectivement n’est pas clair du tout. Est-ce que tu peux nous donner ton énoncé complet stp ? On ne va pas s’en sortir si on doit deviner ce qui est attendu de toi (surtout que ça a l’air un peu bizarre…).

On n’écrira pas le code à ta place ici. Par ailleurs, dans cette fonction, tu écrases l’objet lst passé en argument, donc je ne suis pas sûr de comprendre ce que tu penses que cette fonction fait…

je n’arrive pas a insérer une photo a partir de mes fichiers

Un copier-coller d’une image va fonctionner directement. Tu ne verras pas l’image directement mais quelque chose qui ressemble à ![](nom_du_fichier.png). C’est normal. Clique sur Aperçu pour t’assurer que tu vois bien l’image avant d’envoyer.

EDIT : ok, on vous demande de manipuler des pseudo-listes qui sont des tuples emboîtées. C’est complètement absurde mais bon… supprimer_tete a juste besoin de renvoyer la liste elle-même du coup (le seul cas particulier étant de savoir ce qui doit être fait si lst est vide, mais comme ce n’est pas précisé on peut pas deviner ce que le prof a en tête)… Je ne sais pas qui a élaboré cet exo mais c’est très curieux…

j’ai cela aussi

Par curiosité, qui t’a donné cet exo ?

C’est super bizarre comme exercice parce que littéralement toutes les fonctions qui sont demandées sont déjà des opérations implémentées sur des tuples de toute façon. On dirait quelqu’un qui essaye de forcer désespérément les listes cons de lisp dans Python sans voir que des 2-tuples sont déjà une implémentation de ça.

Peut-être une intro aux listes chaînées ? Le premier élément est un nombre, le second "pointe" sur un tuple construit de la même manière. Mais en Python, c’est très bizarre.

mon prof de nsi

Un coup de recherche et hop : http://tnsi.free.fr/
Cela provient du Lycée Louis de Foix.
en particulier, http://tnsi.free.fr/documents/3.%20Listes_Piles_Files%20cours.pdf précise :

NSI Lycée Louis de FoixStructures de données 1Listes – Piles – Files
Dans ce chapitre, le mot « liste » ne désigne pas les listes que l’on utilise habituellement en Python, mais une structure de données différente définie plus bas

Je ne ferais pas de commentaires sur les options pédagogiques, ils seraient hors sujet.

Ce qui m’étonne est surtout que toute l’API de la question 1 est inutile. Au nil prêt à définir comme None, et est_vide(l) par l is None, on peut directement enlever tous les noms de fonctions et avoir le comportement de base voulu grâce aux tuples. Utiliser ça pour ensuite voir des implémentations variées de longueur et d’autres opérations, pourquoi pas. Mais toute la partie 1 est aberrante et rend le tout ultra-verbeux. J’ai du mal à imaginer dans quel contexte il serait intéressant de faire coder toute l’API de la partie 1 à la main à des gens qui sont prêt à s’amuser avec des listes chaînées dans un langage qui n’est pas prévu pour. Ou inversement, avoir des gens qui auraient besoin de faire la partie 1 si c’est pour les perdre avec la partie 2… Mais bref…

@maxime835 : du coup, qu’est-ce que tu as fait pour les fonctions de la partie 1 ?

j’ai fais ceci pour l’instant

def vide():
     return None
    
def est_vide(lst):
    return lst==None

def ajoute_texte(x,lst):
    return (x, lst)

def longueur_it(lst):
   a = 0
   for i in lst:
      a= a + 1 
   return a

def longueur_rec(lst):
     if lst==None:
          return 0
     else:
          return 1+longueur_rec(lst)

La fonction qui t’es demandée, c’est ajoute_tete, pas ajoute_texte. Okay pour les 3 premières. Un détail cependant, pour lst==None, la syntaxe lst is None est préférée (elle marche pour n’importe quel objet lst même si l’implémentation de == est bizarre). Comment implémenterais-tu supprime_tete ?

Par ailleurs, pour longueur_it, est-ce que tu as essayé cette fonction ? Elle fonctionnerait sur une liste normale, mais si tu l’essayes sur la structure imposée, que se passe-t-il ? Le cas d’une liste vide reste aussi à traiter.

Pour longueur_rec, il y a un embryon de piste mais il manque l’essentiel. Tu l’appelles continuellement avec la même liste donc soit tu vas avoir 0 si la liste est vide, soit avoir une boucle infinie (enfin, tu vas obtenir une exception RecursionError qui est un garde-fou contre ça mais bon).

Tes trois premières fonctions sont bonnes, je dirais juste qu’il est préférable de faire lst is None que lst == None (None étant un singleton, et l’opérateur d’identité is ne pouvant être surchargé, on est alors sûr d’avoir bien None).

longueur_rec est presque bien, tu subdivises chaque nœud entre tête et queue et tu continues récursivement à compter les éléments, mais pas sur la bonne liste.

Par contre ça bloque sur longeur_it qui ne calcule pas la taille de la liste : elle te renvoie la taille de lst qui est un tuple de 2 éléments… donc 2. Il faudrait que tu adoptes un comportement semblable à longueur_rec (itérer sur les queues).