Pythonを使用してディレクトリのサイズを計算しますか？
この特定のホイールを再発明する前に、Pythonを使用してディレクトリのサイズを計算するための素敵なルーチンを誰かが持っていますか？ルーチンがMb/Gbなどでサイズを適切にフォーマットする場合、非常に素晴らしいでしょう。
これはすべてのサブディレクトリを調べます。合計ファイルサイズ：
import os
def get_size(start_path = '.'):
total_size = 0
for dirpath, dirnames, filenames in os.walk(start_path):
for f in filenames:
fp = os.path.join(dirpath, f)
# skip if it is symbolic link
if not os.path.islink(fp):
total_size += os.path.getsize(fp)
return total_size
print(get_size(), 'bytes')
os.listdir （サブディレクトリを含まない）を使用した楽しみのためのワンライナー：
import os
sum(os.path.getsize(f) for f in os.listdir('.') if os.path.isfile(f))
参照：
- os.path.getsize -バイト単位でサイズを指定します
- os.walk
- os.path.islink
Updatedos.path.getsizeを使用するには、os.stat（）を使用するよりも明確です.st_sizeメソッド。
これを指摘してくれたghostdog74に感謝！
os.stat -st_sizeバイト単位でサイズを指定します。ファイルサイズやその他のファイル関連情報を取得するためにも使用できます。
2018年に更新
Python 3.4以前を使用している場合は、サードパーティの walk パッケージで提供されるより効率的なscandirメソッドの使用を検討できます。 Python 3.5以降では、このパッケージは標準ライブラリに組み込まれ、os.walkは対応するパフォーマンスの向上を受けました。
これまでに提案されたアプローチには、再帰を実装するものと、シェルを使用するもの、またはきちんとフォーマットされた結果を生成しないものがあります。コードがLinuxプラットフォームで1回限りの場合、1行として、通常どおり書式設定を取得でき、再帰が含まれます。最後の行のprintを除き、現在のバージョンのpython2およびpython3で機能します：
du.py
-----
#!/usr/bin/python3
import subprocess
def du(path):
"""disk usage in human readable format (e.g. '2,1GB')"""
return subprocess.check_output(['du','-sh', path]).split()[0].decode('utf-8')
if __== "__main__":
print(du('.'))
シンプルで効率的で、ファイルおよびマルチレベルディレクトリで機能します。
$ chmod 750 du.py
$ ./du.py
2,9M
5年後に少し遅れましたが、これはまだ検索エンジンのヒットリストにあるため、助けになるかもしれません...
「du -sb」を実行したときとまったく同じバイトを返す再帰関数（すべてのサブフォルダーとそれぞれのファイルのサイズを再帰的に合計する）を次に示します。 Linuxの場合（「。」は「現在のフォルダー」を意味します）：
import os
def getFolderSize(folder):
total_size = os.path.getsize(folder)
for item in os.listdir(folder):
itempath = os.path.join(folder, item)
if os.path.isfile(itempath):
total_size += os.path.getsize(itempath)
Elif os.path.isdir(itempath):
total_size += getFolderSize(itempath)
return total_size
print "Size: " + str(getFolderSize("."))
os.scandirを使用したPython 3.5再帰フォルダーサイズ
def folder_size(path='.'):
total = 0
for entry in os.scandir(path):
if entry.is_file():
total += entry.stat().st_size
Elif entry.is_dir():
total += folder_size(entry.path)
return total
受け入れられた答えは、ハードリンクまたはソフトリンクを考慮せず、それらのファイルを2回カウントします。どのiノードを見たかを追跡し、それらのファイルのサイズを追加したくないでしょう。
import os
def get_size(start_path='.'):
total_size = 0
seen = {}
for dirpath, dirnames, filenames in os.walk(start_path):
for f in filenames:
fp = os.path.join(dirpath, f)
try:
stat = os.stat(fp)
except OSError:
continue
try:
seen[stat.st_ino]
except KeyError:
seen[stat.st_ino] = True
else:
continue
total_size += stat.st_size
return total_size
print get_size()
monknutの答えは良いですが、壊れたシンボリックリンクで失敗するので、このパスが本当に存在するかどうかも確認する必要があります
if os.path.exists(fp):
total_size += os.stat(fp).st_size
Chrisの答えは良いですが、見たディレクトリをチェックするセットを使用することにより、より慣用的にすることができます。これにより、制御フローの例外の使用も回避できます。
def directory_size(path):
total_size = 0
seen = set()
for dirpath, dirnames, filenames in os.walk(path):
for f in filenames:
fp = os.path.join(dirpath, f)
try:
stat = os.stat(fp)
except OSError:
continue
if stat.st_ino in seen:
continue
seen.add(stat.st_ino)
total_size += stat.st_size
return total_size # size in bytes
再帰的なワンライナー：
def getFolderSize(p):
from functools import partial
prepend = partial(os.path.join, p)
return sum([(os.path.getsize(f) if os.path.isfile(f) else getFolderSize(f)) for f in map(prepend, os.listdir(p))])
質問の2番目の部分について
def human(size):
B = "B"
KB = "KB"
MB = "MB"
GB = "GB"
TB = "TB"
UNITS = [B, KB, MB, GB, TB]
HUMANFMT = "%f %s"
HUMANRADIX = 1024.
for u in UNITS[:-1]:
if size < HUMANRADIX : return HUMANFMT % (size, u)
size /= HUMANRADIX
return HUMANFMT % (size, UNITS[-1])
次のようなことができます：
import commands
size = commands.getoutput('du -sh /path/').split()[0]
この場合、結果を返す前にテストしていません。必要に応じて、commands.getstatusoutputで確認できます。
あなたが言うワンライナー...ここにワンライナーがあります：
sum([sum(map(lambda fname: os.path.getsize(os.path.join(directory, fname)), files)) for directory, folders, files in os.walk(path)])
私はおそらくそれを分割し、チェックを実行しませんが。
KBに変換するには、 ファイルサイズの人間が読めるバージョンを取得するための再利用可能なライブラリ？ を参照して、
パーティーに少し遅れましたが、1行で glob2 および humanize がインストールされていることが条件になりました。 Python 3では、デフォルトのiglobには再帰モードがあります。 Python 3のコードを変更する方法は、読者にとってささいな課題です。
>>> import os
>>> from humanize import naturalsize
>>> from glob2 import iglob
>>> naturalsize(sum(os.path.getsize(x) for x in iglob('/var/**'))))
'546.2 MB'
次のスクリプトは、指定したディレクトリのすべてのサブディレクトリのディレクトリサイズを出力します。また、再帰関数の呼び出しをキャッシュすることで（可能であれば）利益を得ようとします。引数を省略すると、スクリプトは現在のディレクトリで機能します。出力は、ディレクトリサイズの大きい順に並べられます。したがって、ニーズに合わせて調整できます。
PS私は、人に優しい形式でディレクトリサイズを表示するためにレシピ578019を使用しました（ http://code.activestate.com/recipes/578019/ ）
from __future__ import print_function
import os
import sys
import operator
def null_decorator(ob):
return ob
if sys.version_info >= (3,2,0):
import functools
my_cache_decorator = functools.lru_cache(maxsize=4096)
else:
my_cache_decorator = null_decorator
start_dir = os.path.normpath(os.path.abspath(sys.argv[1])) if len(sys.argv) > 1 else '.'
@my_cache_decorator
def get_dir_size(start_path = '.'):
total_size = 0
if 'scandir' in dir(os):
# using fast 'os.scandir' method (new in version 3.5)
for entry in os.scandir(start_path):
if entry.is_dir(follow_symlinks = False):
total_size += get_dir_size(entry.path)
Elif entry.is_file(follow_symlinks = False):
total_size += entry.stat().st_size
else:
# using slow, but compatible 'os.listdir' method
for entry in os.listdir(start_path):
full_path = os.path.abspath(os.path.join(start_path, entry))
if os.path.isdir(full_path):
total_size += get_dir_size(full_path)
Elif os.path.isfile(full_path):
total_size += os.path.getsize(full_path)
return total_size
def get_dir_size_walk(start_path = '.'):
total_size = 0
for dirpath, dirnames, filenames in os.walk(start_path):
for f in filenames:
fp = os.path.join(dirpath, f)
total_size += os.path.getsize(fp)
return total_size
def bytes2human(n, format='%(value).0f%(symbol)s', symbols='customary'):
"""
(c) http://code.activestate.com/recipes/578019/
Convert n bytes into a human readable string based on format.
symbols can be either "customary", "customary_ext", "iec" or "iec_ext",
see: http://goo.gl/kTQMs
>>> bytes2human(0)
'0.0 B'
>>> bytes2human(0.9)
'0.0 B'
>>> bytes2human(1)
'1.0 B'
>>> bytes2human(1.9)
'1.0 B'
>>> bytes2human(1024)
'1.0 K'
>>> bytes2human(1048576)
'1.0 M'
>>> bytes2human(1099511627776127398123789121)
'909.5 Y'
>>> bytes2human(9856, symbols="customary")
'9.6 K'
>>> bytes2human(9856, symbols="customary_ext")
'9.6 kilo'
>>> bytes2human(9856, symbols="iec")
'9.6 Ki'
>>> bytes2human(9856, symbols="iec_ext")
'9.6 kibi'
>>> bytes2human(10000, "%(value).1f %(symbol)s/sec")
'9.8 K/sec'
>>> # precision can be adjusted by playing with %f operator
>>> bytes2human(10000, format="%(value).5f %(symbol)s")
'9.76562 K'
"""
SYMBOLS = {
'customary' : ('B', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'),
'customary_ext' : ('byte', 'kilo', 'mega', 'giga', 'tera', 'peta', 'exa',
'zetta', 'iotta'),
'iec' : ('Bi', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi', 'Yi'),
'iec_ext' : ('byte', 'kibi', 'mebi', 'gibi', 'tebi', 'Pebi', 'exbi',
'zebi', 'yobi'),
}
n = int(n)
if n < 0:
raise ValueError("n < 0")
symbols = SYMBOLS[symbols]
prefix = {}
for i, s in enumerate(symbols[1:]):
prefix[s] = 1 << (i+1)*10
for symbol in reversed(symbols[1:]):
if n >= prefix[symbol]:
value = float(n) / prefix[symbol]
return format % locals()
return format % dict(symbol=symbols[0], value=n)
############################################################
###
### main ()
###
############################################################
if __== '__main__':
dir_tree = {}
### version, that uses 'slow' [os.walk method]
#get_size = get_dir_size_walk
### this recursive version can benefit from caching the function calls (functools.lru_cache)
get_size = get_dir_size
for root, dirs, files in os.walk(start_dir):
for d in dirs:
dir_path = os.path.join(root, d)
if os.path.isdir(dir_path):
dir_tree[dir_path] = get_size(dir_path)
for d, size in sorted(dir_tree.items(), key=operator.itemgetter(1), reverse=True):
print('%s\t%s' %(bytes2human(size, format='%(value).2f%(symbol)s'), d))
print('-' * 80)
if sys.version_info >= (3,2,0):
print(get_dir_size.cache_info())
サンプル出力：
37.61M .\subdir_b
2.18M .\subdir_a
2.17M .\subdir_a\subdir_a_2
4.41K .\subdir_a\subdir_a_1
----------------------------------------------------------
CacheInfo(hits=2, misses=4, maxsize=4096, currsize=4)
編集：null_decoratorをuser2233949が推奨したように上に移動しました
ライブラリを使用 sh ：モジュールduが実行します：
pip install sh
import sh
print( sh.du("-s", ".") )
91154728 .
アスタリスクを渡したい場合は、 here の説明に従ってglobを使用します。
人間が読める形式で値を変換するには、 humanize を使用します。
pip install humanize
import humanize
print( humanize.naturalsize( 91157384 ) )
91.2 MB
便利です：
import os
import stat
size = 0
path_ = ""
def calculate(path=os.environ["SYSTEMROOT"]):
global size, path_
size = 0
path_ = path
for x, y, z in os.walk(path):
for i in z:
size += os.path.getsize(x + os.sep + i)
def cevir(x):
global path_
print(path_, x, "Byte")
print(path_, x/1024, "Kilobyte")
print(path_, x/1048576, "Megabyte")
print(path_, x/1073741824, "Gigabyte")
calculate("C:\Users\Jundullah\Desktop")
cevir(size)
Output:
C:\Users\Jundullah\Desktop 87874712211 Byte
C:\Users\Jundullah\Desktop 85815148.64355469 Kilobyte
C:\Users\Jundullah\Desktop 83803.85609722137 Megabyte
C:\Users\Jundullah\Desktop 81.83970321994275 Gigabyte
pathlibを使用して、フォルダーのサイズを取得するためにこのワンライナーを思いつきました。
sum(file.stat().st_size for file in Path(folder).rglob('*'))
そして、これは私がうまくフォーマットされた出力のために思いついたものです：
from pathlib import Path
def get_folder_size(folder):
return ByteSize(sum(file.stat().st_size for file in Path(folder).rglob('*')))
class ByteSize(int):
_kB = 1024
_suffixes = 'B', 'kB', 'MB', 'GB', 'PB'
def __new__(cls, *args, **kwargs):
return super().__new__(cls, *args, **kwargs)
def __init__(self, *args, **kwargs):
self.bytes = self.B = int(self)
self.kilobytes = self.kB = self / self._kB**1
self.megabytes = self.MB = self / self._kB**2
self.gigabytes = self.GB = self / self._kB**3
self.petabytes = self.PB = self / self._kB**4
*suffixes, last = self._suffixes
suffix = next((
suffix
for suffix in suffixes
if 1 < getattr(self, suffix) < self._kB
), last)
self.readable = suffix, getattr(self, suffix)
super().__init__()
def __str__(self):
return self.__format__('.2f')
def __repr__(self):
return '{}({})'.format(self.__class__.__name__, super().__repr__())
def __format__(self, format_spec):
suffix, val = self.readable
return '{val:{fmt}} {suf}'.format(val=val, fmt=format_spec, suf=suffix)
def __sub__(self, other):
return self.__class__(super().__sub__(other))
def __add__(self, other):
return self.__class__(super().__add__(other))
def __mul__(self, other):
return self.__class__(super().__mul__(other))
def __rsub__(self, other):
return self.__class__(super().__sub__(other))
def __radd__(self, other):
return self.__class__(super().__add__(other))
def __rmul__(self, other):
return self.__class__(super().__rmul__(other))
使用法：
>>> size = get_folder_size("c:/users/tdavis/downloads")
>>> print(size)
5.81 GB
>>> size.GB
5.810891855508089
>>> size.gigabytes
5.810891855508089
>>> size.PB
0.005674699077644618
>>> size.MB
5950.353260040283
>>> size
ByteSize(6239397620)
私もこれに遭遇しました question 、これはファイルサイズを印刷するためのいくつかのよりコンパクトでおそらくより高性能な戦略を持っています。
1つのファイルのサイズを取得するために、os.path.getsize（）があります
>>> import os
>>> os.path.getsize("/path/file")
35L
バイト単位で報告されます。
価値があるのは... treeコマンドはこれをすべて無料で行います：
tree -h --du /path/to/dir # files and dirs
tree -h -d --du /path/to/dir # dirs only
私はPythonが大好きですが、この問題に対する最も簡単な解決策は新しいコードを必要としません。
サブディレクトリのサイズが計算されると、親のフォルダサイズが更新され、ルートの親に達するまでこれが続きます。
次の関数は、フォルダーとそのすべてのサブフォルダーのサイズを計算します。
import os
def folder_size(path):
parent = {} # path to parent path mapper
folder_size = {} # storing the size of directories
folder = os.path.realpath(path)
for root, _, filenames in os.walk(folder):
if root == folder:
parent[root] = -1 # the root folder will not have any parent
folder_size[root] = 0.0 # intializing the size to 0
Elif root not in parent:
immediate_parent_path = os.path.dirname(root) # extract the immediate parent of the subdirectory
parent[root] = immediate_parent_path # store the parent of the subdirectory
folder_size[root] = 0.0 # initialize the size to 0
total_size = 0
for filename in filenames:
filepath = os.path.join(root, filename)
total_size += os.stat(filepath).st_size # computing the size of the files under the directory
folder_size[root] = total_size # store the updated size
temp_path = root # for subdirectories, we need to update the size of the parent till the root parent
while parent[temp_path] != -1:
folder_size[parent[temp_path]] += total_size
temp_path = parent[temp_path]
return folder_size[folder]/1000000.0
私はpython 2.7.13を scandir で使用していますが、フォルダーの合計サイズを取得するための1行の再帰関数を次に示します。
from scandir import scandir
def getTotFldrSize(path):
return sum([s.stat(follow_symlinks=False).st_size for s in scandir(path) if s.is_file(follow_symlinks=False)]) + \
+ sum([getTotFldrSize(s.path) for s in scandir(path) if s.is_dir(follow_symlinks=False)])
>>> print getTotFldrSize('.')
1203245680
Windows OSを使用している場合は、次のことができます。
起動してモジュールpywin32をインストールします。
pip install pywin32
そして、次をコーディングします：
import win32com.client as com
def get_folder_size(path):
try:
fso = com.Dispatch("Scripting.FileSystemObject")
folder = fso.GetFolder(path)
size = str(round(folder.Size / 1048576))
print("Size: " + size + " MB")
except Exception as e:
print("Error --> " + str(e))
以下は、再帰的にそれを行う1つのライナーです（Python 3.5以降で利用可能な再帰オプション）：
import os
import glob
print(sum(os.path.getsize(f) for f in glob.glob('**', recursive=True) if os.path.isfile(f))/(1024*1024))
Pathlibを使用してPython 3.6で機能するソリューション。
from pathlib import Path
sum([f.stat().st_size for f in Path("path").glob("**/*")])
このスクリプトは、CWDで最大のファイルを示し、ファイルがどのフォルダーにあるかを示します。このスクリプトはwin8およびpython 3.3.3 Shellで動作します
import os
folder=os.cwd()
number=0
string=""
for root, dirs, files in os.walk(folder):
for file in files:
pathname=os.path.join(root,file)
## print (pathname)
## print (os.path.getsize(pathname)/1024/1024)
if number < os.path.getsize(pathname):
number = os.path.getsize(pathname)
string=pathname
## print ()
print (string)
print ()
print (number)
print ("Number in bytes")
python3.5 +の場合
from pathlib import Path
def get_size(path):
return sum(p.stat().st_size for p in Path(path).rglob('*'))
私はここで少し遅れています（そして新しい）が、サブプロセスモジュールと 'du'コマンドラインをLinuxで使用して、フォルダーサイズの正確な値をMB単位で取得することにしました。ルートフォルダーにifとElifを使用する必要がありました。
import subprocess
import os
#
# get folder size
#
def get_size(self, path):
if os.path.exists(path) and path != '/':
cmd = str(subprocess.check_output(['Sudo', 'du', '-s', path])).\
replace('b\'', '').replace('\'', '').split('\\t')[0]
return float(cmd) / 1000000
Elif os.path.exists(path) and path == '/':
cmd = str(subprocess.getoutput(['Sudo du -s /'])). \
replace('b\'', '').replace('\'', '').split('\n')
val = cmd[len(cmd) - 1].replace('/', '').replace(' ', '')
return float(val) / 1000000
else: raise ValueError
確かに、これは一種のハッキングであり、Unix/Linuxでのみ機能します。
これはdu -sb .に一致します。これは、これがdu -sb .コマンドを実行するPython bashラッパーであるためです。
import subprocess
def system_command(cmd):
""""Function executes cmd parameter as a bash command."""
p = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
Shell=True)
stdout, stderr = p.communicate()
return stdout, stderr
size = int(system_command('du -sb . ')[0].split()[0])
def recursive_dir_size(path):
size = 0
for x in os.listdir(path):
if not os.path.isdir(os.path.join(path,x)):
size += os.stat(os.path.join(path,x)).st_size
else:
size += recursive_dir_size(os.path.join(path,x))
return size
私はディレクトリの正確な全体サイズを与えるこの関数を書きました、os.walkでループソリューションのために他のものを試しましたが、最終結果が常に実際のサイズよりも小さい理由がわかりません（ubuntu 18 envで）。私は何か間違ったことをしたに違いありませんが、これを書いた人は完全にうまく動作します。
Python 3.6 +os.scandirを使用した再帰的なフォルダー/ファイルサイズ。 @ -blakevによる answer と同様に強力ですが、より短く、EAFP python style。
import os
def size(path, *, follow_symlinks=False):
try:
with os.scandir(path) as it:
return sum(size(entry, follow_symlinks=follow_symlinks) for entry in it)
except NotADirectoryError:
return os.stat(path, follow_symlinks=follow_symlinks).st_size
ディレクトリサイズを取得する
ソリューションのプロパティ：
- 見かけのサイズ（ファイル内のバイト数）とファイルが使用する実際のディスク容量の両方を返します。
- ハードリンクされたファイルを1回だけカウントします
duと同じ方法でシンボリックリンクをカウントします- 再帰を使用しません
- 使用されるディスク容量に
st.st_blocksを使用するため、Unixライクなシステムでのみ動作します
コード：
import os
def du(path):
if os.path.islink(path):
return (os.lstat(path).st_size, 0)
if os.path.isfile(path):
st = os.lstat(path)
return (st.st_size, st.st_blocks * 512)
apparent_total_bytes = 0
total_bytes = 0
have = []
for dirpath, dirnames, filenames in os.walk(path):
apparent_total_bytes += os.lstat(dirpath).st_size
total_bytes += os.lstat(dirpath).st_blocks * 512
for f in filenames:
fp = os.path.join(dirpath, f)
if os.path.islink(fp):
apparent_total_bytes += os.lstat(fp).st_size
continue
st = os.lstat(fp)
if st.st_ino in have:
continue # skip hardlinks which were already counted
have.append(st.st_ino)
apparent_total_bytes += st.st_size
total_bytes += st.st_blocks * 512
for d in dirnames:
dp = os.path.join(dirpath, d)
if os.path.islink(dp):
apparent_total_bytes += os.lstat(dp).st_size
return (apparent_total_bytes, total_bytes)
使用例：
>>> du('/lib')
(236425839, 244363264)
$ du -sb /lib
236425839 /lib
$ du -sB1 /lib
244363264 /lib
人間が読めるファイルサイズ
ソリューションのプロパティ：
コード：
def humanized_size(num, suffix='B', si=False):
if si:
units = ['','K','M','G','T','P','E','Z']
last_unit = 'Y'
div = 1000.0
else:
units = ['','Ki','Mi','Gi','Ti','Pi','Ei','Zi']
last_unit = 'Yi'
div = 1024.0
for unit in units:
if abs(num) < div:
return "%3.1f%s%s" % (num, unit, suffix)
num /= div
return "%.1f%s%s" % (num, last_unit, suffix)
使用例：
>>> humanized_size(236425839)
'225.5MiB'
>>> humanized_size(236425839, si=True)
'236.4MB'
>>> humanized_size(236425839, si=True, suffix='')
'236.4M'