Gestion de liste de paires pointées.

[DenisHen]

Bonjour à la communauté.
Je suis sur un lisp qui cherche dans une liste de chaines la position d'une d'elle, puis j'en fais une paire pointée dans une autre liste (chaine . position).
Ma recherche dans la console sera plus parlante :

_$ (setq Lst (list))
nil
_$ (setq Lst (cons "Pouette" 73))
("Pouette" . 73)
_$ (setq Lst (list (cons "Encore" 74) Lst))
(("Encore" . 74) ("Pouette" . 73))
_$ (setq Lst (list (cons "Plus" 12) Lst))
(("Plus" . 12) (("Encore" . 74) ("Pouette" . 73)))
_$ 

(Oui, je recherche un nombre selon une chaine)
Mon problème est qu'au final, j'ai une liste de plusieurs listes, donc, un (assoc "Denis" Lst) ne fonctionnera pas...
J'ai essayé avec deux (cons, avec un (append.... Aucun résultat.
J'ai trouvé plein de détails sur les listes ("Introduction à AutoLisp" de (gile), le site "DA-Code" de didier...) mais pas grand chose sur la création de listes de paires pointées (qui apparement sont des listes un peu particulières).

[Olivier Eckmann]

(setq Lst             (list (cons "Pouette" 23)) )
(setq Lst (append Lst (list (cons "Plus"    12))))
(setq Lst (append Lst (list (cons "Encore"  19))))

 

Olivier

[bonuscad]

exemple:

(setq
	Lst (list (cons "Pouette" 73))
	Lst (cons (cons "Encore" 74) Lst)
	Lst (cons (cons "Plus" 12) Lst)
)
(cdr (nth (vl-position "Encore" (mapcar 'car lst)) lst))

 

[DenisHen]

Salut Olivier et merci pour ton aide...
Je pense que c'est la seule syntaxe que je n'ai pas tenté ! ! !
Et vu que j'ai un (setq Lst (list)) au début, je peux directement passer à (append Lst ensuite...
Encore merci à toi...
Denis...

[DenisHen]

Salut Bonuscad et merci pour ton aide.
Ce que j'avais tenté (et qui ne fonctionnait pas) était : 

(setq Lst (cons "Encore" 74) (cons Lst)))

Merci pour cet exemple.
En revenche, je ne comprend pas le :

(cdr (nth (vl-position "Encore" (mapcar 'car lst)) lst))

Ca cherche dans la totalité de la liste (contenant d'autres listes) la paire pointée ?

[(gile)]

Comprendre de LISP c'est comprendre les manipulations de listes et les fonctions fondamentales de manipulation des listes sont: cons, car et cdr.

Pour des information sur les 'listes' LISP voir ce sujet.

[DenisHen]

Merci (gile) pour ce lien.
J'ai lu ce genre d'explications plusieurs fois (ton "Introduction...", ce lien, DA-Code....), mais dès que je reprend le Lisp, je me "reforme" aux listes...
Ca ne veux pas rentrer ! Le reste j'arrive à piger, j'arrive à faire plein de trucs, parfois des pas si simples, mais les listes me perdent systématiquement...
Pourtant, je sais bien que c'est un atout indéniable pour le lisp, mais rien n'y fait... Je perd un temps incroyable dès qu'il faut que je touche à une liste.

[DenisHen]

Et chose incroyable, je fini souvent par faire une longue chaine avec séparateur ("Pouette;Encore;Autre;....") que je transforme en liste plus tard (un grand merci pour str2lst) pour la traiter correctement ! !

[didier]

Bonjour @DenisHen

les listes me perdent systématiquement

C'est ballot, je rigole !

Tu as sans doute mis la charrue avant les bœufs comme bien des apprenants en te perdant avec des objectifs éloignés sans avoir intégré la base, car les listes, c'est la base de la base.
On parle de fondations, au sens de ce qui sert de support à tout le reste.

Dois-je rappeler la signification de LISP ? allez je le redis : LIST PROCESSING ...traitement de listes dans notre langue

Amicalement

[DenisHen]

Bonjour @didier.
Je suis entièrement d'accord avec toi, pour la charrue, la base du lisp (Lits Identifiés Soins Palliatifs ?)...
Mais parfois, on n'a pas beaucoup de temps entre marcher et courrir, et c'est mon cas...
Je traine donc une grosse casserole de mauvais reflexes issus d'un apprentissage isolé avec un seul bouquin (tout bleu avec une disquette, mais que je n'ai plus)...

[bonuscad]

Il y a 1 heure, DenisHen a dit :

En revenche, je ne comprend pas le :

(cdr (nth (vl-position "Encore" (mapcar 'car lst)) lst))

Ca cherche dans la totalité de la liste (contenant d'autres listes) la paire pointée ?

Si je te le présente comme ceci?

(cdr
	(nth
		(vl-position "Encore"
			(mapcar 'car lst)
		)
		lst
	)
)

Après tu décompose par ordre de profondeur:

(mapcar 'car lst) -> ("Plus" "Encore" "Pouette") ; retourne la liste lst avec seulement le 1er élément.

puis
(vl-position "Encore" (mapcar 'car lst)) -> 1
ce qui revient à (vl-position "Encore" '("Plus" "Encore" "Pouette")) ; retourne la position de "Encore" dans la liste soumise (rappel l'index 0 est le premier élément)

puis
(nth (vl-position "Encore" (mapcar 'car lst)) lst) -> ("Encore" . 74)
ce qui revient à (nth 1 lst) ; retourne le deuxième élément de la liste lst

et enfin
(cdr (nth (vl-position "Encore" (mapcar 'car lst)) lst)) -> 74
ce qui revient à (cdr '("Encore" . 74)) ; retourne le 2ème élément de la paire pointée, soit la clé recherchée.
NB: A la différence d'une liste normale où le (cadr) serait employé pour avoir le second élémenent.

Comprendo?

[DenisHen]

Comprendo, comprendo... C'est vite dit, je te dirais ça dans une paire d'années 😉😀...
J'arrive à piger le truc, mais de là à le refaire... Oulala ! !
En tous cas, merci pour l'explication.

[Olivier Eckmann]

On peut faire un peu plus simple avec les paires pointées

(cdr (assoc "Encore" Lst))

 

Olivier

[DenisHen]

Oui, c'était mon but au départ.
Construire correctement une liste de paires pointées pour qu'elle soit efficace ensuite avec un simple (assoc...

[bonuscad]

Il y a 2 heures, Olivier Eckmann a dit :

On peut faire un peu plus simple avec les paires pointées

(cdr (assoc "Encore" Lst))

 

Olivier

Mais pourquoi je suis passé à côté de ça ?...😂

Il y a 4 heures, DenisHen a dit :

Comprendo, comprendo... C'est vite dit, je te dirais ça dans une paire d'années 😉😀...

dans une paire d'années pointée 🤣

[GEGEMATIC]

salut à tous,

dans le cas de Denis, à quoi ça sert d'utiliser des paires pointées ?

je n'arrive pas à me souvenir pourquoi, mais il me semble que les paires pointées sont moins facile à utiliser que les simples listes d'association.

Commande: (setq liste '(("a" 1)("b" 2)("c" 3)))
(("a" 1) ("b" 2) ("c" 3))
ou si c'est des variables:
Commande: (setq liste (list (list "a" 1)(list "b" 2)(list "c" 3)))
(("a" 1) ("b" 2) ("c" 3))


Commande: (cadr (assoc "a" liste))
1

 

[(gile)]

il y a une heure, GEGEMATIC a dit :

il me semble que les paires pointées sont moins facile à utiliser que les simples listes d'association.

Je ne vois pas en quoi c'est "plus facile".
Dans les exemples que tu donnes, il suffit d'utiliser (cdr ...) au lieu de (cadr ...).
(cadr ...) est la contraction de (car (cdr ...)), donc cadr est un petit peu plus complexe que cdr.

De plus, dans une liste d'association, l'emploi de paires pointées peut être mélangé à celui de listes classiques comme dans les listes DXF renvoyées par entget en permettant un fonctionnement cohérent avec cdr pour accéder à la "valeur" :
 

Commande: (cdr '(70 . 1))
1
Commande: (cdr '(10 25.4 3.14 0.0))
(25.4 3.14 0.0)

 

[bonuscad]

Pour expliquer la paire pointée, du moins ce que j'en ai compris

Une paire pointée est toujours constitué d'un atom comme 1er élément et elle sera toujours de 1er niveau (pas d'élément imbriqué, tu ne peux pas faire une paire pointée avec 2 listes.)

Comme l'a souligné gilles elle sert dans le dxf à définir la clé dans le 1er élément (car) et la définition dans le second (cdr): (car) et (cdr) étant vraiment la base de la gestion des listes pointée ou non en lisp, donc difficile de faire plus simple et plus rapide pour l’accès aux données...

[DenisHen]

Salut bonuscad...
Il me semble que j'ai vu des paires pointées avec des listes quelques part, et je ne pense pas que ce soit interdit :
(10 . ("Pouette" "Tobogan" "EtAutre"))
Je pensais que les paires pointées était presque sans limites, et d'une approche très facile, comme avec les liste DXF des entités...

[(gile)]

il y a 8 minutes, DenisHen a dit :

Il me semble que j'ai vu des paires pointées avec des listes quelques part, et je ne pense pas que ce soit interdit :
(10 . ("Pouette" "Tobogan" "EtAutre"))

En tout cas, ce n'est pas interdit d'essayer de le faire, c'est certainement un bon exercice.

[DenisHen]

Tu m'étonnes ! ! !
Je passe un temps infini dans la console pour faire des tonnes de testes (merci aux grands : (gile) didier, Bonus, Nihon...)
Car comme tu me l'a déjà expliqué (toi (gile) comme d'autres) et je découvre des raccourcis grâce à cette console...
Ce que j'ai compris des paires pointées : Un élément primaire jumelé avec un autre élément.
Le premier peut être plein de valeur (Integer, string...) et le deuxième, associé, toute forme de "valeur" : une chaine, un nombre, une liste...
Un peu comme si une clef (car) pouvait ouvrir une serrure (cdr), ou plusieurs serrures, avec une seule clef...
Je n'ai jamais eu l'occasion de vérifier cette explication, mais je pense qu'elle reste valable...
Je le saurais quand j'en aurais besoin...
J'ai bon, Messieurs les pro ?

[(gile)]

Qu'est-ce qui n'est pas clair dans ce que je dis dans le sujet sur les listes chainées et les 'cellules cons' ?
 

Citation

 

La représentation la plus évidente d'une cellule cons en LISP est la paire pointée. Dans ce cas, la tête comme la queue pointent sur un atome.

(cons 1 2) retourne (1 . 2)
(car (cons 1 2)) retourne 1
(cdr (cons 1 2)) retourne 2

 

 

[DenisHen]

Je n'ai jamais dis que ce n'était pas claire, je dis juste que j'ai du mal à bien comprendre...
Et je l'ai déjà dis : 
 

(cons "a" '("b" "c")) retourne ("a" "b" "c")

N'est pas systématique (je m'aventure, et m'y perd)... Notamment avec les paires pointées... 
Tout comme les vl-sort, qui ne fonctionnent pas avec les paires pointées... Ce que je comprends, mais pour d'autres (comme pour moi, à mes débuts) ce n'est pas évidant...
Et je n'ai jamais lu la différence entre (cons et (append...
Je ne critique pas votre façon de professer, mais vous êtes trop éloigné des novices qui vous suivent et qui vous lisent...
Je suis prof de guitare depuis une petite vingtaine d'années, mes élèves sont passionnés, bien plus qu'à leurs débuts... Pourquoi ? ? ?
Mais je suis toujours là, toujours présent, toujours à leur dire : "L'apprentissage est dans la répétition" (Socrate ? ?).
Je me répète sans cesses, je fais toujours les même choses avec mes élèves... Mais je ne baisse jamais les bras, je persiste, et ils parviennent toujours à ce qu'ils considéraient comme inaccessible... Mais ils font maintenant du " Keith Richards", du "Clapton"... Et on se fait des parties de plaisirs énormes ! ! !
Et mes élèves ont de 8 à 80 ans ! ! !

[Luna]

Coucou @DenisHen,
La fonction (cons) permet de construire une liste ou bien une paire pointée. En effet

$ (cons 1 2)
(1 . 2)

Créé une paire pointée

$ (cons 1 '(2 3))
(1 2 3)

Théoriquement, la liste ci-dessus est également une paire pointée (bien que le point ne soit pas apparent) puisque la fonction (assoc) fonctionnera exactement pareil si c'est contenu dans une liste (exemple code DXF 10 dans les listes DXF), et

$ (setq lst (cons 1 '(2 3)))
(1 2 3)
$ (car lst)
1
$ (cdr lst)
(2 3)

En revanche si l'on regarde de plus près :

$ (cons 1 2)
(1 . 2)
$ (cons 1 '(2))
(1 2)
$ (cons '(1) 2)
((1) . 2)
$ (cons '(1) '(2))
((1) 2)

Autrement dit, le premier argument de (cons) sera rajouté au début du second argument (si je ne m'abuse, on peut voir chat comme une pile donc dernier entré premier sorti, (car) renvoi la dernière entrée). Et en fonction du type du second argument, le résultat sera plus ou moins différent (apparition d'un point "." ou non).
Tandis que (append) fonctionne différemment puisque dans un premier temps, le nombre d'argument est variable ! En effet

$ (append '(1) '(2) '(3))
(1 2 3)
$ (append '(1) '(2 3))
(1 2 3)
$ (append '(1 2 3))
(1 2 3)

Mais ce n'est pas tout. La fonction (append) n'accepte que des listes (et attention, des LIST ! Donc une paire pointée ne fonctionne pas non plus, c'est-à-dire si tu as utilisé un (cons) avec pour second argument un atom différent de nil), contrairement à (cons) qui accepte tout type de données. La fonction (append) ne fait que combiner un ensemble de liste en une seule liste, dans l'ordre dans lequel les arguments sont renseignés.

$ (append '(1 2) 3)
; erreur: type d'argument incorrect: listp 3
$ (append '(1) (cons 2 3))
; erreur: liste incorrecte: 3

Donc imaginons les 4 exemples ci-dessous :

;; EXEMPLE N°1 :
(setq lst1 '())
(repeat (setq n 5)
  (setq lst1 (append lst1 (list (setq n (1- n)))))
)

;; EXEMPLE N°2 :
(setq lst2 '())
(repeat (setq n 5)
  (setq lst2 (append (list (setq n (1- n))) lst2))
)

;; EXEMPLE N°3 :
(setq lst3 '())
(repeat (setq n 5)
  (setq lst3 (cons (setq n (1- n)) lst3))
)

;; EXEMPLE N°4 :
(setq lst4 '())
(repeat (setq n 5)
  (setq lst4 (cons lst4 (setq n (1- n))))
)

Es-tu en mesure de me donner les résultats obtenus à l'issue de chacun de ces exemples (sans les tester en console dans un premier temps, pour voir) ?

Bisous,
Luna

[(gile)]

La fonction cons prend deux arguments :

(cons new-first-element list-or-atom)

- si le second argument (list-or-atom) est une liste, elle ajoute le premier argument (new-first-element) au début de cette liste
- si le second argument (list-or-atom) est un atome, elle crée une paire pointée

(cons 1 2) crée une paire pointée (1 . 2) parce que 2 est un atome

(cons 1 '(2 3)) ajoute 1 au début la liste (2 3) et renvoie (1 2 3)

(cons 1 nil) ajoute 1 au début la liste vide nil et renvoie (1)

Donc, la réponse à ton interrogation :

il y a une heure, DenisHen a dit :

Il me semble que j'ai vu des paires pointées avec des listes quelques part, et je ne pense pas que ce soit interdit :
(10 . ("Pouette" "Tobogan" "EtAutre"))

est : non ce n'est pas possible parce que le deuxième terme de ta fausse paire pointée est une liste.
Essaye juste d'entrer : '(10 . ("Pouette" "Tobogan" "EtAutre")) dans la console ou à la ligne de commande.

Le point dans une paire pointée peut être vu comme un opérateur correspondant à la fonction cons (ce qui donne lieu à ce qu'on appelle la 'notation en paire pointées' ou 'dotted pair notation')

(cons 1 2) est équivalent à '(1 . 2)

(cons 1 nil) est équivalent à '(1 . nil), tous les deux renvoient (1)

(cons 1 '(2 3)) ou (cons 1 (cons 2 (cons 3 nil))) sont équivalents à '(1 . (2 3)) ou '(1 . (2 . (3 . nil))), tous renvoient (1 2 3)

Par conséquent '(10 . ("Pouette" "Tobogan" "EtAutre")) est équivalent à (cons 10 '("Pouette" "Tobogan" "EtAutre")) et tous deux renvoient (10 "Pouette" "Tobogan" "EtAutre")