Pythonでディレクトリツリー構造をリストしますか？

私os.walk()は、ディレクトリ内のすべてのサブディレクトリまたはすべてのファイルを一覧表示するために使用できることを知っています。ただし、完全なディレクトリツリーの内容をリストしたいと思います。

- Subdirectory 1:
   - file11
   - file12
   - Sub-sub-directory 11:
         - file111
         - file112
- Subdirectory 2:
    - file21
    - sub-sub-directory 21
    - sub-sub-directory 22    
        - sub-sub-sub-directory 221
            - file 2211

これをPythonで最適に行う方法は？

書式設定でこれを行う関数は次のとおりです。

import os

def list_files(startpath):
    for root, dirs, files in os.walk(startpath):
        level = root.replace(startpath, '').count(os.sep)
        indent = ' ' * 4 * (level)
        print('{}{}/'.format(indent, os.path.basename(root)))
        subindent = ' ' * 4 * (level + 1)
        for f in files:
            print('{}{}'.format(subindent, f))

上記の回答に似ていますが、python3の場合、ほぼ読み取り可能でほぼ拡張可能です。

from pathlib import Path

class DisplayablePath(object):
    display_filename_prefix_middle = '├──'
    display_filename_prefix_last = '└──'
    display_parent_prefix_middle = '    '
    display_parent_prefix_last = '│   '

    def __init__(self, path, parent_path, is_last):
        self.path = Path(str(path))
        self.parent = parent_path
        self.is_last = is_last
        if self.parent:
            self.depth = self.parent.depth + 1
        else:
            self.depth = 0

    @property
    def displayname(self):
        if self.path.is_dir():
            return self.path.name + '/'
        return self.path.name

    @classmethod
    def make_tree(cls, root, parent=None, is_last=False, criteria=None):
        root = Path(str(root))
        criteria = criteria or cls._default_criteria

        displayable_root = cls(root, parent, is_last)
        yield displayable_root

        children = sorted(list(path
                               for path in root.iterdir()
                               if criteria(path)),
                          key=lambda s: str(s).lower())
        count = 1
        for path in children:
            is_last = count == len(children)
            if path.is_dir():
                yield from cls.make_tree(path,
                                         parent=displayable_root,
                                         is_last=is_last,
                                         criteria=criteria)
            else:
                yield cls(path, displayable_root, is_last)
            count += 1

    @classmethod
    def _default_criteria(cls, path):
        return True

    @property
    def displayname(self):
        if self.path.is_dir():
            return self.path.name + '/'
        return self.path.name

    def displayable(self):
        if self.parent is None:
            return self.displayname

        _filename_prefix = (self.display_filename_prefix_last
                            if self.is_last
                            else self.display_filename_prefix_middle)

        parts = ['{!s} {!s}'.format(_filename_prefix,
                                    self.displayname)]

        parent = self.parent
        while parent and parent.parent is not None:
            parts.append(self.display_parent_prefix_middle
                         if parent.is_last
                         else self.display_parent_prefix_last)
            parent = parent.parent

        return ''.join(reversed(parts))

使用例：

paths = DisplayablePath.make_tree(Path('doc'))
for path in paths:
    print(path.displayable())

出力例：

doc/
├── _static/
│   ├── embedded/
│   │   ├── deep_file
│   │   └── very/
│   │       └── deep/
│   │           └── folder/
│   │               └── very_deep_file
│   └── less_deep_file
├── about.rst
├── conf.py
└── index.rst

ノート

• これは再帰を使用します。これは、発生しますRecursionError本当に上の深いフォルダツリーを
• ツリーは遅延評価されます。本当に広いフォルダツリーでうまく動作するはずです。ただし、特定のフォルダーの直接の子は遅延評価されません。

編集：

• ボーナス追加！パスをフィルタリングするための基準コールバック。

インデントなしのソリューション：

for path, dirs, files in os.walk(given_path):
  print path
  for f in files:
    print f

os.walkはすでに、探しているトップダウンの深さ優先のウォークを実行します。

dirsリストを無視すると、あなたが言及する重複を防ぎます。

Pythonでディレクトリツリー構造をリストしますか？

私たちは通常、GNUツリーを使用することを好みますが、常にtreeすべてのシステムで使用できるわけではなく、Python 3が使用できる場合もあります。ここでの良い答えは、簡単にコピーして貼り付けることができ、GNU treeを要件にすることはできません。

treeの出力は次のようになります。

$ tree
.
├── package
│   ├── __init__.py
│   ├── __main__.py
│   ├── subpackage
│   │   ├── __init__.py
│   │   ├── __main__.py
│   │   └── module.py
│   └── subpackage2
│       ├── __init__.py
│       ├── __main__.py
│       └── module2.py
└── package2
    └── __init__.py

4 directories, 9 files

上記のディレクトリ構造を、自分が呼び出すディレクトリの下のホームディレクトリに作成しましたpyscratch。

そのような出力にアプローチする他の答えもここにありますが、よりシンプルでよりモダンなコードと遅延評価アプローチを使用して、より良いことができると思います。

Pythonのツリー

まず、次の例を使用してみましょう

• Python 3 Pathオブジェクトを使用します
• yieldand yield from式を使用する（ジェネレーター関数を作成する）
• 再帰を使用してエレガントなシンプルさ
• コメントといくつかの型注釈を使用してさらに明確にする

from pathlib import Path

# prefix components:
space =  '    '
branch = '│   '
# pointers:
tee =    '├── '
last =   '└── '


def tree(dir_path: Path, prefix: str=''):
    """A recursive generator, given a directory Path object
    will yield a visual tree structure line by line
    with each line prefixed by the same characters
    """    
    contents = list(dir_path.iterdir())
    # contents each get pointers that are ├── with a final └── :
    pointers = [tee] * (len(contents) - 1) + [last]
    for pointer, path in zip(pointers, contents):
        yield prefix + pointer + path.name
        if path.is_dir(): # extend the prefix and recurse:
            extension = branch if pointer == tee else space 
            # i.e. space because last, └── , above so no more |
            yield from tree(path, prefix=prefix+extension)

そして今：

for line in tree(Path.home() / 'pyscratch'):
    print(line)

プリント：

├── package
│   ├── __init__.py
│   ├── __main__.py
│   ├── subpackage
│   │   ├── __init__.py
│   │   ├── __main__.py
│   │   └── module.py
│   └── subpackage2
│       ├── __init__.py
│       ├── __main__.py
│       └── module2.py
└── package2
    └── __init__.py

各ディレクトリを具体化してリストにする必要があります。これは、その長さを知る必要があるためですが、その後、リストを破棄します。深くて広範な再帰の場合、これは十分に遅延する必要があります。

上記のコードとコメントは、ここで何をしているのかを完全に理解するのに十分ですが、必要に応じて、デバッガを使用してコードをより適切に理解することができます。

その他の機能

今GNU treeは私がこの機能で持っていたいいくつかの便利な機能を私たちに提供します：

• サブジェクトディレクトリ名を最初に出力します（自動的に実行されますが、自動では行われません）。
• カウントを出力します n directories, m files
• 再帰を制限するオプション、 -L level
• ディレクトリのみに制限するオプション、 -d

また、巨大なツリーがある場合islice、ある時点で出力が冗長になりすぎて役に立たなくなるため、反復を（たとえばで）制限して、インタープリターがテキストでロックされないようにすると便利です。デフォルトでこれを任意に高くすることができます1000。

それでは、前のコメントを削除して、この機能に記入しましょう：

from pathlib import Path
from itertools import islice

space =  '    '
branch = '│   '
tee =    '├── '
last =   '└── '

def tree(dir_path: Path, level: int=-1, limit_to_directories: bool=False,
         length_limit: int=1000):
    """Given a directory Path object print a visual tree structure"""
    dir_path = Path(dir_path) # accept string coerceable to Path
    files = 0
    directories = 0
    def inner(dir_path: Path, prefix: str='', level=-1):
        nonlocal files, directories
        if not level: 
            return # 0, stop iterating
        if limit_to_directories:
            contents = [d for d in dir_path.iterdir() if d.is_dir()]
        else: 
            contents = list(dir_path.iterdir())
        pointers = [tee] * (len(contents) - 1) + [last]
        for pointer, path in zip(pointers, contents):
            if path.is_dir():
                yield prefix + pointer + path.name
                directories += 1
                extension = branch if pointer == tee else space 
                yield from inner(path, prefix=prefix+extension, level=level-1)
            elif not limit_to_directories:
                yield prefix + pointer + path.name
                files += 1
    print(dir_path.name)
    iterator = inner(dir_path, level=level)
    for line in islice(iterator, length_limit):
        print(line)
    if next(iterator, None):
        print(f'... length_limit, {length_limit}, reached, counted:')
    print(f'\n{directories} directories' + (f', {files} files' if files else ''))

これで、次のような出力を取得できますtree。

tree(Path.home() / 'pyscratch')

プリント：

pyscratch
├── package
│   ├── __init__.py
│   ├── __main__.py
│   ├── subpackage
│   │   ├── __init__.py
│   │   ├── __main__.py
│   │   └── module.py
│   └── subpackage2
│       ├── __init__.py
│       ├── __main__.py
│       └── module2.py
└── package2
    └── __init__.py

4 directories, 9 files

そして、レベルに制限できます：

tree(Path.home() / 'pyscratch', level=2)

プリント：

pyscratch
├── package
│   ├── __init__.py
│   ├── __main__.py
│   ├── subpackage
│   └── subpackage2
└── package2
    └── __init__.py

4 directories, 3 files

そして、出力をディレクトリに制限できます：

tree(Path.home() / 'pyscratch', level=2, limit_to_directories=True)

プリント：

pyscratch
├── package
│   ├── subpackage
│   └── subpackage2
└── package2

4 directories

回顧

振り返ってみると、path.globマッチングに使用できたはずです。またpath.rglob、再帰的なグロビングに使用することもできますが、これには書き換えが必要になります。itertools.teeディレクトリの内容のリストを具体化する代わりにを使用することもできますが、これにはマイナスのトレードオフがあり、コードがさらに複雑になる可能性があります。

コメントは大歓迎です！

私は同じことを探してここに来て、dhobbsの答えを使いました。コミュニティに感謝する方法として、私はakshayが尋ねたように、ファイルに書き込むためのいくつかの引数を追加し、ファイルを表示することをオプションにしたので、出力はそれほどビットではありません。また、インデントをオプションの引数にして、変更できるようにしました。

異なるループを使用したため、ファイルを表示しないループでは、各反復で実行する必要があるかどうかがチェックされません。

ドブスの回答が私を助けたので、それが他の誰かを助けることを願っています。どうもありがとう。

def showFolderTree(path,show_files=False,indentation=2,file_output=False):
"""
Shows the content of a folder in a tree structure.
path -(string)- path of the root folder we want to show.
show_files -(boolean)-  Whether or not we want to see files listed.
                        Defaults to False.
indentation -(int)- Indentation we want to use, defaults to 2.   
file_output -(string)-  Path (including the name) of the file where we want
                        to save the tree.
"""


tree = []

if not show_files:
    for root, dirs, files in os.walk(path):
        level = root.replace(path, '').count(os.sep)
        indent = ' '*indentation*(level)
        tree.append('{}{}/'.format(indent,os.path.basename(root)))

if show_files:
    for root, dirs, files in os.walk(path):
        level = root.replace(path, '').count(os.sep)
        indent = ' '*indentation*(level)
        tree.append('{}{}/'.format(indent,os.path.basename(root)))    
        for f in files:
            subindent=' ' * indentation * (level+1)
            tree.append('{}{}'.format(subindent,f))

if file_output:
    output_file = open(file_output,'w')
    for line in tree:
        output_file.write(line)
        output_file.write('\n')
else:
    # Default behaviour: print on screen.
    for line in tree:
        print line

この素晴らしい投稿に基づいています

http://code.activestate.com/recipes/217212-treepy-graphically-displays-the-directory-structur/

ここでは、正確に動作するように洗練されています

http://linux.die.net/man/1/tree

＃！/ usr / bin / env python2 ＃-*-コーディング：utf-8-*-


＃tree.py ＃＃Doug Dahms によって書かれた＃＃コマンドラインで指定されたパスのツリー構造を出力します





OSの輸入LISTDIR 、9月
 からのOS 。path import abspath 、basename 、isdir
 from sys import argv

def tree （dir 、padding 、print_files = False 、isLast = False 、isFirst = False ）：isFirstの場合：パディングを印刷します。デコード（'utf8' ）[：- 1 ]。エンコード
    
        （'utf8' ）+ dir
     else ：if isLast ：パディングを印刷します。デコード（'utf8' ）[：- 1 エンコード 
        
             ]。（'utf8' ）+ '└──' + basename （abspath （dir ））else ：パディングを印刷します。デコード（'utf8' ）[：- 1 ]。エンコード（'utf8' ）+ '├──' + ベース名（abspath （dir ））
    files = [] if print_files ：
        files = listdir （dir ）else 
        files   
        
                
    
    ： = [ X のためのx におけるLISTDIR （DIR ）場合isdir （dirは+ 9月+ X ）] ならないisFirst ：
        パディング= パディング+ '' 
    ファイル= ソートされた  
      （ファイル、キー= ラムダS ：S 。下げる（））
    カウント= 0 
    最後= len （ ファイル）- 1 のために、私、ファイル内の列挙（ファイル）：
        数+ = 1 
        パス= DIR + 9月+ ファイル  
     
        isLast = i == last
         if isdir （path ）：if count == len （files ）：if isFirst ：
                    tree （path 、padding 、print_files 、isLast 、False ）else ：
                    tree （path 、padding + '' 、print_files 、isLast 、誤り）
            
                 
                  
             else ：
                tree （path 、padding + '│' 、print_files 、isLast 、False ）  
        else:
            if isLast:
                print padding + '└── ' + file
            else:
                print padding + '├── ' + file

def usage():
    return '''Usage: %s [-f] 
Print tree structure of path specified.
Options:
-f      Print files as well as directories
PATH    Path to process''' % basename(argv[0])

def main （）：if len （argv ）== 1 ：
      
        print usage()
    elif len(argv) == 2:
        # print just directories
        path = argv[1]
        if isdir(path):
            tree(path, '', False, False, True)
        else:
            print 'ERROR: \'' + path + '\' is not a directory'
    elif len(argv) == 3 and argv [ 1 ] == '-f' ：＃ディレクトリとファイルを出力します
        path = argv [ 2 ] if isdir （path ）：
            tree （path 、'' 、True 、False 、  
        
            True)
        else:
            print 'ERROR: \'' + path + '\'はディレクトリではありません ' else ：print usage （）
    
        

if __name__ == '__main__' ：
    main （） 

import os

def fs_tree_to_dict(path_):
    file_token = ''
    for root, dirs, files in os.walk(path_):
        tree = {d: fs_tree_to_dict(os.path.join(root, d)) for d in dirs}
        tree.update({f: file_token for f in files})
        return tree  # note we discontinue iteration trough os.walk

誰かが興味を持っている場合-その再帰関数は辞書のネストされた構造を返します。キーはfile system（ディレクトリとファイルの）名前で、値は次のいずれかです。

• ディレクトリのサブ辞書
• ファイルの文字列（を参照file_token）

この例では、ファイルを指定する文字列は空です。それらはまた、例えば、与えられたファイルの内容、その所有者情報、特権、またはdictとは異なるあらゆるオブジェクトに与えることができます。辞書でない限り、以降の操作で「ディレクトリタイプ」と簡単に区別できます。

そのようなツリーをファイルシステムに持つ：

# bash:
$ tree /tmp/ex
/tmp/ex
├── d_a
│   ├── d_a_a
│   ├── d_a_b
│   │   └── f1.txt
│   ├── d_a_c
│   └── fa.txt
├── d_b
│   ├── fb1.txt
│   └── fb2.txt
└── d_c

結果は次のようになります。

# python 2 or 3:
>>> fs_tree_to_dict("/tmp/ex")
{
    'd_a': {
        'd_a_a': {},
        'd_a_b': {
            'f1.txt': ''
        },
        'd_a_c': {},
        'fa.txt': ''
    },
    'd_b': {
        'fb1.txt': '',
        'fb2.txt': ''
    },
    'd_c': {}
}

あなたがそれを好きなら、私はすでにこのもの（そして素晴らしいpyfakefsヘルパー）でパッケージ（python 2と3）を作成しました：https： //pypi.org/project/fsforge/

上記のdhobbs回答（https://stackoverflow.com/a/9728478/624597）に加えて、結果をファイルに保存する追加機能があります（私は個人的にそれを使用してFreeMindにコピーアンドペーストし、構造、したがって、私はインデントにスペースの代わりにタブを使用しました）：

import os

def list_files(startpath):

    with open("folder_structure.txt", "w") as f_output:
        for root, dirs, files in os.walk(startpath):
            level = root.replace(startpath, '').count(os.sep)
            indent = '\t' * 1 * (level)
            output_string = '{}{}/'.format(indent, os.path.basename(root))
            print(output_string)
            f_output.write(output_string + '\n')
            subindent = '\t' * 1 * (level + 1)
            for f in files:
                output_string = '{}{}'.format(subindent, f)
                print(output_string)
                f_output.write(output_string + '\n')

list_files(".")

Linuxシェルの「tree」コマンドを実行できます。

インストール：

   ~$sudo apt install tree

Pythonでの使用

    >>> import os
    >>> os.system('tree <desired path>')

例：

    >>> os.system('tree ~/Desktop/myproject')

これにより、構造がすっきりし、視覚的により包括的で入力しやすくなります。

このソリューションはtree、システムにインストールされている場合にのみ機能します。ただし、他の人を助けるために、このソリューションはここに残しておきます。

treeに、ツリー構造をXML（tree -X）またはJSON（tree -J）として出力するように指示できます。もちろん、JSONはpythonで直接解析でき、XMLはで簡単に読み取ることができますlxml。

例として次のディレクトリ構造を使用すると：

[sri@localhost Projects]$ tree --charset=ascii bands
bands
|-- DreamTroll
|   |-- MattBaldwinson
|   |-- members.txt
|   |-- PaulCarter
|   |-- SimonBlakelock
|   `-- Rob Stringer
|-- KingsX
|   |-- DougPinnick
|   |-- JerryGaskill
|   |-- members.txt
|   `-- TyTabor
|-- Megadeth
|   |-- DaveMustaine
|   |-- DavidEllefson
|   |-- DirkVerbeuren
|   |-- KikoLoureiro
|   `-- members.txt
|-- Nightwish
|   |-- EmppuVuorinen
|   |-- FloorJansen
|   |-- JukkaNevalainen
|   |-- MarcoHietala
|   |-- members.txt
|   |-- TroyDonockley
|   `-- TuomasHolopainen
`-- Rush
    |-- AlexLifeson
    |-- GeddyLee
    `-- NeilPeart

5 directories, 25 files

XML

<?xml version="1.0" encoding="UTF-8"?>
<tree>
  <directory name="bands">
    <directory name="DreamTroll">
      <file name="MattBaldwinson"></file>
      <file name="members.txt"></file>
      <file name="PaulCarter"></file>
      <file name="RobStringer"></file>
      <file name="SimonBlakelock"></file>
    </directory>
    <directory name="KingsX">
      <file name="DougPinnick"></file>
      <file name="JerryGaskill"></file>
      <file name="members.txt"></file>
      <file name="TyTabor"></file>
    </directory>
    <directory name="Megadeth">
      <file name="DaveMustaine"></file>
      <file name="DavidEllefson"></file>
      <file name="DirkVerbeuren"></file>
      <file name="KikoLoureiro"></file>
      <file name="members.txt"></file>
    </directory>
    <directory name="Nightwish">
      <file name="EmppuVuorinen"></file>
      <file name="FloorJansen"></file>
      <file name="JukkaNevalainen"></file>
      <file name="MarcoHietala"></file>
      <file name="members.txt"></file>
      <file name="TroyDonockley"></file>
      <file name="TuomasHolopainen"></file>
    </directory>
    <directory name="Rush">
      <file name="AlexLifeson"></file>
      <file name="GeddyLee"></file>
      <file name="NeilPeart"></file>
    </directory>
  </directory>
  <report>
    <directories>5</directories>
    <files>25</files>
  </report>
</tree>

JSON

[sri@localhost Projects]$ tree -J bands
[
  {"type":"directory","name":"bands","contents":[
    {"type":"directory","name":"DreamTroll","contents":[
      {"type":"file","name":"MattBaldwinson"},
      {"type":"file","name":"members.txt"},
      {"type":"file","name":"PaulCarter"},
      {"type":"file","name":"RobStringer"},
      {"type":"file","name":"SimonBlakelock"}
    ]},
    {"type":"directory","name":"KingsX","contents":[
      {"type":"file","name":"DougPinnick"},
      {"type":"file","name":"JerryGaskill"},
      {"type":"file","name":"members.txt"},
      {"type":"file","name":"TyTabor"}
    ]},
    {"type":"directory","name":"Megadeth","contents":[
      {"type":"file","name":"DaveMustaine"},
      {"type":"file","name":"DavidEllefson"},
      {"type":"file","name":"DirkVerbeuren"},
      {"type":"file","name":"KikoLoureiro"},
      {"type":"file","name":"members.txt"}
    ]},
    {"type":"directory","name":"Nightwish","contents":[
      {"type":"file","name":"EmppuVuorinen"},
      {"type":"file","name":"FloorJansen"},
      {"type":"file","name":"JukkaNevalainen"},
      {"type":"file","name":"MarcoHietala"},
      {"type":"file","name":"members.txt"},
      {"type":"file","name":"TroyDonockley"},
      {"type":"file","name":"TuomasHolopainen"}
    ]},
    {"type":"directory","name":"Rush","contents":[
      {"type":"file","name":"AlexLifeson"},
      {"type":"file","name":"GeddyLee"},
      {"type":"file","name":"NeilPeart"}
    ]}
  ]},
  {"type":"report","directories":5,"files":25}
]

たぶん@ellockieより速い（たぶん）

OSをインポート
def file_writer（text）：
    open（ "folder_structure.txt"、 "a"）をf_outputとして：
        f_output.write（テキスト）
def list_files（startpath）：


    ルート、dirs、os.walk（startpath）内のファイルの場合：
        レベル= root.replace（startpath、 ''）.count（os.sep）
        インデント= '\ t' * 1 *（レベル）
        output_string = '{} {} / \ n'.format（indent、os.path.basename（root））
        file_writer（output_string）
        サブインデント= '\ t' * 1 *（レベル+ 1）
        output_string = '％s％s \ n'％（subindent、[f for f in files]）
        file_writer（ ''。join（output_string））


list_files（ "/"）

以下のスクリーンショットのテスト結果：

ここでは、次のような出力を含むコードを見つけることができます：https : //stackoverflow.com/a/56622847/6671330

V .
|-> V folder1
|   |-> V folder2
|   |   |-> V folder3
|   |   |   |-> file3.txt
|   |   |-> file2.txt
|   |-> V folderX
|   |-> file1.txt
|-> 02-hw1_wdwwfm.py
|-> 06-t1-home1.py
|-> 06-t1-home2.py
|-> hw1.py

まだ答えを探している人のために。辞書のパスを取得するための再帰的なアプローチを次に示します。

import os


def list_files(startpath):
    for root, dirs, files in os.walk(startpath):
        dir_content = []
        for dir in dirs:
            go_inside = os.path.join(startpath, dir)
            dir_content.append(list_files(go_inside))
        files_lst = []
        for f in files:
            files_lst.append(f)
        return {'name': root, 'files': files_lst, 'dirs': dir_content}

@dhobbsの答えは素晴らしいです！

レベル情報を簡単に取得するように変更するだけです

def print_list_dir(dir):
    print("=" * 64)
    print("[PRINT LIST DIR] %s" % dir)
    print("=" * 64)
    for root, dirs, files in os.walk(dir):
        level = root.replace(dir, '').count(os.sep)
        indent = '| ' * level
        print('{}{} \\'.format(indent, os.path.basename(root)))
        subindent = '| ' * (level + 1)
        for f in files:
            print('{}{}'.format(subindent, f))
    print("=" * 64)

とのような出力

================================================================
[PRINT LIST DIR] ./
================================================================
 \
| os_name.py
| json_loads.py
| linspace_python.py
| list_file.py
| to_gson_format.py
| type_convert_test.py
| in_and_replace_test.py
| online_log.py
| padding_and_clipping.py
| str_tuple.py
| set_test.py
| script_name.py
| word_count.py
| get14.py
| np_test2.py
================================================================

|カウントでレベルを取得できます！