আমি জানি যে আমরা 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পাইথনে এটি কীভাবে সেরা অর্জন করা যায়?
উত্তর:
বিন্যাস সহ এটি করার জন্য এখানে একটি ফাংশন রয়েছে:
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))ValueError: zero length field name in formatনিক্ষেপ করা হয়।
root.replace(startpath, '', 1)
উপরের উত্তরের মতো, তবে পাইথন 3 এর জন্য, তর্কযোগ্যভাবে পাঠযোগ্য এবং তর্কযোগ্যভাবে বহনযোগ্য:
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আপনার ইন্ডেন্টেশন ছাড়াই একটি সমাধান:
for path, dirs, files in os.walk(given_path):
print path
for f in files:
print fওএসওয়াক ইতিমধ্যে উপরে-ডাউন, গভীরতার-প্রথম পদক্ষেপ আপনি সন্ধান করছেন does
ডায়ার তালিকা উপেক্ষা করা আপনার উল্লিখিত ওভারল্যাপিংটিকে বাধা দেয়।
NameError: name 'path' is not defined
পাইথন ডিরেক্টরি ডিরেক্টরি গাছ কাঠামো?
আমরা সাধারণত GNU ট্রি ব্যবহার করতে পছন্দ করি তবে আমাদের সর্বদা treeপ্রতিটি সিস্টেমে থাকে না এবং কখনও কখনও পাইথন 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।
আমি এখানে অন্যান্য উত্তরগুলিও দেখতে পাই যা এই ধরণের আউটপুটটিতে পৌঁছায় তবে আমি মনে করি সহজ, আরও আধুনিক কোড এবং অলসতার সাথে পদ্ধতির মূল্যায়নের সাথে আমরা আরও ভাল করতে পারি।
শুরু করার জন্য, এর একটি উদাহরণ ব্যবহার করুন
Pathঅবজেক্ট ব্যবহার করেyieldএবং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আমাদের প্রতিটি ডিরেক্টরি একটি তালিকাতে রূপায়িত করতে হবে কারণ এটি কতটা দীর্ঘ তা আমাদের জানতে হবে, তবে পরে আমরা তালিকাটি ফেলে দিই। গভীর এবং বিস্তৃত পুনরাবৃত্তির জন্য এটি যথেষ্ট অলস হওয়া উচিত।
উপরোক্ত কোডগুলি, মন্তব্য সহ, আমরা এখানে কী করছি তা সম্পূর্ণরূপে বোঝার জন্য যথেষ্ট হওয়া উচিত তবে আপনার যদি প্রয়োজন হয় তবে এটি আরও ভালভাবে গ্রাক করতে কোনও ডিবাগার দিয়ে এটিকে পদক্ষেপে নির্দ্বিধায় অনুভব করতে পারেন।
এখন জিএনইউ 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 ডিরেক্টরি সামগ্রীর তালিকা তৈরির পরিবর্তেও , তবে এটিতে নেতিবাচক ট্রেডঅফস থাকতে পারে এবং সম্ভবত কোডটিকে আরও জটিল করে তুলবে।
মন্তব্য স্বাগত!
elif not limit_to_directories:নিম্নলিখিতগুলি যুক্ত করার পরে: সঠিক সাদা-স্থানের জন্য এই লিঙ্কটিinfo = prefix + pointer + path.name; try: with path.open('r') as f: n_lines = len(f.readlines()); loc = f' LOC: {n_lines}'; info += loc; except UnicodeDecodeError: pass; yield info দেখুন ।
contentsযদি limit_to_directoriesসত্য হয় তবে ফিল্টার করা দরকার । অন্যথায় যদি কোনও ফোল্ডারের শেষ ফাইলের জন্য ডিরেক্টরি না থাকে তবে গাছটি সঠিকভাবে আঁকতে হবে না। if limit_to_directories: contents = [path for path in contents if path.is_dir()]
list(dir_path.iterdir())ডিরেক্টরি কাঠামোর যথাযথ অর্ডারযুক্ত টপ-ডাউন গাছকে ফেরত দেওয়ার জন্য পূর্বাভাস দেওয়া হয় । আমি দেখতে কোন ধরনের গ্যারান্টি মধ্যে iterdir জন্য API () । কীভাবে iterdir()অর্ডারগুলি দেয় বা কাঙ্ক্ষিত ক্রম সরবরাহ করার গ্যারান্টিযুক্ত তা দয়া করে একটি রেফারেন্স সরবরাহ করুন ।
os.listdir() - যা আদেশের কোনও গ্যারান্টি দেয় না : "তালিকাটি স্বেচ্ছাসেবী ক্রমে রয়েছে এবং এতে বিশেষ এন্ট্রি অন্তর্ভুক্ত নয় '। এবং '..' ডিরেক্টরিতে উপস্থিত থাকলেও "।
আমি এখানে একই জিনিসটি খুঁজতে এসেছি এবং আমার জন্য ধোবসের উত্তর ব্যবহার করেছি। সম্প্রদায়কে ধন্যবাদ জানানোর উপায় হিসাবে, আমি অক্ষয় যেমন জিজ্ঞাসা করেছি, তেমন কোনও ফাইলকে লেখার জন্য কিছু যুক্তি যুক্ত করেছি এবং ফাইলগুলি alচ্ছিকভাবে দেখিয়েছি যাতে এটি এতটা আউটপুট হয় না। এডেন্টেশনটিকে একটি alচ্ছিক যুক্তিও বানিয়েছে যাতে আপনি এটি পরিবর্তন করতে পারেন, কারও কারও মতো এটি 2 এবং অন্যরা 4 পছন্দ করে।
বিভিন্ন লুপ ব্যবহার করা হয়েছে যাতে ফাইল না দেখানো একেকটি পুনরাবৃত্তির উপর পরীক্ষা করে কিনা তা পরীক্ষা করে না।
আশা করি ধোবসের উত্তর আমাকে সহায়তা করেছিল বলে এটি অন্য কাউকে সহায়তা করবে। অনেক ধন্যবাদ.
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 পাইথন 2 # - * - কোডিং: utf-8 - * - # ট্রি.পিপি # # ডগ ডাহমস দ্বারা লিখিত # # কমান্ড লাইনে নির্দিষ্ট পথের জন্য গাছের কাঠামো মুদ্রণ করে থেকে অপারেটিং সিস্টেম আমদানি listdir , সেপ্টেম্বর থেকে অপারেটিং সিস্টেম । পাথ আমদানি abspath , basename , isdir থেকে sys আমদানি argv হয় ডিফ ট্রি ( ডির , প্যাডিং , মুদ্রণ_ফায়ালস = মিথ্যা , ইসলাস্ট = মিথ্যা , আইফার্স = ভুয়া ): যদি হয় ফার্স্ট : মুদ্রণ প্যাডিং । ডিকোড ( 'utf8' ) [: - 1 ]। এনকোড ( 'utf8' ) + দির অন্য : যদি হয় সর্বশেষ : মুদ্রণ প্যাডিং । ডিকোড ( 'utf8' ) [: - 1 এনকোড ]।( 'UTF8' ) + + '└──' + + basename ( abspath ( Dir )) অন্য : মুদ্রণ প্যাডিং । ডিকোড ( 'utf8' ) [: - 1 ]। সঙ্কেতাক্ষরে লিখা ( 'UTF8' ) + + '├──' + + basename ( abspath ( Dir )) ফাইল = [] যদি print_files : ফাইল = listdir ( Dir ) আর ফাইল : = [ X জন্য এক্স মধ্যে listdir ( Dir ) যদি isdir ( Dir + + সেপ্টেম্বর + + এক্স )] যদি না isFirst : প্যাডিং = প্যাডিং + + '' ফাইল = সাজানো ( ফাইল , কী = ল্যামডা গুলি : গুলি । কম ()) গণনা = 0 শেষ = লেন ( ফাইল ) - 1 জন্য আমি , ফাইল মধ্যে গনা ( ফাইল ): গণনা + + = 1 পাথ = Dir + + সেপ্টেম্বর + + ফাইল isLast = i == শেষটি যদি isdir ( পাথ ) থাকে: যদি গণনা == লেন ( ফাইল ): তবে isFirst : ট্রি ( পথ , প্যাডিং , মুদ্রণ_ফায়ালস , সর্বশেষ , মিথ্যা ) অন্য : গাছ ( পথ , প্যাডিং + '' , মুদ্রণ_ফায়ালস , isLast , মিথ্যা ) অন্য : গাছ ( পথ , প্যাডিং + '│' , মুদ্রণ_ফায়ালগুলি , শেষ , মিথ্যা ) 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 এবং argv হয় [ 1 ] == '-f' : # মুদ্রণ ডিরেক্টরি এবং ফাইল পাথ = argv হয় [ 2 ] যদি isdir ( পথ ): গাছ ( পাথ , '' , সত্য , মিথ্যা , True) else: print 'ERROR: \'' + path + '\' কোনও ডিরেক্টরি নয় ' অন্যথায় : মুদ্রণ ব্যবহার () যদি __ নাম__ == '__ মেইন__' : প্রধান ()
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)স্ট্রিং ডিজাইটিং ফাইলগুলি এই উদাহরণে খালি। এগুলি উদাহরণস্বরূপ প্রদত্ত ফাইল সামগ্রী বা তার মালিকের তথ্য বা সুবিধাগুলি বা ডিকের চেয়ে ভিন্ন যে কোনও বস্তু হতে পারে। এটি অভিধান না থাকলে এটি পরবর্তী ক্রিয়াকলাপগুলিতে একটি "ডিরেক্টরি টাইপ" থেকে সহজেই আলাদা করা যায়।
ফাইল সিস্টেমে এ জাতীয় গাছ থাকা:
# 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সহায়ক) দিয়ে একটি প্যাকেজ (অজগর 2 এবং 3) তৈরি করেছি :
https://pypi.org/project/fsforge/
উপরে ধোবসের উত্তরের উপরে ( https://stackoverflow.com/a/9728478/624597 ), এখানে কোনও ফাইলে ফলাফল সংরক্ষণের অতিরিক্ত কার্যকারিতা রয়েছে (আমি ব্যক্তিগতভাবে এটি অনুলিপি করে ফ্রিমাইন্ডে আটকানোর জন্য ব্যবহার করি যার একটি সুন্দর ওভারভিউ রয়েছে কাঠামো, অতএব আমি ইনডেন্টেশনের জন্য ফাঁকের পরিবর্তে ট্যাব ব্যবহার করেছি):
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(".")আপনি লিনাক্স শেলের 'ট্রি' কমান্ড কার্যকর করতে পারেন।
স্থাপন:
~$sudo apt install treeঅজগর ব্যবহার
>>> import os
>>> os.system('tree <desired path>')উদাহরণ:
>>> os.system('tree ~/Desktop/myproject')এটি আপনাকে একটি ক্লিনার কাঠামো দেয় এবং চাক্ষুষভাবে আরও ব্যাপক এবং টাইপ করা সহজ।
আপনি যদি treeআপনার সিস্টেমে ইনস্টল করে থাকেন তবে এই সমাধানটি কাজ করবে । তবে আমি এই সমাধানটি এখানে রেখে দিচ্ছি যদি এটি অন্য কাউকে সাহায্য করে।
আপনি গাছকে XML ( tree -X) বা JSON ( tree -J) হিসাবে গাছের কাঠামোর আউটপুট করতে বলতে পারেন । জেএসএন অবশ্যই অজগর দিয়ে সরাসরি পার্স করা যায় এবং এক্সএমএল সহজেই পড়তে পারে 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 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 এর চেয়ে দ্রুত (সম্ভবত)
আমদানি ওএস
Def ফাইলের লেখক (পাঠ্য):
এফ_আউটপুট হিসাবে খোলা ("ফোল্ডার_স্ট্রাকচার.টেক্সট", "এ") সহ:
f_output.write (পাঠ্য)
Def list_files (স্টার্টপথ):
রুট, ডায়ার্স, ওএস.ওয়াকের (স্টার্টপথ) ফাইলগুলির জন্য:
স্তর = রুট.প্লেস (স্টার্টপথ, '') .কাউন্ট (os.sep)
ইনডেন্ট = '\ t' * 1 * (স্তর)
আউটপুট_স্ট্রিং = '{} {} / \ n'.format (ইনডেন্ট, os.path.basename (মূল))
file_writer (output_string)
subindent = '\ t' * 1 * (স্তর + 1)
আউটপুট_ স্ট্রিং = '% s% s \ n'% (পঠিত, [ফাইলের জন্য চ এর জন্য])
file_writer ( ''। যোগদানের (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}@ ধোবসের উত্তর দুর্দান্ত!
তবে সহজভাবে স্তর তথ্য সহজেই পরিবর্তন করুন
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
================================================================আপনি |গণনা দ্বারা স্তর পেতে পারেন !