也许有更好的办法，但是:

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

# files_grabbed is the list of pdf and cpp files

也许还有其他的方法，所以等待别人提出更好的答案。

对于glob，这是不可能的。你只能使用: *匹配所有内容 ？ 匹配任何单个字符 [seq]匹配seq中的任意字符 [!Seq]匹配任何不在Seq中的字符

使用操作系统。Listdir和regexp检查模式:

for x in os.listdir('.'):
  if re.match('.*\.txt|.*\.sql', x):
    print x

链接结果:

import itertools as it, glob

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

然后:

for filename in multiple_file_types("*.txt", "*.sql", "*.log"):
    # do stuff

您可以尝试制作一个手动列表，将现有扩展与所需扩展进行比较。

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)

我已经发布了Formic，它以类似于Apache Ant的FileSet和glob的方式实现了多个包含。

搜索可以实现:

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

因为已经实现了完整的Ant glob，所以你可以在每个模式中包含不同的目录，所以你可以在一个子目录中只选择那些.txt文件，而在另一个子目录中选择.markdown，例如:

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

我希望这能有所帮助。

不是glob，这里是另一种使用列表理解的方式:

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

下面的函数_glob用于多个文件扩展名。

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")

from glob import glob

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

print(files)

如果你需要指定一个路径，循环匹配模式，并保持连接在循环中简单:

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)

这应该有用:

import glob
extensions = ('*.txt', '*.mdown', '*.markdown')
for i in extensions:
    for files in glob.glob(i):
        print (files)

来这里寻求帮助后，我有了自己的解决方案，想和大家分享。它基于user2363986的答案，但我认为这更具可伸缩性。这意味着，即使您有1000个扩展，代码仍然看起来很优雅。

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

你可以使用filter:

import os
import glob

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

这是一个Python 3.4+ pathlib解决方案:

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("~"))

此外，它会忽略所有以~开头的文件名。

Glob返回一个列表:为什么不只是多次运行它并连接结果呢?

from glob import glob
project_files = glob('*.txt') + glob('*.mdown') + glob('*.markdown')

例如，*.mp3和*.mp3。Flac在多个文件夹上，你可以做:

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

这个想法可以扩展到更多的文件扩展名，但您必须检查这些组合是否与这些文件夹上可能存在的任何其他不需要的文件扩展名匹配。所以要小心。

要自动将任意扩展列表组合到一个glob模式中，您可以执行以下操作:

def multi_extension_glob_mask(mask_base, *extensions):
    mask_ext = ['[{}]'.format(''.join(set(c))) for c in zip(*extensions)]
    if not mask_ext or len(set(len(e) for e in extensions)) > 1:
        mask_ext.append('*')
    return mask_base + ''.join(mask_ext)

mask = multi_extension_glob_mask('music/*/*.', 'mp3', 'flac', 'wma')
print(mask)  # music/*/*.[mfw][pml][a3]*

你也可以像这样使用reduce():

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

这将从glob.glob()为每个模式创建一个列表，并将它们简化为单个列表。

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

一句俏皮话，只是为了好玩。

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]

输出:

['C:\\multi_pattern_glob_one_liner\\dummy_txt.txt', 'C:\\multi_pattern_glob_one_liner\\dummy_bat.bat']

要glob多种文件类型，需要在循环中多次调用glob()函数。因为这个函数返回一个列表，所以需要连接这些列表。

例如，这个函数是这样的:

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))]

简单的用法:

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

你也可以使用glob.iglob()来拥有一个迭代器:

返回一个迭代器，该迭代器产生与glob()相同的值，但实际上不会同时存储它们。

def iglob_filetypes(root_dir, *patterns):
    return (path
            for pattern in patterns
            for path in glob.iglob(os.path.join(root_dir, pattern)))

一个glob，许多扩展…但不完美的解决方案(可能匹配其他文件)。

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)

这招对我很管用:

import glob
images = glob.glob('*.JPG' or '*.jpg' or '*.png')

我也有同样的问题，这是我想到的

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))

以下是Pat回答的一行列表理解变体(其中还包括您想要在特定的项目目录中glob):

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

循环遍历扩展名(对于extts中的ext)，然后对于每个扩展名，使用匹配glob模式的每个文件(对于glob.glob中的f (os.path. path))。加入(project_dir ext))。

这个解决方案很短，没有任何不必要的for循环、嵌套的列表推导式或使代码混乱的函数。纯粹的，富有表现力的，蟒蛇式的禅宗。

这个解决方案允许您拥有一个自定义的文本列表，可以在不更新代码的情况下进行更改。(这是一个很好的实践!)

在Laurent的解决方案中使用了同样的列表理解(我投票支持)。但我认为，通常没有必要将单行分解为单独的函数，这就是为什么我提供这个作为替代解决方案的原因。

奖金:

如果你不仅需要搜索单个目录，还需要搜索所有子目录，你可以传递递归=True并使用多目录glob符号** 1:

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

这将为每个扩展调用glob.glob('<project_dir>/**/*.txt'， recursive=True)等等。

从技术上讲，** glob符号只是匹配一个或多个字符，包括正斜杠/(不像单数的* glob符号)。在实践中，您只需要记住，只要用斜杠(路径分隔符)包围**，它就可以匹配0个或多个目录。

files = glob.glob('*.txt')
files.extend(glob.glob('*.dat'))

例如:

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']

一个函数:

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

使用扩展列表并遍历

from os.path import join
from glob import glob

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

print(files)

还有另一个解决方案(使用glob使用多个匹配模式获取路径，并使用reduce和add将所有路径组合到一个列表中):

import functools, glob, operator
paths = functools.reduce(operator.add, [glob.glob(pattern) for pattern in [
    "path1/*.ext1",
    "path2/*.ext2"]])

如果你使用pathlib，试试这个:

import pathlib

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

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

print(list(files))

根据我从经验测试中得到的结果，那一团东西。Glob并不是通过扩展名过滤文件的更好方法。其中一些原因是:

通配符“语言”不允许对多个扩展进行完美的规范。 前一点导致根据文件扩展名获得不正确的结果。 经经验证明，通配符法比大多数其他方法都要慢。 即使这很奇怪，甚至其他文件系统对象也可以有“扩展名”，文件夹也是如此。

我已经测试了以下4种不同的方法，通过扩展名过滤文件，并将它们放在一个列表中:

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

通过在我的笔记本电脑上运行上面的代码，我得到了以下自动解释的结果。

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.

通过扩展名过滤文件的最快方法，甚至是最丑陋的方法。也就是说，使用endswith()方法进行嵌套for循环和字符串比较。

此外，正如您所看到的，配色算法(使用模式E:\x\y\z\**/*[py][pyc])即使只给出两个扩展名(py和pyc)也会返回不正确的结果。

这么多的答案都建议全局替换和扩展的数量一样多，我更喜欢只替换一次:

from pathlib import Path

files = (p.resolve() for p in Path(path).glob("**/*") if p.suffix in {".c", ".cc", ".cpp", ".hxx", ".h"})

import glob
import pandas as pd

df1 = pd.DataFrame(columns=['A'])
for i in glob.glob('C:\dir\path\*.txt'):
    df1 = df1.append({'A': i}, ignore_index=True)
for i in glob.glob('C:\dir\path\*.mdown'):
    df1 = df1.append({'A': i}, ignore_index=True)
for i in glob.glob('C:\dir\path\*.markdown):
    df1 = df1.append({'A': i}, ignore_index=True)

虽然Python的默认glob并没有真正遵循Bash的glob，但您可以使用其他库来做到这一点。我们可以在wcmatch的glob中启用大括号。

>>> from wcmatch import glob
>>> glob.glob('*.{md,ini}', flags=glob.BRACE)
['LICENSE.md', 'README.md', 'tox.ini']

你甚至可以使用扩展glob模式，如果这是你的偏好:

from wcmatch import glob
>>> glob.glob('*.@(md|ini)', flags=glob.EXTGLOB)
['LICENSE.md', 'README.md', 'tox.ini']

从前面的答案

glob('*.jpg') + glob('*.png')

这是一个较短的问题，

from glob import glob
extensions = ['jpg', 'png'] # to find these filename extensions

# Method 1: loop one by one and extend to the output list
output = []
[output.extend(glob(f'*.{name}')) for name in extensions]
print(output)

# Method 2: even shorter
# loop filename extension to glob() it and flatten it to a list
output = [p for p2 in [glob(f'*.{name}') for name in extensions] for p in p2]
print(output)

Python 3

我们可以使用pathlib;.glob仍然不支持对多个参数或在大括号内(如POSIX shell)进行通配符操作，但我们可以轻松地过滤结果。

例如，理想情况下你可能喜欢做的事情:

# NOT VALID
Path(config_dir).glob("*.{ini,toml}")
# NOR IS
Path(config_dir).glob("*.ini", "*.toml")

你可以:

filter(lambda p: p.suffix in {".ini", ".toml"}, Path(config_dir).glob("*"))

这也不算太糟。

这对我很管用!

split('.')[-1]

上面的代码分开了文件名后缀(*.xxx)，所以它可以帮助你

    for filename in glob.glob(folder + '*.*'):
        print(folder+filename)
        if  filename.split('.')[-1] != 'tif' and \
            filename.split('.')[-1] != 'tiff' and \
            filename.split('.')[-1] != 'bmp' and \
            filename.split('.')[-1] != 'jpg' and \
            filename.split('.')[-1] != 'jpeg' and \
            filename.split('.')[-1] != 'png':
                continue
        # Your code

与@BPL相同的答案(计算效率高)，但它可以处理任何glob模式，而不是扩展:

import os
from fnmatch import fnmatch

folder = "path/to/folder/"
patterns = ("*.txt", "*.md", "*.markdown")

files = [f.path for f in os.scandir(folder) if any(fnmatch(f, p) for p in patterns)]

这种解决方案既高效又方便。它还与glob的行为紧密匹配(请参阅文档)。

注意，使用内置包pathlib会更简单:

from pathlib import Path

folder = Path("/path/to/folder")
patterns = ("*.txt", "*.md", "*.markdown")

files = [f for f in folder.iterdir() if any(f.match(p) for p in patterns)]

import os
import glob

projectFiles = [i for i in glob.glob(os.path.join(projectDir,"*")) if os.path.splitext(i)[-1].lower() in ['.txt','.markdown','.mdown']]

Os.path.splitext将返回filename & .extension

filename, .extension = os.path.splitext('filename.extension')

.lower()将字符串转换为小写

最简单的方法是使用itertools.chain

from pathlib import Path
import itertools

cwd = Path.cwd()

for file in itertools.chain(
    cwd.rglob("*.txt"),
    cwd.rglob("*.md"),
):
    print(file.name)

也许我遗漏了一些东西但如果只是简单的glob也许你可以这样做?

projectFiles = glob.glob(os.path.join(projectDir, '*.{txt,mdown,markdown}'))

一句话:

img_ext = (".jpg"， ".jpeg"， ".jpeg"， "。就是“,”。jfi”、“.jif”、“jpg”)

目录= './'

files = [glob.glob(目录+'/*')中的文件的文件if file.endswith(img_ext)]

你可以用这个:

project_files = []
file_extensions = ['txt','mdown','markdown']
for file_extension in file_extensions:
    project_files.extend(glob.glob(projectDir  + '*.' + file_extension))