Question bête sur les nombre à virugle

Bonjour à tous,

Je devellope depuis la rentré 2008 avec python et je viens de finir la mise au point d'un programme d'analyse de log d'un parefeu.
Lors d'un calcule de pourcentage j'obtient en résultat un nombre à virugle avec trop de chiffre après cette dernière, comment puis je faire pour réduire ce nombre de chiffre ? :oops:

ex : j'ais 19.15643453813218637 dans la variable a
j'aimerais 19.17. dans la variable a.

Merci à tous et bonne journée

P.S : vous pensez quoi d'un programe traitant un fichier log de 241 Mo en 780 minutes ...?

Bonjour,

utilise la fonction round()

Tu fournis d'abord comme premier argument le nombre que tu souhaites arrondir puis comme deuxième argument le nombre de chiffre que tu souhaites avoir après le point.

Exemple :

Code:

---

round(1.2367, 2)

---

Ceci te donnera un arrondi à deux chiffres après le point soit 1.24

Concernant la taille de ton fichier et le temps de traitement, je n'en ai aucune idée.

Ok merci pour la fonction c'est con mais je ne la connaissait pas.

Avant de clore se sujet très passionant :D:oops: est ce que quelqu'un peut me dire se qu'il en pense de ces données :

temps d'execution du programme avec un AMD Athlon XP cadensé à 2 Ghz et avec 448 Mo Ram:

fichier log de 57 Mo environ 80min
fichier log de 241 Mo environ 740min

les données ne sont pas encore définitive.

Merci

Pour formater l'affichage de données, on utilise plutôt les fonctions de formatage des chaînes de caractères :

Code:

---

1 2 3 4 5

>>> x = 19.15643453813218637 >>> print x 19.1564345381 >>> print "%.2f" % x 19.16

---

Je ne sais pas quel genre de traitement tu fais sur tes logs de parefeu. Mais plus d'une heure pour un fichier de 50 Mo ça me paraît énorme.

N'ayant plus plus d'info, on te peut pas t'aider plus sur ce point. Vérifie tout de même que tu n'utilise pas la méthode readlines() sur tes gros fichiers. Utiliser readlines() charge le fichier entièrement en mémoire et retourne une liste de chaîne de caractères. Si tu fais ça avec des gros fichiers, tu vas ralentir de façon très importante ton programme.

Tu peux également utiliser les profilers [1] Python afin de connaître les parties de code qui consomment le plus de temps CPU.

[1] http://docs.python.org/library/profile.html

Ce que tu dis m'interesse beaucoup, Je n'utilise pas de readlines() .
Le programme traite seulement les requetes bloquées par le firewall, puis il les met dans un compte rendu ( format .txt ) pour avoir une idée de se qui se passe.
Pour le fichier de 50 Mo le programme traite pres de 100 000 requete bloqué par le firewall.
Un autre test nous donne comme résultat 202 lignes traité en moins de 10 sec


Voici une partie du code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

try : fichier_log = open(name_log,"r") except IOError : print "Fichier introuvable, vérifier le nom du fichier" else: comptage = 0 #déclaration des listes vides pour le compte rendu de l'opération P0 tableau = [] liste_p = [] liste_ip =[] for ligne in fichier_log : if re.search(".+ DENY +.",ligne) : ip_src = re.findall("SRC=[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}",ligne) ip_dest = re.findall("DST=[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}",ligne) port_dest = re.findall("DPT=[0-9]{1,5}",ligne) print "\n--------------------------------------------\n" print "@ip source :", ip_src[0] print "@ip destination :", ip_dest[0] print "language correspondant :", port_dest print "\n--------------------------------------------" comptage = comptage + 1   if len(port_dest)!=0 : #and port_dest[0] not in liste_p : liste_p.append(port_dest[0]) liste_ip.append(ip_src[0])   if len(port_dest) != 0 : dico_ip = {'ip_src' : ip_src[0], 'ip_dest':ip_dest[0], 'port':port_dest[0], 'nb':1 }   else : dico_ip = {'ip_src' : ip_src[0], 'ip_dest':ip_dest[0], 'port':'*****', 'nb':1 }   if len(tableau) == 0 : tableau.append(dico_ip) elif len(tableau) != 0 : trouver = 0 c = 0 while trouver == 0 and c != len(tableau) : if tableau[c]['ip_src'] == dico_ip['ip_src'] and tableau[c]['ip_dest'] == dico_ip['ip_dest'] and tableau[c]['port'] == dico_ip['port'] : tableau[c]['nb'] = tableau[c]['nb'] + 1 trouver = 1 else : c=c+1   if trouver == 0 : tableau.append(dico_ip)

---

Les listes sont ensuite envoyé dans une fonction calculant le pourcentage d'apparation de tel port ou tel adresse

En lisant rapidement, quelques remarques :

- puisque tes expressions régulières sont toujours les mêmes et que tu les utilises un très grand nombre de fois, il serait mieux de les compiler [1] :

Citation:

---

[...] the version using compile() is more efficient when the expression will be used several times in a single program.

---

- je pense que tu peux également regrouper les 3 expressions régulières et utiliser plutôt les groupes de capture (parenthèse de groupement ( ) )

- je pense que ton utilisation de la liste tableau est mauvaise, tu y fais de nombreux parcours pour y rechercher des éléments. Il ne sont pas conçus pour ça :

Citation:

---

How can I tell whether a certain element is contained in a list or array?
Hearing the word "in" is an indication that you probably should have used a hash, not a list or array, to store your data. Hashes are designed to answer this question quickly and efficiently. Arrays aren't.

---

[2]
Utilise donc plutôt un hash ou un set.



[1] http://docs.python.org/library/re.html#re.compile
[2] http://perldoc.perl.org/perlfaq4.htm...st-or-array%3f (FAQ de Perl, mais cette question est valable pour n'importe quel langage)

Merci pour toutes ces indications, peux tu me parler des hash que je ne connais pas du tout .

J'aurais plutôt dû utiliser le mot dictionnaire [1] à la place de hash. Tu les utilises déjà dans ton code.
J'ai fais beaucoup de Perl et de Ruby avant de faire du Python, et dans ces deux langages, on utilise plutôt le terme hash.

Pour les sets : [2]. Ils permettent de stocker efficacement des éléments distincts dans un ordre arbitraire. Très souvent utilisés pour retrouver des éléments, supprimer les doublons d'une liste, etc.

[1] http://docs.python.org/library/stdtypes.html#dict
[2] http://docs.python.org/library/stdty...-set-frozenset

Ok pour les dicos, je vais faire ces quelques changements et donnerais les premiers resultat des tests.

Merci pour ton aide

Pour le tableau, tu veux que je stock un dico dans un dico c'est bien sa ?


Enfin je ne comprend po trop la compilation et son fonction une fois compilé, je poursuit mes recherches.

Je trouve le sujet de ton programme très intéressant. Je suis encore incapable de faire ce genre de programme, bien que j'aimerais.

100000 requêtes dans le 50 Mo, donc les 80 minutes si je comprends bien.
Ça fait 21 requêtes traitées par seconde, effectivement assez faible.

1- Il est certain que toute regex introduit de la lenteur dans un programme.
2- Comme le souligne Desintegr, la façon dont on écrit les regex compte aussi
3- Ton code concernant tableau fait effectivement dresser les cheveux sur la tête

Donc, bonne nouvelle, c'est plein de trucs qui ne vont pas, donc c'est améliorable. Allez je dirais que ça devrait pouvoir tourner en 8 secondes au lieu de 80 minutes.

Pour le 1 et l'avantage de compiler, ceci devrait être suffisamment démonstratif:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

from timeit import Timer import re   ch = 'aaaa.+ DENY +.orleansSRC=12.5.689.35.====hdjhgjhgjhgssss' bla = re.compile("\.\+ DENY \+\.")   def fre(): if re.search("\.\+ DENY \+\.",ch): return 1 else: return 0   def fcomp(): if bla.search(ch): return 1 else: return 0   def fin(): if ".+ DENY +." in ch: return 1 else: return 0       iterations = 100000   faire = Timer('fre()','from __main__ import fre') print faire.timeit(iterations)   faire = Timer('fcomp()','from __main__ import fcomp') print faire.timeit(iterations)   faire = Timer('fin()','from __main__ import fin') print faire.timeit(iterations)

---

Pour le 2:

- je ne crois pas que chercher à regrouper dans des groupes de capture comme l'écrit Desintegr soit le mieux à faire. Il est préférable de donner le moins de travail à faire aux regex, c'est à dire d'écrire le plus explicitement possible les RE, écrire soi même des longueurs de caractères au lieu de les faire calculer par une regex:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

from timeit import Timer import re   ch = 'aaaa.+ DENY +.orleansSRC=12.5.689.35.====hdjhgjhgjhgssss'   def fre(): if re.search("SRC=[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.",ch): x = 1 return x   def fre2(): if re.search("SRC=([0-9]{1,3}\.){4}",ch): return 1 else: return 0     iterations = 10000   print re.search("SRC=[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.",ch).group() faire = Timer('fre()','from __main__ import fre') print faire.timeit(iterations)   print   print re.search("SRC=([0-9]{1,3}\.){4}",ch).group() faire = Timer('fre2()','from __main__ import fre2') print faire.timeit(iterations)

---

À mon avis, tu as donc intérêt à garder 3 lignes séparées pour détecter ip_src , ip_dest, port_dest.


- je pense que les points dans
"SRC=[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}"
et "DST=[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}"
sont ...des points-point.
Il faut donc écrire \. sinon la regex les considère comme caractères spéciaux

- peut-il y avoir plusieurs SRC, DST et DPT par ligne ?
Je ne crois pas car je vois que tu prends ip_src[0] , ip_dest[0], port_dest[0]. Normal, car findall() renvoie une liste. Mais s'il n'y a qu'un élément dans les findall() alors il vaut mieux écrire
ip_src = re.findall("SRC=[0-9]{1,3}4.[0-9]{1,3}4.[0-9]{1,3}4.[0-9]{1,3}",ligne).group()
Fais print type(ip_src) tu verras que c'est une chaine.

- je me demande si c'est vraiment nécessaire que tu utilises des regex pour trouver tes motifs.
Il faudrait que tu nous donnes des exemples des lignes telles qu'elles sont.
Admettons par exemple qu'il n'y ait qu'un motif SRC dans une ligne. Alors
ligne[ligne.find('SRC='):] enlève déjà tout ce qui est avant 'SRC='. Si tu sais ce qui peut se trouver à la suite du motif, tu peux envisager un autre découpage pour couper à la fin.
Il y a plein de possibilités, il ne faut pas se laisser impressionner par la puissance des regex.

Pour ce qui est de la fin, il est tout à fait inutile de repérer par les chaines 'ip_src' 'ip_src' 'ip_dest' les 3 chaines constituantes d'une valeur enregistrée, aussi bien dans un dico_ip que dans tableau:
si tu n'enregistres dans tableau que des quadruplets ( 'ip_src','ip_src','ip_dest',nombre d'occurences) il n'y aura pas de raison à s'attendre à y trouver autre chose. ! Dans ce cas les tests seront quand même plus simples:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

if len(port_dest)!=0 : #and port_dest not in liste_p : liste_p.append(port_dest) liste_ip.append(ip_src)   if len(tableau) == 0 : tableau.append(('ip_src','ip_src','ip_dest',1)) elif len(tableau) != 0 : trouver = 0 c = 0 while trouver == 0 and c != len(tableau) : if ('ip_src','ip_src','ip_dest') == tableau[c][0:3] : tableau[c][3] = tableau[c][3] + 1 trouver = 1 else : c=c+1   if trouver == 0 : tableau.append(('ip_src','ip_src','ip_dest',1))

---

Étape supplémentaire de simplification:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

if len(port_dest)!=0 : #and port_dest[0] not in liste_p : liste_p.append(port_dest[0]) liste_ip.append(ip_src[0])     trouver = 0 for c in xrange(0,len(tableau)): if ('ip_src','ip_src','ip_dest') == tableau[c][0:3] : tableau[c][3] = tableau[c][3] + 1 trouver = 1 break if trouver == 0 : tableau.append(('ip_src','ip_src','ip_dest',1))

---

On peut encore aller plus loin dans la simplification de ton code, c'est à dire dans l'organisation des données. Pou le moment je te laisse maturer ça, je n'ai pas trop de temps.
Note que j'ai fait peut être des erreurs à certains endroits parce que j'ai écrit tout ça en vitesse.

pour la compilation des expression regulière, c'est très simple, au lieu d'avoir par ex :

Code:

---

1 2	ip_src = re.findall("SRC=[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}",ligne) ip_dest = re.findall("DST=[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}",ligne)

---

on a :

Code:

---

1 2 3

regex=re.compile("SRC=[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}") ip_src=regex.findall(ligne) ip_dest=regex.findall(ligne)

---

La différence est que l'expression régulière n'est compilée qu'une seule fois, au lieu de deux dans l'exemple (exemple 1 : compilation, recherche compilation, recherche; exemple 2 : compilation, recherche, recherche), cela va donc plus vite.

EDIT : grilled :lol:

search(patern, ch) cherche des motifs matchant patern dans une chaine ch
Elle le fait en utilisant un RegexObject qu'elle compare avec toutes les sous-chaines possibles issues de la chaine ch(je ne sais pas comment ça fonctionne exactement, c'est optimisé, ça n'extrait sans doute pas toutes les sous-chaines possibles de la chaine examinée).

Ce RegexObject est un bidule dans la mémoire, un objet, que search() calcule et crée à chaque fois qu'on la déclenche. Elle calcule ce RegexObject à partir de patern , qui est la représentation sous forme de chaine de caractères de la regex qu'on veut indiquer.
Ce calcul et cette création de l'objet RegexObject à partir de la chaine patern prend du temps.
Si un programme est prévu pour faire plusieurs fois fonctionner search() avec un même patern, on peut éviter à search() de refaire à chaque fois le calcul du RegexObject en lui fournissant directement le RegexObject déjà préalablement compilé, c'est à dire créé.
Cela se fait en écrivant bla = re.compile(patern)

EDIT PS
Il faut bien voir que search(patern, ch) est une fonction qui travaille sur deux arguments qu'on lui passe

tandis que dans

Code:

---

1 2	bla = re.compile(patern) bla.search(ch)

---

search() est une méthode de l'objet bla créé

Je suis allé trop vite. Plusieurs choses ne vont pas dans ce que j'ai proposé

1) J'avais l'idée d'un quadruplet plutôt que d'une liste parce que les tuples sont moins gorumands en ressources.
Mais ils ne sont pas modifiables.

2) de toutes façons ce que j'ai ecrit est très mauvais puisqu'on ne voit pas à quel endroit on entre un nouveau quadrplet, enfin disons une nouvelle liste

Je pense que le mieux est de créer un dictionnaire avec clés qui sont des triplets ('ip_src','ip_src','ip_dest') et valeurs qui sont le nombre d'occurences.
Et pour éviter de faire un test à chaque fois pour savoir si le triplet est déjà dans les clés ou non, utiliser defaultdict(int) (j'ai appris ça de dividee)
Le int indique le type des données qui seront en valeurs dans le dictionnaire.
Il faut importer defaultdict.

Code:

---

1 2 3 4 5 6

from collections import defaultdict d = defaultdict(int) ip_src = re.search("SRC=[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}",ligne).group() ip_dest = re.search("DST=[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}",ligne).group() port_dest = re.search("DPT=[0-9]{1,5}",ligne).group() d[('ip_src','ip_src','ip_dest')] += 1

---

Voilà, je ne pouvais pas te laisser perdre ton temps avec ce que j'avais écrit.

J'ai relu.
Dans messages #11 et #14,
je ne voulais évidemment pas écrire

Code:

---

1 2 3 4 5

if ('ip_src','ip_src','ip_dest') == tableau[c][0:3] : et tableau.append(('ip_src','ip_src','ip_dest',1)) et d[('ip_src','ip_src','ip_dest')] += 1

---

mais

Code:

---

1 2 3

if (ip_src,ip_src,ip_dest) == tableau[c][0:3] : tableau.append((ip_src,ip_src,ip_dest,1)) d[(ip_src,ip_src,ip_dest)] += 1

---

avec ip_src,ip_src,ip_dest des noms de variables dont les valeurs sont trouvées par search()

+1 pour le dictionnaire; c'est bien plus clair et plus rapide.
Je ne sais pas comment sont utilisées liste_p et liste_ip, mais à priori un ensemble (set) conviendrait mieux.

Voici ma proposition

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

from collections import defaultdict   pattern = re.compile( ".* DENY .*" "SRC=(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}).*" "DST=(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}).*?" "(?:DPT=(\d{1,5})|$)")   ports = set() ips = set() tableau = defaultdict(int) comptage = 0   for ligne in fichier_log: m = pattern.match(ligne) if not m: continue comptage += 1 ip_src, ip_dest, port_dest = m.group(1,2,3) # port_dest sera None s'il n'est pas présent dans la ligne if port_dest: ports.add(port_dest) ips.add(ip_src) tableau[(ip_src, ip_dest, port_dest)] += 1

---

L'expression régulière unique devrait convenir, même si elle ne correspond pas à 100% au code de zebulon94, s'il s'agit de logs d'iptables. J'ai du un peu chipoter pour faire une regex dont la partie "DPT" est optionnelle qui fonctionne; il y a peut-être plus simple, je ne suis pas spécialiste en regex.

Bonjour à tous. dans un premier temps, je tiens à vous remercier.

dividee les 2 variables listes sont envoyé dans une fonction calculant le pourcentage d'apparition des donnés comporté.
Ces pourcentages sont ensuite renvoyé au prog principal sont forme de tableau + dico comme précédemment ( DSL mais j'aime bien sa comme toi j'y vois plus clair ) Ensuite le tout est écris dans un fichier txt.
Pourquoi ne vous ais-je pas montré cette parti du code ? Tout simplement sur une execution total du script ( 0.16.... seconde) cette 2eme partie en prend une toute petite part (0.0.2 secondes )

J'ais effectuer quelques modification dans mon script notamment en suivant vos conseils.
Pour le moment j'ai remercié les expressions regulières se qui à amélioré le temps de 57% !!!!!!!!!!

Je vien de lancé un fichier log de 57 Mo qui avait mis 80 min lors des testes précédent, je vous tiendrais au courant des résultats.

Mon programme traite toutes les lignes d'un pare feu mais seule celle avec comme statut le DENY sont exploitées afin que les administrateurs réseaux puisse voire les failles de leurs systèmes.

Si vous avez une idée du temps que devrait mettre le programme pour les fichier donné au debut du sujet je suis preneur.

Malgrés le remplacement des expressions je n'ais pas fait de même pour ma variable tableau encore. Effectivement l'on m'as dis qu'un tableau mettait plus de temps machine pour l'accès qu'un dico .. alors ma question est la suivante est ec qu'un tableau dis 2D met plus de temps qu'un tableau référençant un dico ( comme je fais ) ?

je teste la solution de dividee et vous tien toujours au courant

Encore merci pour votre aide

P.S j'effectue encore des recherche sur le set()

Re-bonjour,

Les resultats sont tombé !!
le meilleur resultat obtenue est de 76 minutes à la place de 80 .

Quand je dis meilleur c'est avec différent code .

Je désespère . lol

MErci

En prenant le dernier code que propose dividee :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

#!/usr/bin/python # -*- coding: utf-8 -*-   from timeit import Timer from collections import defaultdict import re   def test(): pattern = re.compile( ".* DENY .*" "SRC=(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}).*" "DST=(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}).*?" "(?:DPT=(\d{1,5})|$)")   ports = set() ips = set() tableau = defaultdict(int) comptage = 0   fichier_log = open("d:/temp/test.log", "r") for ligne in fichier_log: m = pattern.match(ligne) if not m: continue comptage += 1 ip_src, ip_dest, port_dest = m.group(1,2,3) # port_dest sera None s'il n'est pas présent dans la ligne if port_dest: ports.add(port_dest) ips.add(ip_src) tableau[(ip_src, ip_dest, port_dest)] += 1   print len(tableau)   faire = Timer('test()','from __main__ import test') print faire.timeit(1)

---

En ayant générer un fichier log de ce style dont les adresse ip de SRC ont été générées en random et dont la taille est de 58 994 688 octets

Code:

---

1 2 3

Sep 21 11:45:17 lire kernel: DENY IN=eth0 OUT=eth0 SRC=151.159.38.46 DST=10.0.0.2 LEN=48 TOS=0x00 PREC=0x00 TTL=113 ID=38365 DF PROTO=TCP SPT=3117 DPT=80 WINDOW=16384 RES=0x00 SYN URGP=0 Sep 21 11:45:17 lire kernel: DENY IN=eth0 OUT=eth0 SRC=181.115.157.91 DST=10.0.0.2 LEN=48 TOS=0x00 PREC=0x00 TTL=113 ID=38365 DF PROTO=TCP SPT=3117 DPT=80 WINDOW=16384 RES=0x00 SYN URGP=0 Sep 21 11:45:17 lire kernel: DENY IN=eth0 OUT=eth0 SRC=251.234.49.47 DST=10.0.0.2 LEN=48 TOS=0x00 PREC=0x00 TTL=113 ID=38365 DF PROTO=TCP SPT=3117 DPT=80 WINDOW=16384 RES=0x00 SYN URGP=0

---

dont toutes les lignes provoque le comptage, j'arrive au résultat suivant :

Code:

---

1 2 3

D:\temp>test.py 309991 5.26398410971

---

Je trouve bien dans mon tableau plus de 300 000 entrées pour un temps d'exécution de 5 secondes et des poussières !!

Soit j'ai pas tout compris à ce que tu faisais, soit tu as d'autres traitements, soit tu travailles avec un boulier (et la c'est long c'est normal !!!), mais il y a quelque chose que je ne comprend pas entre mes 5 sec et tes 76 minutes.

Donnes nous ton code complet si possible ou essayes d'isoler que le traitement dont on parle pour comparer.

Citation:

---

Malgrés le remplacement des expressions je n'ais pas fait de même pour ma variable tableau encore. Effectivement l'on m'as dis qu'un tableau mettait plus de temps machine pour l'accès qu'un dico ..

---

Le plus gros gain de performance à attendre (dans la partie du code qu'on a pu voir) est pourtant bien là.

Citation:

---

alors ma question est la suivante est ec qu'un tableau dis 2D met plus de temps qu'un tableau référençant un dico ( comme je fais ) ?

---

En comprenant la question grâce aux posts précédents, le tableau 2D sera un peu plus rapide, car plus simple (le dico n'apporte rien comme tu l'utilises), mais aucune des deux solutions n'est adéquate. Il faut utiliser un dictionnaire, point. Pour rechercher un élément dans un tableau (enfin, il vaut mieux dire "liste" en Python), il faut parcourir tout la liste. Le temps que cela prend est proportionnel au nombre d'éléments dans la liste. Pour rechercher un élément dans un dictionnaire, une seule opération suffit en moyenne. Cela prend un temps constant, quelque soit le nombre d'éléments dans le dictionnaire.

L'ordre de grandeur du nombre d'opérations élémentaires effectuées par l'algorithme passe de quadratique (proportionnel au carré du nombre de lignes) à linéaire; c'est le genre d'amélioration qui peut faire passer le temps de traitement de plusieurs minutes à quelques secondes.

Effectivement le code de divide me fait obtenir un résultat dans le même ordre.

Avant de finir sur ce post j'aurais encore 2 petites questions... je me suis renseigné sur le defaultdict et je trouve sa bien pratique. Par contre j'aimerais bien trier le tableau par ordre décroissant du nombre de répétition. Dans mes premières versions je faisai :

Code:

---

tableau.sort(lambda X,Y : cmp(Y["nb"], X["nb"]))

---

mais vu l'erreur retourner sort() n'est pas dispo avec defaultdict.
Une idée ?

Quant à la deuxième question je ne m'en souvien plus sa ne devait pas être important.

En tout cas un gros merci à vous tous, j'ai appris beaucoup et cela grâce à vous. Si vous avez des conseils je suis toujours preneurs bref, MERCI

Les dictionnaires ne peuvent pas être ordonnés; le plus simple est de transformer le dictionnaire en liste après l'avoir rempli.

Par exemple, si le dictionnaire s'appelle "tableau":

Code:

---

1 2 3 4 5

liste = [(v,k) for k,v in tableau.iteritems()] liste.sort() for count, key in liste: print key, ':', count

---

Une autre approche possible :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#!/usr/bin/env python # -*- coding: utf-8 -*-   d = { 'zzzz': 35, 'mmmm': 12, 'aaaa': 24, }   print d # trier les valeurs print [v for v in sorted(d.values())]   # trier les cles print [v for v in sorted(d.keys())]   # trier les cles, mais afficher les valeurs print [d[v] for v in sorted(d.keys())]

---

P.S. Il serait préférable de créer un sujet par question, cela permets aux autres utilisateurs de savoir de quoi traite le sujet ;)

Salut tu peux essayer de convertir ton fichier python en exécutable (.exe).
A l'aide de "py2exe". Sa accéléra le temps d'exécution.

un tuto (que j'ai fait :mouarf:) : http://www.megaupload.com/fr/?d=94SZO3FC

A+:king:

py2exe n'accélère pas l'exécution d'un programme Python. Il permet simplement de faciliter la distribution des programmes sous Windows.

Il faut plutôt s'orienter vers Psyco [1].

[1] http://psyco.sourceforge.net/

Oui, le programme est exécuter plus rapidement. Et c'est testé!!!

Citation:

---

Envoyé par moumine

Et c'est testé!!!

---

Sources ? :roll:

Par moi!
J'ai fait un programme qui incrémente une variable et je l'ai calibrer (le nombre d'incrément) pour que sa fasse environ 15 sec.
Ensuite une fois le programme convertit il mettait moins de temps!
Maintenant tu peux vérifier par toi même (c'est vite fait).
A+:king:

Faire un benchmark sur une simple incrémentation, on a vu mieux...

Et « rapide à tester », je vais pas installer Windows pour ça :P

Citation:

---

Envoyé par moumine

Par moi!

---

Oui, peut être, mais ce n'est pas comme ca que l'on mesure; il manque des choses dans ton teste. Le fait de faire tourner ton programme sur ta machine de développement, peut être qu'il tourne en mode "Débuguage" alors que ton .exe tourne en mode "Release", peut être que c'est différant..... etc et blabla.....

C'est certain Py2exe n'est pas un accélérateur, car le source n'est pas modifié.

Ben moi je propose que "zebulon94" test sa avec son programme.
Sa ne coute rien d'essayer! :lun:
Et là je suppose que nous pourrons facilement voir la différence!

Pour ce qui est du test que j'ai effectuer. Certes il est simplement mais c'est largement suffisant!!
On peut directement constater que sa exécute plus rapidement.

Donc de dire que:

Citation:

---

Envoyé par Desintegr

py2exe n'accélère pas l'exécution d'un programme Python.

---

C'est FAUX :evilred:
A+

Citation:

---

Envoyé par moumine

C'est FAUX

---

Preuves et sources objectives ?

Je ne peux pas te donner des "Preuves et sources objectives". Car ce test c'est moi qu'il a réalisé.(uniquement)
Peut être bien qu'il n'accélère pas l'exécution mais c'est plus rapide que si on lance le programme directement de python x.x.

Voir l'option -O de l'interpréteur Python.

"TINTIN" :
l'omégazine lu de Sète à Soissons, te dit : «C'est tentant»
:koi::

:question:

:!:

:idea:

:mrgreen:

:frenchy:

:haha:

Savounette y est pas os courant, hin ?
:yaisse3:
:lun:
:mouarf2:
:rire:

:mouarf3:

:twisted: