Discussion :

[N.tox]

Par contre la solution de N.tox a l'air plus rapide mais il me manque des éléments...
Si tu pouvais me dire ou je me plante N.tox

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
def allFilesButHiden3(rootPath):
    for elem in os.listdir(rootPath):
        if elem[0]!='.' and elem[-1:] != '~':
            if os.path.isdir(rootPath+elem):
                for e in allFilesButHiden3(rootPath+elem+'/'):
                    yield rootPath+elem+e
            else:
                yield '/'+elem

(Avec / à la fin de rootPath bien sur)

heuuuuu.....

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#-begin- petites optimisations   #merci Antoine935, j'y pensais plus ;)
listdir=os.listdir
isdir=os.path.isdir
#-end- petites optimisations
 
def allFilesButHiden3(rootPath):
    for elem in listdir(rootPath):
        if elem[0]!='.' and elem[-1] != '~': #[-1:] est strictement pareil à [-1]
            if isdir(rootPath+elem):
                for e in allFilesButHiden3(rootPath+elem+'/'):
                    yield e #les éléments retournés par la fonction sont des noms de fichiers contenant déjà le chemin
            else:
                yield rootPath+elem

Hormis les deux petits détails que j'ai remis à mon goût je vois pas en quoi tu te plantes...

En gros la fonction va parcourir tout un dossier. Pour chaque élément, vérifiera que ce n'est ni un fichier caché ('.') ni une sauvegarde ('~'), puis une fois ces deux conditions vérifiée, déterminera si l'élément est un fichier, ou un dossier. Si c'est un fichier elle renvoie le nom de ce fichier précédé de son chemin, sinon (dossier) elle lance une copie d'elle même sur le dossier rencontré et renvoie tous les résultats obtenues de cette dernière...

Et de façon encore plus résumé, cette fonction parcours tout un dossier et ses sous-dossiers et renvoie tous les noms de fichiers précédés de leur chemin. En ignorant les fichiers et dossiers (et leur contenu du coup) cachés ou sauvegardés.

J'ai cru comprendre que c'était ce que tu cherchais, non ? Manquerait-il quelques conditions de filtrages ? Si c'est le cas, quelles sont-elle ?

[PauseKawa]

Et bien avec ton code il manque des éléments :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
Duree de Resultat1 :
0.83
Resultat d'un os.walk
28703
Duree de Resultat2 :
0.61
Resultat d'un os.lisdir avec amorce sur le root
28703
Duree de Resultat3 :
0.62
Resultat d'un recursif
27793
Manque
910

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
tps1 = time.clock()
Resultat1 = allFilesButHiden1('/home/patrice/Bureau')
tps2 = time.clock()
print 'Duree de Resultat1 :'
print(tps2 - tps1)
print 'Resultat d\'un os.walk'
print len(Resultat1)
 
tps1 = time.clock()
Resultat2 = allFilesButHiden2('/home/patrice/Bureau')
tps2 = time.clock()
print 'Duree de Resultat2 :'
print(tps2 - tps1)
print 'Resultat d\'un os.lisdir avec amorce sur le root'
print len(Resultat2)
 
tps1 = time.clock()
Resultat3 = []
for items in allFilesButHiden3('/home/patrice/Bureau/'):
    Resultat3.append(items)
tps2 = time.clock()
print 'Duree de Resultat3 :'
print(tps2 - tps1)
print 'Resultat d\'un recursif'
print len(Resultat3)
for items in Resultat3:
   Resultat2.remove(items)
 
print 'Manque'
print len(Resultat2)

Et je n'arrive pas a trouver le point commun dans ce qui manque.

[N.tox]

ma fonction ne retourne pas les noms des dossiers, sauf pour indiquer un chemin...

admettons que dans un dossier A, tu ais trois dossiers vides B,C,D et un fichier foo.py. Ma fonction ne te retournerais que /A/foo.py.
Si maintenant il y avait un fichier foo2.py dans le dossier C, ma fonction retournerait :
/A/foo.py
/A/C/foo2.py

je dis ça, même si c'est vrai, je ne sais pas si les autres fonctions font la même choses ou non, j'ai pas regardé... En tous cas, si il manque des entrée, c'est forcément logique, doit y avoir une différence dans le traitement (hormis que l'un est un générateur, et pas l'autre). En même temps, c'est peut-être parce que justement ça fonctionne... non ?

EDIT: Sinon, tu peux aussi te servir de set() pour voir quelles sont les entrées "manquantes", si toutefois le format des sorties sont les même (ie '/Chemin/nomFicher'):
http://www.developpez.net/forums/d80...e/#post4641283
Les sets supportent les opérations logiques (|, &, ^)
dans ton cas:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
f_out=open('./log','w')
miss=set(res1)-set(res2)
for x in miss:
    log.write(x)

EDIT2: Tu peux tout aussi bien ajouter à la longueur de résultat généré par ma fonction, le nombre de dossiers contenus dans le dossier analysé

[PauseKawa]

Merci à tous pour toutes ses informations pertinentes.
A moi maintenant de revoir mon code (tout mon code en fait ).

[eyquem]

C’est bien ce que je pense. Ton code est trop touffu pour être honnête.

Je prépare un message qui se concentre sur ce que tu as exposé dans ton message initial. J’espère pouvoir le poster rapidement.

Mais ensuite, il faudra nettoyer tout ton code de pratiques poussiéreuses et sans doute le modifier un peu aussi sur le plan algorithmique.

[eyquem]

1)
Je voudrais commencer par obtenir une confirmation superflue. Je ne doute pas de la réponse, mais bon sait on jamais....
Quand vous parlez de fichiers cachés, il s’agit bien de fichiers qui,
selon qu’on a coché l’option
Show hidden files and folders
ou l’option
Do not show hidden files and folders (sous Windows)
apparaissent ou n’apparaissent pas dans l’affichage du contenu d’un dossier ?
Ça n’a rien à voir avec les dossiers qui utilisent un cache et pour lesquels existe le module dircache , n’est-ce pas ???




2)
PauseKawa, connais-tu les list comprehension ?
C’est une manière condensée et plus rapide d’écrire la création de listes.
Par exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from time import clock
 
li = []
te = clock()
for x in xrange(0,2000000,5):
 if x%2==0:
   li.append(x)
tf = clock()
print tf-te
 
te = clock()
li = [ x for x in xrange(0,2000000,5) if x%2==0 ]
tf = clock()
print tf-te

La seconde méthode prend 18 % moins de temps que la première.

Il n’est pas envisageable de pratiquer Python sans user des list comprehension, donc autant s’y mettre le plu vite possible. Ça n’a rien de compliqué. Et dans ton cas, c’est à mon avis tout à fait indispensable quand je vois la longueur de ton code et les contournements que tu empruntes.




3)
Message #12 de N.tox

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
def allFilesButHiden(rootPath):
    '''It is important to have the '/' at the end of the rootPath'''
    for elem in os.listdir(rootPath):
        if elem[0]!='.':
            if os.path.isdir(rootPath+elem):
                for e in allFilesButHiden(rootPath+elem+'/'):
                    yield rootPath+elem+'/'+e
            else:
                yield elem

Deux problèmes avec cette fonction:

- Si rootPath contient des fichiers (= pas seulement des dossiers), alors quand elem = l’un de ces fichiers,
l’instruction yield elem renvoit un nom de fichier et non pas un chemin, c’est à dire sans le rootPath en tête du nom.

- j’obtiens des chemins du genre
C:\Documents and Settings\Administrator\Application Data/C:\Documents and Settings\Administrator\Application Data/Adobe/C:\Documents and Settings\Administrator\Application Data/Adobe/Acrobat/C:\Documents and Settings\Administrator\Application Data/Adobe/Acrobat/9.0/AdobeCMapFnt09.lst
En plein milieu d’une génération, l’instruction yield rootPath+elem+'/'+e renvoit dans la variable e antécédente une valeur de chemin à partir du e (qui est lui même un chemin) qu’elle obtient de l’instruction yield rootPath+elem+'/'+e succédente: mis bouts à bouts ces valeurs de chemin donnent le genre de résultat ci-dessus.

Le coup du ’/’ ,
nécessaire dans le premier rootPath fourni à la fonction au démarrage et son ajout systématique ensuite par allFilesButHiden(rootPath+elem+'/')
est un peu alambiqué à mon goût.


Message #19 de PauseKawa

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
def allFilesButHiden3(rootPath):
    for elem in os.listdir(rootPath):
        if elem[0]!='.' and elem[-1:] != '~':
            if os.path.isdir(rootPath+elem):
                for e in allFilesButHiden3(rootPath+elem+'/'):
                    yield rootPath+elem+e
            else:
                yield '/'+elem

C’est une modification légère de allFilesButHiden:
un petit peu plus alambiquée, et mêmes problèmes.


Message #21 de N.tox
Je la rebaptise allFilesButHiden3Tox pour bien l’identifier:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
def allFilesButHiden3(rootPath):
    for elem in listdir(rootPath):
        if elem[0]!='.' and elem[-1] != '~': #[-1:] est strictement pareil à [-1]
            if isdir(rootPath+elem):
                for e in allFilesButHiden3(rootPath+elem+'/'):
                    yield e #les éléments retournés par la fonction sont des noms de fichiers contenant déjà le chemin
            else:
                yield rootPath+elem

Fonction qui fonctionne tout à fait bien.
Personnellement, j’écrirais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
def allFilesButHiden3Tox(rootPath):
    rootPath += '/'
    for elem in listdir(rootPath):
        etc....

pour éviter de devoir penser à mettre un séparateur final dans le répertoire passé en argument au démarrage.



Avec des yield, ces 3 fonctions sont des fonctions génératrices.




4)
Dans le message #18

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
allFilesButHiden1 -> 28703 en 1.0 seconde (avec os.walk(rootPath)) 
allFilesButHiden2 -> 27793 en 0.57 seconde (avec RepAParcourir et ListeARetourner)

allFilesButHiden2 comporte les lignes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
for elem in os.listdir(Rep):
    if elem[0]!='.' and elem[-1:] != '~':
        if os.path.isdir(Rep + '/' + elem):
            RepAParcourir.append(Rep + '/' + elem)
        else: ListeARetourner.append(Rep + '/' + elem)

Malgré leurs noms, ces deux fonctions n’ont rien à voir avec les fonctions génératrices allFilesButHiden , allFilesButHiden3 et allFilesButHiden3Tox des messages #12 , #19 et #21.

En #18,
ListeARetourner.append(Rep + '/' + elem) n’est exécutée que pour des elem==fichier.
Il n’y a donc jamais de dossiers qui sont enregistrés par allFilesButHiden2. D’où la différence entre résultats dans ce message #18.


Dans le message #19,
la différence est éliminée par correction de allFilesButHiden2:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
for elem in os.listdir(Rep):
    if elem[0]!='.' and elem[-1:] != '~':
        ListeARetourner.append(Rep + '/' + elem)
        if os.path.isdir(Rep + '/' + elem):
            RepAParcourir.append(Rep + '/' + elem)

ListeARetourner.append(Rep + '/' + elem), ayant changé de place, est exécutée quelle que soit la nature de elem, donc même les dossiers ont leur chemin enregistré.

allFilesButHiden2 corrigée est comparée avec une fonction allFilesButHiden3 qui est une légère modification de la fonction allFilesButHiden originale de N.Tox et qui donne les mêmes résultats.





5)
Dans le message #22

allFilesButHiden1 -> 28703 en 0.83 seconde ( avec os.walk(rootPath))
allFilesButHiden2 -> 28703 en 0.61 seconde (sans doute la même qu’en #19, avec RepAParcourir et ListeARetourner)
allFilesButHiden3 -> 27793 en 0.62 seconde (tourne dans listdir())

allFilesButHiden2 est certainement la version corrigée de la fonction allFilesButHiden2 du message #19.
Elle donne le même résultat que la fonction allFilesButHiden1.

La différence de allFilesButHiden3 tient au fait que allFilesButHiden3 n’enregistre pas les noms de dossiers.
Et non pas des seuls dossiers vides comme le dit N.Tox.
Il suffit de faire des tests : en créant par exemple dans C: un dossier contenant deux fichiers, il s’ensuit que:
- les nombres donnés par allFilesButHiden1 et allFilesButHiden2 augmentent de 3
- le nombre donné par allFilesButHiden3 n’augmente que de deux

J’ai cru moi-aussi pendant un grand moment que seuls les dossiers vides n’étaient pas décomptés. Mais non.





6)
Dans la fonction allFilesButHiden2 , on parcourt RepAParcourir tout en lui ajoutant des éléments et en lui retranchant d’autres.
Habituellement, il faut extrêmement se méfier des itérations dans des listes qu’on modifie en cours d’itération. Par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
li = [2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]
lu = []
for x in li:
    lu.append(x)
print 'li =',li
print 'lu =',lu
 
 
print '\n'
li = [2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]
lu = []
for x in li:
    lu.append(x)
    li.remove(x)
print 'li =',li
print 'lu =',lu
 
 
print '\n'
li = [2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]
lu = []
ld = li[:]
for x in ld:
    lu.append(x)
    li.remove(x)
print 'li =',li
print 'ld =',ld
print 'lu =',lu
 
 
 
 
print '\n'
li = [2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]
lu = []
for x in li[::-1]:
    lu.append(x)
    li.remove(x)
print 'li =',li
print 'lu[::-1] =',lu[::-1]

li = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
lu = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]


li = [3, 5, 7, 9, 11, 13, 15, 17]
lu = [2, 4, 6, 8, 10, 12, 14, 16, 18]


li = []
ld = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
lu = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]


li = []
lu[::-1] = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

Mais ici, j’ai vérifié que cette fonction allFilesButHiden2 ne commet pas d’erreur de cette nature, sans avoir poussé l’analyse jusqu’à parfaitement comprendre pourquoi.
Le fait que son résultat soit égal à celui de allFilesButHiden1 accrédite qu’elle ne commet pas d’erreur.





7)
Ceci dit, pour que les fonctions génératrices allFilesButHiden et allFilesButHiden3 et allFilesButHiden3Tox enregistrent elles aussi les noms de dossiers et que leurs résultats soient identiques à ceux de allFilesButHiden1 et allFilesButHiden2 corrigée,
il faut ajouter dans les fonctions une ligne yield rootPath+elem :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
def allFilesButHiden3Tox(rootPath):
    rootPath += '/'
    for elem in listdir(rootPath):
        if elem[0]!=lettre and elem[-1] != '~': #[-1:] est strictement pareil à [-1]
            if isdir(rootPath+elem):
                yield rootPath+elem
                for e in allFilesButHiden3Tox(rootPath+elem):
                    yield e #les éléments retournés par la fonction sont des noms de fichiers contenant déjà le chemin
            else:
                yield rootPath+elem

8)
Ce que l’on fait avec les allFilesButHiden3Tox, allFilesButHiden et allFilesButHiden3 peut être fait aussi avec os.walk() d'une façon plus claire à saisir je trouve:
os.walk(rep).next() renvoie la même liste que os.listdir(rep), mais en répartissant les fichiers et les dossiers dans deux listes distinctes, ce qui permet d’éviter de tester si un élément de listdir() est un dossier ou non.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
def Tox_walk(rootPath):
    root,dirs,files = os.walk(rootPath).next()
    yield root
    for f in ( root + '/' +u for u in files if u[0]!=lettre and u[-1] != '~'):
            yield f
    for d in ( u for u in dirs if u[0]!=lettre):
        for elem in Tox_walk(root + '/' + d):
            yield elem

Cette fonction donne un élément de plus que les précédentes fonctions parce que contrairement aux précédentes, elle enregistre le répertoire rootPath totalement initial avec lequel on lance la fonction.

os.walk() présente la particularité par rapport à os.listdir() d'être un générateur. En outre j'ai mis dans l'écriture de Tox_walk() deux expressions génératrices.
Je pensais donc bénéficier en l’utilisant de la même rapidité que les fonctions génératrices allFilesButHiden(rootPath) et allFilesButHiden3(rootPath) de N.tox.

Mais patatras, il ressort que Tox_walk prend 73 % de temps en plus pour tourner par rapport à allFilesButHiden3Tox.

En fait, dans Tox_walk(), os.walk() établit sur tous les paths qu’on lui passe les deux listes dirs et files, même quand le path est celui d’un fichier caché.
Tandis que allFilesButHiden3Tox() évite de le faire grâce à un test préalable. Y a pas de miracle: Tox_walk() ne peut pas travailler plus et être plus rapide.....

Donc c'est entendu, la fonction génératrice de N.Tox est la meilleure. Toutefois, compte tenu de tout ce qui précède, je propose l’amélioration suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
def allFilesButHiden3ToxPlus(rootPath):
    for elem in ( rootPath+'/'+u for u in listdir(rootPath) if u[0]!=lettre and u[-1]!='~'):
        yield elem
        if isdir(elem):
            for e in allFilesButHiden3ToxPlus(elem):
                yield e

9)
Tout ceci étant dit, finalement à quoi doit servir la fonction allFilesButHiden3Tox(rootPath) qui liste les fichiers ET dossiers non cachés d’un répertoire ?

Dis moi si je me trompe: elle ne sert qu’à remplacer et accélérer la partie else: de TriResult() (correpsondant en fait à Checktous_Checkbutton_StringVar.get() == "yes" si on regarde bien).

Cependant, les deux seules fois où TriResult() est appelé (je me réfère au message # 14), c’est sur un argument (root, dirs, files) dans une boucle for root, dirs, files in os.walk(os.getcwd()):

Depuis ce message #14, tu n’as pas dit où tu en es de l’organisation de ton code. Il me semble clair que si tu laisses cette partie telle que dans #14, tu retrouves le défaut sur lequel j’ai buté avec la fonction Tox_walk(), à savoir que l’itération dans un os.walk() fait perdre de la rapidité de la fonction génératrice de N.Tox.
Je dis que c’est clair mais il faudrait le vérifier. Mais j’ai une petite flemme.





L'algorithme de ton code tel qu'on l'a vu jusqu'à présent se résume à ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
if Checkcourrant: on traite os.getcwd() en l'explorant avec listdir() selon 3 cas
    if Checktous
    elif Checkfonly
    elif Checkdonly

if Checkrepsous: on explore os.getcwd() avec walk() de TriResult
ou
if Checkperso : on explore os.environ['HOME'] avec walk() de TriResult
selon 3 cas:
    if Checkfonly
    elif Checkdonly
    else

Dans le message #13, j’ai proposé un code réorganisé se basant sur ce schéma.


Je reprends ce que j’ai ecrit pour le cas if Checkcourrant en écrivant des générateurs au lieu de listes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
    if Checkcourrant_Checkbutton_StringVar.get() == "yes":                
        if Checktous_Checkbutton_StringVar.get() == "yes":
            listresult = ( item for item in os.listdir(os.getcwd()) if items[-1] != '~' )
        elif Checkfonly_Checkbutton_StringVar.get() == "yes":
            listresult = ( item for item in os.walk(os.getcwd()).next()[2] if items[-1] != '~' )
        elif Checkdonly_Checkbutton_StringVar.get() == "yes":
            listresult = ( item for item in os.walk(os.getcwd()).next()[1] )

Il y a utilisation de os.walk() mais ce n’est pas de façon réitérée comme dans les génératrices, c’est avec un seul next(). Je pense donc que ça peut être aussi rapide que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
    if Checkcourrant_Checkbutton_StringVar.get() == "yes":                
        if Checktous_Checkbutton_StringVar.get() == "yes":
            listresult = ( item for item in os.listdir(os.getcwd()) if items[-1] != '~' )
        elif Checkfonly_Checkbutton_StringVar.get() == "yes":
            listresult = ( item for item in os.listdir(os.getcwd()) if isfile(item) and items[-1] != '~' )
        elif Checkdonly_Checkbutton_StringVar.get() == "yes":
            listresult = ( item for item in os.listdir(os.getcwd()) if isdir(item) )

Pour les deux cas if Checkrepsous: et if Checkperso : , je modifie ma proposition en utilisant des génératrices à la N.Tox:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
def allFilesButHiden3ToxPlus_fichier(rootPath):
    for elem in ( rootPath+'/'+u for u in listdir(rootPath) if u[0]!=lettre and u[-1]!='~'):
        if isdir(elem):
            for e in allFilesButHiden3ToxPlus_fichier(elem):
                yield e
        else:
            yield elem
 
def allFilesButHiden3ToxPlus_dossier(rootPath):
    for elem in ( rootPath+'/'+u for u in listdir(rootPath) if u[0]!=lettre and u[-1]!='~'):
        if isdir(elem):
            yield elem
            for e in allFilesButHiden3ToxPlus_dossier(elem):
                yield e
 
def allFilesButHiden3ToxPlus(rootPath):
    for elem in ( rootPath+'/'+u for u in listdir(rootPath) if u[0]!=lettre and u[-1]!='~'):
        yield elem
        if isdir(elem):
            for e in allFilesButHiden3ToxPlus(elem):
                yield e
 
    else:
        if Checkrepsous_Checkbutton_StringVar.get() == "yes":
            what = os.getcwd()
        if Checkperso_Checkbutton_StringVar.get() == "yes":
            what = os.environ['HOME']
 
        if Checkfonly_Checkbutton_StringVar.get() == "yes":
            listresult = allFilesButHiden3ToxPlus_fichier(what)
        elif Checkdonly_Checkbutton_StringVar.get() == "yes":
            listresult = allFilesButHiden3ToxPlus_dossier(what)
        else:
            listresult = allFilesButHiden3ToxPlus(what)

Qu'en penses-tu ?

Précédemment, je te conseillais de te mettre aux list comprehension sans attendre, mais avec tout ce qu’on t’a dit tu as plongé directement plus profond dans le langage: direct aux générateurs !!





10)
Ce qui suit dans ton code, c'est a dire l'utilisation de listresult me reste assez hermétique.

À quoi servent les lignes suivantes ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
                    RalentRecherche += 1
                    if RalentRecherche == 100:
                        IndRecherche += 1
                        if IndRecherche == 190: IndRecherche = 0
                        PgBarre.Maj_Recherche(IndRecherche)
                        RalentRecherche = 0

Pourquoi y a-t-il deux boucles for items in result: ?

Est-ce que tu peux expliquer le bazar qui se passe dans la première boucle ?

Que font ListResultRecherche.insert() et ListResultRecherche.itemconfig() dans la deuxième boucle ?
.

[PauseKawa]

Bonjour eyquem,

Je vais donc essayer de te répondre dans la limite de mes connaissances.

1) Nous parlons bien des hidden files qui sous linux commances par un .
Pour ce qui est de l'exclusion des ~ c'est pour ne pas inclure les fichiers de sauvegarde des applications.

2) Je retouche mon code dans ce sens en se moment.

3) C'est corriger par la suite.

4) Merci de reconnaitre que ma modif 19 améliore la chose.

5) C'est bien ce que je disais à N.tox. Re merci pour allFilesButHiden2.

6) C'est bien pour cela que je teste le résultat. La fonction allFilesButHiden2 donne le même résultat qu'un os.walk + un filtrage sur . et ~. J'ai fais le test avec trés peux de répertoire mais pas mal de fichiers et avec pas mal de répertoires mais quelques fichiers dedans et elle est soit égale soit plus rapide.

7) J'avais bien compris et je teste cela à l'occasion.

8) Je testerais cela aussi.

9) C'est les principes qui m'interresent. Je vais aussi toucher à cela et oui avec des list comprehension bien sur.

10) PgBarre c'est une barre de progression bidon pour faire patienter devant l'écran. Tu retrouve le code bidon un peut plus haut dans la discussion.
ListResultRecherche = Listbox(xFmResultRecherche, selectmode=EXTENDED, height=19, width=45, fg='dark slate blue', bg='white', selectforeground = 'dark slate blue') dans wiResultRecherche (Voir 14) : C'est pour afficher le résultat.

N'hésite pas si tu a d'autres commentaires. J'ai pas mal à apprendre.

@+

[tyrtamos]

Bonjour,

Je n'ai pas tout lu, mais je vois dans les codes pas mal de tests sur les noms de fichier ou de répertoires, et ça peut donc se compliquer si on augmente le nombre de critères.

Parce que j'en avais besoin pour un programme de sauvegarde, j'ai défini la fonction suivante qui permet de savoir si un nom correspond à une liste de sélections, sans être interdit par une liste d'exclusions.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
import fnmatch
 
def okselect(nf, selections=["*"], exclusions=[""]):
    ok = False
    for selection in selections:
        if fnmatch.fnmatch(nf,selection):
            ok = True
            break
    if ok:
        for exclusion in exclusions:
            if fnmatch.fnmatch(nf,exclusion):
                ok = False
                break
    return ok

Exemple d'utilisation:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
sel = ['*']
exc = ['.*','*.~']
print okselect('toto.txt',sel,exc)
print okselect('.toto.txt',sel,exc)
print okselect('toto.~',sel,exc)
True
False
False

Je ne sais pas ce que ça donne comme rapidité, mais ça permet de traiter des sélections complexes.

Tyrtamos

[eyquem]

2) Je retouche mon code dans ce sens en ce moment.

Ce qui est encore mieux que de passer en list comprehension, c’est de passer en générateur, quand ça présente un intérêt de passer à quelque chose de ce genre.


Par exemple, j’avais écrit dans le message #13 une ligne
listresult = [ item for item in os.listdir(os.getcwd()) if items[-1] != '~' ]
qui faisait de lisresult une liste, donc un objet réellement créé en mémoire.

Je l’ai remplacée par le générateur
listresult = ( item for item in os.listdir(os.getcwd()) if items[-1] != '~' )
qui débitera ses “éléments“ à la demande sans les avoir stockés préalablement.


De même , j’ai condensé deux lignes, et même 3, de la fonction allFilesButHiden3Tox en une ligne avec générateur, parce que ça rend le code plus concis:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    rootPath += '/'
    for elem in listdir(rootPath):
        if elem[0]!=lettre and elem[-1] != '~':

deviennent

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

    for elem in ( rootPath+'/'+u for u in listdir(rootPath) if u[0]!=lettre and u[-1]!='~'):

Mais des résultats plus loin montrent que ce n’est pas sans conséquences sur la vitesse.



On peut simplifier ta fonction allFilesButHiden2 selon le même principe.

5) C'est bien ce que je disais à N.tox. Re merci pour allFilesButHiden2.

Oui, ta fonction allFilesButHiden2 corrigée fonctionne correctement.
Mais allFilesButHiden3 se corrige facilement aussi.

Une fois correctement réglées toutes deux , il faut comparer les vitesses des fonctions.

C’est ce que j’ai fait avec le code suivant dans lequel on enregistre les temps minimums d'exécution au cours d' exécutions répétées:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
from os import listdir,walk
from os.path import isdir
from time import clock
 
a_explorer = 'C:\Documents and Settings\Administrator'
 
lettre = 'F'
 
print '\n\n'
 
t1,t2,t3,t4,t5,t6,t7,t8,t9,t10 = 10,10,10,10,10,10,10,10,10,10
 
for x in xrange(50):
 
    def allFilesButHiden2(rootPath):
        RepAParcourir = [rootPath]
        ListeARetourner = []
        while RepAParcourir:
            for Rep in RepAParcourir:
                for elem in listdir(Rep):
                    if elem[0]!=lettre and elem[-1:] != '~':
                        ListeARetourner.append(Rep + '/' + elem)
                        if isdir(Rep + '/' + elem):
                            RepAParcourir.append(Rep + '/' + elem)
                RepAParcourir.remove(Rep)
 
        return ListeARetourner
 
    te = clock()
    h2 = allFilesButHiden2(a_explorer)
    tf = clock()
    #print 'allFilesButHiden2',len(h2)
    t1 =  min(t1,tf-te)
    #print
 
 
 
    def allFilesButHiden2Plus(rootPath):
        RepAParcourir = [rootPath]
        ListeARetourner = []
        while RepAParcourir:
            Rep = RepAParcourir.pop(0)
            for elem in (u for u in listdir(Rep) if u[0]!=lettre and u[-1:] != '~'):
                ListeARetourner.append(Rep + '\\' + elem)
                if isdir(Rep + '\\' + elem):
                    RepAParcourir.append(Rep + '\\' + elem)
        return ListeARetourner
 
    te = clock()
    h2Plus = allFilesButHiden2Plus(a_explorer)
    tf = clock()
    #print 'allFilesButHiden2Plus',len(h2Plus)
    t2 = min(t2,tf-te)
    #print
 
 
 
 
    def allFilesButHiden(rootPath):
        rootPath += '/' # Ligne ajoutee parce que '/' doit terminer rootPath
        for elem in listdir(rootPath):
            if elem[0]!=lettre and elem[-1:] != '~':
                if isdir(rootPath+elem):
                    yield rootPath+elem
                    for e in allFilesButHiden(rootPath+elem+'/'):
                        yield rootPath+elem+'/'+e
                else:
                    yield elem
 
    te = clock()
    h0 = list(allFilesButHiden(a_explorer))
    tf = clock()
    #print 'allFilesButHiden',len(h0)
    t3 = min(t3,tf-te)
    #print
 
 
 
    def allFilesButHiden3(rootPath):
        rootPath += '/' # Ligne ajoutee parce que '/' doit terminer rootPath
        for elem in listdir(rootPath):
            if elem[0]!=lettre and elem[-1:] != '~':
                if isdir(rootPath+elem):
                    yield rootPath+elem
                    for e in allFilesButHiden3(rootPath+elem+'/'):
                        yield rootPath+elem+e
                else:
                    yield '/'+elem
 
    te = clock()
    h3 = list(allFilesButHiden3(a_explorer))
    tf = clock()
    #print 'allFilesButHiden3',len(h3)
    t4 = min(t4,tf-te)
    #print
 
 
 
    def allFilesButHiden3Tox(rootPath):
        rootPath += '/' # Ligne ajoutee parce que '/' doit terminer rootPath
        for elem in listdir(rootPath):
            if elem[0]!=lettre and elem[-1] != '~': #[-1:] est strictement pareil à [-1]
                if isdir(rootPath+elem):
                    yield rootPath+elem
                    for e in allFilesButHiden3Tox(rootPath+elem):
                        yield e #les éléments retournés par la fonction sont des noms de fichiers contenant déjà le chemin
                else:
                    yield rootPath+elem
 
    te = clock()
    h3T = list(allFilesButHiden3Tox(a_explorer))
    tf = clock()
    #print 'allFilesButHiden3Tox',len(h3T)
    t5 = min(t5,tf-te)
    #print
 
 
 
    def Tox_walk(rootPath):
        root,dirs,files = walk(rootPath).next()
        yield root
        for f in ( root + '/' +u for u in files if u[0]!=lettre and u[-1] != '~'):
                yield f
        for d in ( u for u in dirs if u[0]!=lettre):
            for elem in Tox_walk(root + '/' + d):
                yield elem 
 
 
    te = clock() 
    tw = list(Tox_walk(a_explorer))
    tf = clock()
    #print 'Tox_walk',len(tw)
    t6 = min(t6,tf-te)
    if len(tw)<30:
        for u in tw:
            print u
    #print
 
 
 
 
    def allFilesButHiden3ToxPlus(rootPath):
        for elem in ( rootPath+'/'+u for u in listdir(rootPath) if u[0]!=lettre and u[-1]!='~'):
            yield elem
            if isdir(elem):
                for e in allFilesButHiden3ToxPlus(elem):
                    yield e
 
 
    te = clock()
    h3TPlus = list(allFilesButHiden3ToxPlus(a_explorer))
    tf = clock()
    #print 'allFilesButHiden3ToxPlus',len(h3TPlus)
    t7 = min(t7,tf-te)
    if len(h3TPlus)<30:
        for we in h3TPlus:
            print we
    #print
 
 
 
    def allFilesButHiden3ToxXtra(rootPath):
        rootPath += '/'
        for elem in listdir(rootPath):
            if elem[0]!=lettre and elem[-1]!='~':
                if isdir(rootPath+elem):
                    for e in allFilesButHiden3ToxXtra(rootPath+elem):
                        yield e
                yield rootPath+elem
 
 
    te = clock()
    h3TXtra = list(allFilesButHiden3ToxXtra(a_explorer))
    tf = clock()
    #print 'allFilesButHiden3ToxXtra',len(h3TXtra)
    t8 = min(t8,tf-te)
    if len(h3TXtra)<30:
        for we in h3TXtra:
            print we
    #print
 
 
    def allFilesButHiden3ToxXtra_fichier(rootPath):
        rootPath += '/'
        for elem in listdir(rootPath):
            if elem[0]!=lettre and elem[-1]!='~':
                if isdir(elem):
                    for e in allFilesButHiden3ToxXtra_fichier(elem):
                        yield e
                else:
                    yield elem
 
 
    te = clock()
    h3TXtra_f = list(allFilesButHiden3ToxPlus_fichier(a_explorer))
    tf = clock()
    #print 'allFilesButHiden3ToxXtra_fichier',len(h3TXtra_f)
    t9 = min(t9,tf-te)
    if len(h3TXtra_f)<30:
        for we in h3TXtra_f:
            print we
    #print
 
 
 
 
    def allFilesButHiden3ToxXtra_dossier(rootPath):
        rootPath += '/'
        for elem in listdir(rootPath):
            if isdir(elem) and elem[0]!=lettre:
                yield elem
                for e in allFilesButHiden3ToxXtra_dossier(elem):
                    yield e
 
 
    te = clock()
    h3TXtra_d = list(allFilesButHiden3ToxPlus_dossier(a_explorer))
    tf = clock()
    #print 'allFilesButHiden3ToxXtra_dossier',len(h3TXtra_d)
    t10 = min(t10,tf-te)
    if len(h3TXtra_d)<30:
        for we in h3TXtra_d:
            print we
    #print
 
    print x,
 
 
print '\n'
print 'Hiden2               \t',t1,'\t\t',len(h2)
print 'Hiden2Plus           \t',t2,'\t\t',len(h2Plus)
print 'Hiden                \t',t3,'\t\t',len(h0)
print 'Hiden3               \t',t4,'\t\t',len(h3)
print 'Hiden3Tox            \t',t5,'\t\t',len(h3T)
print 'Tox_walk             \t',t6,'\t\t',len(tw)
print 'Hiden3ToxPlus        \t',t7,'\t\t',len(h3TPlus)
print
print 'Hiden3ToxXtra        \t',t8,'\t\t',len(h3TXtra)
print 'Hiden3ToxPlus_fichier\t',t9,'\t\t',len(h3TPlus_f)
print 'Hiden3ToxPlus_dossier\t',t10,'\t\t',len(h3TPlus_d)

Un résultat parmi d'autres

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
0 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 47 48 49 
 
Hiden2               	0.173702523645 		675
Hiden2Plus           	0.193326246771 		675
Hiden                	0.202255593937 		675
Hiden3               	0.201648812907 		675
Hiden3Tox            	0.188553852515 		675
Tox_walk             	0.231085794424 		676
Hiden3ToxPlus        	0.191093560774 		675
 
Hiden3ToxXtra        	0.188813103341 		675
Hiden3ToxPlus_fichier	0.190915884561 		507
Hiden3ToxPlus_dossier	0.18911342084 		168

C’est en effet le temps minimum d’une fonction qui est le plus représentatif de sa rapidité, et non pas la moyenne de diverses exécutions, qui peuvent être perturbées par des tas de choses.


Chaque résultat compare les exécutions lancées sur 'C:\Documents and Settings\Administrator' avec lettre=’F’ pour éliminer le dossier 'Favoris' de la recherche.
N’étant pas sous Linux, la condition elem[0]!=lettre remplace !=’.’



Il ressort des choses surprenantes.


- les fonctions Hiden2Plus et Hiden3ToxPlus sont systématiquement un chouya plus lentes que les fonctions simples Hiden2 et Hiden3Tox:
le fait de condenser 3 lignes, même en un générateur, n’est pas indifférent en temps.
La différence étant minime, on pourrait préférer la version condensée, mais en fait je trouve qu’elle n’est pas nécessairement plus claire.

- des essais répétés avec x in xrange(50 à 100) conduisent à des valeurs suivantes

Hiden3Tox 0.189948 0.187801 0.187490 0.187763 0.188771 0.188553 0.188192

Hiden3ToxXtra 0.189897 0.188617 0.188118 0.188728 0.189129 0.188813 0.188449

La différence est vraiment ténue, mais Hiden3Tox apparaît régulièrement comme un tantinet plus rapide.

Il semble que le code préfère avoir affaire à une partie if...else qu’à une instruction if seule suivie d’une autre instruction.



Conclusion:
la recherche de concision graphique du code n’a vraiment rien à voir avec une augmentation de la vitesse. En fait plus le code est algorithmiquement “coulant“, plus c’est rapide.

Que veut dire “coulant“ ? Ben.... j’en sais rien... c’est chaque fois à sentir de façon nouvelle..... Par ex. il vaut mieux plusieurs instructions très simple (des if..else) que des introductions de générateurs tarabiscotées.

Ça remet en question ce que j’ai pu écrire plus haut.

6) C'est bien pour cela que je teste le résultat. La fonction allFilesButHiden2 donne le même résultat qu'un os.walk + un filtrage sur . et ~. J'ai fais le test avec trés peux de répertoire mais pas mal de fichiers et avec pas mal de répertoires mais quelques fichiers dedans et elle est soit égale soit plus rapide.

Ça par contre, ça me semble clair que l’utilisation de os.walk(), avec allFilesButHiden1, va allonger les temps.

7) J'avais bien compris et je teste cela à l'occasion.

Résultat plus haut:

allFilesButHiden3Tox et allFilesButHiden3ToxXtra sont équivalentes en temps et les plus rapides.

allFilesButHiden3ToxXtra est plus concise.

8) Je testerai cela aussi.

Pas la peine de tester ma fonction Tox_walk(), c’est la plus lente de celles que j’ai comparées.

Quant à allFilesButHiden3ToxPlus avec un générateur inclus, elle est moins rapide que l’originale allFilesButHiden3Tox

9) C'est les principes qui m'intéressent. Je vais aussi toucher à cela et oui avec des list comprehension bien sûr.

Je pense que tu ne devrais pas d’abord fabriquer listresult puis ensuite itérer sur ses éléments pour un traitement subséquent,
mais que tu devrais traiter chaque item à la volée quand il est généré, au lieu de l’emmagasiner en liste. Même un générateur ne serait pas aussi bien que du tout de suite AMHA.

10) PgBarre c'est une barre de progression bidon pour faire patienter devant l'écran.

oh lui !!







Le test !=’.’ et !=’~’ n’est pas suffisamment compliqué pour justifier l’introduction de fonctions supplémentaires proposées par tyrtamos qui viendraient appesantir l’exécution à mon avis.

[tyrtamos]

Le test !=’.’ et !=’~’ n’est pas suffisamment compliqué pour justifier l’introduction de fonctions supplémentaires proposées par tyrtamos qui viendraient appesantir l’exécution à mon avis.

Oui, mais je me référais simplement au message #15 dans lequel il était évoqué la possibilité d'autres critères supplémentaires d'exclusions (*.bak, *.sos, ...).

L'inconvénient du codage actuel est qu'il faut dans ce cas rajouter des conditions dans le code, alors que la méthode proposée ne nécessite que l'ajout de motifs à la liste des exclusions.

D'ailleurs, s'il n'y a que des exclusions et pas de sélection, on peut simplifier un peu:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def okselect(nf, exclusions=[""]):
    ok = True
    for exclusion in exclusions:
        if fnmatch.fnmatch(nf,exclusion):
            ok = False
            break
    return ok
 
exc = ['.*', '*.~', '*.bak', '*.sos']
 
print okselect('toto.txt',exc)
True
print okselect('.toto.txt',exc)
False
print okselect('toto.~',exc)
False

On peut d'ailleurs faire ça en une seule ligne, ce qui donne le même résultat. :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

okselect = lambda nf, exclusions: [False for exclusion in exclusions if fnmatch.fnmatch(nf,exclusion)]==[]

Mais je ne sais pas s'il y a un avantage de vitesse, parce que la solution lambda ne permet pas de faire un break au 1er motif satisfait.

Tyrtamos

[Antoine_935]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
def okselect(nf, exclusions=[""]):
    ok = True
    for exclusion in exclusions:
        if fnmatch.fnmatch(nf,exclusion):
            ok = False
            break
    return ok

Pourquoi un argument aussi important pour la fonction (soit exclusions) est-il facultatif ? Ca n'a pas de sens.

Il y a une simplification simple possible de cette fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
def okselect(nf, exclusions):
    match = fnmatch.fnmatch
    for exclusion in exclusions:
        if match(nf,exclusion):
            return False
 
    return True

[tyrtamos]

Pour Antoine_935: ok avec les simplifications proposées.

Effectivement, j'avais fait la simplification du code précédent un peu rapidement et je ne l'ai vu qu'après coup.

Tyrtamos