Comparaison de noms de fichiers avec recherche aussi approximative

Version imprimable

Bonjour,

Je commence en Python.
Après un essai en batch j'ai vite vu les limites.

Je voulais comparer des noms de fichiers avec des extensions différentes.
Déplacer les fichiers avec un nom identique dans un même répertoire.
Après j'ai des fichiers qui sont presque identiques et j'arrive pas plus que çà à gérer :/

Voici mon code ... un peu d'indulgence et des conseils pour optimiser et apprendre ... merci

listdir (dossier,fic,extension):
Fais la liste des fichiers d'un dossier avec une extension particulière.
Vire ceux qui n'ont pas l'extension recherchée
Renomme l'extension en minuscule

compare(dirRom,dirVid,ficRom,ficVid):
Compare les noms de fichiers stockés dans un fichier txt et les tri

Mon problème dans mes fichiers j'ai deux fichiers ROMS "Airwolf (J).zip" "Airwolf (UE).zip" et un fichier vidéo Airwolf.flv.
Comme on le voit dans le code j'ai essayé avec "IN" et "str.find" mais rien à faire aucune commande ne trouve ...
Ah tiens je ne sais pas non plus crée une arborescence en une fois :/

Help me !!

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
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
 
import os
import shutil
import sys
import time
import string
 
tps1 = time.clock()
chemin= os.path.dirname(sys.argv[0]) #chemin de lancement du script
 
def listdir (dossier,fic,extension):
 
    path=chemin+"\\"+ dossier #chemin de lancement du script + dossier
    if not os.path.isdir(chemin+"\\Poubelle\\"): #vérifie l'existence du répertoire
        os.mkdir(chemin+"\\Poubelle\\", 777) #créé le répertoire
    if not os.path.isdir(chemin+"\\Poubelle\\"+fic): #vérifie l'existence du répertoire
        os.mkdir(chemin+"\\Poubelle\\"+fic, 777) #créé le répertoire
 
    SrcDest = open(chemin+"\\"+fic+".txt","w" ) #ouverture du fichier à la racine
 
    for dirname,subdirs,files in os.walk(path,False):
        for name in files:
            ext = os.path.splitext(name) #extension du fichier en cours
 
            #test l'extension du fichier en cours
            if ext[1] == extension: # si strictement identique (casse comprise)
                SrcDest.write(ext[0]+"\n") #écriture dans le fichier à la racine
            elif ext[1].lower() == extension: # si identique après passage en minuscule
                shutil.move(path+"\\"+ext[0]+ext[1],path+"\\"+ext[0]+ext[1].lower())
                #renomme le fichier correctement avec la casse
            else: # sinon
                shutil.move(path+"\\"+name, chemin+"\\Poubelle\\"+fic+"\\"+name)
                #déplace le fichier dont l'extension n'est pas correcte
    SrcDest.close() # ferme le fichier
 
def compare(dirRom,dirVid,ficRom,ficVid):
    if not os.path.isdir(chemin+"\\Bon"): #vérifie l'existence du répertoire
        os.mkdir(chemin+"\\Bon", 777) #créé le répertoire
 
    SrcRom=open(chemin+"\\"+ficRom,"r") #ouvre le fichier des noms de roms
    SrcVid=open(chemin+"\\"+ficVid,"r") #ouvre le fichier des noms des vidéos
 
    roms = SrcRom.readlines() #récupère les lignes du fichier
    vids = SrcVid.readlines()
 
    SrcRom.close() #ferme le fichier
    SrcVid.close()
    i=0
    for rom in roms:
        i=0
        for vid in vids:
            i = i+1
            #print("str.find(rom,vid)",str.find(rom,vid))
            #print("str.find(vid,rom)",str.find(vid,rom))
            if rom == vid: #la rom A une vidéo associée
                shutil.move(dirRom+"\\"+rom[:len(rom)-1]+".zip",chemin+"\\Bon\\"+rom[:len(rom)-1]+".zip")
                shutil.move(dirVid+"\\"+vid[:len(vid)-1]+".flv",chemin+"\\Bon\\"+vid[:len(vid)-1]+".flv")
                #break
            elif str.find(rom,vid) !=-1:
                print("Roms:",rom,"Videos:",vid)
            elif str.find(vid,rom) !=-1:
                print("Videos:",vid,"Roms:",rom)
            #elif rom in vid:
                #print("Roms:",rom,"Videos:",vid)
            #elif vid in rom:
                #print("Videos:",vid,"Roms:",rom)
 
            #elif rom != vid and i == len(vids): #la rom N'a PAS de vidéo associée
 
listdir("Roms","Roms",".zip")
listdir("Videos","Videos",".flv")
listdir("Images\\Artwork2","Pochettes",".png")
listdir("Images\\Artwork3","Cassettes",".png")
compare(chemin+"\\Roms",chemin+"\\Videos","Roms.txt","Videos.txt")
 
 
tps2 = time.clock() 
print ("Fini en ",tps2-tps1," sec.")

Bonjour,

Je ne suis pas sûr d'avoir compris ce qui était cherché, mais voici au moins une idée:

Pour obtenir la liste de tous les fichiers d'une arborescence du disque, voilà comment on peut faire:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import os
from fnmatch import filter
 
#############################################################################
def cherchefichiers(repertoire, nomfichier="*"):
    """cherche tous les fichiers du répertoire et de ses sous-répertoires 
       dont le nom satisfait au nomfichier. Ce nom peut être un "wildcard", 
       voire plusieurs séparés par un ';'. Exemples: 
         "*.txt", "*toto??.exe", "titi*.exe;titi*.bat"
    """
    motifs = nomfichier.split(';')
    listfics, listerr = [], []
    for rep, sousreps, fics in os.walk(repertoire, onerror=lambda r: listerr.append(str(r))):
        for motif in motifs:
            for fic in filter(fics, motif):
                listfics.append(os.path.join(rep, fic))
    return listfics, listerr

Les noms de fichiers cherchés peuvent être décrits avec "wildcard". Par exemple:
- "*.exe" donnera tous les fichiers avec l'extension "exe".
- "Airwolf*.zip" donnera tous les fichiers commençant par "Airwolf" avec l'extension "zip".

Il est possible d'avoir plusieurs motifs séparés par un ';'. Par exemple: "*.exe;*.bat".

Utilisation:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    repertoire = r"c:\python34"
 
    fichiers, listerr = cherchefichiers(repertoire, "*.exe;*.bat")
 
    for fichier in fichiers:
        print(fichier)
    print()
 
    if listerr==[]:
        print("Pas d'erreur")
    else:
        print("Erreurs:")
        for fichier in listerr:
            print(fichier)

Ce qui donnera tous les exécutables de Python::

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
c:\python34\python.exe
c:\python34\pythonw.exe
c:\python34\Removepywin32.exe
c:\python34\Lib\ctypes\macholib\fetch_macholib.bat
c:\python34\Lib\distutils\command\wininst-10.0-amd64.exe
c:\python34\Lib\distutils\command\wininst-10.0.exe
...
...
c:\python34\Scripts\epylint.bat
c:\python34\Scripts\pylint-gui.bat
c:\python34\Scripts\pylint.bat
c:\python34\Scripts\pyreverse.bat
c:\python34\Scripts\symilar.bat

On peut, bien sûr, sur la même base faire des recherches plus poussées. Par exemple avec des expressions régulières. Mais ce n'est plus la même complexité...

Merci pour tes pistes çà m'a donné plein d'idées notamment les expressions régulières par contre c'est pas super évident ;)

Bon du coup c'était chaotique mon code j'ai simplifié en modifiant mon approche.

Je nettoie d'abord ma liste de fichier en enlevant pour l'instant tous ce qui entre crochet, je vire les espaces superflus et je met les extensions en minuscule en passant.
Je stocke tout çà dans des fichiers pour avoir une trace et faire ma recherche.
Elle en est simplifiée du coup.

J'ai trouvé comment créer une arborescence en une fois dans la FAQ :p

Ma question est comment recherché les ressemblances.
Je check tout et je met dans un nouveau fichier et je le montre les ressemblances à l'utilisateur pour qu'il tri à la main ???
Parce que le souci je ne peux pas m'arrêter à la première ressemblance parce qu'il y en a souvent d'autre derrière :/

Voici mon 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
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
import os
import shutil
import sys
import time
import re
 
tps1 = time.clock()
racine= os.path.dirname(sys.argv[0]) #chemin de lancement du script
 
def nettoyage(dossier,fichier,extension):
    chemin = racine+"\\"+dossier
 
    if not os.path.isdir(racine+"\\Poubelle\\"+dossier): #vérifie l'existence du répertoire
        os.makedirs(racine+"\\Poubelle\\"+dossier, 777) #créé le ou les répertoires
 
    SrcDest = open(racine+"\\"+fichier+".txt","w" ) #ouverture du fichier à la racine
 
    regex=re.compile(r"(\[(.)*\])") #expression régulière compilée qui recherche ce qu'il y a entre crochets
 
    for dirname,subdirs,files in os.walk(chemin,False):
        for name in files:
            nomsplit = os.path.splitext(name) #extension du fichier en cours
 
            ss_espaces=nomsplit[0].strip() #On enlève les espaces superflus
 
            if regex.search(ss_espaces) is not None:
                crochets=re.search(regex, ss_espaces).groups() #Permet de savoir ce qu'il y a entre crochets
                ss_crochets=ss_espaces.replace(crochets[0],"") #Supprime ce qu'il y a entre crochets
                ss_espaces=ss_crochets.strip() #On enlève les espaces superflus
                shutil.move(chemin+"\\"+nomsplit[0]+nomsplit[1],chemin+"\\"+ss_espaces+nomsplit[1])
                #Renomme le fichier avec le nom sans crochets
            else:
                ss_espaces=nomsplit[0].strip() #On enlève les espaces superflus
 
            if nomsplit[1] == extension: #extension identique
                SrcDest.write(ss_espaces+"\n") #écriture dans le fichier à la racine
            elif nomsplit[1].lower() == extension: #extension identique sauf casse
                shutil.move(chemin+"\\"+nomsplit[0]+nomsplit[1],chemin+"\\"+ss_espaces+nomsplit[1].lower())
                #On met l'extension du fichier en minuscule
                SrcDest.write(ss_espaces+"\n") #écriture dans le fichier à la racine
            elif nomsplit[1] != extension:
                shutil.move(chemin+"\\"+name, racine+"\\Poubelle\\"+dossier+"\\"+name)
                #déplace le fichier dont l'extension n'est pas correcte
 
    SrcDest.close() # ferme le fichier
 
#A FAIRE plus de nettoyage dans les noms de fichiers          
 
def compare(dirRom,dirVid,ficRom,ficVid):
    if not os.path.isdir(racine+"\\Bon"): #vérifie l'existence du répertoire
        os.mkdir(racine+"\\Bon", 777) #créé un répertoire
 
    roms = [line.strip() for line in open(racine+"\\"+ficRom, 'r')]
    vids = [line.strip() for line in open(racine+"\\"+ficVid, 'r')]
 
    for rom in roms:
        for vid in vids:
            if rom == vid: #la rom A une vidéo associée
                shutil.move(dirRom+"\\"+rom[:len(rom)]+".zip",racine+"\\Bon\\"+rom[:len(rom)]+".zip")
                shutil.move(dirVid+"\\"+vid[:len(vid)]+".flv",racine+"\\Bon\\"+vid[:len(vid)]+".flv")
                break
            else:
                if rom in vid:
                    print("Roms:",rom)
                    print("Videos:",vid)
                elif vid in rom:
                    print("Videos:",vid)
                    print("Roms:",rom)
            #elif rom != vid and i == len(vids): #la rom N'a PAS de vidéo associée
#A FAIRE chercher des ressemblances
 
#Nettoyage des répertoires
    #On enlève les espaces superflus
    #On enlève ce qui a entre crochets
    #On met les extensions en minuscules
nettoyage("Roms","Roms",".zip")
nettoyage("Videos","Videos",".flv")
#nettoyage("Images\\Artwork2","Pochettes",".png")
#nettoyage("Images\\Artwork3","Cassettes",".png")
 
compare(racine+"\\Roms",racine+"\\Videos","Roms.txt","Videos.txt")
 
 
tps2 = time.clock() 
print ("Fini en ",tps2-tps1," sec.")

Un exemple:
Dans roms.txt j'ai:
Airwolf (J)
Airwolf (UE)
et dans Videos.txt j'ai:
Airwolf

Le problème c'est que j'analyse ligne par ligne.
Arrivé à "Airwolf (J)" si je modifie le nom de la rom comme la video ok
mais quand je vais passer sur "Airwolf (UE) et que je remodifie ouille

Et comment faire que çà soit l'utilisateur qui check ?

Merci d'avance