blocks|key|1244612|text|到目前为止，建议的一些方法实现了递归，其他方法使用shell或不会产生整齐格式化的结果。当您的代码在Linux平台上是一次性的时，您可以像往常一样进行格式化，包括递归，作为一行代码。除了最后一行中的print之外，它将适用于当前版本的python2和python3：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1244613|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+__name__+==+"__main__":
++++print(du('.'))|code-block|syntax|javascript|1244614|简单，高效，适用于文件和多级目录：|1244615|$+chmod+750+du.py
$+./du.py
2,9M|1244616|entityMap^0|2R|5|39|7|3H|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

Some of the approaches suggested so far implement a recursion, others employ a shell or will not produce neatly formatted results. When your code is one-off for Linux platforms, you can get formatting as usual, recursion included, as a one-liner. Except for the <code>print</code> in the last line, it will work for current versions of <code>python2</code> and <code>python3</code>: 

<pre><code>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 __name__ == "__main__":
 print(du('.'))
</code></pre>

is simple, efficient and will work for files and multilevel directories:

<pre><code>$ chmod 750 du.py
$ ./du.py
2,9M
</code></pre>

blocks|key|1459093|text|下面是一个递归函数(它递归地汇总所有子文件夹及其各自文件的大小)，它返回与运行"du+-sb“时完全相同的字节。在linux中(其中的".“表示“当前文件夹”)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1459094|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+%2B=+os.path.getsize(itempath)
++++++++elif+os.path.isdir(itempath):
++++++++++++total_size+%2B=+getFolderSize(itempath)
++++return+total_size

print+"Size:+"+%2B+str(getFolderSize("."))|code-block|syntax|javascript|1459095|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a recursive function (it recursively sums up the size of all subfolders and their respective files) which returns exactly the same bytes as when running "du -sb ." in linux (where the "." means "the current folder"):

<pre><code>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("."))
</code></pre>

blocks|key|1244803|text|使用os.scandir的Python3.5递归文件夹大小|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1244804|def+folder_size(path='.'):
++++total+=+0
++++for+entry+in+os.scandir(path):
++++++++if+entry.is_file():
++++++++++++total+%2B=+entry.stat().st_size
++++++++elif+entry.is_dir():
++++++++++++total+%2B=+folder_size(entry.path)
++++return+total|code-block|syntax|javascript|1244805|entityMap^0|2|A|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Python 3.5 recursive folder size using <code>os.scandir</code>

<pre><code>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
</code></pre>

blocks|key|1245372|text|使用pathlib时，我出现了下面这行代码来获取文件夹的大小：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1245373|sum(file.stat().st_size+for+file+in+Path(folder).rglob('*'))|code-block|syntax|javascript|1245374|这就是我想出的格式很好的输出：|1245375|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))+++|1245376|用法：|1245377|>>>+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)|1245378|我还遇到了这个question，它有一些更紧凑、可能更高效的打印文件大小的策略。|1245379|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1094841/reusable-library-to-get-human-readable-version-of-file-size^0|2|7|0|0|0|0|0|0|7|8|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1A|8|@]|D|@$9|1B|A|1C|1|1D]]|E|$]]|$1|U|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]]]

Using <code>pathlib</code> I came up this one-liner to get the size of a folder:

<pre class="lang-py prettyprint-override"><code>sum(file.stat().st_size for file in Path(folder).rglob('*'))
</code></pre>

And this is what I came up with for a nicely formatted output:

<pre class="lang-py prettyprint-override"><code>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 &lt; getattr(self, suffix) &lt; 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)) 
</code></pre>

Usage:

<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; size = get_folder_size("c:/users/tdavis/downloads")
&gt;&gt;&gt; print(size)
5.81 GB
&gt;&gt;&gt; size.GB
5.810891855508089
&gt;&gt;&gt; size.gigabytes
5.810891855508089
&gt;&gt;&gt; size.PB
0.005674699077644618
&gt;&gt;&gt; size.MB
5950.353260040283
&gt;&gt;&gt; size
ByteSize(6239397620)
</code></pre>

I also came across this <a href="https://stackoverflow.com/questions/1094841/reusable-library-to-get-human-readable-version-of-file-size">question</a>, which has some more compact and probably more performant strategies for printing file sizes.

blocks|key|1244269|text|monknut的答案是好的，但它在断开的符号链接上失败，因此您还必须检查此路径是否真的存在|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1244270|if+os.path.exists(fp):
++++total_size+%2B=+os.stat(fp).st_size|code-block|syntax|javascript|1244271|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

monknut answer is good but it fails on broken symlink, so you also have to check if this path really exists

<pre><code>if os.path.exists(fp):
 total_size += os.stat(fp).st_size
</code></pre>

blocks|key|1245460|text|对于python3.5%2B|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1245461|from+pathlib+import+Path

def+get_size(folder:+str)+->+int:
++++return+sum(p.stat().st_size+for+p+in+Path(folder).rglob('*'))|code-block|syntax|javascript|1245462|用法：：|1245463|In+[6]:+get_size('/etc/not-exist-path')
Out[6]:+0
In+[7]:+get_size('.')
Out[7]:+12038689
In+[8]:+def+filesize(size:+int)+->+str:
+++...:+++++for+unit+in+("B",+"K",+"M",+"G",+"T"):
+++...:+++++++++if+size+<+1024:
+++...:+++++++++++++break
+++...:+++++++++size+/=+1024
+++...:+++++return+f"{size:.1f}{unit}"
+++...:

In+[9]:+filesize(get_size('.'))
Out[9]:+'11.5M'|1245464|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

for python3.5+
<pre><code>from pathlib import Path

def get_size(folder: str) -&gt; int:
 return sum(p.stat().st_size for p in Path(folder).rglob('*'))
</code></pre>
Usage::
<pre><code>In [6]: get_size('/etc/not-exist-path')
Out[6]: 0
In [7]: get_size('.')
Out[7]: 12038689
In [8]: def filesize(size: int) -&gt; str:
 ...: for unit in (&quot;B&quot;, &quot;K&quot;, &quot;M&quot;, &quot;G&quot;, &quot;T&quot;):
 ...: if size &lt; 1024:
 ...: break
 ...: size /= 1024
 ...: return f&quot;{size:.1f}{unit}&quot;
 ...:

In [9]: filesize(get_size('.'))
Out[9]: '11.5M'

</code></pre>

blocks|key|1244381|text|公认的答案没有考虑硬链接或软链接，并且会计算这些文件两次。您可能希望跟踪您所看到的inode，而不是添加这些文件的大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1244382|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+%2B=+stat.st_size

++++return+total_size

print+get_size()|code-block|syntax|javascript|1244383|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The accepted answer doesn't take into account hard or soft links, and would count those files twice. You'd want to keep track of which inodes you've seen, and not add the size for those files.

<pre><code>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()
</code></pre>

blocks|key|1459233|text|递归的一行代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1459234|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))])|code-block|syntax|javascript|1459235|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

a recursive one-liner:

<pre><code>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))])
</code></pre>

blocks|key|1244443|text|Chris的回答很好，但是可以通过使用set来检查看到的目录，这也避免了对控制流使用异常：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1244444|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+%2B=+stat.st_size

++++return+total_size++#+size+in+bytes|code-block|syntax|javascript|1244445|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Chris' answer is good but could be made more idiomatic by using a set to check for seen directories, which also avoids using an exception for control flow:

<pre><code>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
</code></pre>

blocks|key|1459558|text|参加聚会有点晚，但只要你安装了glob2和humanize就行了。请注意，在Python3中，默认的iglob具有递归模式。如何修改Python3的代码留给读者一个微不足道的练习。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1459559|>>>+import+os
>>>+from+humanize+import+naturalsize
>>>+from+glob2+import+iglob
>>>+naturalsize(sum(os.path.getsize(x)+for+x+in+iglob('/var/**'))))
'546.2+MB'|code-block|syntax|javascript|1459560|entityMap|0|LINK|mutability|MUTABLE|url|https://pypi.python.org/pypi/glob2|1|https://pypi.python.org/pypi/humanize^0|1E|5|F|5|0|L|8|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]|$9|10|A|11|1|12]]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

A little late to the party but in one line provided that you have <a href="https://pypi.python.org/pypi/glob2" rel="noreferrer">glob2</a> and <a href="https://pypi.python.org/pypi/humanize" rel="noreferrer">humanize</a> installed. Note that in Python 3, the default <code>iglob</code> has a recursive mode. How to modify the code for Python 3 is left as a trivial exercise for the reader.

<pre><code>&gt;&gt;&gt; import os
&gt;&gt;&gt; from humanize import naturalsize
&gt;&gt;&gt; from glob2 import iglob
&gt;&gt;&gt; naturalsize(sum(os.path.getsize(x) for x in iglob('/var/**'))))
'546.2 MB'
</code></pre>

blocks|key|1459377|text|关于问题的第二部分|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1459378|def+human(size):

++++B+=+"B"
++++KB+=+"KB"+
++++MB+=+"MB"
++++GB+=+"GB"
++++TB+=+"TB"
++++UNITS+=+[B,+KB,+MB,+GB,+TB]
++++HUMANFMT+=+"%25f+%25s"
++++HUMANRADIX+=+1024.

++++for+u+in+UNITS[:-1]:
++++++++if+size+<+HUMANRADIX+:+return+HUMANFMT+%25+(size,+u)
++++++++size+/=+HUMANRADIX

++++return+HUMANFMT+%25+(size,++UNITS[-1])|code-block|syntax|javascript|1459379|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For the second part of the question

<pre><code>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 &lt; HUMANRADIX : return HUMANFMT % (size, u)
 size /= HUMANRADIX

 return HUMANFMT % (size, UNITS[-1])
</code></pre>

blocks|key|1244415|text|你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1244416|import+commands+++
size+=+commands.getoutput('du+-sh+/path/').split()[0]|code-block|syntax|javascript|1244417|在这种情况下，我没有在返回结果之前测试它，如果你愿意，你可以用commands.getstatusoutput检查它。|1244418|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can do something like this : 

<pre><code>import commands 
size = commands.getoutput('du -sh /path/').split()[0]
</code></pre>

in this case I have not tested the result before returning it, if you want you can check it with commands.getstatusoutput.

blocks|key|1244709|text|你说的一句话...这里有一行代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1244710|sum([sum(map(lambda+fname:+os.path.getsize(os.path.join(directory,+fname)),+files))+for+directory,+folders,+files+in+os.walk(path)])|code-block|syntax|javascript|1244711|虽然我可能会拆分它，它不执行任何检查。|1244712|要转换为kb，请参阅Reusable+library+to+get+human+readable+version+of+file+size?并在其中工作|offset|length|1244713|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1094841/reusable-library-to-get-human-readable-version-of-file-size^0|0|0|0|A|1O|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

One-liner you say...
Here is a one liner:

<pre><code>sum([sum(map(lambda fname: os.path.getsize(os.path.join(directory, fname)), files)) for directory, folders, files in os.walk(path)])
</code></pre>

Although I would probably split it out and it performs no checks.

To convert to kb see <a href="https://stackoverflow.com/questions/1094841/reusable-library-to-get-human-readable-version-of-file-size">Reusable library to get human readable version of file size?</a> and work it in

blocks|key|1459479|text|以下脚本打印指定目录的所有子目录的目录大小。它还试图(如果可能)从缓存递归函数的调用中获益。如果省略了参数，脚本将在当前目录中工作。输出按照目录大小从大到小排序。因此，您可以根据自己的需要对其进行调整。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1459480|PS我使用recipe+578019以人类友好的格式(http://code.activestate.com/recipes/578019/)显示目录大小|offset|length|1459481|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+%2B=+get_dir_size(entry.path)
++++++++++++elif+entry.is_file(follow_symlinks+=+False):
++++++++++++++++total_size+%2B=+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+%2B=+get_dir_size(full_path)
++++++++++++elif+os.path.isfile(full_path):
++++++++++++++++total_size+%2B=+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+%2B=+os.path.getsize(fp)
++++return+total_size

def+bytes2human(n,+format='%25(value).0f%25(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,+"%25(value).1f+%25(symbol)s/sec")
++++++'9.8+K/sec'

++++++>>>+#+precision+can+be+adjusted+by+playing+with+%25f+operator
++++++>>>+bytes2human(10000,+format="%25(value).5f+%25(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%2B1)*10
++++for+symbol+in+reversed(symbols[1:]):
++++++++if+n+>=+prefix[symbol]:
++++++++++++value+=+float(n)+/+prefix[symbol]
++++++++++++return+format+%25+locals()
++++return+format+%25+dict(symbol=symbols[0],+value=n)

############################################################
###
###++main+()
###
############################################################
if+__name__+==+'__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('%25s\t%25s'+%25(bytes2human(size,+format='%25(value).2f%25(symbol)s'),+d))

++++print('-'+*+80)
++++if+sys.version_info+>=+(3,2,0):
++++++++print(get_dir_size.cache_info())|code-block|syntax|javascript|1459482|示例输出：|1459483|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)|1459484|编辑:按照user2233949的建议，将null_decorator移到上面|1459485|entityMap|0|LINK|mutability|MUTABLE|url|http://code.activestate.com/recipes/578019/^0|0|R|17|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@$D|10|E|11|1|12]]|A|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|15|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

The following script prints directory size of all sub-directories for the specified directory. It also tries to benefit (if possible) from caching the calls of a recursive functions. If an argument is omitted, the script will work in the current directory. The output is sorted by the directory size from biggest to smallest ones. So you can adapt it for your needs.

PS i've used recipe 578019 for showing directory size in human-friendly format (<a href="http://code.activestate.com/recipes/578019/" rel="nofollow">http://code.activestate.com/recipes/578019/</a>)

<pre><code>from __future__ import print_function
import os
import sys
import operator

def null_decorator(ob):
 return ob

if sys.version_info &gt;= (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) &gt; 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

 &gt;&gt;&gt; bytes2human(0)
 '0.0 B'
 &gt;&gt;&gt; bytes2human(0.9)
 '0.0 B'
 &gt;&gt;&gt; bytes2human(1)
 '1.0 B'
 &gt;&gt;&gt; bytes2human(1.9)
 '1.0 B'
 &gt;&gt;&gt; bytes2human(1024)
 '1.0 K'
 &gt;&gt;&gt; bytes2human(1048576)
 '1.0 M'
 &gt;&gt;&gt; bytes2human(1099511627776127398123789121)
 '909.5 Y'

 &gt;&gt;&gt; bytes2human(9856, symbols="customary")
 '9.6 K'
 &gt;&gt;&gt; bytes2human(9856, symbols="customary_ext")
 '9.6 kilo'
 &gt;&gt;&gt; bytes2human(9856, symbols="iec")
 '9.6 Ki'
 &gt;&gt;&gt; bytes2human(9856, symbols="iec_ext")
 '9.6 kibi'

 &gt;&gt;&gt; bytes2human(10000, "%(value).1f %(symbol)s/sec")
 '9.8 K/sec'

 &gt;&gt;&gt; # precision can be adjusted by playing with %f operator
 &gt;&gt;&gt; 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 &lt; 0:
 raise ValueError("n &lt; 0")
 symbols = SYMBOLS[symbols]
 prefix = {}
 for i, s in enumerate(symbols[1:]):
 prefix[s] = 1 &lt;&lt; (i+1)*10
 for symbol in reversed(symbols[1:]):
 if n &gt;= prefix[symbol]:
 value = float(n) / prefix[symbol]
 return format % locals()
 return format % dict(symbol=symbols[0], value=n)

############################################################
###
### main ()
###
############################################################
if __name__ == '__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 &gt;= (3,2,0):
 print(get_dir_size.cache_info())
</code></pre>

Sample output:

<pre><code>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)
</code></pre>

EDIT: moved null_decorator above, as user2233949 recommended

blocks|key|1459734|text|使用库sh：模块du完成此操作：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1459735|pip+install+sh

import+sh
print(+sh.du("-s",+".")+)
91154728++++++++.|code-block|syntax|javascript|1459736|如果你想通过asterix，可以按照here描述的那样使用glob。|1459737|要转换人类可读内容中的值，请使用humanize|1459738|pip+install+humanize

import+humanize
print(+humanize.naturalsize(+91157384+)+)
91.2+MB|1459739|entityMap|0|LINK|mutability|MUTABLE|url|https://pypi.python.org/pypi/sh/0.107|1|https://stackoverflow.com/questions/32923189/how-to-pass-an-asterisk-to-module-sh-in-python/32923739|2|https://pypi.python.org/pypi/humanize^0|8|2|3|2|0|0|0|T|4|I|4|1|0|G|8|2|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|F|3|G|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@$9|1C|A|1D|1|1E]]|E|$]]|$1|M|3|N|5|6|7|1F|8|@]|D|@$9|1G|A|1H|1|1I]]|E|$]]|$1|O|3|P|5|H|7|1J|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|Z]]|10|$5|T|U|V|E|$W|11]]]]

use library <a href="https://pypi.python.org/pypi/sh/0.107" rel="nofollow noreferrer">sh</a>: the module <code>du</code> does it: 

<pre><code>pip install sh

import sh
print( sh.du("-s", ".") )
91154728 .
</code></pre>

if you want to pass asterix, use <code>glob</code> as described <a href="https://stackoverflow.com/questions/32923189/how-to-pass-an-asterisk-to-module-sh-in-python/32923739">here</a>.

to convert the values in human readables, use <a href="https://pypi.python.org/pypi/humanize" rel="nofollow noreferrer">humanize</a>:

<pre><code>pip install humanize

import humanize
print( humanize.naturalsize( 91157384 ) )
91.2 MB
</code></pre>

blocks|key|1459056|text|为了获得一个文件的大小，可以使用os.path.getsize()|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1459057|>>>+import+os
>>>+os.path.getsize("/path/file")
35L|code-block|syntax|javascript|1459058|以字节为单位进行报告。|1459059|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

for getting the size of one file, there is os.path.getsize()

<pre><code>&gt;&gt;&gt; import os
&gt;&gt;&gt; os.path.getsize("/path/file")
35L
</code></pre>

its reported in bytes.

blocks|key|1459810|text|不管它值多少钱...tree命令免费执行所有这些操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1459811|tree+-h+--du+/path/to/dir++#+files+and+dirs
tree+-h+-d+--du+/path/to/dir++#+dirs+only|code-block|syntax|javascript|1459812|我喜欢Python，但到目前为止，这个问题的最简单解决方案不需要新的代码。|1459813|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

For what it's worth... the tree command does all of this for free:

<pre><code>tree -h --du /path/to/dir # files and dirs
tree -h -d --du /path/to/dir # dirs only
</code></pre>

I love Python, but by far the simplest solution to the problem requires no new code.

blocks|key|1459989|text|它很方便：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1459990|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+%2B=+os.path.getsize(x+%2B+os.sep+%2B+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|code-block|syntax|javascript|1459991|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It is handy:

<pre><code>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
</code></pre>

blocks|key|1244963|text|我将python+2.7.13与scandir结合使用，下面是我的单行递归函数，用于获取文件夹的总大小：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1244964|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)])+%2B+\
++++%2B+sum([getTotFldrSize(s.path)+for+s+in+scandir(path)+if+s.is_dir(follow_symlinks=False)])

>>>+print+getTotFldrSize('.')
1203245680|code-block|syntax|javascript|1244965|https://pypi.python.org/pypi/scandir|1244966|entityMap|0|LINK|mutability|MUTABLE|url|1^0|G|7|0|0|0|0|10|1|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|K|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|J]]|R|$5|N|O|P|C|$Q|J]]]]

I'm using python 2.7.13 with <a href="https://pypi.python.org/pypi/scandir" rel="nofollow noreferrer">scandir</a> and here's my one-liner recursive function to get the total size of a folder:

<pre><code>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)])

&gt;&gt;&gt; print getTotFldrSize('.')
1203245680
</code></pre>

<a href="https://pypi.python.org/pypi/scandir" rel="nofollow noreferrer">https://pypi.python.org/pypi/scandir</a>

blocks|key|1245054|text|当计算子目录的大小时，它应该更新其父目录的文件夹大小，这将一直持续到它到达根父目录。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1245055|下面的函数计算文件夹及其所有子文件夹的大小。|1245056|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+%2B=+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]]+%2B=+total_size
++++++++++++temp_path+=+parent[temp_path]

++++return+folder_size[folder]/1000000.0|code-block|syntax|javascript|1245057|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

When size of the sub-directories is computed, it should update its parent's folder size and this will go on till it reaches the root parent.

The following function computes the size of the folder and all its sub-folders. 

<pre><code>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
</code></pre>

blocks|key|1460046|text|下面是一个递归执行的单行程序(从Python3.5开始可以使用递归选项)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1460047|import+os
import+glob
print(sum(os.path.getsize(f)+for+f+in+glob.glob('**',+recursive=True)+if+os.path.isfile(f))/(1024*1024))|code-block|syntax|javascript|1460048|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a one liner that does it recursively (recursive option available as of Python 3.5):

<pre><code>import os
import glob
print(sum(os.path.getsize(f) for f in glob.glob('**', recursive=True) if os.path.isfile(f))/(1024*1024))
</code></pre>

blocks|key|1245554|text|默认情况下，du不遵循符号链接。这里没有答案，请使用follow_symlinks=False。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1245555|下面是一个遵循du的默认行为的实现：|1245556|def+du(path)+->+int:
++++total+=+0
++++for+entry+in+os.scandir(path):
++++++++if+entry.is_file(follow_symlinks=False):
++++++++++++total+%2B=+entry.stat().st_size
++++++++elif+entry.is_dir(follow_symlinks=False):
++++++++++++total+%2B=+du(entry.path)
++++return+total|code-block|syntax|javascript|1245557|测试：|1245558|class+Test(unittest.TestCase):
++++def+test_du(self):
++++++++root+=+'/tmp/du_test'
++++++++subprocess.run(['rm',+'-rf',+root])
++++++++test_utils.mkdir(root)
++++++++test_utils.create_file(root,+'A',+'1M')
++++++++test_utils.create_file(root,+'B',+'1M')
++++++++sub+=+'/'.join([root,+'sub'])
++++++++test_utils.mkdir(sub)
++++++++test_utils.create_file(sub,+'C',+'1M')
++++++++test_utils.create_file(sub,+'D',+'1M')
++++++++subprocess.run(['ln',+'-s',+'/tmp',+'/'.join([root,+'link']),+])
++++++++self.assertEqual(4+<<+20,+util.du(root))|1245559|entityMap^0|6|2|Q|L|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

<code>du</code> does not follow symlinks by default. No answer here make use of <code>follow_symlinks=False</code>.

Here is an implementation which follows default behavior of du:

<pre><code>def du(path) -&gt; int:
 total = 0
 for entry in os.scandir(path):
 if entry.is_file(follow_symlinks=False):
 total += entry.stat().st_size
 elif entry.is_dir(follow_symlinks=False):
 total += du(entry.path)
 return total
</code></pre>

Test:

<pre><code>class Test(unittest.TestCase):
 def test_du(self):
 root = '/tmp/du_test'
 subprocess.run(['rm', '-rf', root])
 test_utils.mkdir(root)
 test_utils.create_file(root, 'A', '1M')
 test_utils.create_file(root, 'B', '1M')
 sub = '/'.join([root, 'sub'])
 test_utils.mkdir(sub)
 test_utils.create_file(sub, 'C', '1M')
 test_utils.create_file(sub, 'D', '1M')
 subprocess.run(['ln', '-s', '/tmp', '/'.join([root, 'link']), ])
 self.assertEqual(4 &lt;&lt; 20, util.du(root))
</code></pre>

blocks|key|1245571|text|import+os
def+get_size(path+=+os.getcwd()):
++++print("Calculating+Size:+",path)
++++total_size+=+0
++++#if+path+is+directory--
++++if+os.path.isdir(path):
++++++print("Path+type+:+Directory/Folder")
++++++for+dirpath,+dirnames,+filenames+in+os.walk(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+%2B=+os.path.getsize(fp)
++++#if+path+is+a+file---
++++elif+os.path.isfile(path):
++++++print("Path+type+:+File")
++++++total_size=os.path.getsize(path)
++++else:
++++++print("Path+Type+:+Special+File+(Socket,+FIFO,+Device+File)"+)
++++++total_size=0
++++bytesize=total_size
++++print(bytesize,+'bytes')
++++print(bytesize/(1024),+'kilobytes')
++++print(bytesize/(1024*1024),+'megabytes')
++++print(bytesize/(1024*1024*1024),+'gegabytes')
++++return+total_size


x=get_size("/content/examples")|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1245572|我相信这是有帮助的！文件夹和文件也是如此！|unstyled|1245573|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>import os
def get_size(path = os.getcwd()):
 print("Calculating Size: ",path)
 total_size = 0
 #if path is directory--
 if os.path.isdir(path):
 print("Path type : Directory/Folder")
 for dirpath, dirnames, filenames in os.walk(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)
 #if path is a file---
 elif os.path.isfile(path):
 print("Path type : File")
 total_size=os.path.getsize(path)
 else:
 print("Path Type : Special File (Socket, FIFO, Device File)" )
 total_size=0
 bytesize=total_size
 print(bytesize, 'bytes')
 print(bytesize/(1024), 'kilobytes')
 print(bytesize/(1024*1024), 'megabytes')
 print(bytesize/(1024*1024*1024), 'gegabytes')
 return total_size


x=get_size("/content/examples")
</code></pre>

I'm sure this helps! For folders and files as well!

blocks|key|1459280|text|此脚本将告诉您CWD中哪个文件最大，并告诉您该文件位于哪个文件夹中。这个脚本适用于win8和Python3.3.3shell|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1459281|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")|code-block|syntax|javascript|1459282|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This script tells you which file is the biggest in the CWD and also tells you in which folder the file is.
This script works for me on win8 and python 3.3.3 shell

<pre><code>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 &lt; os.path.getsize(pathname):
 number = os.path.getsize(pathname)
 string=pathname


## print ()


print (string)
print ()
print (number)
print ("Number in bytes")
</code></pre>

blocks|key|1244882|text|诚然，这是一种黑客行为，只能在Unix/Linux上运行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1244883|它与du+-sb+.匹配，因为实际上这是一个运行du+-sb+.命令的Python+bash包装器。|offset|length|style|CODE|1244884|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])|code-block|syntax|javascript|1244885|entityMap^0|0|2|8|O|8|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Admittedly, this is kind of hackish and only works on Unix/Linux.

It matches <code>du -sb .</code> because in effect this is a Python bash wrapper that runs the <code>du -sb .</code> command.

<pre><code>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])
</code></pre>

blocks|key|1459898|text|我来得有点晚(而且是新手)，但我选择在Linux中使用子进程模块和'du‘命令行来检索以MB为单位的文件夹大小的精确值。我不得不使用if和elif作为根文件夹，因为否则子进程会因为返回的非零值而引发错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1459899|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|code-block|syntax|javascript|1459900|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I'm a little late (and new) here but I chose to use the subprocess module and the 'du' command line with Linux to retrieve an accurate value for folder size in MB. I had to use if and elif for root folder because otherwise subprocess raises error due to non-zero value returned.

<pre><code>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
</code></pre>

blocks|key|1459952|text|如果您使用的是Windows操作系统，则可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1459953|通过启动以下命令安装模块pywin32：|1459954|pip安装pywin32|1459955|然后编写以下代码：|1459956|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:+"+%2B+size+%2B+"+MB")
+++except+Exception+as+e:
+++++++print("Error+-->+"+%2B+str(e))|code-block|syntax|javascript|1459957|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you are in Windows OS you can do:

install the module pywin32 by launching:

pip install pywin32

and then coding the following:

<pre><code>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 --&gt; " + str(e))
</code></pre>

blocks|key|1245406|text|一个使用pathlib在Python+3.6上工作的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1245407|from+pathlib+import+Path

sum([f.stat().st_size+for+f+in+Path("path").glob("**/*")])|code-block|syntax|javascript|1245408|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A solution that works on Python 3.6 using pathlib.

<pre><code>from pathlib import Path

sum([f.stat().st_size for f in Path("path").glob("**/*")])
</code></pre>

blocks|key|1245501|text|def+recursive_dir_size(path):
++++size+=+0

++++for+x+in+os.listdir(path):
++++++++if+not+os.path.isdir(os.path.join(path,x)):
++++++++++++size+%2B=+os.stat(os.path.join(path,x)).st_size
++++++++else:
++++++++++++size+%2B=+recursive_dir_size(os.path.join(path,x))

++++return+size|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1245502|我写了这个函数，它可以给出准确的目录总大小，我用os.walk尝试了其他for循环解决方案，但我不知道为什么最终结果总是小于实际大小(在ubuntu18env上)。我肯定做错了什么，但谁会关心写这篇文章的效果呢？|unstyled|1245503|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre class="lang-py prettyprint-override"><code>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
</code></pre>

I wrote this function which gives me accurate overall size of a directory, i tried other for loop solutions with os.walk but i don't know why the end result was always less than the actual size (on ubuntu 18 env). I must have done something wrong but who cares wrote this one works perfectly fine.

blocks|key|1244503|text|import+os

def+get_size(path):
++++total_size+=+0
++++for+dirpath,+dirnames,+filenames+in+os.walk(path):
++++++++for+f+in+filenames:
++++++++++++if+os.path.exists(fp):
++++++++++++++++fp+=+os.path.join(dirpath,+f)
++++++++++++++++total_size+%2B=+os.path.getsize(fp)

++++return+total_size+++#+in+megabytes|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1244504|谢谢monkut+&+troex！|unstyled|1244505|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>import os

def get_size(path):
 total_size = 0
 for dirpath, dirnames, filenames in os.walk(path):
 for f in filenames:
 if os.path.exists(fp):
 fp = os.path.join(dirpath, f)
 total_size += os.path.getsize(fp)

 return total_size # in megabytes
</code></pre>

Thanks monkut &amp; troex!

Before I re-invent this particular wheel, has anybody got a nice routine for calculating the size of a directory using Python? It would be very nice if the routine would format the size nicely in Mb/Gb etc.

Calculating a directory's size using Python?

在我重新发明这个轮子之前，有没有人有一个用Python计算目录大小的好例程？如果例程能很好地将大小格式化为Mb/Gb等，那就太好了。

问使用Python计算目录的大小？
EN

回答 30

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用Python计算目录的大小？EN

回答 30

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用Python计算目录的大小？
EN