Python glob plusieurs types de fichiers

Est-il une meilleure façon d'utiliser glob.glob en python pour obtenir une liste de plusieurs types de fichier comme .txt, .mdown, et .markdown? Maintenant j'ai quelque chose comme ceci:

projectFiles1 = glob.glob( os.path.join(projectDir, '*.txt') )
projectFiles2 = glob.glob( os.path.join(projectDir, '*.mdown') )
projectFiles3 = glob.glob( os.path.join(projectDir, '*.markdown') )
InformationsquelleAutor Raptrex | 2010-12-31
  1. 116

    Peut-être il ya une meilleure façon, mais que diriez-vous:

    >>> import glob
>>> types = ('*.pdf', '*.cpp') # the tuple of file types
>>> files_grabbed = []
>>> for files in types:
...     files_grabbed.extend(glob.glob(files))
... 
>>> files_grabbed   # the list of pdf and cpp files

    Peut-être il ya une autre façon, afin d'attendre au cas où quelqu'un d'autre arrive avec une meilleure réponse.

    • files_grabbed = [glob.glob(e) for e in ['*.pdf', '*.cpp']]
    • Novitoll la solution est court, mais il finit par créer des listes imbriquées.
    • vous pouvez toujours le faire 😉 [f for f_ in [glob.glob(e) for e in ('*.jpg', '*.mp4')] for f in f_]
    • files_grabbed = [glob.glob(e) pour e dans ['.pdf', '*."cpp"]]
    • Cette boucle deux fois dans la liste de fichiers. Dans la première itération, il vérifie *.pdf et dans le second, elle vérifie *.rpc. Est-il un moyen de le faire en une seule itération? Vérifiez que le combiné condition à chaque fois?
    InformationsquelleAutor user225312
  2. 38
    from glob import glob

files = glob('*.gif')
files.extend(glob('*.png'))
files.extend(glob('*.jpg'))

print(files)

    Si vous devez spécifier un chemin d'accès, une boucle sur le match de motifs et de garder le rejoindre à l'intérieur de la boucle pour des raisons de simplicité:

    from os.path import join
from glob import glob

files = []
for ext in ('*.gif', '*.png', '*.jpg'):
   files.extend(glob(join("path/to/dir", ext)))

print(files)
    • C'est excellent pour sa simplicité et sa lisibilité.
    InformationsquelleAutor user2363986
  3. 33

    De la chaîne des résultats:

    import itertools as it, glob

def multiple_file_types(*patterns):
    return it.chain.from_iterable(glob.iglob(pattern) for pattern in patterns)

    Alors:

    for filename in multiple_file_types("*.txt", "*.sql", "*.log"):
    # do stuff
    • glob.glob -> glob.iglob de sorte que les itérateurs de la chaîne est pleinement paresseux évalué
    • J'ai trouvé la même solution, mais ne savez pas à propos de chain.from_iterable. Donc, c'est semblable, mais moins lisible: it.chain(*(glob.iglob(pattern) for pattern in patterns)).
    InformationsquelleAutor tzot
  4. 24

    glob renvoie une liste: pourquoi ne pas l'exécuter plusieurs fois et concaténer les résultats?

    from glob import glob
ProjectFiles = glob('*.txt') + glob('*.mdown') + glob('*markdown')
    • C'est peut-être le plus lisible solution donnée. Je voudrais changer le cas de ProjectFiles à projectFiles, mais la bonne solution.
    InformationsquelleAutor patrick-mooney
  5. 15

    avec glob il n'est pas possible. vous pouvez utiliser seulement à:

    * correspond à tout ce qui

    ? correspond à tout caractère unique

    [seq] correspond à tout caractère dans seq

    [!seq] correspond à tout caractère qui n'est pas dans seq

    utiliser os.listdir et une expression régulière pour vérifier les modèles:

    for x in os.listdir('.'):
  if re.match('.*\.txt|.*\.sql', x):
    print x
    • la fin de votre regex avec $ pour correspondre qu'à la fin des noms de fichiers
    • J'aime cette approche - si glob l'expressivité n'est pas assez puissant, la mise à niveau vers une plus puissante regex système, ne pas entailler à l'aide par exemple itertools car ultérieure motif des modifications doivent également être hacky (dites que vous voulez autoriser les majuscules et les minuscules). Oh, et il pourrait être plus propre d'écrire '.*\.(txt|sql)'
    • Est-il une raison de préférer l'os.listdir('.') plus de glob.iglob('.')?
    InformationsquelleAutor Christian
  6. 10

    Par exemple, pour *.mp3 et *.flac sur plusieurs dossiers, vous pouvez faire:

    mask = r'music/*/*.[mf][pl][3a]*'
glob.glob(mask)

    L'idée peut être étendue à plusieurs extensions de fichier, mais vous devez vérifier que les combinaisons ne correspondent à aucun indésirables extension de fichier que vous pouvez avoir sur ces dossiers. Donc, être prudent avec cette.

    Pour combiner automatiquement un arbitraire liste des extensions en un seul glob modèle, vous pouvez effectuer les opérations suivantes:

    mask_base = r'music/*/*.'
exts = ['mp3', 'flac', 'wma']
chars = ''.join('[{}]'.format(''.join(set(c))) for c in zip(*exts))
mask = mask_base + chars + ('*' if len(set(len(e) for e in exts)) > 1 else '')
print(mask)  # music/*/*.[fmw][plm][3a]*
    InformationsquelleAutor feqwix
  7. 4

    Après de venir ici pour de l'aide, j'ai fait ma propre solution et je voulais le partager. Il est basé sur user2363986 réponse, mais je pense que c'est plus évolutif. Ce qui signifie que si vous avez 1000 extensions, le code sera toujours un peu l'air élégant.

    from glob import glob

directoryPath  = "C:\\temp\\*." 
fileExtensions = [ "jpg", "jpeg", "png", "bmp", "gif" ]
listOfFiles    = []

for extension in fileExtensions:
    listOfFiles.extend( glob( directoryPath + extension ))

for file in listOfFiles:
    print(file)   # Or do other stuff
    • Ne fonctionne pas pour moi. J'utilise directoryPath = "/Users/bla/bla/images_dir*."
    • J'aurais besoin de plus d'informations de débogage pour vous... Êtes-vous d'obtenir une exception? Aussi, si vous êtes sur Windows, ce chemin n'a pas l'air possible (manque la lettre de lecteur).
    InformationsquelleAutor Hans Goldman
  8. 4

    Un one-liner, Juste pour l'enfer de celui-ci..

    folder = "C:\\multi_pattern_glob_one_liner"
files = [item for sublist in [glob.glob(folder + ext) for ext in ["/*.txt", "/*.bat"]] for item in sublist]

    de sortie:

    ['C:\\multi_pattern_glob_one_liner\\dummy_txt.txt', 'C:\\multi_pattern_glob_one_liner\\dummy_bat.bat']
    InformationsquelleAutor Gil-Mor
  9. 3

    C'est un Python 3.4+ pathlib solution:

    exts = ".pdf", ".doc", ".xls", ".csv", ".ppt"
filelist = (str(i) for i in map(pathlib.Path, os.listdir(src)) if i.suffix.lower() in exts and not i.stem.startswith("~"))

    Aussi il ignore tous les noms de fichiers commençant par ~.

    InformationsquelleAutor Winand
  10. 3

    Ici est d'une ligne à la liste de compréhension de la variante de la Pat de la réponse (qui comprend aussi que tu voulais glob dans un répertoire du projet):

    import os, glob
exts = ['*.txt', '*.mdown', '*.markdown']
files = [f for ext in exts for f in glob.glob(os.path.join(project_dir, ext))]

    Vous en boucle sur les extensions (for ext in exts), puis pour chaque extension que vous prenez chaque fichier correspondant à la glob modèle (for f in glob.glob(os.path.join(project_dir, ext)).

    Cette solution est court, et sans aucune inutiles pour des boucles imbriquées liste des compréhensions, des fonctions ou à l'encombrement du code. Juste pur, expressif, pythonic Zen.

    Cette solution vous permet d'avoir une liste personnalisée de exts qui peut être changé sans avoir à mettre à jour votre code. (Ce qui est toujours une bonne pratique!)

    La liste-la compréhension est la même que celle utilisée dans Laurent solution (que j'ai voté pour). Mais je dirais qu'il est généralement inutile de factoriser une seule ligne à une fonction distincte, qui est pourquoi je suis de fournir cela comme une solution alternative.

    Bonus:

    Si vous avez besoin d'une recherche non seulement d'un seul répertoire, mais également tous les sous-répertoires, vous pouvez passer recursive=True et utiliser le multi-répertoire glob symbole ** 1:

    files = [f for ext in exts 
         for f in glob.glob(os.path.join(project_dir, '**', ext), recursive=True)]

    Cela invoquer glob.glob('<project_dir>/**/*.txt', recursive=True) et ainsi de suite pour chaque extension.

    1 Techniquement, le ** glob symbole simplement correspond à un ou plusieurs caractères y compris la barre oblique / (contrairement au singulier * glob symbole). Dans la pratique, vous avez juste besoin de se rappeler que, tant que vous entourent ** avec des barres obliques (séparateurs de chemin), il correspond à zéro ou plusieurs répertoires.

    InformationsquelleAutor scholer
  11. 3
    files = glob.glob('*.txt')
files.extend(glob.glob('*.dat'))
    • Les bonnes réponses fournissent également une explication de code et peut-être même certains de votre raisonnement derrière le code.
    InformationsquelleAutor Derek White
  12. 2

    J'ai publié Formique qui met en œuvre de multiples comprend une manière similaire à Apache Ant FileSet et les Globules.

    La recherche peut être mis en œuvre:

    import formic
patterns = ["*.txt", "*.markdown", "*.mdown"]
fileset = formic.FileSet(directory=projectDir, include=patterns)
for file_name in fileset.qualified_files():
    # Do something with file_name

    Parce que le plein Ant glob est mis en œuvre, vous pouvez inclure des répertoires différents avec chaque modèle, de sorte que vous pourriez choisir seulement ceux .les fichiers txt dans un sous-répertoire, et le .markdown dans un autre, par exemple:

    patterns = [ "/unformatted/**/*.txt", "/formatted/**/*.mdown" ]

    J'espère que cette aide.

    InformationsquelleAutor Andrew Alcock
  13. 2

    Pas glob, mais voici une autre façon à l'aide d'une compréhension de liste:

    extensions = 'txt mdown markdown'.split()
projectFiles = [f for f in os.listdir(projectDir) 
                  if os.path.splitext(f)[1][1:] in extensions]
    InformationsquelleAutor joemaller
  14. 2

    La fonction suivante _glob globs pour plusieurs extensions de fichier.

    import glob
import os
def _glob(path, *exts):
    """Glob for multiple file extensions

    Parameters
    ----------
    path : str
        A file name without extension, or directory name
    exts : tuple
        File extensions to glob for

    Returns
    -------
    files : list
        list of files matching extensions in exts in path

    """
    path = os.path.join(path, "*") if os.path.isdir(path) else path + "*"
    return [f for files in [glob.glob(path + ext) for ext in exts] for f in files]

files = _glob(projectDir, ".txt", ".mdown", ".markdown")
    InformationsquelleAutor Tim Fuller
  15. 1

    À glob plusieurs types de fichiers, vous devez appeler glob() fonction plusieurs fois dans une boucle. Puisque cette fonction renvoie une liste, vous avez besoin de concaténer les listes.

    Par exemple, cette fonction de faire le travail:

    import glob
import os


def glob_filetypes(root_dir, *patterns):
    return [path
            for pattern in patterns
            for path in glob.glob(os.path.join(root_dir, pattern))]

    Simple d'utilisation:

    project_dir = "path/to/project/dir"
for path in sorted(glob_filetypes(project_dir, '*.txt', '*.mdown', '*.markdown')):
    print(path)

    Vous pouvez également utiliser glob.iglob() avoir un itérateur:

    Retourne un itérateur qui donne les mêmes valeurs que glob() sans avoir à les stocker simultanément.

    def iglob_filetypes(root_dir, *patterns):
    return (path
            for pattern in patterns
            for path in glob.iglob(os.path.join(root_dir, pattern)))
    InformationsquelleAutor Laurent LAPORTE
  16. 0

    Vous pouvez essayer de faire un manuel liste de comparer l'extension de l'existant avec ceux dont vous avez besoin.

    ext_list = ['gif','jpg','jpeg','png'];
file_list = []
for file in glob.glob('*.*'):
  if file.rsplit('.',1)[1] in ext_list :
    file_list.append(file)
    InformationsquelleAutor thegauraw
  17. 0

    Vous pouvez utiliser le filtre:

    import os
import glob

projectFiles = filter(
    lambda x: os.path.splitext(x)[1] in [".txt", ".mdown", ".markdown"]
    glob.glob(os.path.join(projectDir, "*"))
)
    InformationsquelleAutor LK__
  18. 0

    Vous pouvez également utiliser reduce() comme suit:

    import glob
file_types = ['*.txt', '*.mdown', '*.markdown']
project_files = reduce(lambda list1, list2: list1 + list2, (glob.glob(t) for t in file_types))

    cela crée une liste à partir de glob.glob() pour chaque modèle et les réduit à une seule liste.

    InformationsquelleAutor cyht
  19. 0
    import os    
import glob
import operator
from functools import reduce

types = ('*.jpg', '*.png', '*.jpeg')
lazy_paths = (glob.glob(os.path.join('my_path', t)) for t in types)
paths = reduce(operator.add, lazy_paths, [])

    https://docs.python.org/3.5/library/functools.html#functools.reduce
    https://docs.python.org/3.5/library/operator.html#operator.add

    InformationsquelleAutor unpangloss
  20. 0

    Un glob, de nombreuses extensions... mais la solution imparfaite (peut correspondre à d'autres fichiers).

    filetypes = ['tif', 'jpg']

filetypes = zip(*[list(ft) for ft in filetypes])
filetypes = ["".join(ch) for ch in filetypes]
filetypes = ["[%s]" % ch for ch in filetypes]
filetypes = "".join(filetypes) + "*"
print(filetypes)
# => [tj][ip][fg]*

glob.glob("/path/to/*.%s" % filetypes)
    InformationsquelleAutor colllin
  21. 0

    J'ai eu le même problème et c'est ce que je suis venu avec 

    import os, sys, re

#without glob

src_dir = '/mnt/mypics/'
src_pics = []
ext = re.compile('.*\.(|{}|)$'.format('|'.join(['png', 'jpeg', 'jpg']).encode('utf-8')))
for root, dirnames, filenames in os.walk(src_dir):
  for filename in filter(lambda name:ext.search(name),filenames):
    src_pics.append(os.path.join(root, filename))
    InformationsquelleAutor Justin
  22. 0

    Par exemple:

    import glob
lst_img = []
base_dir = '/home/xy/img/'

# get all the jpg file in base_dir 
lst_img += glob.glob(base_dir + '*.jpg')
print lst_img
# ['/home/xy/img/2.jpg', '/home/xy/img/1.jpg']

# append all the png file in base_dir to lst_img
lst_img += glob.glob(base_dir + '*.png')
print lst_img
# ['/home/xy/img/2.jpg', '/home/xy/img/1.jpg', '/home/xy/img/3.png']

    Une fonction:

    import glob
def get_files(base_dir='/home/xy/img/', lst_extension=['*.jpg', '*.png']):
    """
    :param base_dir:base directory
    :param lst_extension:lst_extension: list like ['*.jpg', '*.png', ...]
    :return:file lists like ['/home/xy/img/2.jpg','/home/xy/img/3.png']
    """
    lst_files = []
    for ext in lst_extension:
        lst_files += glob.glob(base_dir+ext)
    return lst_files
    InformationsquelleAutor Jayhello
  23. 0

    Utiliser une liste d'extension et de parcourir

    from os.path import join
from glob import glob

files = ['*.gif', '*.png', '*.jpg']
for ext in files:
   files.extend(glob(join("path/to/dir", ext)))

print(files)
    InformationsquelleAutor Projesh Bhoumik
  24. 0

    Encore une autre solution (utilisation glob pour obtenir des tracés à l'aide de multiples match patterns et de combiner tous les chemins dans une seule liste à l'aide de reduce et add):

    import functools, glob, operator
paths = functools.reduce(operator.add, [glob.glob(pattern) for pattern in [
    "path1/*.ext1",
    "path2/*.ext2"]])
    InformationsquelleAutor Petr Vepřek
  25. 0

    Si vous utilisez pathlib essayez ceci:

    import pathlib

extensions = ['.py', '.txt']
root_dir = './test/'

files = filter(lambda p: p.suffix in extensions, pathlib.Path(root_dir).glob('**/*'))

print(list(files))
    InformationsquelleAutor qik
  26. 0

    Par les résultats que j'ai obtenus à partir de tests empiriques, il s'est avéré que glob.glob n'est pas la meilleure façon de filtrer les fichiers par leur extension. Certaines des raisons sont les suivantes:

    • Le globbing "langue" ne permettant pas parfait spécification de plusieurs extension.
    • L'ancien point de résultats à obtenir des résultats incorrects en fonction de l'extension de fichier.
    • L'expansion de la méthode est empiriquement prouvé à être plus lent que la plupart des autres méthodes.
    • Même si c'est étrange même d'autres systèmes de fichiers, les objets peuvent avoir des "extensions", les dossiers de trop.

    J'ai testé (pour correcteness et de l'efficacité dans le temps) à l'issue de 4 différentes méthodes pour filtrer les fichiers par les extensions et les met dans une list:

    from glob import glob, iglob
from re import compile, findall
from os import walk


def glob_with_storage(args):

    elements = ''.join([f'[{i}]' for i in args.extensions])
    globs = f'{args.target}/**/*{elements}'
    results = glob(globs, recursive=True)

    return results


def glob_with_iteration(args):

    elements = ''.join([f'[{i}]' for i in args.extensions])
    globs = f'{args.target}/**/*{elements}'
    results = [i for i in iglob(globs, recursive=True)]

    return results


def walk_with_suffixes(args):

    results = []
    for r, d, f in walk(args.target):
        for ff in f:
            for e in args.extensions:
                if ff.endswith(e):
                    results.append(path_join(r,ff))
                    break
    return results


def walk_with_regs(args):

    reg = compile('|'.join([f'{i}$' for i in args.extensions]))

    results = []
    for r, d, f in walk(args.target):
        for ff in f:
            if len(findall(reg,ff)):
                results.append(path_join(r, ff))

    return results

    En exécutant le code ci-dessus sur mon ordinateur portable que j'ai obtenus à la suite de l'auto-explicatifs des résultats.

    Elapsed time for '7 times glob_with_storage()':  0.365023 seconds.
mean   : 0.05214614
median : 0.051861
stdev  : 0.001492152
min    : 0.050864
max    : 0.054853

Elapsed time for '7 times glob_with_iteration()':  0.360037 seconds.
mean   : 0.05143386
median : 0.050864
stdev  : 0.0007847381
min    : 0.050864
max    : 0.052859

Elapsed time for '7 times walk_with_suffixes()':  0.26529 seconds.
mean   : 0.03789857
median : 0.037899
stdev  : 0.0005759071
min    : 0.036901
max    : 0.038896

Elapsed time for '7 times walk_with_regs()':  0.290223 seconds.
mean   : 0.04146043
median : 0.040891
stdev  : 0.0007846776
min    : 0.04089
max    : 0.042885

Results sizes:
0 2451
1 2451
2 2446
3 2446

Differences between glob() and walk():
0 E:\x\y\z\venv\lib\python3.7\site-packages\Cython\Includes\numpy
1 E:\x\y\z\venv\lib\python3.7\site-packages\Cython\Utility\CppSupport.cpp
2 E:\x\y\z\venv\lib\python3.7\site-packages\future\moves\xmlrpc
3 E:\x\y\z\venv\lib\python3.7\site-packages\Cython\Includes\libcpp
4 E:\x\y\z\venv\lib\python3.7\site-packages\future\backports\xmlrpc

Elapsed time for 'main':  1.317424 seconds.

    Le moyen le plus rapide pour filtrer les fichiers par les extensions, arrive même à être le plus laid qu'un. Qui est, imbriqués for boucles et string comparaison à l'aide de la endswith() méthode.

    En outre, comme vous pouvez le voir, l'expansion des algorithmes (avec le modèle E:\x\y\z\**/*[py][pyc]), même avec seulement 2 extension donnée (py et pyc) renvoie également à des résultats incorrects.

    InformationsquelleAutor GiovaLomba
  27. -1

    Cela Devrait Fonctionner:

    import glob
extensions = ('*.txt', '*.mdown', '*.markdown')
for i in extensions:
    for files in glob.glob(i):
        print (files)
    InformationsquelleAutor jdnoon
  28. -2

    cela a fonctionné pour moi:

    import glob
images = glob.glob('*.JPG' or '*.jpg' or '*.png')
    • Cela ne peut pas fonctionner comme vous le souhaitons. Le or opérateur renvoie le premier "non-falsy" de la valeur, donc dans votre cas: *.JPG. Cela transforme votre appel en glob.glob('*.JPG') en ce sens qu'elle ne retourne que les *.JPG fichiers, l'oublier totalement les autres extensions.
    InformationsquelleAutor Sarvagya Gupta