Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2021-09-18T13:22:27+02:00Les derniers messages parus sur le forum de Zeste de Savoir.Quel moyen pour avoir des éléments uniques à partir des éléments d'une liste ?, message #2376042021-09-18T13:22:27+02:00sgble/@sgblehttps://zestedesavoir.com/forums/sujet/15701/quel-moyen-pour-avoir-des-elements-uniques-a-partir-des-elements-dune-liste/?page=1#p237604<blockquote>
<p>Je ne sais pas trop comment appliquer set() à un itérateur fonctionne pour cela je sollicite votre aide pour m’indiquer quelle est la meilleure façon, ou si y’en a d’autres ^^.</p>
</blockquote>
<p>Si je comprends bien <a href="https://github.com/python/cpython/blob/92bf8691fb78f3484bf2daba836c416efedb1d8d/Objects/setobject.c#L953">le code de CPython</a>, le fait d’appliquer <code>set()</code> à une liste (un itérable en général) conduit à exécuter un algorithme que l’on pourrait écrire de cette façon en Python pur (j’ai essayé de faire le mapping avec le code en C) :</p>
<div class="hljs-code-div hljs-code-python"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span></div><pre><code class="hljs language-python"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">make_new_set</span>(<span class="hljs-params">it</span>):</span>
so = <span class="hljs-built_in">set</span>() <span class="hljs-comment"># PySetObject *so;</span>
<span class="hljs-comment"># set_update_internal(so, iterable)</span>
<span class="hljs-keyword">for</span> key <span class="hljs-keyword">in</span> it: <span class="hljs-comment"># while ((key = PyIter_Next(it)) != NULL) {</span>
so.add(key) <span class="hljs-comment"># set_add_key(so, key)</span>
<span class="hljs-keyword">return</span> so <span class="hljs-comment"># return (PyObject *)so;</span>
</code></pre></div>
<p>Sauf qu’en faisant <code>set(it)</code> directement, on le fait directement en C, ce qui est donc vraisemblablement plus efficace que de le faire à la main en Python. </p>
<p>Autre détail important, déjà soulevé par <a href="/@adri1" rel="nofollow" class="ping ping-link">@<span class="ping-username">adri1</span></a>, dans ton exemple tu testes un <code>in</code> sur une liste, donc en complexité linéaire : il faut parcourir successivement les éléments de <code>nouveau</code> jusqu’à ce qu’on trouve un doublon, ou non, auquel cas on aura parcouru l’intégralité de la liste. L’implémentation pur Python (ou son équivalent en C quand on fait <code>set(it)</code>) ne souffre pas de ce problème car l’implémentation sous-jacente permet de tester l’existence d’un élément de façon efficace grâce à l’utilisation d’un table de hashage (en temps constant <em>ou à peu près</em><sup id="fnref-1-5A0dYBzEf"><a href="#fn-1-5A0dYBzEf" class="footnote-ref">1</a></sup>), un peu comme avec un <code>dict</code>. Lors d’un <code>s.add()</code> (ou du <code>set_add_key(so, key)</code> sous-jacent en C), l’existence est testée efficacement.</p>
<div class="hljs-code-div hljs-code-c"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span></div><pre><code class="hljs language-c"><span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">int</span>
<span class="hljs-title">set_add_key</span><span class="hljs-params">(PySetObject *so, PyObject *key)</span>
</span>{
Py_hash_t hash;
<span class="hljs-comment">/* ... */</span>
<span class="hljs-keyword">return</span> set_add_entry(so, key, hash); <span class="hljs-comment">// test et insertion si absent</span>
}
</code></pre></div>
<p>En bref, si tu veux une liste <code>l</code> sans doublon, fais <code>set(l)</code>, je ne pense pas que tu puisses faire mieux. Si tu as besoin d’avoir une liste sans doublon de type <code>list</code> et non pas de type <code>set</code>, tu peux la convertir en lui appliquant <code>list()</code> : <code>list(set(l))</code>.</p>
<p>Cependant, cela n’est pas gratuit. Toujours en lisant le code de CPython, j’ai l’impression que cela revient à créer une nouvelle liste (alors vide), puis de <a href="https://github.com/python/cpython/blob/92bf8691fb78f3484bf2daba836c416efedb1d8d/Objects/listobject.c#L2750">l’initialiser à l’aide d’un itérable arbitraire</a> à coup de <a href="https://github.com/python/cpython/blob/92bf8691fb78f3484bf2daba836c416efedb1d8d/Objects/listobject.c#L860"><code>extend</code></a>.
Malgré cela, l’implémentation reste efficace en cela que la nouvelle liste est allouée une seule fois avec la bonne taille (avec <code>list_preallocate_exact</code>), à savoir celle de la longueur de l’objet de type <code>set</code> qu’on lui passe en argument. En Python pur, il ne serait sans doute pas possible de faire plus efficace.</p>
<p>En résumé : faire <code>set(l)</code> ou <code>list(set(l))</code>, c’est efficace par rapport à ce que tu pourrais écrire en Python pur à la main.</p>
<p>Si tu n’as pas besoin des propriétés des listes mais seulement des propriétés des itérables, tu peux te contenter de garder un <code>set</code> sans le passer en <code>list</code> pour économiser une allocation et des itération. Dans ton exemple, tu pourrais par exemple tout à fait itérer de façon unique sur les éléments d’une liste sans avoir à reconvertir :</p>
<div class="hljs-code-div hljs-code-python"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span></div><pre><code class="hljs language-python"><span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">set</span>(ma_liste):
faire_qqchose_avec(i)
</code></pre></div>
<div class="footnotes">
<hr>
<ol>
<li id="fn-1-5A0dYBzEf">Le code nous indique clairement que l’algorithme de lookup se base sur celui de D. Knuth: <code>The basic lookup function used by all operations. This is based on Algorithm D from Knuth Vol. 3, Sec. 6.4.</code> en haut du fichier C. Je suis incapable de lire un livre pareil, mais si tu veux le détail exact de l’algorithme et de son analyse et de pourquoi c’est très rapide, c’est là-dedans qu’il y a la réponse.<a href="#fnref-1-5A0dYBzEf" class="footnote-backref" title="Retourner au texte de la note 1">↩</a></li>
</ol>
</div>Quel moyen pour avoir des éléments uniques à partir des éléments d'une liste ?, message #2375972021-09-17T20:46:57+02:00cvanaret/@cvanarethttps://zestedesavoir.com/forums/sujet/15701/quel-moyen-pour-avoir-des-elements-uniques-a-partir-des-elements-dune-liste/?page=1#p237597<p>Bah vraiment la créer sans doublons. <code>nouveau = list(set(l))</code>, ça crée une nouvelle liste sans doublons. Mais si l’originale <code>l</code> est créée sans doublons (si c’est possible, bien sûr), c’est encore mieux.</p>Quel moyen pour avoir des éléments uniques à partir des éléments d'une liste ?, message #2375742021-09-17T10:54:47+02:00etherpin/@etherpinhttps://zestedesavoir.com/forums/sujet/15701/quel-moyen-pour-avoir-des-elements-uniques-a-partir-des-elements-dune-liste/?page=1#p237574<figure><blockquote>
<p>Il n’y a pas moyen de créer la liste <code>l</code> directement sans doublons ?</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/15701/quel-moyen-pour-avoir-des-elements-uniques-a-partir-des-elements-dune-liste/?page=1#p237573">cvanaret</a> </figcaption></figure>
<p>Que veux-tu dire avec "directement" ? <kbd>nouveau = list(set(l))</kbd> me semble déjà pas mal.</p>Quel moyen pour avoir des éléments uniques à partir des éléments d'une liste ?, message #2375732021-09-17T10:38:26+02:00cvanaret/@cvanarethttps://zestedesavoir.com/forums/sujet/15701/quel-moyen-pour-avoir-des-elements-uniques-a-partir-des-elements-dune-liste/?page=1#p237573<p>Il n’y a pas moyen de créer la liste <code>l</code> directement sans doublons ?</p>Quel moyen pour avoir des éléments uniques à partir des éléments d'une liste ?, message #2375632021-09-16T22:08:36+02:00DavidKayo/@DavidKayohttps://zestedesavoir.com/forums/sujet/15701/quel-moyen-pour-avoir-des-elements-uniques-a-partir-des-elements-dune-liste/?page=1#p237563<p>Bonsoir,</p>
<p>Merci pour vos réponses. Je vais continuer à utiliser donc <code>set</code> mais je vais garder à l’esprit cette technique de trier la liste avant d’éliminer les redondances.</p>Quel moyen pour avoir des éléments uniques à partir des éléments d'une liste ?, message #2375622021-09-16T22:00:52+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/15701/quel-moyen-pour-avoir-des-elements-uniques-a-partir-des-elements-dune-liste/?page=1#p237562<p>Salut,</p>
<blockquote>
<p>Je ne sais pas exactement ce que fait set, mais j’imagine que ça doit être mieux que quadratique</p>
</blockquote>
<p>Ça utilise une table de hashage, donc avec un temps amorti linéaire. Comme en plus ça repose entièrement sur du code en C, ce sera toujours largement plus efficace que n’importe quelle implémentation avec des boucles explicites en Python.</p>Quel moyen pour avoir des éléments uniques à partir des éléments d'une liste ?, message #2375612021-09-16T21:50:04+02:00Holosmos/@Holosmoshttps://zestedesavoir.com/forums/sujet/15701/quel-moyen-pour-avoir-des-elements-uniques-a-partir-des-elements-dune-liste/?page=1#p237561<p>Cela va dépendre de la taille de tes listes, mais asymptotiquement tu gagnerais à trier la liste et à éliminer les redondances au fur et à mesure. Ce sera en nlog(n) plutôt qu’un quadratique comme tu proposes</p>
<p>Je ne sais pas exactement ce que fait set, mais j’imagine que ça doit être mieux que quadratique </p>Quel moyen pour avoir des éléments uniques à partir des éléments d'une liste ?, message #2375602021-09-16T21:47:04+02:00artragis/@artragishttps://zestedesavoir.com/forums/sujet/15701/quel-moyen-pour-avoir-des-elements-uniques-a-partir-des-elements-dune-liste/?page=1#p237560<p>En gros, le "contrat" que passe avec toi le constructeur de "set" c’est que si tu lui passe un itérable en paramètre, il te créera un objet de type <code>set</code> dont tous les éléments sont uniques.</p>
<p>L’équivalent fonctionnel de ton code est donc <code>nouveau = list(set(l))</code>.</p>
<p>Ce code dit qu’on prend un "set" à partir de la liste <code>l</code>, ce qui permet de dédoublonner les éléments, puis on en refait une liste avec tout ce que ça implique.</p>
<p>Bien sûr si tu as juste besoin de parcourir l’ensemble des valeurs sans les doublons, tu n’as pas besoin de repasser par la liste. faire simplement <code>set(l)</code> suffira.</p>Quel moyen pour avoir des éléments uniques à partir des éléments d'une liste ?, message #2375592021-09-16T21:10:28+02:00DavidKayo/@DavidKayohttps://zestedesavoir.com/forums/sujet/15701/quel-moyen-pour-avoir-des-elements-uniques-a-partir-des-elements-dune-liste/?page=1#p237559<p>Bonjour,</p>
<p>Etant donné une liste <code>l</code>, j’ai l’habitude pour me débarrasser de toutes les occurrences des éléments de simplement prendre <code>set(l)</code>. Mais je me demande si c’est plus optimal (en mémoire et en temps) que de faire : </p>
<div class="hljs-code-div hljs-code-text"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span></div><pre><code class="hljs language-text">nouveau = [l[0]]
for i in l[1:]
if i not in nouveau:
nouveau.append(i)
</code></pre></div>
<p>Je ne sais pas trop comment appliquer <code>set()</code> à un itérateur fonctionne pour cela je sollicite votre aide pour m’indiquer quelle est la meilleure façon, ou si y’en a d’autres ^^.</p>
<p>Cordialement</p>Les listes doublement chaînée, message #2364632021-08-06T10:42:45+02:00lesnox/@lesnoxhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p236463<p>Bonjour entwanne, </p>
<p>finalement j’ai bien réussit hier à corriger les soucis, voici le nouveau code : </p>
<div class="hljs-code-div hljs-code-text"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span><span data-count="23"></span><span data-count="24"></span><span data-count="25"></span><span data-count="26"></span><span data-count="27"></span><span data-count="28"></span><span data-count="29"></span><span data-count="30"></span><span data-count="31"></span><span data-count="32"></span><span data-count="33"></span><span data-count="34"></span><span data-count="35"></span><span data-count="36"></span><span data-count="37"></span><span data-count="38"></span><span data-count="39"></span><span data-count="40"></span><span data-count="41"></span><span data-count="42"></span><span data-count="43"></span><span data-count="44"></span><span data-count="45"></span><span data-count="46"></span><span data-count="47"></span><span data-count="48"></span><span data-count="49"></span><span data-count="50"></span><span data-count="51"></span><span data-count="52"></span><span data-count="53"></span><span data-count="54"></span><span data-count="55"></span><span data-count="56"></span><span data-count="57"></span><span data-count="58"></span><span data-count="59"></span><span data-count="60"></span><span data-count="61"></span><span data-count="62"></span><span data-count="63"></span><span data-count="64"></span><span data-count="65"></span><span data-count="66"></span><span data-count="67"></span><span data-count="68"></span><span data-count="69"></span><span data-count="70"></span><span data-count="71"></span><span data-count="72"></span><span data-count="73"></span><span data-count="74"></span><span data-count="75"></span><span data-count="76"></span><span data-count="77"></span><span data-count="78"></span><span data-count="79"></span><span data-count="80"></span><span data-count="81"></span><span data-count="82"></span><span data-count="83"></span><span data-count="84"></span><span data-count="85"></span><span data-count="86"></span><span data-count="87"></span><span data-count="88"></span><span data-count="89"></span><span data-count="90"></span><span data-count="91"></span><span data-count="92"></span><span data-count="93"></span><span data-count="94"></span><span data-count="95"></span><span data-count="96"></span><span data-count="97"></span><span data-count="98"></span><span data-count="99"></span><span data-count="100"></span><span data-count="101"></span><span data-count="102"></span><span data-count="103"></span><span data-count="104"></span><span data-count="105"></span><span data-count="106"></span><span data-count="107"></span><span data-count="108"></span><span data-count="109"></span><span data-count="110"></span><span data-count="111"></span><span data-count="112"></span><span data-count="113"></span><span data-count="114"></span><span data-count="115"></span><span data-count="116"></span><span data-count="117"></span><span data-count="118"></span><span data-count="119"></span><span data-count="120"></span><span data-count="121"></span><span data-count="122"></span><span data-count="123"></span><span data-count="124"></span><span data-count="125"></span><span data-count="126"></span><span data-count="127"></span><span data-count="128"></span><span data-count="129"></span><span data-count="130"></span><span data-count="131"></span><span data-count="132"></span><span data-count="133"></span><span data-count="134"></span><span data-count="135"></span><span data-count="136"></span><span data-count="137"></span><span data-count="138"></span><span data-count="139"></span><span data-count="140"></span><span data-count="141"></span><span data-count="142"></span><span data-count="143"></span><span data-count="144"></span><span data-count="145"></span><span data-count="146"></span><span data-count="147"></span><span data-count="148"></span><span data-count="149"></span><span data-count="150"></span><span data-count="151"></span><span data-count="152"></span><span data-count="153"></span><span data-count="154"></span><span data-count="155"></span><span data-count="156"></span><span data-count="157"></span><span data-count="158"></span><span data-count="159"></span><span data-count="160"></span><span data-count="161"></span><span data-count="162"></span><span data-count="163"></span><span data-count="164"></span><span data-count="165"></span><span data-count="166"></span><span data-count="167"></span><span data-count="168"></span><span data-count="169"></span><span data-count="170"></span><span data-count="171"></span><span data-count="172"></span><span data-count="173"></span><span data-count="174"></span><span data-count="175"></span><span data-count="176"></span><span data-count="177"></span><span data-count="178"></span><span data-count="179"></span><span data-count="180"></span><span data-count="181"></span><span data-count="182"></span><span data-count="183"></span><span data-count="184"></span><span data-count="185"></span><span data-count="186"></span><span data-count="187"></span><span data-count="188"></span><span data-count="189"></span><span data-count="190"></span><span data-count="191"></span><span data-count="192"></span><span data-count="193"></span><span data-count="194"></span><span data-count="195"></span><span data-count="196"></span><span data-count="197"></span><span data-count="198"></span><span data-count="199"></span><span data-count="200"></span><span data-count="201"></span><span data-count="202"></span><span data-count="203"></span><span data-count="204"></span><span data-count="205"></span><span data-count="206"></span><span data-count="207"></span><span data-count="208"></span><span data-count="209"></span><span data-count="210"></span><span data-count="211"></span><span data-count="212"></span><span data-count="213"></span><span data-count="214"></span><span data-count="215"></span><span data-count="216"></span><span data-count="217"></span><span data-count="218"></span><span data-count="219"></span><span data-count="220"></span><span data-count="221"></span><span data-count="222"></span><span data-count="223"></span><span data-count="224"></span><span data-count="225"></span><span data-count="226"></span><span data-count="227"></span><span data-count="228"></span><span data-count="229"></span><span data-count="230"></span><span data-count="231"></span><span data-count="232"></span><span data-count="233"></span><span data-count="234"></span><span data-count="235"></span><span data-count="236"></span><span data-count="237"></span><span data-count="238"></span><span data-count="239"></span><span data-count="240"></span><span data-count="241"></span><span data-count="242"></span><span data-count="243"></span><span data-count="244"></span><span data-count="245"></span><span data-count="246"></span><span data-count="247"></span><span data-count="248"></span><span data-count="249"></span><span data-count="250"></span><span data-count="251"></span><span data-count="252"></span><span data-count="253"></span><span data-count="254"></span><span data-count="255"></span><span data-count="256"></span><span data-count="257"></span><span data-count="258"></span><span data-count="259"></span><span data-count="260"></span><span data-count="261"></span><span data-count="262"></span><span data-count="263"></span><span data-count="264"></span><span data-count="265"></span><span data-count="266"></span><span data-count="267"></span><span data-count="268"></span><span data-count="269"></span><span data-count="270"></span><span data-count="271"></span><span data-count="272"></span><span data-count="273"></span><span data-count="274"></span><span data-count="275"></span><span data-count="276"></span><span data-count="277"></span><span data-count="278"></span><span data-count="279"></span><span data-count="280"></span><span data-count="281"></span><span data-count="282"></span><span data-count="283"></span><span data-count="284"></span><span data-count="285"></span><span data-count="286"></span><span data-count="287"></span><span data-count="288"></span><span data-count="289"></span><span data-count="290"></span><span data-count="291"></span><span data-count="292"></span><span data-count="293"></span><span data-count="294"></span><span data-count="295"></span><span data-count="296"></span><span data-count="297"></span><span data-count="298"></span><span data-count="299"></span><span data-count="300"></span><span data-count="301"></span><span data-count="302"></span><span data-count="303"></span><span data-count="304"></span><span data-count="305"></span><span data-count="306"></span><span data-count="307"></span><span data-count="308"></span><span data-count="309"></span><span data-count="310"></span><span data-count="311"></span><span data-count="312"></span><span data-count="313"></span><span data-count="314"></span><span data-count="315"></span><span data-count="316"></span><span data-count="317"></span><span data-count="318"></span><span data-count="319"></span><span data-count="320"></span><span data-count="321"></span><span data-count="322"></span><span data-count="323"></span><span data-count="324"></span><span data-count="325"></span><span data-count="326"></span><span data-count="327"></span><span data-count="328"></span><span data-count="329"></span><span data-count="330"></span><span data-count="331"></span><span data-count="332"></span><span data-count="333"></span><span data-count="334"></span><span data-count="335"></span><span data-count="336"></span><span data-count="337"></span><span data-count="338"></span><span data-count="339"></span><span data-count="340"></span><span data-count="341"></span><span data-count="342"></span><span data-count="343"></span><span data-count="344"></span><span data-count="345"></span><span data-count="346"></span><span data-count="347"></span><span data-count="348"></span><span data-count="349"></span><span data-count="350"></span><span data-count="351"></span><span data-count="352"></span><span data-count="353"></span><span data-count="354"></span><span data-count="355"></span><span data-count="356"></span><span data-count="357"></span><span data-count="358"></span><span data-count="359"></span><span data-count="360"></span><span data-count="361"></span><span data-count="362"></span><span data-count="363"></span><span data-count="364"></span><span data-count="365"></span><span data-count="366"></span><span data-count="367"></span><span data-count="368"></span><span data-count="369"></span><span data-count="370"></span><span data-count="371"></span><span data-count="372"></span><span data-count="373"></span><span data-count="374"></span><span data-count="375"></span><span data-count="376"></span><span data-count="377"></span><span data-count="378"></span><span data-count="379"></span><span data-count="380"></span><span data-count="381"></span><span data-count="382"></span><span data-count="383"></span><span data-count="384"></span><span data-count="385"></span><span data-count="386"></span><span data-count="387"></span><span data-count="388"></span><span data-count="389"></span><span data-count="390"></span><span data-count="391"></span><span data-count="392"></span><span data-count="393"></span><span data-count="394"></span><span data-count="395"></span><span data-count="396"></span><span data-count="397"></span><span data-count="398"></span><span data-count="399"></span><span data-count="400"></span><span data-count="401"></span><span data-count="402"></span><span data-count="403"></span><span data-count="404"></span><span data-count="405"></span><span data-count="406"></span><span data-count="407"></span><span data-count="408"></span><span data-count="409"></span><span data-count="410"></span><span data-count="411"></span><span data-count="412"></span><span data-count="413"></span><span data-count="414"></span><span data-count="415"></span><span data-count="416"></span><span data-count="417"></span><span data-count="418"></span><span data-count="419"></span><span data-count="420"></span><span data-count="421"></span><span data-count="422"></span><span data-count="423"></span><span data-count="424"></span><span data-count="425"></span><span data-count="426"></span><span data-count="427"></span><span data-count="428"></span><span data-count="429"></span><span data-count="430"></span><span data-count="431"></span><span data-count="432"></span><span data-count="433"></span><span data-count="434"></span><span data-count="435"></span><span data-count="436"></span><span data-count="437"></span><span data-count="438"></span><span data-count="439"></span><span data-count="440"></span><span data-count="441"></span><span data-count="442"></span><span data-count="443"></span><span data-count="444"></span><span data-count="445"></span><span data-count="446"></span><span data-count="447"></span><span data-count="448"></span><span data-count="449"></span><span data-count="450"></span><span data-count="451"></span><span data-count="452"></span><span data-count="453"></span><span data-count="454"></span><span data-count="455"></span><span data-count="456"></span><span data-count="457"></span><span data-count="458"></span><span data-count="459"></span><span data-count="460"></span><span data-count="461"></span><span data-count="462"></span><span data-count="463"></span><span data-count="464"></span><span data-count="465"></span><span data-count="466"></span><span data-count="467"></span><span data-count="468"></span><span data-count="469"></span><span data-count="470"></span><span data-count="471"></span><span data-count="472"></span><span data-count="473"></span><span data-count="474"></span><span data-count="475"></span><span data-count="476"></span><span data-count="477"></span><span data-count="478"></span><span data-count="479"></span><span data-count="480"></span><span data-count="481"></span><span data-count="482"></span><span data-count="483"></span><span data-count="484"></span><span data-count="485"></span><span data-count="486"></span><span data-count="487"></span><span data-count="488"></span><span data-count="489"></span><span data-count="490"></span><span data-count="491"></span><span data-count="492"></span><span data-count="493"></span><span data-count="494"></span><span data-count="495"></span><span data-count="496"></span><span data-count="497"></span><span data-count="498"></span><span data-count="499"></span><span data-count="500"></span></div><pre><code class="hljs language-text">###################################
##### Implémentation des LDC#######
###################################
def creerListeVide():
"""
Crée une liste vide
:paramètre : None
:return : None
"""
## la liste vide vaut None
return None
def setPrecedent (n, ns):
"""
Mets la liste doublement chainée précendente du noeud dans le noeuds n
:paramètre : n : un noeud
ns : liste doucblement chainée
:return : None
"""
n[1] = ns
def setSuivant (n, ns):
"""
Mets la liste doublement chainée suivante du noeud dans le noeuds n
:paramètre : n : un noeud
ns : liste doucblement chainée suivante
:return : None
"""
n[2] = ns
def creerNoeudLDC(val, precedent, suivant):
"""
Crée un noeud (une liste Python de trois cases) [valeur, noeud présecéent, noeud suivant]
:paramètre : val : valeur du noeud
precedent : contient les noeuds précédent le noeud courant, None si pas de noeud précédent
suivant : contient les noeuds suivant le noeud courant, None si pas de noeud suivant
:return : noeud sous la forme [valeur, noeud présecéent, noeud suivant]
"""
if precedent == None and suivant != None:
return [val, None, suivant]
if precedent != None and suivant == None:
return [val, precedent, None]
if precedent != None and suivant != None:
return [val, precedent, suivant]
else :
return [val, None, None]
def EstNoeudLDC_Precedent(n):
"""
"""
pass
assert (n == None) or (isinstance(n, list) and len(n) == 3 and EstNoeudLDC_Precedent(n[1])) ## Devrait être None ou une liste de 3 éléments [entier, noeudLDC ou None, noeudLDC ou None]
return True
def EstNoeudLDC_Suivant(n):
"""
"""
pass
assert (n == None) or (isinstance(n,list) and len(n)==3 and EstNoeudLDC_Suivant(n[2])) ## Devrait être None ou une liste de 3 éléments [entier, noeudLDC ou None, noeudLDC ou None]
return True
def EstNoeudLDC(n):
"""
"""
pass
assert (n == None) or (EstNoeudLDC_Precedent(n) and EstNoeudLDC_Suivant(n)) ## Devrait être None ou une liste de 3 éléments [entier, noeudLDC ou None, noeudLDC ou None]
return True
def GetValLDC(n):
"""
Permet d'obtenir la valeur du noeud
:paramètre : n : un noeud
:return : la valeur du noeud
"""
assert(n != None) ## on ne peut pas obtenir la valeur d'une liste vide
assert (EstNoeudLDC(n)) ## Doit être un noeud
return n[0]
def GetSuivantLDC(n):
"""
Permet d'obtenir la liste des noeuds suivant
:paramètre : n : un noeud
:return : la liste des noeuds suivant
"""
assert(n != None) ## on ne peut pas obtenir la noeud suivant sur une liste vide
assert (EstNoeudLDC(n)) ## Doit être un noeud
return n[2]
def GetPrecedentLDC(n):
"""
Permet d'obtenir la liste des noeuds précédent
:paramètre : n : un noeud
:return : la liste des noeuds précédent
"""
assert(n != None) ## on ne peut pas obtenir la noeud précédent sur une liste vide
assert (EstNoeudLDC(n)) ## Doit être un noeud
return n[1]
def LongueurLDC(l):
"""
Permet d'obtenir la longeur de la liste doublement chainée
:paramètre : l : liste doublement chainée
:return : int : la valeur de la longeur de la liste
"""
lg = 0
n = l
if l is None :
return lg
else :
lg = 1
while n[2] != None:
lg += 1
n = GetSuivantLDC(n)
return lg
def InsererDebutLDC(l,val):
"""
Permet d'inserer une valeur en début de liste doublement chainée
:paramètre : l : liste doublement chainée
val : valeur du noeud
:return : nn : la nouvelle liste chainée
"""
if l is None:
return creerNoeudLDC(val, None, None)
else:
n = l
while GetPrecedentLDC(n) != None :
n = GetPrecedentLDC(n)
nn = creerNoeudLDC(val, None, n) # l pointe vers le 1er et non vers la tête de la LDC ?
setPrecedent (n,nn)
return nn
def InsererFinLDC(l,val):
"""
Permet d'inserer une valeur en fin de liste doublement chainée
:paramètre : l : liste doublement chainée
val : valeur du noeud
:return : l : la nouvelle liste chainée
"""
if l is None:
return creerNoeudLDC(val, None, None)
else:
## on parcoure la liste jusqu'à atteindre le dernier noeud
n = l
while GetSuivantLDC(n) != None:
n = GetSuivantLDC(n)
## on met à jour le noeud suivant
n[2] = creerNoeudLDC(val, n, None)
m = GetSuivantLDC(l)
p = GetPrecedentLDC(l)
if p != None :
setPrecedent (n, m)
return l
def SupprimerDebutLDC(l):
"""
Permet de supprimer le premier noeud de la liste doublement chainée
:paramètre : l : liste doublement chainée
:return : n : la nouvelle liste chainée
"""
assert(l != None) ## on ne peut pas supprimer un noeud dans une liste vide
n = l
if LongueurLDC(l) == 1:
return None
else :
n = GetSuivantLDC(n)
n[1] = None
return n
def SupprimerFinLDC(l):
"""
Permet de supprimer le dernier noeud de la liste doublement chainée
:paramètre : l : liste doublement chainée
:return : l : la nouvelle liste chainée
"""
assert(l != None) ## on ne peut pas supprimer un noeud dans une liste vide
n = l
if LongueurLDC(l) == 1:
return None
else :
while GetSuivantLDC(n) != None:
n = GetSuivantLDC(n)
setSuivant (GetPrecedentLDC(n), None)
setPrecedent (n, None)
return l
def AccesLDC(l,p):
"""
Permet d'accéder au noeud d'indice p dans la liste doublement chainée l
:paramètre : l : liste doublement chainée
p : int : indice du noeud souhaiter
:return : liste : une liste de 3 éléments avec [la valeur du noeud, noeuds précédents, noeuds suivants]
"""
assert(l != None) ## on ne peut pas accéder à un noeud dans une liste vide
assert p <= LongueurLDC(l) ##L'indice auqu'elle vous souhaitez accéder est trop grand par rapport à la liste
j = 0
m = l
while j < p:
j +=1
m = GetSuivantLDC(m)
return [m[0],m[1],m[2]]
def InsererPlaceLDC(l,val,p):
"""
Permet d'inserer une valeur à la postion p dans la liste doublement chainée l
:paramètre : l : liste doublement chainée
val : valeur du noeud
p : int : indice du noeud souhaiter
:return : l : la nouvelle liste chainée
"""
assert p <= LongueurLDC(l) ##L'indice donnée pour placer la valeur est trop grand par rapport à la liste
if l is None:
return creerNoeudLDC(val, None, None)
elif p == 0 :
InsererDebutLDC(l,val)
elif p == LongueurLDC(l) :
InsererFinLDC(l,val)
else:
j = 0
m = l
while j < p:
j +=1
m = GetSuivantLDC(m)
n = GetPrecedentLDC(m)
nn = creerNoeudLDC(val, m[1], m)
m[1] = nn
n[2] = m[1]
return l
def SupprimerPlaceLDC(l,p):
"""
Permet de supprimer le noeud d'indice p dans la liste doublement chainée l
:paramètre : l : liste doublement chainée
p : int : indice du noeud souhaiter
:return : l : la nouvelle liste chainée
"""
assert(l != None) ## on ne peut pas supprimer à un noeud dans une liste vide
assert p <= (LongueurLDC(l)-1) ##L'indice auqu'elle vous souhaitez supprimer la valeur est trop grand par rapport à la liste
m = l
if p == 0 :
m = SupprimerDebutLDC(l)
elif p == LongueurLDC(l)-1 :
m = SupprimerFinLDC(l)
else:
j = 0
while j < p:
j +=1
m = GetSuivantLDC(m)
n = GetPrecedentLDC(m)
GetSuivantLDC(m)[1] = m[1]
GetPrecedentLDC(m)[2] = m[2]
m[1] = None
m[2] = None
return l
def SupprimerValLDC(l,val):
"""
Permet de supprimer le premier noeud de valeur val dans la liste doublement chainée l
:paramètre : l : liste doublement chainée
val : valeur du noeud à supprimer
:return : n : la nouvelle liste chainée
"""
assert(l != None) ## on ne peut pas supprimer à un noeud dans une liste vide
n = l
j = 0
while GetValLDC(n) != val:
n = GetSuivantLDC(n)
assert(n != None)## la valeur donnée ne ce trouve pas dans la liste
j +=1
n = SupprimerPlaceLDC(l,j)
return n
def LDC2List(l):
"""
Permet de convertir la liste doublement chainée en une liste qui contient toute les valeurs des noeuds
:paramètre : l : liste doublement chainée
:return : List : la liste qui contient toute les valeurs de LDC
"""
long = LongueurLDC(l)
n = l
j = 0
List = []
while j < long :
List.append(GetValLDC(n))
n = GetSuivantLDC(n)
j += 1
return List
def List2LDC(l):
"""
Permet de convertir la liste qui contient la valeurs des noeuds en une liste doublement chainée
:paramètre : l : la liste qui contient toute les valeurs de LDC
:return : list : liste doublement chainée
"""
if l != None :
list = None
for i in range (len(l)) :
list = InsererFinLDC(list, l[i])
else :
assert () ## Ce n'est pas une liste !
return list
#################################
##### Fonction de Test des LDC###
#################################
def est_vide(l):
"""
Permet de testé si une liste l et vide ou non
:paramètre : l : une liste doublement chainée
:return : bool : True si la liste est vide et False si la liste n'est pas vide.
"""
if LongueurLDC(l) == 0:
return True
else :
return False
def test_creation_liste():
"""
Test du Cosntructeur de la liste doublement chainée
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
assert est_vide(ma_liste)
return True
def test_ajout_tete():
"""
Test de l'ajout d'une valeur en tête de la liste
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 28)
assert not est_vide(ma_liste)
assert LongueurLDC(ma_liste) == 1
return True
def test_ajout_tete_a_fin():
"""
Test de l'ajout d'une valeur en fin de la liste
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererFinLDC(ma_liste, 12)
assert LongueurLDC(ma_liste) == 3
return True
##def test_acces_LDC():
## ma_liste = creerListeVide()
## ma_liste = InsererDebutLDC(ma_liste, 32)
## ma_liste = InsererDebutLDC(ma_liste, 14)
## ma_liste = InsererFinLDC(ma_liste, 12)
## Noeud_1 = AccesLDC(ma_liste, 1)
def test_supression_debut():
"""
Test de supression de la tête de la LDC
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererFinLDC(ma_liste, 12)
ma_liste = SupprimerDebutLDC(ma_liste) # La LDC est 14, 32, 12
assert LongueurLDC(ma_liste) == 2
assert AccesLDC(ma_liste, 0)[0] == 32
return True
def test_supression_fin():
"""
Test de supression de la fin de la LDC
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste,32)
ma_liste = InsererDebutLDC(ma_liste,14)
ma_liste = InsererFinLDC(ma_liste,12)
ma_liste = SupprimerFinLDC(ma_liste) # La LDC est 14, 32, 12
assert LongueurLDC(ma_liste) == 2
assert AccesLDC(ma_liste, 2)[0] == 32
return True
def test_ajout_place(val,p):
"""
Test d'ajout une valeur à la place p
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererFinLDC(ma_liste, 12)
ma_liste = InsererPlaceLDC(ma_liste, val, p) # La LDC est 14, 32, 12,42
assert LongueurLDC(ma_liste) == 4
assert AccesLDC(ma_liste, p)[0] == val
return True
def test_supression_place():
"""
Test de supression d'un noeud à une place définit
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererDebutLDC(ma_liste, 66)
ma_liste = InsererDebutLDC(ma_liste, 33)
ma_liste = SupprimerPlaceLDC(ma_liste, 2) # La LDC est 33, 66, 14, 32 ici on souhiate supprimer 14 le
assert LongueurLDC(ma_liste) == 3
assert AccesLDC(ma_liste, 2)[0] == 32
return True
def test_supression_valeur():
"""
Test de supression d'une valeur dans la LDC
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererDebutLDC(ma_liste, 66)
ma_liste = InsererDebutLDC(ma_liste, 33)
ma_liste = SupprimerValLDC(ma_liste, 14) # La LDC est 33, 66, 14, 32 ici on souhiate supprimer 14
assert LongueurLDC(ma_liste) == 3
assert AccesLDC(ma_liste, 2)[0] == 32
return True
def test_LDC_To_List():
"""
Test de Conversion de la LDC en List
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererDebutLDC(ma_liste, 66)
ma_liste = InsererDebutLDC(ma_liste, 33)
ma_liste = LDC2List(ma_liste) # La LDC est 33, 66, 14, 32 ici on souhaite la convertir le List [33, 66, 14, 32]
assert ma_liste == [33, 66, 14, 32]
return True
def test_List_To_LDC():
"""
Test de la conversion de la List en LDC
:return : bool : True le test est correct
"""
ma_liste = creerListeVide()
ma_liste = InsererDebutLDC(ma_liste, 32)
ma_liste = InsererDebutLDC(ma_liste, 14)
ma_liste = InsererDebutLDC(ma_liste, 66)
ma_liste = InsererDebutLDC(ma_liste, 33)
ma_liste_test = [33, 66, 14, 32]
ma_liste_test = List2LDC(ma_liste_test)
print("Ma liste : ", ma_liste)
print("Ma liste test : ", ma_liste_test) # La liste est [33, 66, 14, 32] ici on souhiate supprimer 14
assert LongueurLDC(ma_liste_test) == LongueurLDC(ma_liste)
for i in range (LongueurLDC(ma_liste_test)):
assert AccesLDC(ma_liste_test,i) == AccesLDC(ma_liste,i)
return True
##############################################
##### Programme de test des fonction #########
##############################################
if __name__ == '__main__':
print('Test liste vide :', test_creation_liste())
print('Test ajout tête :', test_ajout_tete())
print('Test ajout fin :', test_ajout_tete_a_fin())
print('Test supression début :', test_supression_debut())
print('Test supression fin :', test_supression_debut())
print('Test ajouter à la place :', test_ajout_place(422,2))
print('Test supression Place :', test_supression_place())
print('Test supression Valeur :', test_supression_valeur())
print('Test conversion en List :', test_LDC_To_List())
print('Test conversion en LDC :', test_List_To_LDC())
## print('Test liste acces :', test_acces_LDC())
</code></pre></div>
<p>J’en suis maintenant à essayer les jeux de test pour les fonctions.
Pour test_acces_LDC() j’ai cette erreur : </p>
<div class="hljs-code-div hljs-code-text"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span></div><pre><code class="hljs language-text">Traceback (most recent call last):
File "C:\Users\Julie\Downloads\Projet david bloc 3\Fonction_LDC.py", line 511, in <module>
print('Test conversion en LDC :', test_List_To_LDC())
File "C:\Users\Julie\Downloads\Projet david bloc 3\Fonction_LDC.py", line 493, in test_List_To_LDC
assert AccesLDC(ma_liste_test,i) == AccesLDC(ma_liste,i)
RecursionError: maximum recursion depth exceeded in comparison
</code></pre></div>
<p>Mais je ne voit pas comment faire autrement pour automatiser le test ? a moins de l’afficher à l’utilisateur ? </p>
<p>Bonne journée.
Lesnox</p>Les listes doublement chaînée, message #2364622021-08-06T10:36:04+02:00entwanne/@entwannehttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p236462<figure><blockquote>
<p>voilà où j’en suis, j’ai un soucis avec deux fonction, la fonction SupprimerPlaceLDC(l,p), je ne n’arrive pas à comprendre comment supprimer le nœud quand il est au milieu de la liste.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p236448">lesnox</a></figcaption></figure>
<p>Déjà je ne pense pas qu’il soit utile de calculer la taille de la liste, ça te fait parcourir entièrement al liste pour rien (la taille dans ton cas n’étant pas une donnée connue mais demandant à être calculée).</p>
<p>Ensuite, le principe de la suppression d’un élément, c’est de localiser l’élément qui le précède et celui qui le suit pour les lier entre-eux, faisant ainsi sauter ton maillon.
Il faut donc faire la liaison dans les deux sens.</p>
<p>Aussi, là tu calcules un maillon <code>n</code> à chaque tour de boucle que tu n’utilises pas. Et qui correspond juste à la précédente valeur de <code>m</code>.
C’est noms ne sont d’ailleurs pas très explicites et nuisent à la lisibilité de ton code.</p>
<figure><blockquote>
<p>De même pour la fonction SupprimerValLDC(l,val), si l’utilisateur rentre une valeur qui n’est pas dasn la liste je vais sortir avec un assert mais pas le bon et je voudrait d’abord vérifier que la valeur val est bien dans la liste doublement chainée.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p236448">lesnox</a></figcaption></figure>
<p>C’est exactement le même principe que <code>SupprimerPlaceLDC</code> sauf que tu ne repères pas un élément par rapport à sa position mais par sa valeur.
Il te faut donc parcourir tous les éléments de ta liste et t’arrêter quand tu trouves la bonne valeur.</p>
<p>Si tu as parcouru tous les éléments sans trouver la valeur, alors elle n’est pas dans la liste.
Le problème est que la condition de fin de ta boucle n’est pas bonne puisqu’elle ne t’empêche pas d’aller au-delà de la liste.</p>Les listes doublement chaînée, message #2364482021-08-04T22:41:39+02:00lesnox/@lesnoxhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p236448<p>Bonjour à tous, </p>
<p>voilà où j’en suis, j’ai un soucis avec deux fonction, la fonction SupprimerPlaceLDC(l,p), je ne n’arrive pas à comprendre comment supprimer le nœud quand il est au milieu de la liste.</p>
<p>De même pour la fonction SupprimerValLDC(l,val), si l’utilisateur rentre une valeur qui n’est pas dasn la liste je vais sortir avec un assert mais pas le bon et je voudrait d’abord vérifier que la valeur val est bien dans la liste doublement chainée.</p>
<p>Merci d’avance de votre aide.
Lesnox</p>
<div class="hljs-code-div hljs-code-text"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span><span data-count="23"></span><span data-count="24"></span><span data-count="25"></span><span data-count="26"></span><span data-count="27"></span><span data-count="28"></span><span data-count="29"></span><span data-count="30"></span><span data-count="31"></span><span data-count="32"></span><span data-count="33"></span><span data-count="34"></span><span data-count="35"></span><span data-count="36"></span><span data-count="37"></span><span data-count="38"></span><span data-count="39"></span><span data-count="40"></span><span data-count="41"></span><span data-count="42"></span><span data-count="43"></span><span data-count="44"></span><span data-count="45"></span><span data-count="46"></span><span data-count="47"></span><span data-count="48"></span><span data-count="49"></span><span data-count="50"></span><span data-count="51"></span><span data-count="52"></span><span data-count="53"></span><span data-count="54"></span><span data-count="55"></span><span data-count="56"></span><span data-count="57"></span><span data-count="58"></span><span data-count="59"></span><span data-count="60"></span><span data-count="61"></span><span data-count="62"></span><span data-count="63"></span><span data-count="64"></span><span data-count="65"></span><span data-count="66"></span><span data-count="67"></span><span data-count="68"></span><span data-count="69"></span><span data-count="70"></span><span data-count="71"></span><span data-count="72"></span><span data-count="73"></span><span data-count="74"></span><span data-count="75"></span><span data-count="76"></span><span data-count="77"></span><span data-count="78"></span><span data-count="79"></span><span data-count="80"></span><span data-count="81"></span><span data-count="82"></span><span data-count="83"></span><span data-count="84"></span><span data-count="85"></span><span data-count="86"></span><span data-count="87"></span><span data-count="88"></span><span data-count="89"></span><span data-count="90"></span><span data-count="91"></span><span data-count="92"></span><span data-count="93"></span><span data-count="94"></span><span data-count="95"></span><span data-count="96"></span><span data-count="97"></span><span data-count="98"></span><span data-count="99"></span><span data-count="100"></span><span data-count="101"></span><span data-count="102"></span><span data-count="103"></span><span data-count="104"></span><span data-count="105"></span><span data-count="106"></span><span data-count="107"></span><span data-count="108"></span><span data-count="109"></span><span data-count="110"></span><span data-count="111"></span><span data-count="112"></span><span data-count="113"></span><span data-count="114"></span><span data-count="115"></span><span data-count="116"></span><span data-count="117"></span><span data-count="118"></span><span data-count="119"></span><span data-count="120"></span><span data-count="121"></span><span data-count="122"></span><span data-count="123"></span><span data-count="124"></span><span data-count="125"></span><span data-count="126"></span><span data-count="127"></span><span data-count="128"></span><span data-count="129"></span><span data-count="130"></span><span data-count="131"></span><span data-count="132"></span><span data-count="133"></span><span data-count="134"></span><span data-count="135"></span><span data-count="136"></span><span data-count="137"></span><span data-count="138"></span><span data-count="139"></span><span data-count="140"></span><span data-count="141"></span><span data-count="142"></span><span data-count="143"></span><span data-count="144"></span><span data-count="145"></span><span data-count="146"></span><span data-count="147"></span><span data-count="148"></span><span data-count="149"></span><span data-count="150"></span><span data-count="151"></span><span data-count="152"></span><span data-count="153"></span><span data-count="154"></span><span data-count="155"></span><span data-count="156"></span><span data-count="157"></span><span data-count="158"></span><span data-count="159"></span><span data-count="160"></span><span data-count="161"></span><span data-count="162"></span><span data-count="163"></span><span data-count="164"></span><span data-count="165"></span><span data-count="166"></span><span data-count="167"></span><span data-count="168"></span><span data-count="169"></span><span data-count="170"></span><span data-count="171"></span><span data-count="172"></span><span data-count="173"></span><span data-count="174"></span><span data-count="175"></span><span data-count="176"></span><span data-count="177"></span><span data-count="178"></span><span data-count="179"></span><span data-count="180"></span><span data-count="181"></span><span data-count="182"></span><span data-count="183"></span><span data-count="184"></span><span data-count="185"></span><span data-count="186"></span><span data-count="187"></span><span data-count="188"></span><span data-count="189"></span><span data-count="190"></span><span data-count="191"></span><span data-count="192"></span><span data-count="193"></span><span data-count="194"></span><span data-count="195"></span><span data-count="196"></span><span data-count="197"></span><span data-count="198"></span><span data-count="199"></span><span data-count="200"></span><span data-count="201"></span><span data-count="202"></span><span data-count="203"></span><span data-count="204"></span><span data-count="205"></span><span data-count="206"></span><span data-count="207"></span><span data-count="208"></span><span data-count="209"></span><span data-count="210"></span><span data-count="211"></span><span data-count="212"></span><span data-count="213"></span><span data-count="214"></span><span data-count="215"></span><span data-count="216"></span><span data-count="217"></span><span data-count="218"></span><span data-count="219"></span><span data-count="220"></span><span data-count="221"></span><span data-count="222"></span><span data-count="223"></span><span data-count="224"></span><span data-count="225"></span><span data-count="226"></span><span data-count="227"></span><span data-count="228"></span><span data-count="229"></span><span data-count="230"></span><span data-count="231"></span><span data-count="232"></span><span data-count="233"></span><span data-count="234"></span><span data-count="235"></span><span data-count="236"></span><span data-count="237"></span><span data-count="238"></span><span data-count="239"></span><span data-count="240"></span><span data-count="241"></span><span data-count="242"></span><span data-count="243"></span><span data-count="244"></span><span data-count="245"></span><span data-count="246"></span><span data-count="247"></span><span data-count="248"></span><span data-count="249"></span><span data-count="250"></span><span data-count="251"></span><span data-count="252"></span></div><pre><code class="hljs language-text">###################################
##### Implémentation des LDC#######
###################################
def creerListeVide():
"""
"""
## la liste vide vaut None
return None
def setPrecedent (n, ns):
"""
"""
n[1] = ns
def setSuivant (n, ns):
"""
"""
n[2] = ns
def creerNoeudLDC(val, precedent, suivant):
""" un noeud est une liste Python de trois cases [valeur,noeud présecéent, noeud suivant]
"""
if precedent == None and suivant != None:
return [val, None, suivant]
if precedent != None and suivant == None:
return [val, precedent, None]
if precedent != None and suivant != None:
return [val, precedent, suivant]
else :
return [val, None, None]
def EstNoeudLDC(n):
"""
"""
if n == None:
return True
if (isinstance(n[0], int) == True and isinstance(EstNoeudLDC(n[1]), True) == True and isinstance(EstNoeudLDC(n[2]), True) == True):
return True
else :
return False
def GetValLDC(n):
"""
"""
assert(n != None) ## on ne peut pas obtenir la valeur d'une liste vide
return n[0]
def GetSuivantLDC(n):
"""
"""
assert(n != None) ## on ne peut pas obtenir la noeud suivant sur une liste vide
return n[2]
def GetPrecedentLDC(n):
"""
"""
assert(n != None) ## on ne peut pas obtenir la noeud précédent sur une liste vide
return n[1]
def LongueurLDC(l):
"""
"""
lg = 0
n = l
if l == None :
return lg
else :
lg = 1
while n[2] != None:
lg += 1
n = GetSuivantLDC(n)
return lg
def InsererDebutLDC(l,val):
"""
"""
if l == None:
return creerNoeudLDC(val, None, None)
else:
n = l
while GetPrecedentLDC(n) != None :
n = GetPrecedentLDC(n)
nn = creerNoeudLDC(val, None, n) # l pointe vers le 1er et non vers la tête de la LDC ?
setPrecedent (n,nn)
return nn
def InsererFinLDC(l,val):
"""
"""
if l == None:
return creerNoeudLDC(val, None, None)
else:
## on parcoure la liste jusqu'à atteindre le dernier noeud
n = l
while GetSuivantLDC(n) != None:
n = GetSuivantLDC(n)
## on met à jour le noeud suivant
n[2] = creerNoeudLDC(val, n, None)
m = GetSuivantLDC(l)
p = GetPrecedentLDC(l)
if p != None :
setPrecedent (n, m)
return l
def SupprimerDebutLDC(l):
"""
"""
assert(l != None) ## on ne peut pas supprimer un noeud dans une liste vide
n = l
print ("la liste n est : ", n)
n = GetSuivantLDC(n)
n[1] = None
return n
def SupprimerFinLDC(l):
"""
"""
assert(l != None) ## on ne peut pas supprimer un noeud dans une liste vide
n = l
while GetSuivantLDC(n) != None:
n = GetSuivantLDC(n)
setSuivant (GetPrecedentLDC(n), None)
setPrecedent (n, None)
return l
def AccesLDC(l,p):
"""
"""
assert(l != None) ## on ne peut pas accéder à un noeud dans une liste vide
assert p <= LongueurLDC(l) ##L'indice auqu'elle vous souhaitez accéder est trop grand par rapport à la liste
j = 0
m = l
while j < p:
j +=1
m = GetSuivantLDC(m)
return [m[0],m[1],m[2]]
def InsererPlaceLDC(l,val,p):
"""
"""
assert p <= LongueurLDC(l) ##L'indice donnée pour placer la valeur est trop grand par rapport à la liste
if l == None:
return creerNoeudLDC(val, None, None)
elif p == 0 :
InsererDebutLDC(l,val)
elif p == LongueurLDC(l) :
InsererFinLDC(l,val)
else:
j = 0
m = l
while j < p:
j +=1
m = GetSuivantLDC(m)
n = GetPrecedentLDC(m)
nn = creerNoeudLDC(val, m[1], m)
m[1] = nn
n[2] = m[1]
return l
def SupprimerPlaceLDC(l,p):
"""
"""
assert(l != None) ## on ne peut pas supprimer à un noeud dans une liste vide
assert p <= (LongueurLDC(l)-1) ##L'indice auqu'elle vous souhaitez supprimer la valeur est trop grand par rapport à la liste
m = l
if p == 0 :
m = SupprimerDebutLDC(l)
elif p == LongueurLDC(l)-1 :
m = SupprimerFinLDC(l)
else:
j = 0
while j < p:
j +=1
m = GetSuivantLDC(m)
n = GetPrecedentLDC(m)
print ("j vaut : ", j)
print("n est : ",m)
print("m est : ",GetPrecedentLDC(m))
setPrecedent(GetPrecedentLDC(m),GetSuivantLDC(m))
print("m''' est : ",m)
m[1] = None
m[2] = None
print("l'' vaut : ",m)
return m
##
##def SupprimerValLDC(l,val):
## """
## """
## assert(l != None) ## on ne peut pas supprimer à un noeud dans une liste vide
## n = l
## j = 0
## print(n)
## for i in range (LongueurLDC(l)):
## print(n)
## GetValLDC(n) == val :
## SupprimerPlaceLDC(l,i)
## else :
## assert(i == LongueurLDC(l)) ## La valeur que l'on souhaite supprimer ne ce trouve pas dans la liste.
## return l
def SupprimerValLDC(l,val):
assert(l != None) ## on ne peut pas supprimer à un noeud dans une liste vide
n = l
j = 0
print("la longeur de la lsite est : ", LongueurLDC(l))
while GetValLDC(n) != val:
n = GetSuivantLDC(n)
j +=1
print ("j vaut : ",j)
print("j vaut : ",j)
n = SupprimerPlaceLDC(l,j)
print("n' est : ", n)
return n
def LDC2List(l):
long = LongueurLDC(l)
n = l
j = 0
List = []
while j <= long :
List.append(GetValLDC(n))
n = GetSuivantLDC(n)
j += 1
return List
def List2LDC(l):
if l != None :
list = None
for i in range (len(l)) :
list = InsererFinLDC(list,l[i])
elif l == None :
return None
return list
l = creerListeVide()
l = InsererDebutLDC(l,28)
l = InsererDebutLDC(l,16)
l = InsererDebutLDC(l,23)
l = InsererFinLDC(l,100)
l = InsererPlaceLDC(l,44,2)
print(l)
l = SupprimerValLDC(l,44)
print(l)
</code></pre></div>[Python] Chercher et remplacer une chaine de caractères dans une liste par une autre chaine, message #2364282021-08-04T09:48:43+02:00Drakop/@Drakophttps://zestedesavoir.com/forums/sujet/15561/python-chercher-et-remplacer-une-chaine-de-caracteres-dans-une-liste-par-une-autre-chaine/?page=1#p236428<p>Ah oui c’etait tres con de ma part, c’est ok !</p>
<p>merci beaucoup !</p>[Python] Chercher et remplacer une chaine de caractères dans une liste par une autre chaine, message #2364272021-08-04T09:39:55+02:00entwanne/@entwannehttps://zestedesavoir.com/forums/sujet/15561/python-chercher-et-remplacer-une-chaine-de-caracteres-dans-une-liste-par-une-autre-chaine/?page=1#p236427<p>Salut,</p>
<p>Le <code>*</code> ne correspond à rien dans tes remplacements : la méthode <code>replace</code> fait une substitution bête et méchante, elle ne comprend pas de caractères spéciaux (pas de <code>\</code> ou de <code>*</code>, ce n’est pas une expression rationnelle).
Pour remplacer les <code>^</code> par des <code>-P</code> il faut alors appeler <code>replace('^', '-P')</code>.</p>
<p>Nul besoin de savoir ce qui se situe avant ou après.</p>[Python] Chercher et remplacer une chaine de caractères dans une liste par une autre chaine, message #2364262021-08-04T08:39:49+02:00Drakop/@Drakophttps://zestedesavoir.com/forums/sujet/15561/python-chercher-et-remplacer-une-chaine-de-caracteres-dans-une-liste-par-une-autre-chaine/?page=1#p236426<p>Bonjour,</p>
<p>Merci beaucoup</p>
<p>Jai cependant un soucis,</p>
<p>Car la valeur apres le '^' n’est pas toujours la meme et donc je ne dois pas remplacer toujours par le meme valeur, par exemple pour la liste suivante :</p>
<div class="hljs-code-div hljs-code-py"><div class="hljs-line-numbers"><span data-count="1"></span></div><pre><code class="hljs language-py">[<span class="hljs-string">'AAA^B'</span>,<span class="hljs-string">'AAA^A'</span>,<span class="hljs-string">'AEI^C'</span>,<span class="hljs-string">'MSFT'</span>,<span class="hljs-string">'AAPL'</span>,<span class="hljs-string">'AOI'</span>,<span class="hljs-string">'MCRE^B'</span>]
</code></pre></div>
<p>La liste avec les caracteres transformee doit donner cela :</p>
<div class="hljs-code-div hljs-code-py"><div class="hljs-line-numbers"><span data-count="1"></span></div><pre><code class="hljs language-py">[<span class="hljs-string">'AAA-PB'</span>,<span class="hljs-string">'AAA-PA'</span>,<span class="hljs-string">'AEI-PC'</span>,<span class="hljs-string">'MSFT'</span>,<span class="hljs-string">'AAPL'</span>,<span class="hljs-string">'AOI'</span>,<span class="hljs-string">'MCRE-PB'</span>]
</code></pre></div>
<p>Du coup je n’arrive pas a modifier selon la valeur apres le '^'</p>
<p>Voici mon code :</p>
<div class="hljs-code-div hljs-code-py"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span></div><pre><code class="hljs language-py">stock_list = [<span class="hljs-string">'AAA^B'</span>,<span class="hljs-string">'AAA^c'</span>,<span class="hljs-string">'AEI^C'</span>,<span class="hljs-string">'MSFT'</span>,<span class="hljs-string">'AAPL'</span>,<span class="hljs-string">'AOI'</span>,<span class="hljs-string">'MCRE^B'</span>]
stock_list2 = []
<span class="hljs-keyword">for</span> stock <span class="hljs-keyword">in</span> stock_list:
stmp = stock.replace(<span class="hljs-string">'\^*'</span>, <span class="hljs-string">'\-P*'</span>)
stock_list2.append(stmp)
<span class="hljs-built_in">print</span>(stmp)
<span class="hljs-built_in">print</span>(stock_list2)
</code></pre></div>
<p>Je ne sais pas comment faire en sorte que le scrip fasse la modif en fonction de la valeur apres le '^'</p>
<p>Bonne journee,</p>
<p>merci d’avance</p>[Python] Chercher et remplacer une chaine de caractères dans une liste par une autre chaine, message #2363782021-07-31T17:15:08+02:00Drahkcir/@Drahkcirhttps://zestedesavoir.com/forums/sujet/15561/python-chercher-et-remplacer-une-chaine-de-caracteres-dans-une-liste-par-une-autre-chaine/?page=1#p236378<p>bonjour,
il y a plusieurs moyens de remplacer une partie de chaine de caractère la plus simple est de faire appel a la méthode replace().</p>
<div class="hljs-code-div hljs-code-text"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span></div><pre><code class="hljs language-text">string="abcd"
result=string.replace('bc','test')
print(result)
</code></pre></div>
<p>la seconde méthode possible qui peut être utilisé est de faire appel a la librairie <strong>re</strong> de python pour utiliser des expressions régulières cette seconde méthodes est plus avancée est je pense un peu trop complexe pour ce problème. Cependant avec quelques recherches sur internet ont trouve facilement des documentations dessus.</p>[Python] Chercher et remplacer une chaine de caractères dans une liste par une autre chaine, message #2363752021-07-31T15:24:57+02:00Drakop/@Drakophttps://zestedesavoir.com/forums/sujet/15561/python-chercher-et-remplacer-une-chaine-de-caracteres-dans-une-liste-par-une-autre-chaine/?page=1#p236375<p>Bonjour,</p>
<p>je suis debutant en Python et je cherche a remplacer une chaine par une autre chaine dans une liste.</p>
<p>Voici la liste :</p>
<div class="hljs-code-div hljs-code-py"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span></div><pre><code class="hljs language-py">[<span class="hljs-string">'AAA^B'</span>,<span class="hljs-string">'AAA^B'</span>,<span class="hljs-string">'AEI^C'</span>,<span class="hljs-string">'MSFT'</span>,<span class="hljs-string">'AAPL'</span>,<span class="hljs-string">'AOI'</span>,<span class="hljs-string">'MCRE^B'</span>]
</code></pre></div>
<p>je souhaite remplacer le pattern :</p>
<div class="hljs-code-div hljs-code-py"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span></div><pre><code class="hljs language-py">
<span class="hljs-string">'^*'</span> par <span class="hljs-string">'-P*'</span>
donc ^<span class="hljs-string">B' ou '</span>^C<span class="hljs-string">' par exemple par '</span>-P<span class="hljs-string">B' et '</span>-PC<span class="hljs-string">'
</span></code></pre></div>
<p>J’ai essaye d’utiliser ca :</p>
<div class="hljs-code-div hljs-code-py"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span></div><pre><code class="hljs language-py">stock_list = [<span class="hljs-string">'-P{}'</span> <span class="hljs-keyword">if</span> i==<span class="hljs-string">'^{}'</span> <span class="hljs-keyword">else</span> i <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> stock_list]
</code></pre></div>
<p>Mais ca ne semble pas fonctionner car je pense que cela cherche la chaine entiere et non juste '^{}'</p>
<p>J’ai essaye de regarder du cote de re.sub mais je ne vois pas trop comment commencer, si vous avez des suggestions ou remarques</p>
<p>merci par avance ! </p>Les listes doublement chaînée, message #2351582021-06-10T12:49:42+02:00entwanne/@entwannehttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235158<p>Pour créer la liaison il faut identifier le nœud précédent : normalement tu le connais puisque tu as une liste double chaînée et que tu sais où tu insères ton maillon.</p>
<p>Donc tu peux faire pointer la liaison <code>next</code> du maillon précédent sur le nouveau maillon, et la liaison <code>prev</code> sur maillon suivant sur le nouveau maillon aussi.
Puis bien sûr faire pointer les liaisons <code>prev</code> et <code>next</code> de ce nouveau maillon vers les deux autres.</p>
<p>Essaie de prendre un papier et de faire des schémas, ça peut beaucoup aider.</p>Les listes doublement chaînée, message #2351522021-06-10T11:20:24+02:00lesnox/@lesnoxhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235152<figure><blockquote>
<p>Comment faire quoi plus précisément ? Les fonctions manquantes ?</p>
<p>Je pense que tu pourrais déjà retravailler et simplifier ton code existant :</p>
<ul>
<li>les <code>== True</code> dans les conditions sont inutiles, une expression booléenne s’évalue déjà à <code>True</code> ou <code>False</code></li>
<li>pour comparer un objet avec <code>None</code> on utilisera l’opérateur <code>is</code> (test d’identité) plutôt que <code>==</code> (test d’égalité)</li>
<li>ta fonction <code>creerNoeudLDC</code> peut être grandement simplifiée puisque tout ce qu’elle fait se résumé en <code>return [val, precedent, suivant]</code>. Par contre ne devrait-elle pas s’occuper aussi de créer les liaisons avec les nœuds voisins ?</li>
</ul>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235084">entwanne</a></figcaption></figure>
<p>Bonjour <a href="/membres/voir/entwanne/" rel="nofollow" class="ping ping-link">@<span class="ping-username">entwanne</span></a>, </p>
<p>En effet si mais c’est la que j’ai un soucis de compréhension sur comment faire cette liaisons ? </p>
<p>Merci.
Lesnox
Lesnox</p>Les listes doublement chaînée, message #2351502021-06-10T10:48:30+02:00lesnox/@lesnoxhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235150<p>Bonjour <a href="/membres/voir/kayou/" rel="nofollow" class="ping ping-link">@<span class="ping-username">kayou</span></a>, </p>
<p>voici le code que j’ai mis en place pour les listes chaînée : </p>
<div class="hljs-code-div hljs-code-python"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span><span data-count="23"></span><span data-count="24"></span><span data-count="25"></span><span data-count="26"></span><span data-count="27"></span><span data-count="28"></span><span data-count="29"></span><span data-count="30"></span><span data-count="31"></span><span data-count="32"></span><span data-count="33"></span><span data-count="34"></span><span data-count="35"></span><span data-count="36"></span><span data-count="37"></span><span data-count="38"></span><span data-count="39"></span><span data-count="40"></span><span data-count="41"></span><span data-count="42"></span><span data-count="43"></span><span data-count="44"></span><span data-count="45"></span><span data-count="46"></span><span data-count="47"></span><span data-count="48"></span><span data-count="49"></span><span data-count="50"></span><span data-count="51"></span><span data-count="52"></span><span data-count="53"></span><span data-count="54"></span><span data-count="55"></span><span data-count="56"></span><span data-count="57"></span><span data-count="58"></span><span data-count="59"></span><span data-count="60"></span><span data-count="61"></span><span data-count="62"></span><span data-count="63"></span><span data-count="64"></span><span data-count="65"></span><span data-count="66"></span><span data-count="67"></span><span data-count="68"></span><span data-count="69"></span><span data-count="70"></span><span data-count="71"></span><span data-count="72"></span><span data-count="73"></span><span data-count="74"></span><span data-count="75"></span><span data-count="76"></span><span data-count="77"></span><span data-count="78"></span><span data-count="79"></span></div><pre><code class="hljs language-python"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">creerNoeud</span>(<span class="hljs-params">val,suivant</span>):</span>
<span class="hljs-comment">## un noeud est une liste Python de deux cases [valeur,noueud suivant] """</span>
<span class="hljs-keyword">return</span> [val,suivant]
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">creerListeVide</span>():</span>
<span class="hljs-comment">## la liste vide vaut None </span>
<span class="hljs-keyword">return</span> <span class="hljs-literal">None</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">tete</span>(<span class="hljs-params">l</span>):</span>
<span class="hljs-keyword">assert</span>(l != <span class="hljs-literal">None</span>) <span class="hljs-comment">## on ne peut pas obtenir la tete d'une liste videe</span>
<span class="hljs-keyword">return</span> l[<span class="hljs-number">0</span>]
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">suivant</span>(<span class="hljs-params">l</span>):</span>
<span class="hljs-keyword">assert</span>(l != <span class="hljs-literal">None</span>) <span class="hljs-comment">## on ne peut pas obtenir la noeud suivant sur une liste vide</span>
<span class="hljs-keyword">return</span> l[<span class="hljs-number">1</span>]
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">setSuivant</span>(<span class="hljs-params">n,ns</span>):</span>
n[<span class="hljs-number">1</span>] = ns
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">ajouterDebut</span>(<span class="hljs-params">l,val</span>):</span>
<span class="hljs-keyword">if</span> l == <span class="hljs-literal">None</span>:
<span class="hljs-keyword">return</span> creerNoeud(val,<span class="hljs-literal">None</span>)
<span class="hljs-keyword">else</span>:
<span class="hljs-keyword">return</span> creerNoeud(val,l)
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">ajouterFin</span>(<span class="hljs-params">l,val</span>):</span>
<span class="hljs-keyword">if</span> l == <span class="hljs-literal">None</span>:
<span class="hljs-keyword">return</span> creerNoeud(val,<span class="hljs-literal">None</span>)
<span class="hljs-keyword">else</span>:
<span class="hljs-comment">## on parcoure la liste jusqu'à atteindre le dernier noeud</span>
n = l
<span class="hljs-keyword">while</span> suivant(n) != <span class="hljs-literal">None</span>:
n = suivant(n)
<span class="hljs-comment">## on met à jour le noeud suivant</span>
n[<span class="hljs-number">1</span>] = creerNoeud(val,<span class="hljs-literal">None</span>)
<span class="hljs-keyword">return</span> l
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">longueur</span>(<span class="hljs-params">l</span>):</span>
lg = <span class="hljs-number">0</span>
n = l
<span class="hljs-keyword">while</span> n != <span class="hljs-literal">None</span>:
lg += <span class="hljs-number">1</span>
n = suivant(n)
<span class="hljs-keyword">return</span> lg
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">ajouterPlace</span>(<span class="hljs-params">l,val,x</span>):</span>
<span class="hljs-comment">## attention, il faut vérifier que x est cohérent par</span>
<span class="hljs-comment">## rapport à la liste</span>
<span class="hljs-keyword">assert</span>(x>=<span class="hljs-number">0</span>)
<span class="hljs-keyword">assert</span>(x<longueur(l) <span class="hljs-keyword">or</span> (x==<span class="hljs-number">0</span> <span class="hljs-keyword">and</span> longueur(l)==<span class="hljs-number">0</span> ))
<span class="hljs-keyword">if</span> l == <span class="hljs-literal">None</span>:
<span class="hljs-comment">## normalement, suite au assert, x vaut 0</span>
<span class="hljs-keyword">return</span> creerNoeud(val,<span class="hljs-literal">None</span>)
<span class="hljs-keyword">else</span>:
xcourant = x
n = l <span class="hljs-comment">## n pointeur sur la même adresse que l</span>
<span class="hljs-keyword">while</span> xcourant != <span class="hljs-number">0</span>:
setSuivant(n,suivant(n))
xcourant = xcourant - <span class="hljs-number">1</span>
nn = creerNoeud(val,suivant(n)) <span class="hljs-comment">## 1 (creation nn), #2 branchment de nn sur le suivant de n</span>
setSuivant(n,nn) <span class="hljs-comment">## 3</span>
<span class="hljs-keyword">return</span> l <span class="hljs-comment">## l'adresse de l n'a pas bougé</span>
l = creerListeVide()
l = ajouterDebut(l,<span class="hljs-number">28</span>)
l = ajouterDebut(l,<span class="hljs-number">16</span>)
l = ajouterDebut(l,<span class="hljs-number">23</span>)
l = ajouterFin(l,<span class="hljs-number">100</span>)
l = ajouterPlace(l,<span class="hljs-number">67</span>,<span class="hljs-number">2</span>)
print(longueur(l))
print(l[<span class="hljs-number">1</span>][<span class="hljs-number">1</span>][<span class="hljs-number">0</span>])
print(id(l[<span class="hljs-number">1</span>]))
</code></pre></div>
<p>En effet ce que je rechercher c’est à programmer par à l’aide de fonction mais sans passer par le type class. (j’ai trouver pleins d’exemple sur internet mais je souhaiterais faire sans.</p>Les listes doublement chaînée, message #2350862021-06-08T16:39:47+02:00kayou/@kayouhttps://zestedesavoir.com/forums/sujet/15415/les-listes-doublement-chainee/?page=1#p235086<p>Dans ton 1<sup>er</sup> message tu parles de programmation fonctionnelle tu ne confondrais pas pas avec programmation à l’aide de fonctions ?</p>
<p>Ton code actuellement n’utlise pas vraiment les principes de la <a href="https://fr.wikipedia.org/wiki/Programmation_fonctionnelle">programmation fonctionelle</a>, et si python donne accès a certains element de programmation fonctionnelle, ce n’est pas un language prévu pour cet usage.</p>
<p>Dans le 2eme message avec la liste des fonctions à creer : </p>
<p>La description de ce qui est retouné par CreerNoeudLDC, correspond déja la definition d’un objet.</p>
<blockquote>
<p>• Créer la fonction CreerNoeudLDC(val,precedent,suivant) : NoeudLDC
o val (entier) : la valeur contenue dans le noeud
o precedent (NoeudLDC) : le nœud précédent. Vaut None pour un nœud en début de liste
o suivant (NoeudLDC) : le nœud suivant. Vaut None pour un nœud en fin de liste</p>
</blockquote>
<p>De plsu , la spec de la fonction `EstNoeudLDC' est :</p>
<blockquote>
<p>• Créer la fonction EstNoeudLDC(n : NoeudLDC) : booleen : qui vérifie que n est bien un nœud de liste doublement chainée, c’est-à-dire que n vaut None ou :
o n est une liste de 3 éléments (la fonction native isinstance sera utile)</p>
</blockquote>
<p>La définition de la fonction et l’utlisation de <code>isinstance</code> pour verifier que tu as un bien un noeud en argument laisse à penser que les noeuds sont des objets, je pense que tu devrais creer une classe <code>NoeudLDC</code> avec uniquement 3 proprietés : val, precedent et suivant, cette classe aura uniquement la méthode __init__.</p>
<p>Ensuite tu codes des fonctions "normales" qui travaillent sur des objet <code>NoeudLDC</code></p>
<p>Nota: le code que tu as soumis ne fait rien d’autres que définir des fonctions, as tu essayé de créer une liste chainée ? quels ont les résultats ?</p>