06:27 <alain_afpy> ERROR membres(2) HTTPConnectionPool(host='www.afpy.org', port=80): Request timed out. (timeout=10)
06:30 <alain_afpy> INFO membres fixed
08:53 <foxmask> bonjello
14:31 <tshirtman> tiens c'est marrant ça, un tupple de n élément a toujours le même id que n'importe quel autre tupple de n éléments?
14:32 <tshirtman> et au dessus d'une certaine valeur de n, l'id ne change plus
14:32 <tshirtman> j'imagine que c'est un détail d'implémentation non spécifié, mais intéressant à savoir
14:33 <tshirtman> je pensais pas qu'id puisse retourner une valeur égale pour des choses différentes
14:35 <tshirtman> je retire ce que j'ai dis pour le statisme au delà d'une certaine longueure, c'est plus compliqué que ça
14:35 <haypo> tshirtman: salut. le type tuple utilise une "free list" pour limiter le coût des allocations mémoires
14:35 <haypo> tshirtman: ce n'est utilisé que pour les tuples d'une certaine longueur
14:35 <tshirtman> ok, intéressant
14:36 <tshirtman> "free list" est la clé pour trouver plus d'infos parfait :)
14:36 <haypo> https://hg.python.org/cpython/file/c7a700132018/Objects/tupleobject.c#l7
14:37 <tshirtman> thx :)
14:37 <haypo> tshirtman: une fois, j'ai tenté de documenter un peu l'implémentation de CPython, mais je ne suis pas allé bien loin :-p http://cpython-internals.readthedocs.org/en/latest/
14:38 <tshirtman> l'intention est louable ^^
14:38 <haypo> tshirtman: je peux compléter à la demande ;)
14:39 <haypo> tshirtman: y'a aussi plein de singletons, genre les entiers -5..256, chaîne vide, chaîne d'un seul caractère (U+0000..0+00ff pour le cas d'unicode)
14:39 <tshirtman> j'ai déjà de quoi lire ;) merci, si j'ai par le plus grand des hasards, des question non adressé la dedans, je te dirais :)
14:39 <tshirtman> pour les chaines courtes je savais
14:39 <tshirtman> j'ai crus lire quelque part ou entendre, que choisir des variables a une lettre causait un lookup plus rapide pour cette raison, c'est vrai?
14:40 <haypo> tshirtman: hu
14:40 <tshirtman> j'ai tendance a copier les longues variables (surtout quand y'a un dot lookup) avant une boucle pour cette raison
14:40 <tshirtman> dans une variable courte :o
14:40 <haypo> tshirtman: c'est difficile de comprendre les perfs de python, il faut bien connaitre l'implémentation :-/
14:40 <tshirtman> oui, du coup y'a un peu de cargo-culting ^^
14:41 <haypo> les variables sont stockés dans un dict
14:41 <haypo> y'a une astuce pour les dict
14:41 <haypo> on peut "intern" ("interner"?) une chaîne de caractères avec sys.intern()
14:41 <haypo> il ne faut pas le faire explicitement, c'est fait de manière transparente dans plein de cas
14:41 <tshirtman> ça a un peu les effets d'une mise en cache?
14:42 <haypo> si une chaîne est internée, on peut la comparer en fonction de son adresse mémoire au lieu de son contenu -en gros-
14:42 <tshirtman> ok
14:42 <tshirtman> comment je sais si c'est fait? dis?
14:42 <tshirtman> pour le faire si c'est pas le cas et que je pense que ça aiderait
14:42 <haypo> un lookup utilise hash(key) mais aussi le contenu de key en cas de doublon (key == lookup)
14:42 <haypo> or == est "cher", avec intern tu peux éviter le ==
14:43 <haypo> tshirtman: sans gdb, je ne sais pas te dire si une chaîne est "internée" ou non
14:43 <haypo> je préfère éviter de trop penser aux micro-optimisations car ça me donne très mal à la tête
14:44 <tshirtman> dis moi si j'ai raté un truc, mais l'interne, c'est faire a une chaine > 1 la même chose que pour celle de len < 1, donc c'est moins cher pour celles-ci de base?
14:44 <haypo> une fois, j'ai passé 3 heures à lire du assembleur pour comprendre pourquoi une modification totalement anodine faisait perdre genre 30% de perf
14:44 <tshirtman> ah, les joies de la compilation…
14:44 <tshirtman> < 2*
14:45 <haypo> y'a des trucs super complexes comme cache L1, le cache de translation d'adresse mémoire virtuelle-physique, etc.
14:45 <haypo> (TLB?)
14:45 <tshirtman> ouais, c'est pour ça que je kiffe python :) loin de moi toutes ces notions barbares :)
14:45 <tshirtman> merci pour les explications en tout cas, c'est cool :)
14:47 <haypo> tshirtman: je ne pense pas que les chaînes de 1 caractère sont automatiquement internées
14:49 <tshirtman> ok
14:50 <haypo> tshirtman: par contre, je sais que le format de sérialisation marshal (utilisé notamment pour les fichiers .pyc) conserve la propriété "intern"
14:50 <tshirtman> ah, donc c'est une façon de voir si c'est le cas, sans sortir gdb?
14:51 <haypo> si tu sais lire du binaire ouais :)
14:51 <tshirtman> enfin, c'est pas forcément plus facile, j'imagine
14:51 <tshirtman> hexdumb et compagnie
14:51 <tshirtman> enfin, je pense que j'ai surement pleins de choses bien plus importantes à voir au niveau perfs avant ça :]
14:52 <haypo> tshirtman: hachoir sait lire des .pyc pour info
14:53 <tshirtman> ah, je l'avais oublié lui
14:53 <haypo> tshirtman: à priori, quand tu écris "def func(): xyz=1", xyz est interné
14:54 <tshirtman> ok
14:54 <haypo> ... mais en même temps, quand tu arrives au niveau bytecode, le nom des variables peut devenir des nombres pour les perfs ;)
14:54 <tshirtman> ouais logique :)
16:41 <feth> Avez-vous un site de covoiturage à recommander ?
16:41 <feth> (je vais à strasbourg en train là, ça me coûte un bras, je reviens demain, je veux voir si je peux garder l'autre bras)
16:46 <feth> (blablacar ne propose rien pour moi là)
17:00 <feth> donc, au niveau prix, le mieux c'est de passer par paris (mais le prix n'est pas mon seul critère :)