Discussion :

[PauseKawa]

Bonjour,

J'ai une class pour rechercher des fichiers ou dossiers et j'ai un petit souci de lenteur dans la rapidité de mes traitements. J'utilise os.listdir ou os.walk suivant les options choisis par l'utilisateur mais dans le cadre d'un os.walk le temps de tri sur les résultats est bien trop important par rapport à l'os.walk en lui même (c'est visible au niveau du temps de traitement et au voyant d'activité du disque).

Voici comment cela se passe :

Dans un premier temps j'ai un Toplevel Tkinter (mais ce n'est pas le sujet) wiClassRechercher avec des Checkbutton pour définir des options de recherche ([img=http://img171.imageshack.us/img171/6343/interfce.th.png])
Après validation et d'après les StringVar je fais un wiClassRechercher.withdraw() et je crée un Toplevel wiResultRecherche que je withdraw aussi dans l'attente de mes résultats.

Donc pour en venir au traitement proprement dit je procède de cette manière :

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
                if Checkcourrant_Checkbutton_StringVar.get() == "yes":
                    listresult = []
                    listtmp = os.listdir(os.getcwd())
                    for items in listtmp:
                        CheminItem = os.path.join(os.getcwd(), items)
                        if CheminItem == CheminItem.replace('/.','/'):
                            if Checktous_Checkbutton_StringVar.get() == "yes" and items[-1] != '~':
                                listresult.append(CheminItem)
                            elif Checkfonly_Checkbutton_StringVar.get() == "yes" and items[-1] != '~' and os.path.isfile(CheminItem):
                                listresult.append(CheminItem)
                            elif Checkdonly_Checkbutton_StringVar.get() == "yes" and os.path.isdir(CheminItem):
                                listresult.append(CheminItem)
                elif Checkrepsous_Checkbutton_StringVar.get() == "yes":
                    listresult = []
                    for root, dirs, files in os.walk(os.getcwd()):
                        RalentRecherche += 1
                        if RalentRecherche == 100:
                            IndRecherche += 1
                            if IndRecherche == 190: IndRecherche = 0
                            PgBarre.Maj_Recherche(IndRecherche)
                            RalentRecherche = 0
                        TriResult(root, dirs, files)
                elif Checkperso_Checkbutton_StringVar.get() == "yes":
                    listresult = []
                    for root, dirs, files in os.walk(os.environ['HOME']):
                        RalentRecherche += 1
                        if RalentRecherche == 100:
                            IndRecherche += 1
                            if IndRecherche == 190: IndRecherche = 0
                            PgBarre.Maj_Recherche(IndRecherche)
                            RalentRecherche = 0
                        TriResult(root, dirs, files)
                for items in listresult:
                    RalentRecherche += 1
                    if RalentRecherche == 100:
                        IndRecherche += 1
                        if IndRecherche == 190: IndRecherche = 0
                        PgBarre.Maj_Recherche(IndRecherche)
                        RalentRecherche = 0
                    if Checkcomplet_Checkbutton_StringVar.get() == "yes":
                        if Checkcase_Checkbutton_StringVar.get() == "yes" and str(os.path.basename(items)) == str(Entry_Recherche_StringVar.get()):
                            result.append(items)
                        elif Checkcase_Checkbutton_StringVar.get() == "no" and str(os.path.basename(items)).lower() == str(Entry_Recherche_StringVar.get()).lower():
                            result.append(items)
                    else:
                        if len(str(Entry_Recherche_StringVar.get())) < len(str(os.path.basename(items))) + 1:
                            Val_Ind = 0
                            while (Val_Ind < len(str(os.path.basename(items)))-len(str(Entry_Recherche_StringVar.get())) + 1):
                                if Checkcase_Checkbutton_StringVar.get() == "yes":
                                    if str(os.path.basename(items))[Val_Ind:len(str(Entry_Recherche_StringVar.get()))+Val_Ind] == str(Entry_Recherche_StringVar.get()):
                                        result.append(items)
                                        break
                                else:
                                    if str(os.path.basename(items))[Val_Ind:len(str(Entry_Recherche_StringVar.get()))+Val_Ind].lower() == str(Entry_Recherche_StringVar.get()).lower():
                                        result.append(items)
                                        break
                                Val_Ind += 1 
                for items in result:
                    RalentRecherche += 1
                    if RalentRecherche == 100:
                        IndRecherche += 1
                        if IndRecherche == 190: IndRecherche = 0
                        PgBarre.Maj_Recherche(IndRecherche)
                        RalentRecherche = 0
                    ListResultRecherche.insert(END, items)
                    if os.path.isfile(items):
                        ListResultRecherche.itemconfig(ListResultRecherche.size() - 1, fg='#2a7aff', selectforeground = '#2a7aff')
                wiResultRecherche.deiconify()
                wiClassRechercher.destroy()

Ce qui me fais déjà un traitement de trois listes plus le Def TriResult que voici... :

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
            def TriResult(root, dirs, files):
                if Checkfonly_Checkbutton_StringVar.get() == "yes":
                    for items in files:
                        CheminFiles = os.path.join(root, items)
                        if CheminFiles == CheminFiles.replace('/.','/') and items[-1:] != '~':
                            listresult.append(CheminFiles)
                elif Checkdonly_Checkbutton_StringVar.get() == "yes":
                    for items in dirs:
                        CheminDir = os.path.join(root, items)
                        if CheminDir == CheminDir.replace('/.','/'):
                            listresult.append(CheminDir)
                else:
                    for items in files:
                        CheminFiles = os.path.join(root, items)
                        if CheminFiles == CheminFiles.replace('/.','/') and items[-1:] != '~':
                            listresult.append(CheminFiles)
                    for items in dirs:
                        CheminDir = os.path.join(root, items)
                        if CheminDir == CheminDir.replace('/.','/'):
                            listresult.append(CheminDir)

Pour ce qui est de PgBarre ([img=http://img406.imageshack.us/img406/1214/captureah.th.png]) j'ai mis cela en place le temps de trouver une solution pour accélérer tout cela (et faire patienter l'utilisateur). En voici toutefois le code :

Code :

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

PgBarre = BarreProgress(IndRecherche, lanceur)

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
class BarreProgress(Toplevel):
 
    def __init__(self, IndRecherche, lanceur):
        Toplevel.__init__(self, IndRecherche)
        self.withdraw()
        global TmpAttendCanvas
        global BarreBleu
        global wiTmpAttend
        if lanceur == 'Zip': # Non utiliser pour le moment.
            TextBarre = u'Archivage en cours...'
        elif lanceur == 'Recherche':
            TextBarre = 'Recherche en cours...'
        elif lanceur == 'Tempo':
            TextBarre = u'Vérification en cours...'
        wiTmpAttend = Toplevel()
        wiTmpAttend.overrideredirect(1)
        wt = wiTmpAttend.winfo_screenwidth()
        ht = wiTmpAttend.winfo_screenheight()
        wiTmpAttend.geometry("%dx%d+%d+%d" % (200,90, (wt-200)/2, (ht-90)/2 ) )
        BordureTmpAttend = Frame(wiTmpAttend, bd=2, relief=GROOVE)
        BordureTmpAttend.place(x=1, y=1, relwidth = 1, relheight = 1, bordermode="inside")
        Label(BordureTmpAttend, fg = "red", text = os.linesep + TextBarre + os.linesep).pack(side=TOP)
        TmpAttendCanvas = Canvas(BordureTmpAttend, height=20, width=180, bg='white', bd=2, relief=SUNKEN)
        TmpAttendCanvas.pack(side=TOP)
        BarreBleu = TmpAttendCanvas.create_rectangle((IndRecherche, 0, 20 + IndRecherche, 20), outline='#2a7aff',fill='#2a7aff', width=2)
 
    def Maj_Recherche(self, IndRecherche):
        TmpAttendCanvas.coords(BarreBleu, (IndRecherche, 0, 20 + IndRecherche, 20))
        TmpAttendCanvas.update_idletasks()
 
    def BarreQuit(self):
        wiTmpAttend.destroy()

Et pour finir j'affiche donc mon Toplevel wiResultRecherche ([img=http://img30.imageshack.us/img30/2971/capture1u.th.png]).

Comment réduire tous ses traitements ? En fait j'ai besoin des résultats du tri de la liste précédente pour la filtrer sur la suivante donc je cale sur la manière de procéder...

Pour la partie :

Code :

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

1
2
3
4
5
6
7
8
9
                else:
                    for items in files:
                        CheminFiles = os.path.join(root, items)
                        if CheminFiles == CheminFiles.replace('/.','/') and items[-1:] != '~':
                            listresult.append(CheminFiles)
                    for items in dirs:
                        CheminDir = os.path.join(root, items)
                        if CheminDir == CheminDir.replace('/.','/'):
                            listresult.append(CheminDir)

j'ai bien penser aux threads, un pour files et un pour dirs, mais est il raisonnable de faire cela sur la même liste ? (Je n'ai pas l'habitude des threads)

Merci

[Antoine_935]

Si j'ai bien compris, tu veux lister les fichiers et dossiers non cachés.
Or, os.walk va tout faire, sans exception.
Le mieux serait de tenir deux listes:
1. les éléments trouvés
2. les éléments à explorer

Tu démarres alors en mettant le dossier de base dans la liste à explorer, et tant qu'il y a des éléments dans cette liste, tu explores.
Et quand tu trouves un dossier non caché, tu le rajoutes à cette liste.
Enfin, je dis liste, mais du coup tu t'en servirais comme une queue.
De cette manière, tu évites de te plonger dans les méandres des dossiers cachés, c'est déjà ça de gagné.


De plus, ta fonction TriResult est un peu mal nommée puisqu'il s'agit plus d'un filtrage que d'un tri, mais c'est vrai que "tri" est asse vague.

Tu pourrais simplifier la condition suivante, et du coup supprimer le os.path.join

Code :

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

1
2
3
4
5
6
7
8
9
10
CheminFiles == CheminFiles.replace('/.','/')
# Tu sais que tu fais toujours un os.path.join avec le root.
# Donc, si le root n'est pas caché, il est inutile de le vérifier une fois encore
# On peut donc simplifier par ceci:
item[0] == '.'
 
# Aussi,
item[-1:]
# est équivalent, mais peut-être un rien plus lent à
item[-1]

Toujours dans TriResult, tu accèdes à une variable listresult. Est-elle en scope global, ou de classe ? C'est plus efficace de la prendre en variable locale. Ou mieux, tu peux juste garder une référence vers sa méthode append

Code :

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

1
2
3
append = listresult.app
append(1)
append(2)

Aussi, tu pourrais utiliser la fonction filter à la place de tes boucles for. Ca aurait en tout cas pour effet de simplifier ton code, et sans doute de le rendre plus rapide


Il serait possible de tirer parti des threads pour ce traitement, en théorie du moins. Hélas Python a ce qu'on appelle un GIL qui rend les threads standard de python complètement inutiles pour améliorer les performances. Il existe le module multiprocessing, qui pourrait t'aider, mais ce n'est pas une solution miracle.

[PauseKawa]

Ce n'est pas le root mais le résultat d'un for root, dirs, files in os.walk(item).
C'est donc le chemin jusqu'à un répertoire (qui se trouve dans la liste dirs) ou un fichier (stocké dans files).
A un moment donné le chemin risque de se retrouver dans un répertoire caché, surtout si c'est un os.walk sur os.environ['HOME'] ou l'on retrouve les dossiers de configuration des applications.
J'occulte donc ses résultats.

[PauseKawa]

Si j'ai bien compris, tu veux lister les fichiers et dossiers non cachés.
Or, os.walk va tout faire, sans exception.
Le mieux serait de tenir deux listes:
1. les éléments trouvés
2. les éléments à explorer

Tu démarres alors en mettant le dossier de base dans la liste à explorer, et tant qu'il y a des éléments dans cette liste, tu explores.
Et quand tu trouves un dossier non caché, tu le rajoutes à cette liste.
Enfin, je dis liste, mais du coup tu t'en servirais comme une queue.
De cette manière, tu évites de te plonger dans les méandres des dossiers cachés, c'est déjà ça de gagné.

L'idée est bonne mais de la à la mettre en pratique...
Je vais réfléchir à la chose bien que pour le moment je ne vois pas comment procéder.

Tu pourrais simplifier la condition suivante, et du coup supprimer le os.path.join
[code]CheminFiles == CheminFiles.replace('/.','/')

Ce n'est valable que si je supprime la recherche dans les dossiers cachés comme dit si dessus et dans ce cas je n'ai qu'a faire la vérification sur les fichiers.

Toujours dans TriResult, tu accèdes à une variable listresult. Est-elle en scope global, ou de classe ? C'est plus efficace de la prendre en variable locale. Ou mieux, tu peux juste garder une référence vers sa méthode append

Code :

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

1
2
3
append = listresult.app
append(1)
append(2)

C'est une locale du parent.

Aussi, tu pourrais utiliser la fonction filter à la place de tes boucles for. Ca aurait en tout cas pour effet de simplifier ton code, et sans doute de le rendre plus rapide


Il serait possible de tirer parti des threads pour ce traitement, en théorie du moins. Hélas Python a ce qu'on appelle un GIL qui rend les threads standard de python complètement inutiles pour améliorer les performances. Il existe le module multiprocessing, qui pourrait t'aider, mais ce n'est pas une solution miracle.

Bon, il ne reste qu'a tester tout cela (si je trouve ).

Merci pour les idées en tout cas.

[Antoine_935]

Ce n'est valable que si je supprime la recherche dans les dossiers cachés comme dit si dessus et dans ce cas je n'ai qu'a faire la vérification sur les fichiers.

Non, c'est quand même toujours le même dossier avec lequel tu fais le os.path.join. Si vraiment tu tiens à faire cette vérification, fais le une seule fois en début de fonction, mais pas pour chaque fichier.

C'est une locale du parent.

Euh... j'en devine que c'est une variable de classe ? ou alors tu as une closure, ou euh...
En tous les cas, l'accès aux variables locales (locales locales... direct quoi, ya pas d'autres locales) est toujours plus rapide que les autres accès.

[PauseKawa]

Non, c'est quand même toujours le même dossier avec lequel tu fais le os.path.join. Si vraiment tu tiens à faire cette vérification, fais le une seule fois en début de fonction, mais pas pour chaque fichier.

C'est la que je ne trouve pas comment faire : comment parcourir un répertoire et ses sous répertoires en excluant les dossiers cachés (et ne pas les parcourirs) et inclure cela dans une liste.

Euh... j'en devine que c'est une variable de classe ? ou alors tu as une closure, ou euh...
En tous les cas, l'accès aux variables locales (locales locales... direct quoi, ya pas d'autres locales) est toujours plus rapide que les autres accès.

Code :

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

1
2
3
4
5
6
    Def parent(...):
 
        Def enfant(...):
             traite x
 
        x = cequetuveux

[N.tox]

C'est la que je ne trouve pas comment faire : comment parcourir un répertoire et ses sous répertoires en excluant les dossiers cachés (et ne pas les parcourirs) et inclure cela dans une liste.

Une fonction récursive parait on ne peut plus adaptée :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
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

Elle est peut-être à modifier légèrement, cause je suis parti de l'hypothèse que tu ne voulais pas non plus obtenir les FICHIERS cachés

exemple d'utilisation :

Code :

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

not_hidden_files=list(allFilesButHiden('~/'))

[eyquem]

Hello,

Je ne comprends pas l’idée à l’origine du test

Code :

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

if CheminItem == CheminItem.replace('/.','/'):

J’ai fait

Code :

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

1
2
3
4
5
os.chdir('C:\Documents and Settings\Administrator')
listtmp = os.listdir(os.getcwd())
for items in listtmp:
    CheminItem = os.path.join(os.getcwd(), items)
    print CheminItem, CheminItem == CheminItem.replace('/.','/')

et j’obtiens des CheminItem == CheminItem.replace('/.','/') égaux à True pour TOUS les fichiers et dossiers,
alors qu’il y a des fichiers et dossiers cachés dans ce répertoire.


Antoine, qu’est ce qui te fait penser que Kawa veut lister les fichiers et dossiers non cachés, stp ?

[Antoine_935]

Pour ne parcourir que les fichiers et dossiers non cachés, il te suffit de ne pas utiliser os.walk, mais plutôt os.listdir. Ce dernier n'est pas récursif.
Donc, pour chaque dossier que tu listes, tu dois retrouver les sous dossiers qui ne sont pas cachés, et les rajouter à la liste des éléments devant être explorés.

Exemple rapide:

Code :

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

1
2
3
4
5
6
7
8
aExplorer = []
aExplorer.append(leDossierDeBase)
 
while aExplorer:
    dossierAVisiter = aExplorer.sortirPremierElement()
    dossiers, fichiers = lireDossier(dossierAVisiter)
 
    aExplorer.ajouterLesDossiersNonCachés(dossiers)

Code :

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

1
2
3
4
5
6
    Def parent(...):
 
        Def enfant(...):
             traite x
 
        x = cequetuveux

Tu as donc une closure (ou "fermeture" en français). listresult n'est donc plus une variable locale, et son accès est plus lent.

Antoine, qu’est ce qui te fait penser que Kawa veut lister les fichiers et dossiers non cachés, stp ?

Sous linux (et *nix en général), les fichiers cachés sont marqués par un nom commençant par un point.

Code :

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

1
2
3
4
In [8]: path = "/home/antoine/.gimp"
 
In [9]: path.replace("/.", "/")
Out[9]: '/home/antoine/gimp'

[PauseKawa]

Hello,

Je ne comprends pas l’idée à l’origine du test

Code :

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

if CheminItem == CheminItem.replace('/.','/'):

J’ai fait

Code :

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

1
2
3
4
5
os.chdir('C:\Documents and Settings\Administrator')
listtmp = os.listdir(os.getcwd())
for items in listtmp:
    CheminItem = os.path.join(os.getcwd(), items)
    print CheminItem, CheminItem == CheminItem.replace('/.','/')

et j’obtiens des CheminItem == CheminItem.replace('/.','/') égaux à True pour TOUS les fichiers et dossiers,
alors qu’il y a des fichiers et dossiers cachés dans ce répertoire.


Antoine, qu’est ce qui te fait penser que Kawa veut lister les fichiers et dossiers non cachés, stp ?

Bonjour eyquem,

Puisque Antoine_935 est timide j'en profite pour te recommander cette lecture : http://www.developpez.net/forums/d80...r/#post4626592