Uzyskanie listy wszystkich podkatalogów w bieżącym katalogu

Możesz po prostu użyć glob.glob

from glob import glob
glob("/path/to/directory/*/")

Nie zapomnij o ciągnięciu / po *.

import os

d = '.'
[os.path.join(d, o) for o in os.listdir(d) 
                    if os.path.isdir(os.path.join(d,o))]

Znacznie ładniejszy niż powyższy, ponieważ nie potrzebujesz kilku systemów operacyjnych./ align = "left" / join() i otrzymasz pełną ścieżkę bezpośrednio (jeśli chcesz), możesz to zrobić w Python 3.5 i wyżej.

subfolders = [ f.path for f in os.scandir(folder) if f.is_dir() ]

To da pełną ścieżkę do podkatalogu. Jeśli chcesz tylko nazwę podkatalogu użyj f.name zamiast f.path

Https://docs.python.org/3/library/os.html#os.scandir

Lekko OT: w razie potrzeby wszystkie podfoldery rekurencyjnie i/lub wszystkie pliki rekurencyjnie, spójrz na tę funkcję, która jest szybsza niż os.walk & glob i zwróci listę wszystkich podfolderów, a także wszystkich plików wewnątrz tych (pod-)podfolderów: https://stackoverflow.com/a/59803793/2441026

Jeśli chcesz tylko wszystkie podfoldery rekurencyjnie :

def fast_scandir(dirname):
    subfolders= [f.path for f in os.scandir(dirname) if f.is_dir()]
    for dirname in list(subfolders):
        subfolders.extend(fast_scandir(dirname))
    return subfolders

Zwraca listę wszystkich podfolderów z ich pełnymi ścieżkami. To znowu jest szybsze niż os.walk i dużo szybciej niż glob.

Analiza wszystkich funkcji

Tl;dr:
- Jeśli chcesz uzyskać wszystkie natychmiastowe podkatalogi dla folderu użyj os.scandir.
- Jeśli chcesz uzyskać wszystkie podkatalogi, nawet zagnieżdżone, użyj os.walk lub - nieco szybciej - powyższej funkcji fast_scandir.
- Nigdy nie używaj os.walk tylko dla podkatalogów najwyższego poziomu, ponieważ mogą to być setki (!) razy wolniej niż os.scandir.

• jeśli uruchomisz poniższy kod, zrób pamiętaj, aby uruchomić go raz, aby Twój system operacyjny miał dostęp do folderu, Odrzuć wyniki i uruchom test, w przeciwnym razie wyniki będą wkręcane.
• możesz chcieć pomieszać wywołania funkcji, ale przetestowałem to i to nie miało znaczenia.
• wszystkie przykłady dadzą pełną ścieżkę do folderu. Przykład pathlib jako obiekt (Windows)Path.
• pierwszym elementem os.walk będzie katalog podstawowy. Więc nie dostaniesz tylko podkatalogi. Możesz użyć fu.pop(0), aby usunąć to.
• żaden z wyników nie będzie używał sortowania naturalnego . Oznacza to, że wyniki będą sortowane w następujący sposób: 1, 10, 2. Aby uzyskać naturalne sortowanie (1, 2, 10), proszę spojrzeć na https://stackoverflow.com/a/48030307/2441026

Wyniki :

os.scandir      took   1 ms. Found dirs: 439
os.walk         took 463 ms. Found dirs: 441 -> it found the nested one + base folder.
glob.glob       took  20 ms. Found dirs: 439
pathlib.iterdir took  18 ms. Found dirs: 439
os.listdir      took  18 ms. Found dirs: 439

Testowane z W7x64, Python 3.8.1.

# -*- coding: utf-8 -*-
# Python 3


import time
import os
from glob import glob
from pathlib import Path


directory = r"<insert_folder>"
RUNS = 1


def run_os_walk():
    a = time.time_ns()
    for i in range(RUNS):
        fu = [x[0] for x in os.walk(directory)]
    print(f"os.walk\t\t\ttook {(time.time_ns() - a) / 1000 / 1000 / RUNS:.0f} ms. Found dirs: {len(fu)}")


def run_glob():
    a = time.time_ns()
    for i in range(RUNS):
        fu = glob(directory + "/*/")
    print(f"glob.glob\t\ttook {(time.time_ns() - a) / 1000 / 1000 / RUNS:.0f} ms. Found dirs: {len(fu)}")


def run_pathlib_iterdir():
    a = time.time_ns()
    for i in range(RUNS):
        dirname = Path(directory)
        fu = [f for f in dirname.iterdir() if f.is_dir()]
    print(f"pathlib.iterdir\ttook {(time.time_ns() - a) / 1000 / 1000 / RUNS:.0f} ms. Found dirs: {len(fu)}")


def run_os_listdir():
    a = time.time_ns()
    for i in range(RUNS):
        dirname = Path(directory)
        fu = [os.path.join(directory, o) for o in os.listdir(directory) if os.path.isdir(os.path.join(directory, o))]
    print(f"os.listdir\t\ttook {(time.time_ns() - a) / 1000 / 1000 / RUNS:.0f} ms. Found dirs: {len(fu)}")


def run_os_scandir():
    a = time.time_ns()
    for i in range(RUNS):
        fu = [f.path for f in os.scandir(directory) if f.is_dir()]
    print(f"os.scandir\t\ttook {(time.time_ns() - a) / 1000 / 1000 / RUNS:.0f} ms.\tFound dirs: {len(fu)}")


if __name__ == '__main__':
    run_os_scandir()
    run_os_walk()
    run_glob()
    run_pathlib_iterdir()
    run_os_listdir()

Jeśli potrzebujesz rekurencyjnego rozwiązania, które znajdzie wszystkie podkatalogi w podkatalogach, użyj opcji walk zgodnie z wcześniejszą propozycją.

Jeśli potrzebujesz tylko katalogów podrzędnych bieżącego katalogu, połącz os.listdir z os.path.isdir

Wolę używać filtra ( https://docs.python.org/2/library/functions.html#filter ), ale to tylko kwestia gustu.

d='.'
filter(lambda x: os.path.isdir(os.path.join(d, x)), os.listdir(d))

Python 3.4 wprowadził Moduł pathlib do biblioteki standardowej, który zapewnia obiektowe podejście do obsługi ścieżek systemu plików:

from pathlib import Path

p = Path('./')

# All subdirectories in the current directory, not recursive.
[f for f in p.iterdir() if f.is_dir()]

Aby rekurencyjnie wyświetlić listę wszystkich podkatalogów, można użyć globbingu ścieżek ze wzorem **.

# This will also include the current directory '.'
list(p.glob('**'))

Zauważ, że pojedynczy * jako wzorzec glob będzie zawierał zarówno pliki, jak i katalogi nie rekurencyjnie. Aby uzyskać tylko katalogi, można dodać końcowe /, ale działa to tylko podczas korzystania z biblioteka glob bezpośrednio, Nie podczas korzystania z glob poprzez pathlib:

import glob

# These three lines return both files and directories
list(p.glob('*'))
list(p.glob('*/'))
glob.glob('*')

# Whereas this returns only directories
glob.glob('*/')

Więc Path('./').glob('**') pasuje do tych samych ścieżek co glob.glob('**/', recursive=True).

Pathlib jest również dostępny w Pythonie 2.7 za pośrednictwem modułu pathlib2 na PyPi.

Zaimplementowano to używając python-os-walk. ( http://www.pythonforbeginners.com/code-snippets-source-code/python-os-walk/)

import os

print("root prints out directories only from what you specified")
print("dirs prints out sub-directories from root")
print("files prints out all files from root and directories")
print("*" * 20)

for root, dirs, files in os.walk("/var/log"):
    print(root)
    print(dirs)
    print(files)

Możesz uzyskać listę podkatalogów (i plików) w Pythonie 2.7 używając systemu operacyjnego.listdir (ścieżka)

import os
os.listdir(path)  # list of subdirectories and files

Wypisywanie tylko katalogów

print("\nWe are listing out only the directories in current directory -")
directories_in_curdir = filter(os.path.isdir, os.listdir(os.curdir))
print(directories_in_curdir)

Wypisywanie tylko plików w bieżącym katalogu

files = filter(os.path.isfile, os.listdir(os.curdir))
print("\nThe following are the list of all files in the current directory -")
print(files)

Ponieważ natknąłem się na ten problem używając Pythona 3.4 i ścieżek Windows UNC, oto wariant dla tego środowiska:

from pathlib import WindowsPath

def SubDirPath (d):
    return [f for f in d.iterdir() if f.is_dir()]

subdirs = SubDirPath(WindowsPath(r'\\file01.acme.local\home$'))
print(subdirs)

Pathlib jest nowością w Pythonie 3.4 i znacznie ułatwia pracę ze ścieżkami w różnych systemach operacyjnych: https://docs.python.org/3.4/library/pathlib.html

Chociaż odpowiedź na to pytanie jest już dawno temu. Chcę polecić korzystanie z pathlib moduł, ponieważ jest to solidny sposób pracy na systemach Windows i Unix OS.

Tak aby uzyskać wszystkie ścieżki w określonym katalogu łącznie z podkatalogami:

from pathlib import Path
paths = list(Path('myhomefolder', 'folder').glob('**/*.txt'))

# all sorts of operations
file = paths[0]
file.name
file.stem
file.parent
file.suffix

Itd.

Dzięki za wskazówki. Natknąłem się na problem z softlinkami (nieskończona rekurencja) zwracanymi jako dirs. Softlinks? Nie chcemy żadnych śmierdzących miękkich linków! Więc...

To tylko dirs, nie softlinks:

>>> import os
>>> inf = os.walk('.')
>>> [x[0] for x in inf]
['.', './iamadir']

Copy paste friendly in ipython:

import os
d='.'
folders = list(filter(lambda x: os.path.isdir(os.path.join(d, x)), os.listdir(d)))

Wyjście z print(folders):

['folderA', 'folderB']

Oto kilka prostych funkcji opartych na przykładzie @ Blair Conrad -

import os

def get_subdirs(dir):
    "Get a list of immediate subdirectories"
    return next(os.walk(dir))[1]

def get_subfiles(dir):
    "Get a list of immediate subfiles"
    return next(os.walk(dir))[2]

Tak to robię.

    import os
    for x in os.listdir(os.getcwd()):
        if os.path.isdir(x):
            print(x)

Bazując na rozwiązaniu Eli Bendersky ' ego, użyj następującego przykładu:

import os
test_directory = <your_directory>
for child in os.listdir(test_directory):
    test_path = os.path.join(test_directory, child)
    if os.path.isdir(test_path):
        print test_path
        # Do stuff to the directory "test_path"

Gdzie <your_directory> jest ścieżką do katalogu, który chcesz przejść.

Z pełną ścieżką i rozliczaniem ścieżki ., .., \\, ..\\..\\subfolder, itd:

import os, pprint
pprint.pprint([os.path.join(os.path.abspath(path), x[0]) \
    for x in os.walk(os.path.abspath(path))])

Ta odpowiedź wydaje się jeszcze nie istnieć.

directories = [ x for x in os.listdir('.') if os.path.isdir(x) ]

Miałem ostatnio podobne pytanie i dowiedziałem się, że najlepszą odpowiedzią dla Pythona 3.6 (jak dodał użytkownik havlock) jest użycie os.scandir. Ponieważ wydaje się, że nie ma rozwiązania przy jego użyciu, dodam własne. Po pierwsze, nie rekurencyjne rozwiązanie, które wymienia tylko podkatalogi bezpośrednio pod katalogiem głównym.

def get_dirlist(rootdir):

    dirlist = []

    with os.scandir(rootdir) as rit:
        for entry in rit:
            if not entry.name.startswith('.') and entry.is_dir():
                dirlist.append(entry.path)

    dirlist.sort() # Optional, in case you want sorted directory names
    return dirlist

Wersja rekurencyjna wyglądałaby tak:

def get_dirlist(rootdir):

    dirlist = []

    with os.scandir(rootdir) as rit:
        for entry in rit:
            if not entry.name.startswith('.') and entry.is_dir():
                dirlist.append(entry.path)
                dirlist += get_dirlist(entry.path)

    dirlist.sort() # Optional, in case you want sorted directory names
    return dirlist

Należy pamiętać, że entry.path dzierży absolutną ścieżkę do podkatalogu. Jeśli potrzebujesz tylko nazwy folderu, możesz zamiast tego można użyć entry.name. Zobacz os.DirEntry aby uzyskać dodatkowe informacje o obiekcie entry.

Najprostszy sposób:

from pathlib import Path
from glob import glob

current_dir = Path.cwd()
all_sub_dir_paths = glob(str(current_dir) + '/*/') # returns list of sub directory paths

all_sub_dir_names = [Path(sub_dir).name for sub_dir in all_sub_dir_paths] 

Użyj funkcji filtra os.path.isdir nad os.listdir() coś takiego filter(os.path.isdir,[os.path.join(os.path.abspath('PATH'),p) for p in os.listdir('PATH/')])

Spowoduje wyświetlenie wszystkich podkatalogów w drzewie plików.

import pathlib


def list_dir(dir):
    path = pathlib.Path(dir)
    dir = []
    try:
        for item in path.iterdir():
            if item.is_dir():
                dir.append(item)
                dir = dir + list_dir(item)
        return dir
    except FileNotFoundError:
        print('Invalid directory')

pathlib jest nowy w wersji 3.4

Funkcja zwracająca listę wszystkich podkatalogów w podanej ścieżce do pliku. Przeszukuje całe drzewo plików.

import os

def get_sub_directory_paths(start_directory, sub_directories):
    """
    This method iterates through all subdirectory paths of a given 
    directory to collect all directory paths.

    :param start_directory: The starting directory path.
    :param sub_directories: A List that all subdirectory paths will be 
        stored to.
    :return: A List of all sub-directory paths.
    """

    for item in os.listdir(start_directory):
        full_path = os.path.join(start_directory, item)

        if os.path.isdir(full_path):
            sub_directories.append(full_path)

            # Recursive call to search through all subdirectories.
            get_sub_directory_paths(full_path, sub_directories)

return sub_directories

Możemy uzyskać listę wszystkich folderów używając os.spacer()

import os

path = os.getcwd()

pathObject = os.walk(path)

Ten pathObject jest obiektem i możemy uzyskać tablicę przez

arr = [x for x in pathObject]

arr is of type [('current directory', [array of folder in current directory], [files in current directory]),('subdirectory', [array of folder in subdirectory], [files in subdirectory]) ....]

Możemy uzyskać listę wszystkich podkatalogów poprzez iterację arr i wydrukowanie Środkowej tablicy

for i in arr:
   for j in i[1]:
      print(j)

Wyświetli wszystkie podkatalog.

Aby pobrać wszystkie pliki:

for i in arr:
   for j in i[2]:
      print(i[0] + "/" + j)

Łącząc wiele rozwiązań stąd, To właśnie z tego skorzystałem:

import os
import glob

def list_dirs(path):
    return [os.path.basename(x) for x in filter(
        os.path.isdir, glob.glob(os.path.join(path, '*')))]

Ta funkcja, z danym rodzicem directory iteruje wszystkie swoje directories rekurencyjnie i prints wszystkie filenames, które znajduje w środku. Zbyt przydatne.

import os

def printDirectoryFiles(directory):
   for filename in os.listdir(directory):  
        full_path=os.path.join(directory, filename)
        if not os.path.isdir(full_path): 
            print( full_path + "\n")


def checkFolders(directory):

    dir_list = next(os.walk(directory))[1]

    #print(dir_list)

    for dir in dir_list:           
        print(dir)
        checkFolders(directory +"/"+ dir) 

    printDirectoryFiles(directory)       

main_dir="C:/Users/S0082448/Desktop/carpeta1"

checkFolders(main_dir)


input("Press enter to exit ;")

Wiele ładnych odpowiedzi tam, ale jeśli przyszedłeś tutaj szukając prostego sposobu, aby uzyskać listę wszystkich plików lub folderów na raz. Możesz skorzystać z oferowanego systemu operacyjnego find na Linuksie i Macu, który jest znacznie szybszy niż system operacyjny.spacer

import os
all_files_list = os.popen("find path/to/my_base_folder -type f").read().splitlines()
all_sub_directories_list = os.popen("find path/to/my_base_folder -type d").read().splitlines()

Lub

import os

def get_files(path):
    all_files_list = os.popen(f"find {path} -type f").read().splitlines()
    return all_files_list

def get_sub_folders(path):
    all_sub_directories_list = os.popen(f"find {path} -type d").read().splitlines()
    return all_sub_directories_list

To powinno działać, ponieważ tworzy również drzewo katalogów;

import os
import pathlib

def tree(directory):
    print(f'+ {directory}')
    print("There are " + str(len(os.listdir(os.getcwd()))) + \
    " folders in this directory;")
    for path in sorted(directory.glob('*')):
        depth = len(path.relative_to(directory).parts)
        spacer = '    ' * depth
        print(f'{spacer}+ {path.name}')

To powinno wyświetlić listę wszystkich katalogów w folderze za pomocą biblioteki pathlib. path.relative_to(directory).parts pobiera elementy względem bieżącego katalogu roboczego.

Ta poniżej klasa będzie w stanie pobrać listę plików, folderów i wszystkich podkatalogów wewnątrz danego katalogu

import os
import json

class GetDirectoryList():
    def __init__(self, path):
        self.main_path = path
        self.absolute_path = []
        self.relative_path = []


    def get_files_and_folders(self, resp, path):
        all = os.listdir(path)
        resp["files"] = []
        for file_folder in all:
            if file_folder != "." and file_folder != "..":
                if os.path.isdir(path + "/" + file_folder):
                    resp[file_folder] = {}
                    self.get_files_and_folders(resp=resp[file_folder], path= path + "/" + file_folder)
                else:
                    resp["files"].append(file_folder)
                    self.absolute_path.append(path.replace(self.main_path + "/", "") + "/" + file_folder)
                    self.relative_path.append(path + "/" + file_folder)
        return resp, self.relative_path, self.absolute_path

    @property
    def get_all_files_folder(self):
        self.resp = {self.main_path: {}}
        all = self.get_files_and_folders(self.resp[self.main_path], self.main_path)
        return all

if __name__ == '__main__':
    mylib = GetDirectoryList(path="sample_folder")
    file_list = mylib.get_all_files_folder
    print (json.dumps(file_list))

Przykładowy katalog wygląda jak

sample_folder/
    lib_a/
        lib_c/
            lib_e/
                __init__.py
                a.txt
            __init__.py
            b.txt
            c.txt
        lib_d/
            __init__.py
        __init__.py
        d.txt
    lib_b/
        __init__.py
        e.txt
    __init__.py

Uzyskany Wynik

[
  {
    "files": [
      "__init__.py"
    ],
    "lib_b": {
      "files": [
        "__init__.py",
        "e.txt"
      ]
    },
    "lib_a": {
      "files": [
        "__init__.py",
        "d.txt"
      ],
      "lib_c": {
        "files": [
          "__init__.py",
          "c.txt",
          "b.txt"
        ],
        "lib_e": {
          "files": [
            "__init__.py",
            "a.txt"
          ]
        }
      },
      "lib_d": {
        "files": [
          "__init__.py"
        ]
      }
    }
  },
  [
    "sample_folder/lib_b/__init__.py",
    "sample_folder/lib_b/e.txt",
    "sample_folder/__init__.py",
    "sample_folder/lib_a/lib_c/lib_e/__init__.py",
    "sample_folder/lib_a/lib_c/lib_e/a.txt",
    "sample_folder/lib_a/lib_c/__init__.py",
    "sample_folder/lib_a/lib_c/c.txt",
    "sample_folder/lib_a/lib_c/b.txt",
    "sample_folder/lib_a/lib_d/__init__.py",
    "sample_folder/lib_a/__init__.py",
    "sample_folder/lib_a/d.txt"
  ],
  [
    "lib_b/__init__.py",
    "lib_b/e.txt",
    "sample_folder/__init__.py",
    "lib_a/lib_c/lib_e/__init__.py",
    "lib_a/lib_c/lib_e/a.txt",
    "lib_a/lib_c/__init__.py",
    "lib_a/lib_c/c.txt",
    "lib_a/lib_c/b.txt",
    "lib_a/lib_d/__init__.py",
    "lib_a/__init__.py",
    "lib_a/d.txt"
  ]
]