listing recursif de repertoire avec x niveaux

Version imprimable

22/01/2013, 16h03
kiby56

listing recursif de repertoire avec x niveaux

Bonjour,

Je cherche un moyen de faire un listing recursif de repertoire mais pas à l'infini, sur un nombre de sous niverau donné. style :

recursList(mypath, 1) -> listing de mypath, mypath/x
recursList(mypath, 2) -> listing de mypath, mypath/x, mypath/x/x

une idée ? :calim2:
22/01/2013, 17h01
tyrtamos

Bonjour,

Oui, c'est facile.

Au 1er appel de la fonction récursive, on place 2 arguments supplémentaires:

- le niveau_maxi (=0 par défaut). Si le niveau_maxi=0, cela veut dire: profondeur maxi.

- le niveau_courant (=1 par défaut). Au 1er appel, on le laisse par défaut.

la fonction appelle les sous-répertoires seulement: si le niveau maxi est =0 ou si le niveau courant est < au niveau maxi.

Si les sous-répertoires sont appelés, l'appel récursif passe les arguments: niveau_maxi et niveau_courant+1

Ok?

Si t'a un example de code je suis preneur (je comprends bien, mais comment arreter le os.walk ?)

sinon avec glob, je viens de faire çà qui marche bien :

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
 
#!/usr/bin/env python
#-*- coding: UTF-8 -*-
 
 
import os, glob
 
def recursListPath(path, nth = 1):
    list = []
    for i in range (1, nth+1):
        currentpath = path + (i * "/*")
        for name in glob.glob(currentpath):
            list.append(name)
    return list
#
 
DirPath = r"C:\Program Files (x86)\Common Files\System"
list = recursListPath(DirPath, 2)
print "number of item:", len(list)
for item in list:
    if os.path.isfile(item):
        print "_file:", item
    if os.path.isdir(item):
        print "_dir:", item

Je n'utilise jamais walk et quelquefois glob. Je préfère utiliser os.listdir parce que je peux faire ce que je veux avec.

Voilà un petit exemple de 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
#!/usr/bin/python
# -*- coding: utf-8 -*-
from __future__ import division
# Python 2.7
 
import os
 
##############################################################################
def contenurep(rep, nivmax=0, nivcour=1):
 
    # trouver le contenu du répertoire rep
    entrees = os.listdir(rep)
    entrees.sort(key=lambda v: v.upper()) # tri sans tenir compte de la casse
    sousrep = [] # recevra les noms des sous-répertoires
    sousfic = [] # recevra les noms des fichiers
    for entree in entrees:
        if os.path.isdir(os.path.join(rep, entree)):
            sousrep.append(entree)
        else:
            sousfic.append(entree)
    # affichage
    print
    print rep
    for srep in sousrep:
        print "[R]", srep
    for sfic in sousfic:
        print sfic
    # appel récursif si demandé        
    if nivmax==0 or nivcour<nivmax:
        for srep in sousrep:
            contenurep(os.path.join(rep, srep), nivmax, nivcour+1)

Utilisation:

Code:

1
2
rep = r"C:\Python27\Lib\ctypes"
contenurep(rep, nivmax=1)

Avec l'argument nivmax=1, seul le contenu du répertoire rep sera affiché:

Code:

1
2
3
4
5
6
7
8
9
C:\Python27\Lib\ctypes
[R] macholib
[R] test
util.py
wintypes.py
_endian.py
_endian.pyc
__init__.py
__init__.pyc

Avec l'argument nivmax=2, les 2 niveaux seront affichés:

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
C:\Python27\Lib\ctypes
[R] macholib
[R] test
util.py
wintypes.py
_endian.py
_endian.pyc
__init__.py
__init__.pyc
 
C:\Python27\Lib\ctypes\macholib
dyld.py
dylib.py
framework.py
__init__.py
 
C:\Python27\Lib\ctypes\test
runtests.py
test_anon.py
test_arrays.py
test_array_in_pointer.py
test_as_parameter.py
test_bitfields.py
test_buffers.py
test_byteswap.py
test_callbacks.py
test_cast.py
test_cfuncs.py
test_checkretval.py
test_delattr.py
test_errcheck.py
test_errno.py
test_find.py
test_frombuffer.py
test_funcptr.py
test_functions.py
test_incomplete.py
test_init.py
test_integers.py
test_internals.py
test_keeprefs.py
test_libc.py
test_loading.py
test_macholib.py
test_memfunctions.py
test_numbers.py
test_objects.py
test_parameters.py
test_pep3118.py
test_pickling.py
test_pointers.py
test_prototypes.py
test_python_api.py
test_random_things.py
test_refcounts.py
test_repr.py
test_returnfuncptrs.py
test_simplesubclasses.py
test_sizes.py
test_slicing.py
test_stringptr.py
test_strings.py
test_structures.py
test_struct_fields.py
test_unaligned_structures.py
test_unicode.py
test_values.py
test_varsize_struct.py
test_win32.py
__init__.py

Et avec nivmax=0 ou non cité dans l'appel, l'affichage traitera toute la profondeur de l'arbre.

01/10/2013, 00h31
marco056
Bonsoir,
Le dernier code est excellent !
Je débute un peu en python et je souhaiterais copier par exemple tous les fichiers .txt listés précédemment dans les répertoire et sous-répertoires et les déplacer dans un autre répertoire (par exemple Copie) qui contiendra, lui, tous les fichiers txt.

Je suis un peu perdu et je m'égare peut-être en voulant utiliser :

Code:

shutil.copy('*.txt',"Copie/")

Est-ce la bonne voie ?
Faut-il le faire dans la boucle :
Code:

1 2 for sfic in sousfic: print(sfic)
?
A bientôt.
01/10/2013, 06h38
tyrtamos

Bonjour,

@marco056

C'est un problème différent sur plusieurs points:

- ce n'est plus un listing, mais une copie: il faut donc passer un répertoire destination dans la fonction récursive. Attention: il ne faudra pas seulement copier les fichiers, mais aussi créer les sous-répertoires autant que nécessaire.

- il y a un joker (="wildcard") comme "*.txt" qu'il faut tester avant de faire la copie, et qu'il faut donc passer dans la fonction récursive. Pour ce test, j'utilise la fonction fnmatch du module fnmatch

- par ailleurs, tu parles de "déplacer" les fichiers, je suppose que c'est plutôt "copier". Sinon, il faudrait aussi supprimer les fichiers copiés de la source.

- enfin, je ne sais pas si ta copie demande la notion de "niveaux" comme le code plus haut le demandait.

Pour répondre à ta question sur shutil: shutil.copy demande pour sa source un nom de fichier sans joker et avec son chemin. Pour la destination, si c'est un répertoire, le fichier est recopié avec le même nom, sinon, il faut donner le nouveau nom du fichier avec son chemin. Mais je suis en train de reproduire le manuel...

Si ça ne te suffit pas, précise ta demande. Si elle ne nécessite pas de "niveaux" (point important qui justifie ce fil), il faut créer une nouvelle question.
01/10/2013, 09h43
grim7reaper
Bonjour,

Citation:

Envoyé par kiby56

une idée ? :calim2:

Oui, c’est assez simple en fait.
Pas besoin de récursivité ici (surtout que la récursivité est très mal géré en Python…).
Pour lister un niveau il suffit de faire :

Code:

glob('*')

Pour 2 niveaux :

Code:

glob('*/*')

Pour 3 niveaux :

Code:

glob('*/*/*')

Si on connais la profondeur, il suffit donc de générer la bonne chaîne et de faire un glob dessus :
Code:

1 2 3 4 5 from glob import glob from os.path import join def listdir_depth(directory='.', depth=1): return glob(join(directory, *(['*']*depth)))

Merci tyrtamos, tu m'as donné une bonne piste avec fnmatch.

Je mets mon code au as ou cela intéresserait quelqu'un ...

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
 
import os
import os.path
import shutil
import fnmatch
 
rep_source = ['/home/Musique/'] # Liste des répertoires source
rep_exclus = [] # sous-répertoire à exclure
rep_dest = '/home/Copie/' # Liste des répertoires destination
type_fichier = ['*.mp3', '*.jpg'] # par exemple
 
for repertoire in rep_source:
	for root, repertoires, fichiers in os.walk(repertoire):
		# Parcours récursif des répertoires
		for dir in rep_exclus:
			# On parcourt les répertoires exclus
			if dir in dirs:
				dirs.remove(dir)
				# On enlève les répertoires exclus
		if not os.path.exists(rep_dest):
			os.makedirs(rep_dest)
			# créé le répertoire destination si besoin
		for chaque_type in type_fichier:
			for fichier in fnmatch.filter(fichiers, chaque_type):
				# filtre les fichiers à copier
				print(fichier) # écrit les fichiers
				shutil.copy2(os.path.join(root, fichier), rep_dest)
				#copie les fichiers