Heeft iemand, voordat ik dit specifieke wiel opnieuw uitvind, een goede routine voor het berekenen van de grootte van een map met Python? Het zou heel mooi zijn als de routine de grootte mooi zou formatteren in Mb/Gb enz.

Antwoord 1, autoriteit 100%

Hiermee worden alle submappen doorlopen; bestandsgrootte optellen:

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

En een oneliner voor de lol met behulp van os.listdir(Bevat geen submappen):

import os
sum(os.path.getsize(f) for f in os.listdir('.') if os.path.isfile(f))

Referentie:

• os.path.getsize– Geeft de grootte in bytes
• os.walk
• os.path.islink

Bijgewerkt
Om os.path.getsizete gebruiken, is dit duidelijker dan het gebruik van de os.stat().st_size methode.

Met dank aan ghostdog74 voor het wijzen hierop!

os.stat– st_size Geeft de grootte in bytes. Kan ook worden gebruikt om bestandsgrootte en andere bestandsgerelateerde informatie te krijgen.

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

Update 2018

Als u Python 3.4 of eerder gebruikt, kunt u overwegen de efficiëntere walk-methode te gebruiken die wordt aangeboden door de externe scandirpakket. In Python 3.5 en later is dit pakket opgenomen in de standaardbibliotheek en heeft os.walkde bijbehorende prestatieverbetering ontvangen.

Update 2019

De laatste tijd gebruik ik pathlibsteeds meer, hier is een pathlib-oplossing:

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

Antwoord 2, autoriteit 17%

Sommige van de tot nu toe voorgestelde benaderingen implementeren een recursie, andere gebruiken een shell of zullen geen netjes opgemaakte resultaten opleveren. Wanneer uw code eenmalig is voor Linux-platforms, kunt u op de gebruikelijke manier formatteren, inclusief recursie, als een one-liner. Behalve de printin de laatste regel, werkt het voor de huidige versies van python2en 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('.'))

is eenvoudig, efficiënt en werkt voor bestanden en mappen met meerdere niveaus:

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

Antwoord 3, autoriteit 7%

Hier is een recursieve functie (deze somt recursief de grootte van alle submappen en hun respectievelijke bestanden op) die exact dezelfde bytes retourneert als bij het uitvoeren van “du -sb .” in linux (waar de “.” “de huidige map” betekent):

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

Antwoord 4, Autoriteit 6%

Python 3.5 Recursieve mapformaat met 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

Antwoord 5, Autoriteit 5%

Gebruik pathlibIk heb deze one-liner opgenomen om de grootte van een map te krijgen:

sum(file.stat().st_size for file in Path(folder).rglob('*'))

En dit is waar ik bij kwam voor een mooi geformatteerde output:

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

Gebruik:

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

Ik kwam ook deze vraag , die een aantal compacter en waarschijnlijk meer presterende strategieën voor het afdrukken van bestandsgroottes heeft.

Antwoord 6, Autoriteit 3%

Monknut antwoord is goed, maar het faalt op gebroken symlink, dus je moet ook controleren of dit pad echt

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

Antwoord 7, Autoriteit 3%

voor python3.5 +

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

Gebruik ::

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'

Antwoord 8, autoriteit 2%

Het geaccepteerde antwoord houdt geen rekening met harde of zachte links en zou die bestanden twee keer tellen. Je zou willen bijhouden welke inodes je hebt gezien, en niet de grootte voor die bestanden toevoegen.

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

Antwoord 9, autoriteit 2%

een recursieve oneliner:

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

Antwoord 10, autoriteit 2%

Het antwoord van Chris is goed, maar kan meer idiomatisch worden gemaakt door een set te gebruiken om te controleren op geziene mappen, wat ook voorkomt dat er een uitzondering wordt gebruikt voor de controlestroom:

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

Antwoord 11, autoriteit 2%

Een beetje laat voor het feest, maar in één regel, op voorwaarde dat je glob2en humaniserengeïnstalleerd. Merk op dat in Python 3 de standaard iglobeen recursieve modus heeft. Het wijzigen van de code voor Python 3 wordt overgelaten als een triviale oefening voor de lezer.

>>> import os
>>> from humanize import naturalsize
>>> from glob2 import iglob
>>> naturalsize(sum(os.path.getsize(x) for x in iglob('/var/**'))))
'546.2 MB'

Antwoord 12

Voor het tweede deel van de vraag

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

Antwoord 13

Je kunt zoiets als dit doen:

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

in dit geval heb ik het resultaat niet getest voordat ik het terugstuurde, als je wilt kun je het controleren met commands.getstatusoutput.

Antwoord 14

Oneliner zeg je…
Hier is een one-liner:

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

Hoewel ik het waarschijnlijk zou opsplitsen en het geen controles uitvoert.

Om te converteren naar kb, zie Herbruikbare bibliotheek om door mensen leesbare versie van bestandsgrootte?en werk het in

Antwoord 15

Het volgende script drukt de mapgrootte af van alle submappen voor de opgegeven map. Het probeert ook te profiteren (indien mogelijk) van het cachen van de aanroepen van een recursieve functie. Als een argument wordt weggelaten, werkt het script in de huidige map. De uitvoer wordt gesorteerd op mapgrootte van de grootste naar de kleinste. U kunt het dus aanpassen aan uw behoeften.

PS ik heb recept 578019 gebruikt voor het weergeven van de mapgrootte in een mensvriendelijke indeling (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\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())

Voorbeelduitvoer:

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)

EDIT: null_decorator hierboven verplaatst, zoals aanbevolen door gebruiker2233949

Antwoord 16

gebruik bibliotheek sh: de module dudoet het:

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

als je asterix wilt doorgeven, gebruik dan globzoals beschreven hier.

gebruik humanize:

om de waarden in menselijke readables om te zetten.

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

Antwoord 17

voor het verkrijgen van de grootte van één bestand is er os.path.getsize()

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

het wordt gerapporteerd in bytes.

Antwoord 18

Voor wat het waard is… het tree-commando doet dit allemaal gratis:

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

Ik ben dol op Python, maar verreweg de eenvoudigste oplossing voor het probleem vereist geen nieuwe code.

Antwoord 19

Het is handig:

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

Antwoord 20

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

Ik heb deze functie geschreven die me een nauwkeurige totale grootte van een map geeft, ik heb andere for loop-oplossingen geprobeerd met os.walk, maar ik weet niet waarom het eindresultaat altijd kleiner was dan de werkelijke grootte (op ubuntu 18 env) . Ik moet iets verkeerd hebben gedaan, maar who cares schreef dat deze prima werkt.

Antwoord 21

Ik gebruik python 2.7.13 met scandiren hier is mijn recursieve one-liner functie om de totale grootte van een map te krijgen:

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

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

Antwoord 22

Als de grootte van de submappen wordt berekend, moet deze de grootte van de bovenliggende map bijwerken en dit gaat door totdat de hoofdmap de bovenliggende map bereikt.

De volgende functie berekent de grootte van de map en al zijn submappen.

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

Antwoord 23

Hier is een one-liner die het recursief doet (recursieve optie beschikbaar vanaf 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))

Antwoord 24

Mapgrootte ophalen

Eigenschappen van de oplossing:

• retourneert zowel: de schijnbare grootte (aantal bytes in het bestand) en de werkelijke schijfruimte die de bestanden gebruiken.
• telt hard gekoppelde bestanden slechts één keer
• telt symbolische links op dezelfde manier als dudat doet
• maakt geen gebruik van recursie
• gebruikt st.st_blocksvoor gebruikte schijfruimte, werkt dus alleen op Unix-achtige systemen

De code:

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)

Voorbeeld van gebruik:

>>> du('/lib')
(236425839, 244363264)
$ du -sb /lib
236425839   /lib
$ du -sB1 /lib
244363264   /lib

Menselijk leesbare bestandsgrootte

Eigenschappen van de oplossing:

• Ondersteunt tot Yottabytes
• Ondersteunt SI-eenhedenof IEC-eenheden
• Ondersteuning van aangepaste achtervoegsels

De code:

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)

Voorbeeld van gebruik:

>>> humanized_size(236425839)
'225.5MiB'
>>> humanized_size(236425839, si=True)
'236.4MB'
>>> humanized_size(236425839, si=True, suffix='')
'236.4M'

Antwoord 25

duvolgt standaard geen symbolische links. Geen antwoord hier gebruik follow_symlinks=False.

Hier is een implementatie die het standaardgedrag van du volgt:

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

Testen:

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

Antwoord 26

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

Ik weet zeker dat dit helpt! Voor mappen en bestanden ook!

Antwoord 27

Dit script vertelt u welk bestand de grootste in de CWD is en vertelt u ook in welke map het bestand is.
Dit script werkt voor mij op Win8 en 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")

Antwoord 28

Toegegeven, dit is een soort hackish en werkt alleen op Unix / Linux.

Het komt overeen met du -sb .Omdat dit in feite een Python Bash-wrapper is die de du -sb .-opdracht.

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

Antwoord 29

Ik ben een beetje laat (en nieuw) hier, maar ik koos ervoor om de subprocesmodule en de ‘du’-opdrachtregel met Linux te gebruiken om een ​​nauwkeurige waarde voor mapformaat in MB op te halen. Ik moest gebruiken als en ELIF voor rootmap omdat anders subproces fouten verhoogt als gevolg van niet-nulwaarde geretourneerd.

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

Antwoord 30

Als u in Windows OS bent, kunt u doen:

Installeer de module Pywin32 door te starten:

PIP Installeer Pywin32

en vervolgens het volgende coderen:

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