使用 Python 计算目录的大小？

2025-01-08 08:50:00
admin
原创
128
摘要：问题描述：在我重新发明这个特定的轮子之前，有人有使用 Python 计算目录大小的很好的例程吗？如果例程能够以 Mb/Gb 等格式很好地格式化大小，那就太好了。解决方案 1：这将遍历所有子目录；计算文件大小：import os def get_size(start_path = '.'): tota...

问题描述：

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

解决方案 1：

这将遍历所有子目录；计算文件大小：

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

已更新
为使用os.path.getsize，这比使用 os.stat().st_size 方法更清晰。

感谢ghostdog74指出这一点！

os.stat - st_size给出以字节为单位的大小。也可用于获取文件大小和其他文件相关信息。

import os

nbytes = sum(d.stat().st_size for d in os.scandir('.') if d.is_file())

2018 年更新

如果你使用 Python 3.4 或更早的版本，那么你可以考虑使用walk第三方scandir包提供的更高效的方法。在 Python 3.5 及更高版本中，此包已被纳入标准库，并os.walk获得了相应的性能提升。

2019 年更新

最近用的pathlib越来越多了，下面给出pathlib解决办法：

from pathlib import Path

root_directory = Path('.')
sum(f.stat().st_size for f in root_directory.glob('**/*') if f.is_file())

解决方案 2：

到目前为止，建议的一些方法实现了递归，其他方法则使用 shell 或不会产生格式整齐的结果。当您的代码是针对 Linux 平台的一次性代码时，您可以像往常一样将格式设置为一行，包括递归。除了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 __name__ == "__main__":
    print(du('.'))

简单、高效，适用于文件和多级目录：

$ chmod 750 du.py
$ ./du.py
2,9M

解决方案 3：

我想出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)

我也遇到过这个问题，它有一些更紧凑、可能更高效的打印文件大小策略。

解决方案 4：

这是一个递归函数（它以递归方式汇总所有子文件夹及其各自文件的大小），它返回的字节与在 Linux 中运行“du -sb .”时完全相同（其中“。”表示“当前文件夹”）：

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

解决方案 5：

Python 3.5 使用递归文件夹大小os.scandir

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

解决方案 6：

适用于 Python3.5+

from pathlib import Path

def get_size(folder: str) -> int:
    return sum(p.stat().st_size for p in Path(folder).rglob('*'))

用法：：

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'

解决方案 7：

Monknut 的答案很好，但它在损坏的符号链接上失败，因此您还必须检查此路径是否真的存在

if os.path.exists(fp):
    total_size += os.stat(fp).st_size

解决方案 8：

可接受的答案不考虑硬链接或软链接，并且会将这些文件计算两次。您需要跟踪您看到的 inode，而不是添加这些文件的大小。

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()

解决方案 9：

递归单行：

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

解决方案 10：

克里斯的回答很好，但可以通过使用集合来检查看到的目录，使其更加惯用，这也避免了使用控制流异常：

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

解决方案 11：

虽然有点晚了，但只要您安装了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'

解决方案 12：

获取目录大小

解决方案的性质：

  • 返回：表观大小（文件中的字节数）和文件使用的实际磁盘空间。

  • 仅计算一次硬链接文件

  • 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

人类可读的文件大小

解决方案的性质：

  • 支持高达Yottabytes

  • 支持SI 单位或IEC 单位

  • 支持自定义后缀

代码：

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'

解决方案 13：

你可以做这样的事情：

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

在这种情况下，我没有在返回结果之前测试结果，如果您愿意，可以使用commands.getstatusoutput进行检查。

解决方案 14：

对于问题的第二部分

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

解决方案 15：

你说的一行...这里有一行：

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

尽管我可能会把它分离出来并且它不会执行任何检查。

要转换为 kb，请参阅可重用库以获取文件大小的可读版本？并在

解决方案 16：

要获取一个文件的大小，可以使用 os.path.getsize()

>>> import os
>>> os.path.getsize("/path/file")
35L

其以字节为单位报告。

解决方案 17：

以下脚本打印指定目录的所有子目录的目录大小。它还尝试（如果可能）从缓存递归函数的调用中获益。如果省略参数，脚本将在当前目录中运行。输出按目录大小从大到小排序。因此您可以根据需要对其进行调整。

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 __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    %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_asubdir_a_2
4.41K   .subdir_asubdir_a_1
----------------------------------------------------------
CacheInfo(hits=2, misses=4, maxsize=4096, currsize=4)

编辑：按照 user2233949 的建议，将 null_decorator 移至上方

解决方案 18：

使用库sh：模块du执行以下操作：

pip install sh

import sh
print( sh.du("-s", ".") )
91154728        .

如果您想传递星号，请按照此处glob所述使用。

要将值转换为人类可读的形式，请使用humanize：

pip install humanize

import humanize
print( humanize.naturalsize( 91157384 ) )
91.2 MB

解决方案 19：

值得一提的是... tree 命令可以免费完成所有这些操作：

tree -h --du /path/to/dir  # files and dirs
tree -h -d --du /path/to/dir  # dirs only

我喜欢 Python，但迄今为止，该问题最简单的解决方案不需要新代码。

解决方案 20：

它很方便：

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:UsersJundullahDesktop")
cevir(size)

Output:
C:UsersJundullahDesktop 87874712211 Byte
C:UsersJundullahDesktop 85815148.64355469 Kilobyte
C:UsersJundullahDesktop 83803.85609722137 Megabyte
C:UsersJundullahDesktop 81.83970321994275 Gigabyte

解决方案 21：

这是一个以递归方式执行此操作的一行程序（从 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))

解决方案 22：

使用 pathlib 适用于 Python 3.6 的解决方案。

from pathlib import Path

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

解决方案 23：

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 的 for 循环解决方案，但我不知道为什么最终结果总是小于实际大小（在 ubuntu 18 环境中）。我肯定做错了什么，但谁在乎呢，这个运行得很好。

解决方案 24：

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")

我相信这会有所帮助！对于文件夹和文件也一样！

解决方案 25：

我正在使用带有scandir 的python 2.7.13 ，这是我的单行递归函数来获取文件夹的总大小：

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)]) + \n    + sum([getTotFldrSize(s.path) for s in scandir(path) if s.is_dir(follow_symlinks=False)])

>>> print getTotFldrSize('.')
1203245680

https://pypi.python.org/pypi/scandir

解决方案 26：

当计算出子目录的大小时，它应该更新其父文件夹的大小，并且此过程将持续直至到达根父文件夹。

以下函数计算文件夹及其所有子文件夹的大小。

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

解决方案 27：

Python 3.6+使用递归文件夹/文件大小。与@blakev 的答案os.scandir一样强大，但更短且采用EAFP Python 风格。

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

解决方案 28：

du默认情况下不遵循符号链接。这里没有答案，请使用follow_symlinks=False。

以下是遵循 du 默认行为的实现：

def du(path) -> 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

测试：

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))

解决方案 29：

此脚本会告诉您 CWD 中哪个文件最大，还会告诉您该文件位于哪个文件夹中。此脚本适用于 win8 和 python 3.3.3 shell

import os

folder = os.getcwd()

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(string)
print()
print(number)
print("Number in bytes")

解决方案 30：

不可否认，这有点不合常理，并且只适用于 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])
相关推荐
置顶 政府信创国产化的10大政策解读
政府信创国产化的10大政策解读
  政府信创国产化的10大政策解读一、信创国产化的背景与意义信创国产化，即信息技术应用创新国产化，是当前中国信息技术领域的一个重要发展方向。其核心在于通过自主研发和创新，实现信息技术应用的自主可控，减少对外部技术的依赖，并规避潜在的技术制裁和风险。随着全球信息技术竞争的加剧，以及某些国家对中国在科技领域的打压，信创国产化显...
工程项目管理   2941  
置顶 2025年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
2025年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
  为什么项目管理通常仍然耗时且低效？您是否还在反复更新电子表格、淹没在便利贴中并参加每周更新会议？这确实是耗费时间和精力。借助软件工具的帮助，您可以一目了然地全面了解您的项目。如今，国内外有足够多优秀的项目管理软件可以帮助您掌控每个项目。什么是项目管理软件？项目管理软件是广泛行业用于项目规划、资源分配和调度的软件。它使项...
项目管理软件   1803  
PLM系统如何应对资源冲突？5大解决方法
PLM系统如何应对资源冲突？5大解决方法
  PLM（产品生命周期管理）系统在企业的产品研发、生产与管理过程中扮演着至关重要的角色。然而，在实际运行中，资源冲突是经常会遇到的难题。资源冲突可能导致项目进度延迟、成本增加以及产品质量下降等一系列问题，严重影响企业的效益与竞争力。因此，如何有效应对PLM系统中的资源冲突，成为众多企业关注的焦点。接下来，我们将详细探讨5...
plm项目管理系统   31  
敏捷项目管理如何融入PLM？2025年7步实现研发流程优化
敏捷项目管理如何融入PLM？2025年7步实现研发流程优化
  敏捷项目管理与产品生命周期管理（PLM）的融合，正成为企业在复杂多变的市场环境中提升研发效率、增强竞争力的关键举措。随着技术的飞速发展和市场需求的快速更迭，传统的研发流程面临着诸多挑战，而将敏捷项目管理理念融入PLM，有望在2025年实现研发流程的深度优化，为企业创造更大的价值。理解敏捷项目管理与PLM的核心概念敏捷项...
plm项目   31  
PLM系统如何支持模块化设计？2025年3大技术实践
PLM系统如何支持模块化设计？2025年3大技术实践
  模块化设计在现代产品开发中扮演着至关重要的角色，它能够提升产品开发效率、降低成本、增强产品的可维护性与可扩展性。而产品生命周期管理（PLM）系统作为整合产品全生命周期信息的关键平台，对模块化设计有着强大的支持能力。随着技术的不断发展，到 2025 年，PLM 系统在支持模块化设计方面将有一系列令人瞩目的技术实践。数字化...
plm软件   28  
热门文章
项目管理软件
政府信创国产化的10大政策解读
2025soft
2025年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
img020
使用 Python 'Requests' 模块的代理
img044
10个项目管理常见问题解答：包括难点和解决方法
项目管理软件
项目延期的原因有哪些？如何有效预防和管理？
项目管理软件
5个成功案例解析项目进度管理的最佳实践
项目里程碑计划模板
项目里程碑计划模板怎么写?设定项目里程碑的5个方法
项目管理软件有哪些？
热门标签
更多>
IPD流程 项目管理 plm项目管理软件 敏捷开发 项目管理软件 Scrum 敏捷项目管理 IPD流程管理 项目风险管理 项目管理工具 项目经理 极限编程  产品管理  项目经理职责 项目路线图 项目进度管理 团队管理 测试管理工具 项目预算管理 PMP认证 瀑布式管理 项目范围管理 IT科技 项目管理平台 工程项目管理 项目资源管理 pmp证书考试
曾咪二维码

扫码咨询，免费领取项目管理大礼包！

云禅道AD
禅道项目管理软件

云端的项目管理软件

尊享禅道项目软件收费版功能

无需维护，随时随地协同办公

内置subversion和git源码管理

每天备份，随时转为私有部署

免费试用