Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2023-02-27T15:29:24+01:00Les derniers messages parus sur le forum de Zeste de Savoir.Algorithme... en Lua, message #2493662023-02-27T15:29:24+01:00adri1/@adri1https://zestedesavoir.com/forums/sujet/16838/algorithme-en-lua/?page=1#p249366<p>Hmm, tu réalises beaucoup d’opérations dans cette fonction, tu as d’une part la recherche des chunks elle-même, et tu as en plus une transformation non-triviale (dupliquée!) parce que tes chunks trimbalent des métadonnées.</p>
<p>Je serais toi, je garderais la fonction <code>get_chunks</code> telle que je l’ai écrite qui se contente de prendre un array et renvoyer la position et longueur des chunks, et <code>Pipe:getChunks</code> pourrait transformer le résultat de cette fonction pour ajouter les métadonnées. Ça t’évite de mélanger la logique de "chercher des chunks" avec celle qui consiste à "ajouter quelques métadonnées à chaque chunk". Cette dernière n’est alors plus dupliquée, et ton code gagne en lisibilité. Il est aussi plus facilement testable parce que tu peux écrire des tests pour chacune de ces deux logiques indépendamment.</p>Algorithme... en Lua, message #2493642023-02-27T15:08:27+01:00Tri-Opt/@Tri-Opthttps://zestedesavoir.com/forums/sujet/16838/algorithme-en-lua/?page=1#p249364<p>C’est en effet un bel algorithme ! J’aime beaucoup le fait que toutes les opérations (récupérer les sous-tableaux, calculer la position et la longueur, insérer le nouveau sous-tableau) sont réalisés en même temps. Cela rend le code bien plus propre et compréhensible. J’ai légèrement adapté celui-ci pour mon utilisation :</p>
<div class="hljs-code-div hljs-code-lua"><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></div><pre><code class="hljs language-lua"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">Pipe:getChunks</span><span class="hljs-params">()</span></span>
<span class="hljs-keyword">local</span> chunks = {}
<span class="hljs-keyword">local</span> currentIndex = <span class="hljs-literal">nil</span>
<span class="hljs-keyword">for</span> i, chunk <span class="hljs-keyword">in</span> <span class="hljs-built_in">ipairs</span>(<span class="hljs-built_in">self</span>.bitmap) <span class="hljs-keyword">do</span>
<span class="hljs-keyword">if</span> currentIndex <span class="hljs-keyword">and</span> chunk == <span class="hljs-number">0</span> <span class="hljs-keyword">then</span>
<span class="hljs-built_in">table</span>.<span class="hljs-built_in">insert</span>(chunks, {
x = <span class="hljs-built_in">self</span>.x,
y = (currentIndex - <span class="hljs-number">1</span>) * <span class="hljs-built_in">self</span>.chunkHeight,
width = <span class="hljs-built_in">self</span>.width,
height = (i - currentIndex) * <span class="hljs-built_in">self</span>.chunkHeight
})
currentIndex = <span class="hljs-literal">nil</span>
<span class="hljs-keyword">elseif</span> (<span class="hljs-keyword">not</span> currentIndex) <span class="hljs-keyword">and</span> chunk == <span class="hljs-number">1</span> <span class="hljs-keyword">then</span>
currentIndex = i
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">if</span> currentIndex <span class="hljs-keyword">then</span>
<span class="hljs-built_in">table</span>.<span class="hljs-built_in">insert</span>(chunks, {
x = <span class="hljs-built_in">self</span>.x,
y = (currentIndex - <span class="hljs-number">1</span>) * <span class="hljs-built_in">self</span>.chunkHeight,
width = <span class="hljs-built_in">self</span>.width,
height = (#<span class="hljs-built_in">self</span>.bitmap + <span class="hljs-number">1</span> - currentIndex) * <span class="hljs-built_in">self</span>.chunkHeight
})
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">return</span> chunks
<span class="hljs-keyword">end</span>
</code></pre></div>Algorithme... en Lua, message #2493312023-02-24T17:22:49+01:00adri1/@adri1https://zestedesavoir.com/forums/sujet/16838/algorithme-en-lua/?page=1#p249331<p>Salut,</p>
<p>Quelque chose de linéaire dans ce goût là serait beaucoup plus simple (et donc facile à écrire).</p>
<div class="hljs-code-div hljs-code-lua"><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></div><pre><code class="hljs language-lua"><span class="hljs-keyword">local</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">get_chunks</span><span class="hljs-params">(arr)</span></span>
<span class="hljs-keyword">local</span> chunks = {}
<span class="hljs-keyword">local</span> i0_current = <span class="hljs-literal">nil</span>
<span class="hljs-keyword">for</span> i, elt <span class="hljs-keyword">in</span> <span class="hljs-built_in">ipairs</span>(arr) <span class="hljs-keyword">do</span>
<span class="hljs-keyword">if</span> i0_current <span class="hljs-keyword">and</span> elt == <span class="hljs-number">0</span> <span class="hljs-keyword">then</span>
chunks[i0_current] = i - i0_current
i0_current = <span class="hljs-literal">nil</span>
<span class="hljs-keyword">elseif</span> (<span class="hljs-keyword">not</span> i0_current) <span class="hljs-keyword">and</span> elt == <span class="hljs-number">1</span> <span class="hljs-keyword">then</span>
i0_current = i
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">if</span> i0_current <span class="hljs-keyword">then</span>
chunks[i0_current] = #arr + <span class="hljs-number">1</span> - i0_current
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">return</span> chunks
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">for</span> k, v <span class="hljs-keyword">in</span> <span class="hljs-built_in">pairs</span>(get_chunks({ <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">1</span> })) <span class="hljs-keyword">do</span>
<span class="hljs-built_in">print</span>(k, v)
<span class="hljs-keyword">end</span>
</code></pre></div>
<p>Là je retourne <code>chunks</code> comme un mapping entre l’indice de départ et la longueur de chaque chunk, mais c’est facile à adapter au format que tu veux. Les indices commencent à <code>1</code> au lieu de <code>0</code> comme ton exemple suggère aussi, mais là encore c’est simple à adapter.</p>Algorithme... en Lua, message #2493262023-02-24T13:23:26+01:00Tri-Opt/@Tri-Opthttps://zestedesavoir.com/forums/sujet/16838/algorithme-en-lua/?page=1#p249326<p>Bonjour, j’essaye de m’améliorer en algorithmie et, alors que je réalise un petit jeu avec <a href="https://love2d.org/">LÖVE2D</a>, je suis confronté à l’exercice suivant :</p>
<p>Imaginez un tableau formé de <code>0</code> et de <code>1</code> (une bitmap à une dimension, techniquement) : <code>{1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1}</code>.</p>
<p>Comme vous pouvez le remarquer, en Lua, les tableaux utilisent des accolades, et non des crochets.</p>
<p>Je souhaiterais alors créer une fonction <code>getChunks()</code> (un <em>chunk</em> est un morceau de notre bitmap) :</p>
<ul>
<li>
<p>Récupérer les sous-tableaux formés de <code>1</code>, ici nous avons trois sous-tableaux : <code>{1, 1, 1}</code>, <code>{1, 1}</code> et <code>{1}</code></p>
</li>
<li>
<p>Retourner, pour chaque sous-tableau, un tableau comportant deux éléments :</p>
<ul>
<li>la position du premier élément du sous-tableau dans la bitmap ;</li>
<li>la longueur du sous-tableau.</li>
<li>dans notre exemple, on obtient : <code>{0, 3}</code>, <code>{7, 2}</code> et <code>{11, 1}</code>. C’est le <code>return</code> de notre fonction.</li>
</ul>
<p>Voici le code que j’ai écris :</p>
</li>
</ul>
<div class="hljs-code-div hljs-code-lua"><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></div><pre><code class="hljs language-lua"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getChunks</span><span class="hljs-params">(bitmap)</span></span>
<span class="hljs-keyword">local</span> totalArr = {}
<span class="hljs-keyword">local</span> currentArr = {}
<span class="hljs-keyword">for</span> i, chunk <span class="hljs-keyword">in</span> <span class="hljs-built_in">ipairs</span>(bitmap) <span class="hljs-keyword">do</span>
<span class="hljs-keyword">if</span> chunk == <span class="hljs-number">1</span> <span class="hljs-keyword">then</span>
<span class="hljs-built_in">table</span>.<span class="hljs-built_in">insert</span>(currentArr, i - <span class="hljs-number">1</span>) <span class="hljs-comment">-- en Lua, les indices des tableaux débutent par 1, et non par 0 !</span>
<span class="hljs-keyword">else</span>
<span class="hljs-keyword">if</span> currentArr ~= {} <span class="hljs-keyword">then</span>
<span class="hljs-built_in">table</span>.<span class="hljs-built_in">insert</span>(totalArr, currentArr)
currentArr = {}
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">if</span> i == #bitmap <span class="hljs-keyword">then</span> <span class="hljs-built_in">table</span>.<span class="hljs-built_in">insert</span>(totalArr, currentArr) <span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">local</span> chunks = {}
<span class="hljs-keyword">for</span> _, arr <span class="hljs-keyword">in</span> <span class="hljs-built_in">ipairs</span>(totalArr) <span class="hljs-keyword">do</span>
<span class="hljs-built_in">table</span>.<span class="hljs-built_in">insert</span>(chunks, {
pos = arr[<span class="hljs-number">1</span>]
length = #bitmap
})
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">return</span> chunks
<span class="hljs-keyword">end</span>
</code></pre></div>
<p>L’algorithme fonctionne pour les tableaux <code>{ 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 }</code> et <code>{ 1, 0, 1, 0, 1 }</code> mais pas pour <code>{1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1}</code>… <img src="/static/smileys/svg/pleure.svg" alt=":'(" class="smiley"> </p>
<p>De plus, comme vous avez pu le constater, le code est assez brutal et pas très subtil. Du coup, si vous avez une idée de comment écrire quelque chose de plus élégant (et de fonctionnel), je vous remercie d’avance.</p>Créer un jeu de plateformes avec LÖVE, message #2223952020-06-15T04:09:26+02:00Helmasaur/@Helmasaurhttps://zestedesavoir.com/forums/sujet/14222/creer-un-jeu-de-plateformes-avec-love/?page=1#p222395<figure><blockquote>
<p><del>Je conseil Unreal Engine 4 personnellement, mais mieux vaut attendre le 5 pour profiter pleinement du ray-tracing.</del></p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14222/creer-un-jeu-de-plateformes-avec-love/?page=1#p222358">Tchaïkovski</a></figcaption></figure>
<p>J’ai déjà utilisé Unity mais il est vrai qu’Unreal Engine m’intéresse. Par contre, ce n’est pas le bon moment <img src="/static/smileys/svg/heureux.svg" alt=":D" class="smiley"> !</p>
<figure><blockquote>
<p>J’ai commencé par lire ce tutoriel pour débuter avec LÖVE : <a href="https://sheepolution.com/learn/book/contents">https://sheepolution.com/learn/book/contents</a></p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14222/creer-un-jeu-de-plateformes-avec-love/?page=1#p222358">Tchaïkovski</a></figcaption></figure>
<p>Ça a l’air sympa ! Je vais lire ça <img src="/static/smileys/svg/hihi.svg" alt="^^" class="smiley"> .</p>Créer un jeu de plateformes avec LÖVE, message #2223582020-06-14T11:35:41+02:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/14222/creer-un-jeu-de-plateformes-avec-love/?page=1#p222358<p><del>Je conseil Unreal Engine 4 personnellement, mais mieux vaut attendre le 5 pour profiter pleinement du ray-tracing.</del></p>
<p>J’ai commencé par lire ce tutoriel pour débuter avec LÖVE : <a href="https://sheepolution.com/learn/book/contents">https://sheepolution.com/learn/book/contents</a></p>Créer un jeu de plateformes avec LÖVE, message #2223532020-06-14T01:20:09+02:00Helmasaur/@Helmasaurhttps://zestedesavoir.com/forums/sujet/14222/creer-un-jeu-de-plateformes-avec-love/?page=1#p222353<figure><blockquote>
<p>Tu connais déjà Lua ?</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14222/creer-un-jeu-de-plateformes-avec-love/?page=1#p222340">adri1</a></figcaption></figure>
<p>Oui, j’ai déjà fais quelques scripts en Lua et la prise en main est vraiment sympa !</p>
<p>Sinon, merci pour le retour, si la documentation est correct et LÖVE accessible, je vais tenter ça !</p>Créer un jeu de plateformes avec LÖVE, message #2223402020-06-13T18:29:00+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/14222/creer-un-jeu-de-plateformes-avec-love/?page=1#p222340<p>Salut,</p>
<p>Löve est vraiment bien fait et la doc est claire (parfois peut être un peu légère si on ne sait pas trop ce qu’on essaye de faire, mais comme les fonctionnalités sont bien classées on s’y retrouve).</p>
<p>Tu connais déjà Lua ? Si oui, en quelque heures sans trop forcer tu peux déjà avoir un prototype respectable je pense. Si non, c’est un langage assez simple à apprendre donc même ça ne serait pas bloquant.</p>Créer un jeu de plateformes avec LÖVE, message #2223342020-06-13T17:12:32+02:00Helmasaur/@Helmasaurhttps://zestedesavoir.com/forums/sujet/14222/creer-un-jeu-de-plateformes-avec-love/?page=1#p222334<p>Bonjour,</p>
<p>Dans les prochaines semaines, j’aimerai réaliser un petit jeu de plateforme. Tout est déjà conçu sur papier. Je me suis dit que ce projet pourrait être un bon support pour utiliser LÖVE. J’ai lu en diagonal <a href="https://zestedesavoir.com/tutoriels/1399/un-jeu-de-casse-briques-en-lua-avec-love2d/#3-les-vies-et-la-balle">le tutoriel utilisant ce moteur de jeu pour faire un casse-brique</a> et j’ai vu que la prise en main est assez simple.</p>
<p>Dans le cadre d’un jeu de plateforme, cela demanderait beaucoup de travail ? Je précise qu’il n’y a pas de pouvoir comme les champignons de Mario ni d’ennemis comme les Goomba.</p>scripting pour rust : sur quels criteres choisir entre gluon et dyon, message #2194542020-04-22T18:02:07+02:00Rond2a/@Rond2ahttps://zestedesavoir.com/forums/sujet/13937/scripting-pour-rust-sur-quels-criteres-choisir-entre-gluon-et-dyon/?page=1#p219454<p>I am using serde to de -serialize them from ron files and load them into Game <a href="https://prepaidgiftbalance.net/">Prepaid Gift Balance</a>.</p>scripting pour rust : sur quels criteres choisir entre gluon et dyon, message #2192862020-04-20T14:24:16+02:00Leist258/@Leist258https://zestedesavoir.com/forums/sujet/13937/scripting-pour-rust-sur-quels-criteres-choisir-entre-gluon-et-dyon/?page=1#p219286<p>To see what is happening, we have to go back to the Dyson–Schwinger equation … k ≡ p + q, <sub>Z3 and </sub>Z1 are ghost and ghost-gluon vertex renormalization constants, … If we subtract, from (10.17), the same equation at p2 = 0, then we have … is the correct choice in D[2 dimensions, it means that the Kugo-Ojima criterion ..</p>scripting pour rust : sur quels criteres choisir entre gluon et dyon, message #2191882020-04-18T00:33:23+02:00buffalo974/@buffalo974https://zestedesavoir.com/forums/sujet/13937/scripting-pour-rust-sur-quels-criteres-choisir-entre-gluon-et-dyon/?page=1#p219188<p>Salut,
j’ai trouvé un binding de lua pour rust : rlua.
Mais apparemment, gluon et dyon sont mieux adaptés pour marcher avec rust.
Comment choisir entre gluon et dyon ?
c’est pour faire un jeu de plateau ou de cartes.</p>"python is limited to 120KPH Lua goes to 2000KPH", message #2182862020-04-04T06:38:20+02:00DeliriousKoala/@DeliriousKoalahttps://zestedesavoir.com/forums/sujet/13771/python-is-limited-to-120kph-lua-goes-to-2000kph/?page=1#p218286<figure><blockquote>
<p>Je pense que comparer Python et Lua <em>dans l’absolu</em> n’est pas du tout pertinent, a fortiori comparer leurs performances. Suivant les cas d’usage, l’un va éclater l’autre et inversement.</p>
<p>Certes, le code Lua est plus rapide à interpréter, et l’interpréteur Lua est <strong>beaucoup</strong> plus léger que l’interpréteur standard Python. Cela fait de Lua un <a href="https://myfedloan.us/fedloan-servicing/">fedloan servicing</a> langage de choix pour être embarqué dans d’autres applications. On peut citer notamment: </p>
<ul>
<li>Les jeux vidéo, où il sert à scripter des niveaux ou des comportements,</li>
<li>Certaines applications massivement customisables comme <em>AwesomeWM</em>, où il sert de langage de configuration,</li>
<li>Des bases de données comme Redis, où Lua peut être utilisé pour scripter des opérations complexes à exécuter en une seule transaction par le serveur (un peu comme des procédures stockées dans les SGBD classiques).</li>
</ul>
<p>Dans ces cas d’usages, il ne me viendrait pas à l’esprit une seule seconde d’utiliser Python. </p>
<p>Par contre, pour écrire des applications un peu complexes, qui font intervenir de nombreuses bibliothèques/briques logicielles, et qui ont besoin d’être un minimum fiables et bien intégrées, il serait complètement farfelu de partir sur du Lua en <em>standalone</em>. Je ne dis pas que ce ne serait pas faisable dans l’absolu, mais simplement qu’en termes de confort, de richesse de l’écosystème, de profusion d’outils périphériques au développement du projet, Python est un choix beaucoup plus évident. Et on se moque totalement de la différence de performances, car en réalité dans une telle application, comme dit plus haut, le code le plus critique est rarement écrit en Python (c’est plutôt généralement des bibliothèques externes, <em>bindées</em> en Python, qui font le plus gros du travail). </p>
<p>Dans ce cas, le confort de développement et la facilité à trouver des outils qui font ce dont on a besoin ne sont pas du tout les mêmes.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/13771/python-is-limited-to-120kph-lua-goes-to-2000kph/?page=1#p217581">nohar</a></figcaption></figure>
<p>Brilliant, thanks for sharing this info. This is all very interesting 🙂</p>"python is limited to 120KPH Lua goes to 2000KPH", message #2175812020-03-23T16:54:51+01:00nohar/@noharhttps://zestedesavoir.com/forums/sujet/13771/python-is-limited-to-120kph-lua-goes-to-2000kph/?page=1#p217581<p>Je pense que comparer Python et Lua <em>dans l’absolu</em> n’est pas du tout pertinent, a fortiori comparer leurs performances. Suivant les cas d’usage, l’un va éclater l’autre et inversement.</p>
<p>Certes, le code Lua est plus rapide à interpréter, et l’interpréteur Lua est <strong>beaucoup</strong> plus léger que l’interpréteur standard Python. Cela fait de Lua un langage de choix pour être embarqué dans d’autres applications. On peut citer notamment: </p>
<ul>
<li>Les jeux vidéo, où il sert à scripter des niveaux ou des comportements,</li>
<li>Certaines applications massivement customisables comme <em>AwesomeWM</em>, où il sert de langage de configuration,</li>
<li>Des bases de données comme Redis, où Lua peut être utilisé pour scripter des opérations complexes à exécuter en une seule transaction par le serveur (un peu comme des procédures stockées dans les SGBD classiques).</li>
</ul>
<p>Dans ces cas d’usages, il ne me viendrait pas à l’esprit une seule seconde d’utiliser Python. </p>
<p>Par contre, pour écrire des applications un peu complexes, qui font intervenir de nombreuses bibliothèques/briques logicielles, et qui ont besoin d’être un minimum fiables et bien intégrées, il serait complètement farfelu de partir sur du Lua en <em>standalone</em>. Je ne dis pas que ce ne serait pas faisable dans l’absolu, mais simplement qu’en termes de confort, de richesse de l’écosystème, de profusion d’outils périphériques au développement du projet, Python est un choix beaucoup plus évident. Et on se moque totalement de la différence de performances, car en réalité dans une telle application, comme dit plus haut, le code le plus critique est rarement écrit en Python (c’est plutôt généralement des bibliothèques externes, <em>bindées</em> en Python, qui font le plus gros du travail). </p>
<p>Dans ce cas, le confort de développement et la facilité à trouver des outils qui font ce dont on a besoin ne sont pas du tout les mêmes.</p>"python is limited to 120KPH Lua goes to 2000KPH", message #2175762020-03-23T13:50:40+01:00sgble/@sgblehttps://zestedesavoir.com/forums/sujet/13771/python-is-limited-to-120kph-lua-goes-to-2000kph/?page=1#p217576<figure><blockquote>
<p>Salut,
j’ai lu cette phrase</p>
<blockquote>
<p>python is limited to 120KPH Lua goes to 2000KPH
sur le <strong>post#11</strong> ici:</p>
</blockquote>
<p><a href="https://forums.civfanatics.com/threads/converting-python-code-to-lua.378560/">https://forums.civfanatics.com/threads/converting-python-code-to-lua.378560/</a></p>
<p>c’est quoi cette unité ?!</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/13771/python-is-limited-to-120kph-lua-goes-to-2000kph/?page=1#p217564">buffalo974</a></figcaption></figure>
<p>KPH = <em>Kilometers Per Hour</em>, soit en français : kilomètre par heure (km/h). C’est histoire de dire que Lua grille complètement Python en vitesse d’exécution d’après l’auteur de l’expression.</p>"python is limited to 120KPH Lua goes to 2000KPH", message #2175722020-03-23T08:54:31+01:00Aabu/@Aabuhttps://zestedesavoir.com/forums/sujet/13771/python-is-limited-to-120kph-lua-goes-to-2000kph/?page=1#p217572<p>Je peux reformuler : bien que le choix du langage influe sur la performance, ce n’est pas la première chose à changer en cas de soucis. On doit avant tout identifier ce qui est lent pour agir dessus. </p>
<p>Une fois la partie lente identifiée, qui en général n’est qu’une petite partie du programme, différentes solutions sont possibles.</p>
<ul>
<li>Par exemple, il est possible d’optimiser un algo existant en faisant plus attention à ce qu’on fait (création d’objets pour Python typiquement) ou changer d’algo complètement.</li>
<li>On peut aussi utiliser des bibliothèques externes qui sont fortement optimisées. Par exemple, pour Python, on peut utiliser numpy. De nombreux outils de calcul scientifique utilisent par exemple des routines bas niveau programmées en C. C’est une manière de sortir du langage sans changer de langage.</li>
<li>Si ce genre de solutions n’est pas possible, on peut faire soi-même les parties critiques dans un autre langage et les inclure. Pour Python, il est même possible de changer d’implémentation de Python pour une qui fonctionne différemment et possiblement plus rapide.</li>
</ul>
<p>Après, on peut réfléchir à changer de langage, par exemple si on a des problèmes avec l’empreinte mémoire du système de base et qu’on ne veut pas reprogrammer tout un environnement léger ou qu’on a épuisé toutes les solutions alternatives.</p>
<p>Évidemment, rien n’interdit de partir sur un langage réputé performant dès le départ, mais ce n’est en général pas le seul critère à prendre en compte. Il y aussi la facilité ou rapidité de développement. Qui aurait envie de coder un site web entièrement en C si ce n’est pas nécessaire ?</p>"python is limited to 120KPH Lua goes to 2000KPH", message #2175712020-03-23T08:26:19+01:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/13771/python-is-limited-to-120kph-lua-goes-to-2000kph/?page=1#p217571<blockquote>
<p>Les problèmes de performance vont venir de l’usage que tu as, plus que du langage en lui-même.</p>
</blockquote>
<p>Je ne comprends pas bien cette phrase.<br>
Je pense que le choix du langage est important, il me semble que ceux de bas niveau sont davantage performants.</p>"python is limited to 120KPH Lua goes to 2000KPH", message #2175662020-03-22T23:43:13+01:00Aabu/@Aabuhttps://zestedesavoir.com/forums/sujet/13771/python-is-limited-to-120kph-lua-goes-to-2000kph/?page=1#p217566<p>Salut,</p>
<p>Je pense que ce sont des kilomètres par heure. Une traduction/correction serait : </p>
<blockquote>
<p>Python est limité à 120 km/h, Lua va à 2000 km/h</p>
</blockquote>
<p>La personne veut dire que Lua est exécuté plus vite que Python. Après, garde en tête que tout ça ce sont des discussions de café du commerce et qu’elles datent d’il y a 10 ans. Les problèmes de performance vont venir de l’usage que tu as, plus que du langage en lui-même.</p>"python is limited to 120KPH Lua goes to 2000KPH", message #2175642020-03-22T23:20:38+01:00buffalo974/@buffalo974https://zestedesavoir.com/forums/sujet/13771/python-is-limited-to-120kph-lua-goes-to-2000kph/?page=1#p217564<p>Salut,
j’ai lu cette phrase</p>
<blockquote>
<p>python is limited to 120KPH Lua goes to 2000KPH
sur le <strong>post#11</strong> ici:</p>
</blockquote>
<p><a href="https://forums.civfanatics.com/threads/converting-python-code-to-lua.378560/">https://forums.civfanatics.com/threads/converting-python-code-to-lua.378560/</a></p>
<p>c’est quoi cette unité ?!</p>Scripter pour Rust, message #2170902020-03-14T20:07:53+01:00buffalo974/@buffalo974https://zestedesavoir.com/forums/sujet/13721/scripter-pour-rust/?page=1#p217090<p>Je reviens vers vous pour votre avis sur <strong>lupa</strong> : sur le papier ça pourrait m' être utile par rapport au sujet en question, mais dans la vraie vie, j' ignore si ça règle le problème.</p>
<p>Released: Dec 21, 2019
<a href="https://pypi.org/project/lupa/">https://pypi.org/project/lupa/</a></p>
<p>extrait:</p>
<blockquote>
<p>Lupa integrates the runtimes of Lua or LuaJIT2 into CPython. It is a partial rewrite of LunaticPython in Cython with some additional features such as proper coroutine support.</p>
<p>Major features</p>
<div class="hljs-code-div"><div class="hljs-line-numbers"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></div><pre><code class="hljs language-pgsql">separate Lua runtime states through a LuaRuntime <span class="hljs-keyword">class</span>
Python coroutine <span class="hljs-keyword">wrapper</span> <span class="hljs-keyword">for</span> Lua coroutines
iteration support <span class="hljs-keyword">for</span> Python objects <span class="hljs-keyword">in</span> Lua <span class="hljs-keyword">and</span> Lua objects <span class="hljs-keyword">in</span> Python
proper <span class="hljs-keyword">encoding</span> <span class="hljs-keyword">and</span> decoding <span class="hljs-keyword">of</span> strings (configurable per runtime, UTF<span class="hljs-number">-8</span> <span class="hljs-keyword">by</span> <span class="hljs-keyword">default</span>)
frees the GIL <span class="hljs-keyword">and</span> supports threading <span class="hljs-keyword">in</span> separate runtimes <span class="hljs-keyword">when</span> calling <span class="hljs-keyword">into</span> Lua
tested <span class="hljs-keyword">with</span> Python <span class="hljs-number">2.6</span>/<span class="hljs-number">3.2</span> <span class="hljs-keyword">and</span> later
written <span class="hljs-keyword">for</span> LuaJIT2 (tested <span class="hljs-keyword">with</span> LuaJIT <span class="hljs-number">2.0</span><span class="hljs-number">.2</span>), but <span class="hljs-keyword">also</span> works <span class="hljs-keyword">with</span> the normal Lua interpreter (<span class="hljs-number">5.1</span> <span class="hljs-keyword">and</span> <span class="hljs-number">5.2</span>)
easy <span class="hljs-keyword">to</span> hack <span class="hljs-keyword">on</span> <span class="hljs-keyword">and</span> extend <span class="hljs-keyword">as</span> it <span class="hljs-keyword">is</span> written <span class="hljs-keyword">in</span> Cython, <span class="hljs-keyword">not</span> C
</code></pre></div>
</blockquote>
<p>Le projet ancestral lunatic python est mort</p>
<blockquote>
<p>Lunatic Python is a two-way bridge between Python and Lua, allowing these languages to intercommunicate. Being two-way means that it allows Lua inside Python, Python inside Lua, Lua inside Python inside Lua, Python inside Lua inside Python, and so on.</p>
</blockquote>
<p>Peut on passer des objet python complexes dans lua qui lui va ensuite dans un moteur rust ou c++ ?</p>Scripter pour Rust, message #2170372020-03-13T12:13:28+01:00buffalo974/@buffalo974https://zestedesavoir.com/forums/sujet/13721/scripter-pour-rust/?page=1#p217037<p><a href="/membres/voir/nohar/" rel="nofollow" class="ping ping-link">@<span class="ping-username">nohar</span></a>: tu m’as vendu Lua. Depuis le temps que je résiste…</p>