os.listdir() dar - lhe-á tudo o que está num directório-ficheiros e directórios.

Se você quiser Apenas arquivos, você pode filtrar isto usando os.path:

from os import listdir
from os.path import isfile, join
onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]

Ou podias usar os.walk() que irá produzir duas listas para cada directório que visita - dividindo-se em ficheiros e dirs para si. Se você só quiser a pasta de topo você pode apenas quebrar a primeira vez que ela produz

from os import walk

f = []
for (dirpath, dirnames, filenames) in walk(mypath):
    f.extend(filenames)
    break

E por último, como este exemplo mostra, adicionando de uma lista para outra você pode usar .extend() quer

>>> q = [1, 2, 3]
>>> w = [4, 5, 6]
>>> q = q + w
>>> q
[1, 2, 3, 4, 5, 6]

Prefiro usar o glob Módulo, como faz correspondência padrão e expansão.

import glob
print(glob.glob("/home/adam/*.txt"))

Irá devolver uma lista com os ficheiros pesquisados:

['/home/adam/file1.txt', '/home/adam/file2.txt', .... ]

import os
os.listdir("somedirectory")

Irá devolver uma lista de todos os ficheiros e directórios em "somedirectory".

Obtenha uma lista de ficheiros com Python 2 e 3

Python: como obter uma lista de ficheiros numa pasta

Os.listdir()

ou..... está quente para obter todos os ficheiros (e pastas) na pasta actual (Python 3)

A maneira mais simples de ter o ficheiro no directório actual do Python 3 é esta. É realmente simples; use o módulo os e o listdir () função e você terá o arquivo nesse diretório (e eventuais pastas que estão no diretório, mas você não terá o arquivo no subdiretório, para que você possa usar walk - eu falarei sobre isso mais tarde).

>>> import os
>>> arr = os.listdir()
>>> arr
['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']

Usar o glob

eu achei glob mais fácil de selecionar Arquivo do mesmo tipo ou com algo em comum. Veja o seguinte exemplo::

import glob

txtfiles = []
for file in glob.glob("*.txt"):
    txtfiles.append(file)

usar a compreensão da lista

import glob

mylist = [f for f in glob.glob("*.txt")]

>>> import os
>>> files_path = [os.path.abspath(x) for x in os.listdir()]
>>> files_path
['F:\\documenti\applications.txt', 'F:\\documenti\collections.txt']

Obter o nome completo do caminho de um tipo de ficheiro em todos subdirectórios com walk

Acho isto muito útil para encontrar coisas em muitos directórios, e ajudou-me a encontrar um ficheiro sobre o qual não me lembrava do nome:

import os

# Getting the current work directory (cwd)
thisdir = os.getcwd()

# r=root, d=directories, f = files
for r, d, f in os.walk(thisdir):
    for file in f:
        if ".docx" in file:
            print(os.path.join(r, file))

Os.listdir (): obter os ficheiros na pasta actual (Python 2)

No Python 2 você, se quiser a lista dos ficheiros na pasta actual, terá de apresentar o argumento como '. ou os.getcwd() in the os.método listdir.

>>> import os
>>> arr = os.listdir('.')
>>> arr
['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']

Para subir no directório árvore

>>> # Method 1
>>> x = os.listdir('..')

# Method 2
>>> x= os.listdir('/')

>>> import os
>>> arr = os.listdir('F:\\python')
>>> arr
['$RECYCLE.BIN', 'work.txt', '3ebooks.txt', 'documents']

Obter ficheiros de uma subdiretoria em particular com o SO.listdir ()

import os

x = os.listdir("./content")

>>> import os
>>> arr = next(os.walk('.'))[2]
>>> arr
['5bs_Turismo1.pdf', '5bs_Turismo1.pptx', 'esperienza.txt']

Módulo Glob - todos os ficheiros

import glob
print(glob.glob("*"))

out:['content', 'start.py']

>>> import os
>>> arr = []
>>> for d,r,f in next(os.walk("F:\_python")):
>>>     for file in f:
>>>         arr.append(os.path.join(r,file))
...
>>> for f in arr:
>>>     print(files)

>output

F:\\_python\\dict_class.py
F:\\_python\\programmi.txt

>>> [os.path.join(r,file) for r,d,f in next(os.walk("F:\\_python")) for file in f]
['F:\\_python\\dict_class.py', 'F:\\_python\\programmi.txt']

Os.walk-get full path-all files in sub dirs

x = [os.path.join(r,file) for r,d,f in os.walk("F:\\_python") for file in f]

>>>x
['F:\\_python\\dict.py', 'F:\\_python\\progr.txt', 'F:\\_python\\readl.py']

>>> arr_txt = [x for x in os.listdir() if x.endswith(".txt")]
>>> print(arr_txt)
['work.txt', '3ebooks.txt']

Glob-get only txt files

>>> import glob
>>> x = glob.glob("*.txt")
>>> x
['ale.txt', 'alunni2015.txt', 'assenze.text.txt', 'text2.txt', 'untitled.txt']

Usando o glob para obter a localização completa dos ficheiros

Se eu precisar do caminho absoluto dos ficheiros:

>>> from path import path
>>> from glob import glob
>>> x = [path(f).abspath() for f in glob("F:\*.txt")]
>>> for f in x:
...  print(f)
...
F:\acquistionline.txt
F:\acquisti_2018.txt
F:\bootstrap_jquery_ecc.txt

Outra utilização de glob

Se eu quiser todos os ficheiros no directório:

>>> x = glob.glob("*")

Usar So.caminho.isfile para evitar as pastas na lista

import os.path
listOfFiles = [f for f in os.listdir() if os.path.isfile(f)]
print(listOfFiles)

> output

['a simple game.py', 'data.txt', 'decorator.py']

A usar a pathlib de (Python 3.4)

import pathlib

>>> flist = []
>>> for p in pathlib.Path('.').iterdir():
...  if p.is_file():
...   print(p)
...   flist.append(p)
...
error.PNG
exemaker.bat
guiprova.mp3
setup.py
speak_gui2.py
thumb.PNG

Se quiseres usar a compreensão da lista

>>> flist = [p for p in pathlib.Path('.').iterdir() if p.is_file()]

*também pode usar apenas pathlib.Path() em vez de pathlib.Caminho(".")

Usar o método glob na pathlib.Path ()

import pathlib

py = pathlib.Path().glob("*.py")
for file in py:
    print(file)

Resultado:

stack_overflow_list.py
stack_overflow_list_tkinter.py

import os
x = [i[2] for i in os.walk('.')]
y=[]
for t in x:
    for f in t:
        y.append(f)

>>> y
['append_to_list.py', 'data.txt', 'data1.txt', 'data2.txt', 'data_180617', 'os_walk.py', 'READ2.py', 'read_data.py', 'somma_defaltdic.py', 'substitute_words.py', 'sum_data.py', 'data.txt', 'data1.txt', 'data_180617']

Obter apenas ficheiros com o próximo e entrar numa pasta

>>> import os
>>> x = next(os.walk('F://python'))[2]
>>> x
['calculator.bat','calculator.py']

Obter apenas directórios com o seguinte e entrar numa pasta

>>> import os
>>> next(os.walk('F://python'))[1] # for the current dir use ('.')
['python3','others']

Obter todos os nomes das sub-pastas com andar

>>> for r,d,f in os.walk("F:\_python"):
...  for dirs in d:
...   print(dirs)
...
.vscode
pyexcel
pyschool.py
subtitles
_metaprogramming
.ipynb_checkpoints

>>> import os
>>> x = [f.name for f in os.scandir() if f.is_file()]
>>> x
['calculator.bat','calculator.py']

# Another example with scandir (a little variation from docs.python.org)
# This one is more efficient than os.listdir.
# In this case, it shows the files only in the current directory
# where the script is executed.

>>> import os
>>> with os.scandir() as i:
...  for entry in i:
...   if entry.is_file():
...    print(entry.name)
...
ebookmaker.py
error.PNG
exemaker.bat
guiprova.mp3
setup.py
speakgui4.py
speak_gui2.py
speak_gui3.py
thumb.PNG
>>>

Ex. 1: quantos arquivos existem nos subdiretórios?

Neste exemplo, procuramos o número de ficheiros que estão incluídos em todo o directório e nas suas sub-pastas.

import os

def count(dir, counter=0):
    "returns number of files in dir and subdirs"
    for pack in os.walk(dir):
        for f in pack[2]:
            counter += 1
    return dir + " : " + str(counter) + "files"

print(count("F:\\python"))

> output

>'F:\\\python' : 12057 files'

Ex.2: Como copiar todos os arquivos de um diretório para outro?

UM programa para fazer a ordem no seu computador encontrar todos os ficheiros de um tipo (por omissão: pptx) e copiá-los numa nova pasta.

import os
import shutil
from path import path

destination = "F:\\file_copied"
# os.makedirs(destination)

def copyfile(dir, filetype='pptx', counter=0):
    "Searches for pptx (or other - pptx is the default) files and copies them"
    for pack in os.walk(dir):
        for f in pack[2]:
            if f.endswith(filetype):
                fullpath = pack[0] + "\\" + f
                print(fullpath)
                shutil.copy(fullpath, destination)
                counter += 1
    if counter > 0:
        print("------------------------")
        print("\t==> Found in: `" + dir + "` : " + str(counter) + " files\n")

for dir in os.listdir():
    "searches for folders that starts with `_`"
    if dir[0] == '_':
        # copyfile(dir, filetype='pdf')
        copyfile(dir, filetype='txt')


> Output

_compiti18\Compito Contabilità 1\conti.txt
_compiti18\Compito Contabilità 1\modula4.txt
_compiti18\Compito Contabilità 1\moduloa4.txt
------------------------
==> Found in: `_compiti18` : 3 files

Ex. 3: Como obter todos os arquivos em um txt ficheiro

No caso de querer criar um ficheiro txt com todos os nomes dos ficheiros:

import os
mylist = ""
with open("filelist.txt", "w", encoding="utf-8") as file:
    for eachfile in os.listdir():
        mylist += eachfile + "\n"
    file.write(mylist)

"""We are going to save a txt file with all the files in your directory.
We will use the function walk()

"""

import os

# see all the methos of os
# print(*dir(os), sep=", ")
listafile = []
percorso = []
with open("lista_file.txt", "w", encoding='utf-8') as testo:
    for root, dirs, files in os.walk("D:\\"):
        for file in files:
            listafile.append(file)
            percorso.append(root + "\\" + file)
            testo.write(file + "\n")
listafile.sort()
print("N. of files", len(listafile))
with open("lista_file_ordinata.txt", "w", encoding="utf-8") as testo_ordinato:
    for file in listafile:
        testo_ordinato.write(file + "\n")

with open("percorso.txt", "w", encoding="utf-8") as file_percorso:
    for file in percorso:
        file_percorso.write(file + "\n")

os.system("lista_file.txt")
os.system("lista_file_ordinata.txt")
os.system("percorso.txt")

Uma solução de uma linha para obter apenas uma lista de ficheiros (sem subpastas):

filenames = next(os.walk(path))[2]

Ou nomes paternais absolutos:

paths = [os.path.join(path,fn) for fn in next(os.walk(path))[2]]

A obter os locais completos de Ficheiros de uma pasta e de todas as suas sub-pastas

import os

def get_filepaths(directory):
    """
    This function will generate the file names in a directory 
    tree by walking the tree either top-down or bottom-up. For each 
    directory in the tree rooted at directory top (including top itself), 
    it yields a 3-tuple (dirpath, dirnames, filenames).
    """
    file_paths = []  # List which will store all of the full filepaths.

    # Walk the tree.
    for root, directories, files in os.walk(directory):
        for filename in files:
            # Join the two strings in order to form the full filepath.
            filepath = os.path.join(root, filename)
            file_paths.append(filepath)  # Add it to the list.

    return file_paths  # Self-explanatory.

# Run the above function and store its results in a variable.   
full_file_paths = get_filepaths("/Users/johnny/Desktop/TEST")

• o caminho que eu forneci na função acima continha 3 ficheiros-dois deles no directório raiz, e outro numa subpasta chamada "subpasta"."Agora podes fazer coisas como:

• print full_file_paths que irá imprimir a lista:

  • ['/Users/johnny/Desktop/TEST/file1.txt', '/Users/johnny/Desktop/TEST/file2.txt', '/Users/johnny/Desktop/TEST/SUBFOLDER/file3.dat']

Se quiser, pode abrir e ler o conteúdo, ou concentrar-se apenas nos ficheiros com a extensão ".tipo no código abaixo:

for f in full_file_paths:
  if f.endswith(".dat"):
    print f

/Users/johnny/Desktop/TEST/SUBFOLDER/file3.dat

Desde a versão 3.4 existem iteradores para isto que são muito mais eficientes do que os.listdir():

pathlib: Novo na versão 3.4.

>>> import pathlib
>>> [p for p in pathlib.Path('.').iterdir() if p.is_file()]

De Acordo com PEP 428, o objetivo do pathlib a biblioteca é fornecer uma simples hierarquia de classes para lidar com caminhos de sistema de arquivos e as operações comuns que os usuários fazem sobre eles.

os.scandir(): Novo na versão 3.5.

>>> import os
>>> [entry for entry in os.scandir('.') if entry.is_file()]

Note que os.walk() utilizações os.scandir() em vez de os.listdir() a partir da versão 3.5, e sua velocidade aumentou 2-20 vezes de acordo com PEP 471 .

Gostei muito da resposta de adamk , sugerindo que você use glob(), do módulo do mesmo nome. Isto permite-lhe ter correspondência de padrões com * s.

Exemplos:

from glob import glob

# Return everything under C:\Users\admin that contains a folder called wlp.
glob('C:\Users\admin\*\wlp')

O acima é terrível - o caminho tem sido duro e só vai trabalhar em janelas entre o nome do disco e os \ s sendo hardcoded no caminho.

from glob    import glob
from os.path import join

# Return everything under Users, admin, that contains a folder called wlp.
glob(join('Users', 'admin', '*', 'wlp'))

O acima funciona melhor, mas depende do nome da pasta Users que é frequentemente encontrado no Windows e não tão frequentemente encontrado em outros OSs. Ele também depende do usuário ter um nome específico, admin.

from glob    import glob
from os.path import expanduser, join

# Return everything under the user directory that contains a folder called wlp.
glob(join(expanduser('~'), '*', 'wlp'))

from glob    import glob
from os      import getcwd
from os.path import join

# Return everything under the current directory that contains a folder called wlp.
glob(join(getcwd(), '*', 'wlp'))

Espero que estes exemplos o ajudem a ver o poder de algumas das funções que pode encontrar nos módulos normais da biblioteca Python.

def list_files(path):
    # returns a list of names (with extension, without full path) of all files 
    # in folder path
    files = []
    for name in os.listdir(path):
        if os.path.isfile(os.path.join(path, name)):
            files.append(name)
    return files 

Deve usar o módulo os para listar o conteúdo da pasta.os.listdir(".") devolve todo o conteúdo da pasta. Iteramos o resultado e adicionamos à lista.

import os

content_list = []

for content in os.listdir("."): # "." means current directory
    content_list.append(content)

print content_list

Primeira Parte ¹

Notas preliminares

• embora haja uma clara diferenciação entre ficheiro e directório termos no texto da pergunta, alguns podem argumentar que os directórios são na verdade ficheiros especiais
• a declaração: "todos os ficheiros de um directório " podem ser interpretados de duas formas::
  1. todos os descendentes directos (ou nível 1) apenas
  2. todos os descendentes em todo o directório árvore (incluindo as das sub-pastas)
• Quando a pergunta foi feita, imagino que o Python 2, foi a versão LTS , no entanto as amostras de código serão executadas por Python 3(.5) (eu vou mantê-los comoPython 2 compatível o mais possível; além disso, qualquer código pertencente a Python que eu vou publicar, é de v3.5.4 - salvo indicação em contrário). Isso tem consequências. relacionado com outra palavra-chave na pergunta: " adicione-os a uma lista ":
  • nas versões pre Python 2.2 , as sequências (iterables) eram representadas principalmente por listas (tuplas, conjuntos, ...)
  • Em Python 2.2, o conceito de gerador ([Python]: Geradores) - cortesia de [Python]: O rendimento instrução) - foi introduzido. Com o passar do tempo, as contrapartes do gerador começaram a aparecer para funções que devolvidos / trabalhados com listas
  • em Python 3 , O gerador é o comportamento por omissão
  Agora, eu não sei se devolver uma lista ainda é obrigatório( ou um gerador faria o mesmo), mas passar um gerador para o construtor list, criará uma lista a partir dela (e também consumi-la). O exemplo abaixo ilustra as diferenças no mapa [Python]: (função iterável, ...)

Python 2.7.10 (default, Mar  8 2016, 15:02:46) [MSC v.1600 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> m = map(lambda x: x, [1, 2, 3])  # Just a dummy lambda function
>>> m, type(m)
([1, 2, 3], <type 'list'>)
>>> len(m)
3

Python 3.5.4 (v3.5.4:3f56838, Aug  8 2017, 02:17:05) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> m = map(lambda x: x, [1, 2, 3])
>>> m, type(m)
(<map object at 0x000001B4257342B0>, <class 'map'>)
>>> len(m)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'map' has no len()
>>> lm0 = list(m)  # Construct a list out of the generator
>>> lm0, type(lm0)
([1, 2, 3], <class 'list'>)
>>>
>>> lm1 = list(m)  # Construct a list out of the same generator
>>> lm1, type(lm1)  # Empty list this time - generator already consumed
([], <class 'list'>)

Soluções

Programático abordagens:

1. [Python]: os.listdir(path=".')

   Devolve uma lista com os nomes dos itens do directório indicados pela localização. A lista está em ordem arbitrária, e não inclui as entradas especiais '.' e '..' ...

   
   

   >>> import os
   >>> root_dir = "root_dir"  # Path relative to current dir (os.getcwd())
   >>>
   >>> os.listdir(root_dir)  # List all the items in root_dir
   ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
   >>>
   >>> [item for item in os.listdir(root_dir) if os.path.isfile(os.path.join(root_dir, item))]  # Filter the items and only keep files (strip out directories)
   ['file0', 'file1']
   

   Eis um exemplo mais elaborado. ([68]} code_os_listdir.py):

   import os
   from pprint import pformat
   
   
   def _get_dir_content(path, include_folders, recursive):
       entries = os.listdir(path)
       for entry in entries:
           entry_with_path = os.path.join(path, entry)
           if os.path.isdir(entry_with_path):
               if include_folders:
                   yield entry_with_path
               if recursive:
                   for sub_entry in _get_dir_content(entry_with_path, include_folders, recursive):
                       yield sub_entry
           else:
               yield entry_with_path
   
   
   def get_dir_content(path, include_folders=True, recursive=True, prepend_folder_name=True):
       path_len = len(path) + len(os.path.sep)
       for item in _get_dir_content(path, include_folders, recursive):
           yield item if prepend_folder_name else item[path_len:]
   
   
   def _get_dir_content_old(path, include_folders, recursive):
       entries = os.listdir(path)
       ret = list()
       for entry in entries:
           entry_with_path = os.path.join(path, entry)
           if os.path.isdir(entry_with_path):
               if include_folders:
                   ret.append(entry_with_path)
               if recursive:
                   ret.extend(_get_dir_content_old(entry_with_path, include_folders, recursive))
           else:
               ret.append(entry_with_path)
       return ret
   
   
   def get_dir_content_old(path, include_folders=True, recursive=True, prepend_folder_name=True):
       path_len = len(path) + len(os.path.sep)
       return [item if prepend_folder_name else item[path_len:] for item in _get_dir_content_old(path, include_folders, recursive)]
   
   
   def main():
       root_dir = "root_dir"
       ret0 = get_dir_content(root_dir, include_folders=True, recursive=True, prepend_folder_name=True)
       lret0 = list(ret0)
       print(ret0, len(lret0), pformat(lret0))
       ret1 = get_dir_content_old(root_dir, include_folders=False, recursive=True, prepend_folder_name=False)
       print(len(ret1), pformat(ret1))
   
   
   if __name__ == "__main__":
       main()
   

   Notas:

   Há duas implementações.:
   • um que usa geradores (claro que neste exemplo parece inútil, já que converto o resultado para uma lista imediatamente)
   • O clássico (nomes de funções que terminam em _old)
2. a recursão é usada (para entrar nas sub-pastas)
3. para cada implementação existem duas funções:
   Um que começa com um sublinhado (_): "privado" (não deve ser chamado diretamente) - que faz todo o trabalho
4. o público (envoltório sobre o anterior): apenas retira o caminho inicial (se necessário) das entradas devolvidas. É uma implementação feia, mas é a única ideia com que eu poderia vir nesta altura.
5. em termos de desempenho, os geradores são geralmente um pouco mais rápidos (considerando tanto a criação e iteração vezes), mas eu não os testei em funções recursivas, e também estou iterando dentro da função sobre Geradores internos - não sei o quão amigável desempenho é que
6. Jogue com os argumentos para obter resultados diferentes




Resultado:

(py35x64_test) E:\Work\Dev\StackOverflow\q003207219>"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" "code_os_listdir.py"
<generator object get_dir_content at 0x000001BDDBB3DF10> 22 ['root_dir\\dir0',
 'root_dir\\dir0\\dir00',
 'root_dir\\dir0\\dir00\\dir000',
 'root_dir\\dir0\\dir00\\dir000\\file0000',
 'root_dir\\dir0\\dir00\\file000',
 'root_dir\\dir0\\dir01',
 'root_dir\\dir0\\dir01\\file010',
 'root_dir\\dir0\\dir01\\file011',
 'root_dir\\dir0\\dir02',
 'root_dir\\dir0\\dir02\\dir020',
 'root_dir\\dir0\\dir02\\dir020\\dir0200',
 'root_dir\\dir1',
 'root_dir\\dir1\\file10',
 'root_dir\\dir1\\file11',
 'root_dir\\dir1\\file12',
 'root_dir\\dir2',
 'root_dir\\dir2\\dir20',
 'root_dir\\dir2\\dir20\\file200',
 'root_dir\\dir2\\file20',
 'root_dir\\dir3',
 'root_dir\\file0',
 'root_dir\\file1']
11 ['dir0\\dir00\\dir000\\file0000',
 'dir0\\dir00\\file000',
 'dir0\\dir01\\file010',
 'dir0\\dir01\\file011',
 'dir1\\file10',
 'dir1\\file11',
 'dir1\\file12',
 'dir2\\dir20\\file200',
 'dir2\\file20',
 'file0',
 'file1']

1. [Python]: os.scandir(path=".') (!!! Python 3.5+ !!! embora eu pense que para versões anteriores era um módulo separado (também portado para Python 2))

   Devolve um iterador de os.DirEntry objectos correspondentes às entradas na pasta dada por localização . As entradas são apresentadas em ordem arbitrária, e as entradas especiais '.' e '..' não estão incluídas.

   A utilização de scandir () em vez de listdir() pode aumentar significativamente a desempenho de código que também precisa de tipo de arquivo ou informações de atributo de arquivo, porque os.Os objectos DirEntry expõem esta informação se o sistema operativo a fornecer ao analisar uma pasta. Todos os.DirEntry os métodos podem executar uma chamada de sistema, mas is_dir() e is_ file() normalmente só requerem uma chamada de sistema para ligações simbólicas; os.DirEntry.stat () necessita sempre de uma chamada de sistema no Unix, mas só necessita de uma para ligações simbólicas em Janela.

   
   

   >>> import os
   >>> root_dir = os.path.join(".", "root_dir")  # Explicitly prepending current directory
   >>> root_dir
   '.\\root_dir'
   >>>
   >>> scandir_iterator = os.scandir(root_dir)
   >>> scandir_iterator
   <nt.ScandirIterator object at 0x00000268CF4BC140>
   >>> [item.path for item in scandir_iterator]
   ['.\\root_dir\\dir0', '.\\root_dir\\dir1', '.\\root_dir\\dir2', '.\\root_dir\\dir3', '.\\root_dir\\file0', '.\\root_dir\\file1']
   >>>
   >>> [item.path for item in scandir_iterator]  # Will yield an empty list as it was consumed by previous iteration (automatically performed by the list comprehension)
   []
   >>>
   >>> scandir_iterator = os.scandir(root_dir)  # Reinitialize the generator
   >>> for item in scandir_iterator :
   ...     if os.path.isfile(item.path):
   ...             print(item.name)
   ...
   file0
   file1
   

   Notas:

   É semelhante a os.listdir
2. , Mas é também mais flexível (e oferece mais funcionalidade), mais Pythonic (e, em alguns casos, mais rápido)

1. [Python]: os.Anda.( top, topdown = True, onerror = None, followlinks=False)

   Gerar os nomes dos ficheiros num árvore de diretório andando a árvore de cima para baixo ou de baixo para cima. Para cada directório na árvore enraizada no directório top (incluindo top ), produz uma tripla (dirpath, dirnames, filenames).

   
   

   >>> import os
   >>> root_dir = os.path.join(os.getcwd(), "root_dir")  # Specify the full path
   >>> root_dir
   'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir'
   >>>
   >>> walk_generator = os.walk(root_dir)
   >>> root_dir_entry = next(walk_generator)  # First entry corresponds to the root dir (that was passed as an argument)
   >>> root_dir_entry
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir', ['dir0', 'dir1', 'dir2', 'dir3'], ['file0', 'file1'])
   >>>
   >>> root_dir_entry[1] + root_dir_entry[2]  # Display the dirs and the files (that are direct descendants) in a single list
   ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
   >>>
   >>> [os.path.join(root_dir_entry[0], item) for item in root_dir_entry[1] + root_dir_entry[2]]  # Display all the entries in the previous list by their full path
   ['E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir1', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir2', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir3', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\file0', 'E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\file1']
   >>>
   >>> for entry in walk_generator:  # Display the rest of the elements (corresponding to every subdir)
   ...     print(entry)
   ...
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0', ['dir00', 'dir01', 'dir02'], [])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir00', ['dir000'], ['file000'])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir00\\dir000', [], ['file0000'])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir01', [], ['file010', 'file011'])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir02', ['dir020'], [])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir02\\dir020', ['dir0200'], [])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir0\\dir02\\dir020\\dir0200', [], [])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir1', [], ['file10', 'file11', 'file12'])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir2', ['dir20'], ['file20'])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir2\\dir20', [], ['file200'])
   ('E:\\Work\\Dev\\StackOverflow\\q003207219\\root_dir\\dir3', [], [])
   

   Notas:

   Debaixo das cenas, usa os.listdir (os.scandir se disponível)
Faz o trabalho pesado repetindo-se em subpastas

1. [Python]: glob.glob(nome do caminho,*, recursivo=falso) ([Python]: glob.iglob(nome do caminho,*, recursivo=falso))

   Devolve uma lista possivelmente vazia de nomes dos locais que correspondem a o nome do local , que deve ser um texto que contém uma especificação de localização. o nome do caminho pode ser absoluto (como /usr/src/Python-1.5/Makefile) ou relativo (como ../../Tools/*/*.gif), e pode conter caracteres especiais ao estilo da concha. As ligações simbólicas quebradas estão incluídas nos resultados (como na shell).
   ...
   alterado na versão 3.5: Suporte para globos recursivos usando " **".

   
   

   >>> import glob, os
   >>> wildcard_pattern = "*"
   >>> root_dir = os.path.join("root_dir", wildcard_pattern)  # Match every file/dir name
   >>> root_dir
   'root_dir\\*'
   >>>
   >>> glob_list = glob.glob(root_dir)
   >>> glob_list
   ['root_dir\\dir0', 'root_dir\\dir1', 'root_dir\\dir2', 'root_dir\\dir3', 'root_dir\\file0', 'root_dir\\file1']
   >>>
   >>> [item.replace("root_dir" + os.path.sep, "") for item in glob_list]  # Strip the dir name and the path separator from begining
   ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
   >>>
   >>> for entry in glob.iglob(root_dir + "*", recursive=True):
   ...     print(entry)
   ...
   root_dir\
   root_dir\dir0
   root_dir\dir0\dir00
   root_dir\dir0\dir00\dir000
   root_dir\dir0\dir00\dir000\file0000
   root_dir\dir0\dir00\file000
   root_dir\dir0\dir01
   root_dir\dir0\dir01\file010
   root_dir\dir0\dir01\file011
   root_dir\dir0\dir02
   root_dir\dir0\dir02\dir020
   root_dir\dir0\dir02\dir020\dir0200
   root_dir\dir1
   root_dir\dir1\file10
   root_dir\dir1\file11
   root_dir\dir1\file12
   root_dir\dir2
   root_dir\dir2\dir20
   root_dir\dir2\dir20\file200
   root_dir\dir2\file20
   root_dir\dir3
   root_dir\file0
   root_dir\file1
   

   Notas:

   • usos os.listdir
   • para árvores grandes (especialmente se {[29] } Está ligado), {[30] } é preferido
   • permite uma filtragem avançada com base no nome (devido ao wildcard)

1. [Python]: class pathlib.Caminho(*elementos de localização) (!!! Python3+ !!! Não sei se backported)

   >>> import pathlib
   >>> root_dir = "root_dir"
   >>> root_dir_instance = pathlib.Path(root_dir)
   >>> root_dir_instance
   WindowsPath('root_dir')
   >>> root_dir_instance.name
   'root_dir'
   >>> root_dir_instance.is_dir()
   True
   >>>
   >>> [item.name for item in root_dir_instance.glob("*")]  # Wildcard searching for all direct descendants
   ['dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
   >>>
   >>> [os.path.join(item.parent.name, item.name) for item in root_dir_instance.glob("*") if not item.is_dir()]  # Display paths (including parent) for files only
   ['root_dir\\file0', 'root_dir\\file1']
   

   Notas:

   Esta é uma maneira de atingir o nosso objectivo.
   • é o estilo OOP de manipulação dos caminhos
   • oferece muitos funcionalidades

1. [dircache.listdir(localização) (!!! removido em Python3 !!!)

   • Mas, de acordo com ${PYTHON_SRC_DIR}/Lib/dircache.py: ~#20+ (a partir de v2.7.14), é só uma (fina) wrapper os.listdir

   
   

   def listdir(path):
       """List directory contents, using cache."""
       try:
           cached_mtime, list = cache[path]
           del cache[path]
       except KeyError:
           cached_mtime, list = -1, []
       mtime = os.stat(path).st_mtime
       if mtime != cached_mtime:
           list = os.listdir(path)
           list.sort()
       cache[path] = mtime, list
       return list
   

1. [man!: OPENDIR(3) / [READDIR(3) / [man]: CLOSEDIR(3) via [Python]: ctypes - uma biblioteca de funções estrangeiras para Python (!!! UX específico !!!)

   Ctypes é uma biblioteca de funções estrangeiras para Python. Ele fornece tipos de dados compatíveis com C, e permite funções de chamada em DLLs ou bibliotecas compartilhadas. Pode ser usado para embrulhar estas bibliotecas em puro Jiboia.

   code_ctypes.py:

   #!/usr/bin/env python3
   
   import sys
   from ctypes import Structure, \
       c_ulonglong, c_longlong, c_ushort, c_ubyte, c_char, c_int, \
       CDLL, POINTER, \
       create_string_buffer, get_errno, set_errno, cast, sizeof
   
   
   DT_DIR = 4
   DT_REG = 8
   
   char256 = c_char * 256
   
   class LinuxDirent64(Structure):
       _fields_ = [
           ("d_ino", c_ulonglong),
           ("d_off", c_longlong),
           ("d_reclen", c_ushort),
           ("d_type", c_ubyte),
           ("d_name", char256),
       ]
   
   LinuxDirent64Ptr = POINTER(LinuxDirent64)
   
   libc_dll = CDLL(None)
   opendir = libc_dll.opendir
   readdir = libc_dll.readdir
   closedir = libc_dll.closedir
   libc_dll.__errno_location.restype = POINTER(c_int)
   errno_loc_func = libc_dll.__errno_location
   
   
   def _get_errno():
       return "errno: {:d}({:d})".format(get_errno(), errno_loc_func().contents.value)
   
   
   def get_dir_content(path):
       ret = [path, list(), list()]
       dir_stream = opendir(create_string_buffer(path.encode()))
       if (dir_stream == 0):
           print("opendir returned NULL ({:s})".format(_get_errno()))
           return ret
       set_errno(0)
       dirent_addr = readdir(dir_stream)
       while dirent_addr:
           dirent_ptr = cast(dirent_addr, LinuxDirent64Ptr)
           dirent = dirent_ptr.contents
           name = dirent.d_name.decode()
           if dirent.d_type & DT_DIR:
               if name not in (".", ".."):
                   ret[1].append(name)
           elif dirent.d_type & DT_REG:
               ret[2].append(name)
           dirent_addr = readdir(dir_stream)
       if get_errno() or errno_loc_func().contents.value:
           print("readdir returned NULL ({:s})".format(_get_errno()))
       closedir(dir_stream)
       return ret
   
   
   def main():
       print("{:s} on {:s}\n".format(sys.version, sys.platform))
       root_dir = "root_dir"
       entries = get_dir_content(root_dir)
       print(entries)
   
   
   if __name__ == "__main__":
       main()
   

   Notas:

   • carrega as três funções de libc (carregado no processo actual) e chama-as (para mais detalhes, verifique [Stack Overflow]: como é que verifico se existe um ficheiro com o Python? (Resposta de@CristiFati) - últimas notas do item #4.). Isso colocaria esta abordagem muito perto do Python / C edge
   • LinuxDirent64 é a representaçãoctypes de struct dirent64 de dirent.h (assim são as DT_* constantes) da minha máquina: Ubtu 16 x64 (4.10.0-40-genérico e libc6-dev:amd64). Em outros sabores / versões, a definição de struct pode diferir, E se assim for, octypes alias deve ser atualizado, caso contrário irá produzir comportamento indefinido
   • errno_loc_func (e tudo o que está relacionado com ele) é porque o conjunto de funções errno em caso de erro, e preciso de verificar o seu valor. Aparentemente, get_errno não funciona (com um nome inválido, opendir devolve NULL, mas get_errno ainda devolve 0), ou ainda não o descobri
   • devolve os dados no formato de os.walk. Eu não me preocupei em torná-lo recursivo, mas a partir do código existente, Isso seria uma tarefa bastante trivial
   • tudo é possível em Win também, os dados (bibliotecas, funções, estruturas, constantes, ...) differ

   
   

   Resultado:

   cfati@testserver:~/work/stackoverflow/q003207219$ ./code_ctypes.py
   3.5.2 (default, Nov 23 2017, 16:37:01)
   [GCC 5.4.0 20160609] on linux
   
   ['root_dir', ['dir3', 'dir2', 'dir0', 'dir1'], ['file0', 'file1']]
   

1. [ActiveState]: win32file.FindFilesW (!!! win específico !!!)

   Obtém uma lista de nomes de ficheiros correspondentes, usando a API do Windows Unicode. Uma interface para a API FindFirstFileW/FindNextFileW/Find close funcao.

   
   

   >>> import os, win32file, win32con
   >>> root_dir = "root_dir"
   >>> wildcard = "*"
   >>> root_dir_wildcard = os.path.join(root_dir, wildcard)
   >>> entry_list = win32file.FindFilesW(root_dir_wildcard)
   >>> len(entry_list)  # Don't display the whole content as it's too long
   8
   >>> [entry[-2] for entry in entry_list]  # Only display the entry names
   ['.', '..', 'dir0', 'dir1', 'dir2', 'dir3', 'file0', 'file1']
   >>>
   >>> [entry[-2] for entry in entry_list if entry[0] & win32con.FILE_ATTRIBUTE_DIRECTORY and entry[-2] not in (".", "..")]  # Filter entries and only display dir names (except self and parent)
   ['dir0', 'dir1', 'dir2', 'dir3']
   >>>
   >>> [os.path.join(root_dir, entry[-2]) for entry in entry_list if entry[0] & (win32con.FILE_ATTRIBUTE_NORMAL | win32con.FILE_ATTRIBUTE_ARCHIVE)]  # Only display file "full" names
   ['root_dir\\file0', 'root_dir\\file1']
   

   Notas:

   • win32file.FindFilesW faz parte de [GitHub]: Python para as extensões do Windows (pywin32) , que é umPython wrapper sobre WINAPI S
   • a ligação de documentação é de https://www.activestate.com , como não encontrei nenhumpywin32 documentação oficial

1. instale algum (outro) pacote de terceiros que faz o truque
   • muito provavelmente, irá confiar em um (ou mais) dos acima (talvez com ligeiras personalizações)

Notas (sobre as coisas acima):

• o código destina - se a ser portátil (excepto os locais destinados a uma área específica-marcada) ou cruzado.:
  • plataforma ( Ux, Win, )
  • Python versão (2, 3, )
• vários estilos de caminho (absolutos, parentes) foram usados nas variantes acima, para ilustrar o fato de que as "ferramentas" usadas são flexíveis nesta direção
• os.listdir e os.scandir usar opendir / readdir / closedir ([MSDN]: função FindFirstFile / [MSDN]: função FindNextFile / [MSDN]: FindClose função) (via "${PYTHON_SRC_DIR}/Modules/posixmodule.c")
• win32file.FindFilesW usa aqueles (específicos para o Win funções também (via " ${PYWIN32_ SRC_DIR}/win32/src / win32file.i")
• get_dir_content (do ponto #1.([69]}) pode ser implementado usando qualquer uma destas abordagens (algumas necessitarão de mais trabalho e outras menos)
  • avançadas de filtragem (em vez de apenas um arquivo vs. dir), o que poderia ser feito: e.g. o include_folders argumento poderia ser substituído por um outro (por exemplo, filter_func), o que seria uma função que leva um caminho como argumento: filter_func=lambda x: True (isto não tira nada) e dentro de get_dir_content algo como: if not filter_func(entry_with_path): continue (se a função falhar para uma entrada, será ignorada), mas quanto mais complexo o código se tornar, mais tempo levará para executar
• Nota bene! uma vez que a recursão é usada, devo mencionar que fiz alguns testes no meu laptop (Win 10 x64), totalmente sem relação com este problema, e quando o nível de recursão estava a atingir valores algures no (990 .. 1000) intervalo (limite recursivo - 1000 (default)), I got StackOverflow {[[69]}:). Se a árvore de diretórios exceder esse limite (Eu não sou um especialista em FS, então eu não sei se isso é possível), isso pode ser um problema.
  Devo também mencionar que não tentei aumentar o limite recursivo porque não tenho experiência na área (quanto posso aumentá-la antes de ter que aumentar também a pilha no nível OS), mas em teoria haverá sempre a possibilidade de falha, se a profundidade de dir for maior do que o mais elevado possível limite recursivo (nessa máquina)
• as amostras de código são apenas para fins demonstrativos. Isso significa que eu não levei em conta o manuseio de erros (Eu não acho que haja qualquer try / except / else / finally block), de modo que o código não é robusto (a razão é: mantê-lo o mais simples e curto possível). Para a produção de , deve adicionar-se também o tratamento de erros

_{1. Devido ao facto de o limite de SO's post (question / answer) ser 30000 chars ( [SE.Meta]: conhecer os seus limites: Qual é o comprimento máximo de uma pergunta título, post, imagem e links utilizados?, a resposta foi dividida em duas partes. Por favor, visite também [SO]: Como faço para listar todos os arquivos de um diretório? (Resposta de@CristiFati - "Parte Dois").}

import os
lst=os.listdir(path)

Os.a listdir devolve uma lista que contém os nomes dos itens na pasta indicada pela localização.

Se está à procura de uma implementação em Python de find, esta é uma receita que uso com bastante frequência:

from findtools.find_files import (find_files, Match)

# Recursively find all *.sh files in **/usr/bin**
sh_files_pattern = Match(filetype='f', name='*.sh')
found_files = find_files(path='/usr/bin', match=sh_files_pattern)

for found_file in found_files:
    print found_file

Então eu fiz um pacote PyPI a partir dele e há também um repositório de GitHub . Espero que alguém o ache potencialmente útil para este código.

O Python 3.5 introduziu um novo método mais rápido para percorrer o directório - os.scandir().

Exemplo:

for file in os.scandir('/usr/bin'):
    line = ''
    if file.is_file():
        line += 'f'
    elif file.is_dir():
        line += 'd'
    elif file.is_symlink():
        line += 'l'
    line += '\t'
    print("{}{}".format(line, file.name))

A devolução de uma lista de ficheiros absolutos não se repete nas sub-pastas

L = [os.path.join(os.getcwd(),f) for f in os.listdir('.') if os.path.isfile(os.path.join(os.getcwd(),f))]

Lista todos os ficheiros numa pasta:

import os
from os import path

files = [x for x in os.listdir(directory_path) if path.isfile(directory_path+os.sep+x)]

import os
import os.path


def get_files(target_dir):
    item_list = os.listdir(target_dir)

    file_list = list()
    for item in item_list:
        item_dir = os.path.join(target_dir,item)
        if os.path.isdir(item_dir):
            file_list += get_files(item_dir)
        else:
            file_list.append(item_dir)
    return file_list

# -** coding: utf-8 -*-
import os
import traceback

print '\n\n'

def start():
    address = "/home/ubuntu/Desktop"
    try:
        Folders = []
        Id = 1
        for item in os.listdir(address):
            endaddress = address + "/" + item
            Folders.append({'Id': Id, 'TopId': 0, 'Name': item, 'Address': endaddress })
            Id += 1         

            state = 0
            for item2 in os.listdir(endaddress):
                state = 1
            if state == 1: 
                Id = FolderToList(endaddress, Id, Id - 1, Folders)
        return Folders
    except:
        print "___________________________ ERROR ___________________________\n" + traceback.format_exc()

def FolderToList(address, Id, TopId, Folders):
    for item in os.listdir(address):
        endaddress = address + "/" + item
        Folders.append({'Id': Id, 'TopId': TopId, 'Name': item, 'Address': endaddress })
        Id += 1

        state = 0
        for item in os.listdir(endaddress):
            state = 1
        if state == 1: 
            Id = FolderToList(endaddress, Id, Id - 1, Folders)
    return Id

print start()

import dircache
list = dircache.listdir(pathname)
i = 0
check = len(list[0])
temp = []
count = len(list)
while count != 0:
  if len(list[i]) != check:
     temp.append(list[i-1])
     check = len(list[i])
  else:
    i = i + 1
    count = count - 1

print temp

Usando geradores

import os
def get_files(search_path):
     for (dirpath, _, filenames) in os.walk(search_path):
         for filename in filenames:
             yield os.path.join(dirpath, filename)
list_files = get_files('.')
for filename in list_files:
    print(filename)

Se te importas com o desempenho, tenta scandir. Para O Python 2.x, você pode precisar instalá-lo manualmente. Exemplos:

# python 2.x
import scandir
import sys

de = scandir.scandir(sys.argv[1])
while 1:
    try:
        d = de.next()
        print d.path
    except StopIteration as _:
        break

Isto poupa muito tempo quando você precisa de digitalizar uma pasta enorme, e você não precisa de buffer uma lista enorme, basta obter uma a uma. E também você pode fazer isso recursivamente:

def scan_path(path):
    de = scandir.scandir(path)
    while 1:
        try:
            e = de.next()
            if e.is_dir():
                scan_path(e.path)
            else:
                print e.path
        except StopIteration as _:
                break

Utilize esta função se quiser usar um tipo de ficheiro diferente ou obter a pasta completa:

import os

def createList(foldername, fulldir = True, suffix=".jpg"):
    file_list_tmp = os.listdir(foldername)
    #print len(file_list_tmp)
    file_list = []
    if fulldir:
        for item in file_list_tmp:
            if item.endswith(suffix):
                file_list.append(os.path.join(foldername, item))
    else:
        for item in file_list_tmp:
            if item.endswith(suffix):
                file_list.append(item)
    return file_list

import os 
os.listdir(path)

Isto irá devolver uma lista de todos os ficheiros e pastas em path.

filenames = next(os.walk(path))[2]

Isto irá devolver apenas uma lista de ficheiros, não sub-pastas.

Usando os biblioteca.

import os
for root, dirs,files in os.walk("your dir path", topdown=True):
    for name in files:
        print(os.path.join(root, name))

Execute ficheiros de pesquisa () com um directório como parâmetro e ele irá devolver uma lista de todos os ficheiros nele contidos.

import os
def findfiles(directory):
    objects = os.listdir(directory)  # find all objects in a dir

    files = []
    for i in objects:  # check if very object in the folder ...
        if os.path.isfile(os.path.join(directory, i)):  # ... is a file.
            files.append(i)  # if yes, append it.
    return files

Referindo-se à resposta por @adamk, aqui está o meu método de detecção de osem resposta ao Comentário de inconsistência de barra por @Anti Earth

import sys
import os
from pathlib import Path
from glob import glob
platformtype = sys.platform
if platformtype == 'win32':
    slash = "\\"
if platformtype == 'darwin':
    slash = "/"

# TODO: How can I list all files of a directory in Python and add them to a list?

# Step 1 - List all files of a directory

# Method 1: Find only pre-defined filetypes (.txt) and no subfiles, answer provided by @adamk
dir1 = "%sfoo%sbar%s*.txt" % (slash)
_files = glob(dir1)

# Method 2: Find all files and no subfiles
dir2 = "%sfoo%sbar%s" % (slash)
_files = (x for x in Path("dir2").iterdir() if x.is_file())

# Method 3: Find all files and all subfiles
dir3 = "%sfoo%sbar" % (slash)
_files = (x for x in Path('dir3').glob('**/*') if x.is_file())


# Step 2 - Add them to a list

files_list = []
for eachfiles in _files:
    files_basename = os.path.basename(eachfiles)
    files_list.append(files_basename)

print(files_list)
['file1.txt', 'file2.txt', .... ]

Presumo que queira apenas os nomes de base na lista.

Consulte este post para definir previamente vários formatos de ficheiro para o Método 1.

Vou fornecer uma amostra de um invólucro onde o tipo de origem e o tipo de ficheiro podem ser fornecidos como entrada. O código devolve uma lista de nomes de ficheiros com extensão csv. Utilizar . no caso de todos os ficheiros terem de ser devolvidos. Isto também irá digitalizar recursivamente as sub-pastas.

[y for x in os.walk(sourcePath) for y in glob(os.path.join(x[0], '*.csv'))]

Modificar as extensões de ficheiros e a localização de origem, conforme necessário.

Versão muito simples:

import os
[f for f in os.listdir(os.getcwd) if ...]

Outra variante muito legível para o Python 3.4+ está a usar o pathlib.Caminho.glob:

from pathlib import Path
folder = '/foo'
[f for f in Path(folder).glob('*') if f.is_file()]

É simples tornar mais específico, por exemplo, procurar apenas ficheiros de código Python que não sejam ligações simbólicas, também em todas as sub-pastas:

[f for f in Path(folder).glob('**/*.py') if not f.is_symlink()]

Segunda Parte ¹

Soluções (continuação)

Outras abordagens:

1. Usar Python apenas como um invólucro

   • Tudo é feito usando outra tecnologia
   • essa tecnologia é invocada a partir de Python

   • O sabor mais famoso que eu conheço é o que eu chamo de administrador de Sistemaabordagem:

     • usar Python (ou qualquer linguagem de programação para isso matter) para executar os comandos shell (e analisar as suas saídas - em geral, esta abordagem deve ser evitada, uma vez que se algum formato de saída de comandos diferir ligeiramente entreOs versões / sabores, o código de análise deve ser adaptado também; para não mencionar non EN locales)
     Há quem considere isto um golpe limpo.
     • eu considero-o mais como uma forma de trabalho esfarrapada (gainarie ), como a acção em si é realizada a partir de shell (cmd neste caso), e assim não tem nada a ver com Python.
     • filtragem (grep / findstr) ou formatação de saída pode ser feito em ambos os lados, mas eu não vou insistir nisso. Além disso, usei deliberadamente os.system em vez de subprocess.Popen.

     (py35x64_test) E:\Work\Dev\StackOverflow\q003207219>"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" -c "import os;os.system(\"dir /b root_dir\")"
     dir0
     dir1
     dir2
     dir3
     file0
     file1
     

_{1. Devido ao facto de o limite de SO's post (question / answer) ser 30000 caracteres ([77]} [SE.Meta]: conhecer os seus limites: Qual é o comprimento máximo de uma pergunta título, post, imagem e links utilizados?A resposta foi dividida em duas partes. Por favor, certifique-se de ler [SO]: Como faço para listar todos os arquivos de um diretório? (Resposta de@CristiFati - "parte um") antes.}