पायथन का उपयोग करके एक निर्देशिका के आकार की गणना करना?


182

इससे पहले कि मैं इस विशेष पहिये का फिर से आविष्कार करूं, क्या किसी को पायथन का उपयोग करके एक निर्देशिका के आकार की गणना करने के लिए एक अच्छी दिनचर्या मिल गई है? यह बहुत अच्छा होगा यदि दिनचर्या एमबी / जीबी आदि में आकार को अच्छी तरह से प्रारूपित करेगी।


13
यह बहुत अच्छा नहीं होगा। आपके पास आकार और एक काफी स्वतंत्र फ़ंक्शन की गणना करने के लिए एक फ़ंक्शन होना चाहिए (जिसका उपयोग स्मृति आकारों के साथ भी किया जा सकता है, उदाहरण के लिए) "एमबी / जीबी आदि में आकार को अच्छी तरह से प्रारूपित करने के लिए"।
जॉन माचिन

17
हाँ, मुझे पता है लेकिन यह दो सवाल पूछने से बचाता है।
गैरी विलोबी

1
tree* Nix सिस्टम पर आदेश मुक्त करने के लिए यह सब करता है। tree -h -d --du /path/to/dir
meh

@mehdu -sh /path/to/dir/*
मर्ग्लोम

जवाबों:


252

यह सभी उप-निर्देशिकाओं को चलाता है; फ़ाइल का आकार सम्‍मिलित करें:

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

यदि आप पायथन 3.4 या पिछले का उपयोग करते हैं तो आप walkतृतीय-पक्ष scandirपैकेज द्वारा प्रदान की गई अधिक कुशल विधि का उपयोग करने पर विचार कर सकते हैं । पायथन 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())

14
+1 लेकिन oneliner एक वैध परिणाम वापस नहीं करता है, क्योंकि यह पुनरावर्ती नहीं है
ल्यूक

2
हाँ, यह सिर्फ फ्लैट डायरेक्टरी केस के लिए है।
10

35
असली मज़ा के लिए आप एक पंक्ति में एक पुनरावर्ती आकार कर सकते हैं: dirpath, dirnames, filename में फ़ाइल नाम के लिए os.walk (PATH) में फ़ाइल नाम के लिए योग (os.path.getsize (os.path.join (dirpath, फ़ाइल नाम))।
20

2
लेकिन st_sizeअगर आपको सिमिलिंक का पालन नहीं करना है तो आपको इसका उपयोग करना होगा, जैसा कि आपको तब उपयोग करना चाहिए lstat
asmeurer

3
चेतावनी! यह 'du -sb' जैसा नहीं है। सैमुअल लम्पा द्वारा उत्तर देखें! आपका कोड FAT को संग्रहीत करने के लिए उपयोग किए गए फ़ोल्डर के आकार को अनदेखा करता है।
योहान याकिमोविच

43

सुझाए गए दृष्टिकोणों में से कुछ अब तक एक पुनरावृत्ति को लागू करते हैं, अन्य एक शेल को नियुक्त करते हैं या बड़े करीने से स्वरूपित परिणाम नहीं देंगे। जब आपका कोड लिनक्स प्लेटफॉर्म के लिए वन-ऑफ होता है, तो आप एक-लाइनर के रूप में हमेशा की तरह फॉर्मेटिंग, रिकर्सन शामिल कर सकते हैं। 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

13
नायब। केवल लिनक्स।
मेवप्लप

15
अजगर, प्रकृति में क्रॉस-प्लेटफॉर्म होने के नाते, शायद इससे दूर भागना चाहिए
जोनाथन

11
इन टिप्पणियों के लिए धन्यवाद। मैंने उत्तर के लिए प्लेटफ़ॉर्म निर्भरता के संबंध में कुछ चेतावनी को जोड़ा। हालाँकि, पायथन कोड की अगर एक-से स्क्रिप्टिंग। इस तरह के कोड को किसी भी जरूरत से परे पोर्टेबिलिटी की खातिर कार्यात्मक सीमाओं, लंबी और त्रुटि-प्रवण मार्ग या किनारे के मामलों में असामान्य परिणाम नहीं आने चाहिए । यह, हमेशा की तरह, एक व्यापार बंद है, और यह डेवलपर की जिम्मेदारी में बुद्धिमानी से चुनने के लिए है;)
flaschbier

9
नाइटपिक: लिनक्स नहीं बल्कि यूनिक्स / पॉज़िक्स विशिष्ट :)
श्री शार्क

3
फ़ाइल सिस्टम में खोज को सीमित करने के लिए डु कमांड में '-x' विकल्प जोड़ना संभव है। दूसरे शब्दों में, इसके बजाय ['du', '-shx', पथ] का उपयोग करें।
कीथ हनलन

24

यहाँ एक पुनरावर्ती कार्य है (यह पुनरावर्ती रूप से सभी सबफ़ोल्डर्स और उनके संबंधित फ़ाइलों के आकार को पूरा करता है) जो "डु -एसबी" चलाते समय बिल्कुल उसी बाइट्स के रूप में वापस आता है। लिनक्स में (जहां ""। "का अर्थ है" वर्तमान फ़ोल्डर "):

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

2
यह फ़ंक्शन सीमलिंक के आकार की भी गणना करता है - यदि आप सीमलिंक को छोड़ना चाहते हैं, तो आपको यह जांचना होगा कि क्या नहीं है: यदि os.path.isfile (itempath) और os.path.islink (itempath) और elif os.path.isdir () आइटमपैथ) और ओएस.पाथ.लिंक (आइटमपैथ)।
एयरवे

17

पायथन 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

1
पायथन 3 वन-लाइनर विधि यदि पुनरावर्ती-नेस के बारे में चिंतित नहीं हैं sum([entry.stat().st_size for entry in os.scandir(file)])। नोट आउटपुट एमबी पाने के लिए बाइट्स, / 1024 में KB और / (1024 * 1024) है।
वीजी १४

4
@ weiji14 कोष्ठक खो देते हैं, अर्थात sum(entry.stat().st_size for entry in os.scandir(file))। सूची बनाने का कोई कारण नहीं है, क्योंकि sumपुनरावृत्तियों को भी लेता है।
वेदरन Novego

8

monknut का उत्तर अच्छा है, लेकिन यह टूटी हुई सिमिलिंक पर विफल रहता है, इसलिए आपको यह भी जांचना होगा कि क्या यह मार्ग वास्तव में मौजूद है

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

3
आप शायद सहानुभूति का पालन नहीं करना चाहते हैं। आपको उपयोग करना चाहिए lstat
asmeurer

8

स्वीकृत उत्तर हार्ड या सॉफ्ट लिंक को ध्यान में नहीं रखता है, और उन फाइलों को दो बार गिना जाएगा। आप उन इनोड्स का ट्रैक रखना चाहेंगे जो आपने देखे हैं, और उन फ़ाइलों के लिए आकार नहीं जोड़ें।

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

5
उपयोग करने पर विचार करें os.lstat(इसके बजाय os.stat), जो प्रतीकात्मक लिंक का पालन करने से बचता है: docs.python.org/2/library/os.html#os.lstat
पीटर ब्रिग्स

7

क्रिस का जवाब अच्छा है, लेकिन देखा निर्देशिका के लिए एक सेट का उपयोग करके अधिक मुहावरेदार बनाया जा सकता है, जो नियंत्रण प्रवाह के लिए एक अपवाद का उपयोग करने से भी बचता है:

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

2
क्रिस के जवाब में भी न तो सहानुभूति है और न ही निर्देशिका के आकार। मैंने आपके उत्तर को उसी के अनुसार संपादित किया है, निश्चित फ़ंक्शन का आउटपुट अब इसके समान है df -sb
क्रेशल

7

एक पुनरावर्ती एक लाइनर:

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

1
हालांकि यह एक लाइनर नहीं है। हालाँकि, यह बाइट्स में पुनरावर्ती फ़ोल्डर आकार (भले ही फ़ोल्डर में कई फ़ोल्डर हों) की गणना करता है और सही मान देता है।
वेंकटेश 19

मैं इसे इस्तेमाल करने में आसान था और पहली बार विंडोज पर काम किया
hum3

5

प्रश्न के दूसरे भाग के लिए

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

5

का उपयोग करते हुए 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

आप ऐसा कुछ कर सकते हैं:

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

इस मामले में मैंने इसे वापस करने से पहले परिणाम का परीक्षण नहीं किया है, यदि आप चाहते हैं कि आप इसे कमांड के साथ जांच सकते हैं ।getstatusoutput


os.walkउप फ़ोल्डर आकार की पुनरावृत्ति की जांच करने के लिए उपयोग की तुलना में प्रदर्शन कैसा है ?
टॉमसॉयर

4

एक-लाइनर आप कहते हैं ... यहाँ एक लाइनर है:

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

हालांकि मैं शायद इसे अलग कर दूंगा और यह कोई जांच नहीं करता है।

फ़ाइल आकार के मानव पठनीय संस्करण प्राप्त करने के लिए पुन: प्रयोज्य पुस्तकालय देखने के लिए kb में परिवर्तित करने के लिए ? और इसमें काम करते हैं


4

एक छोटी सी पार्टी के लिए देर हो चुकी है, लेकिन एक पंक्ति में प्रदान की तुम हो कि glob2 और मानवीय स्थापित। ध्यान दें कि पायथन 3 में, डिफ़ॉल्ट iglobमें एक पुनरावर्ती मोड है। पायथन 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'

1
पायथन 3.5 के साथ शुरू, अंतर्निहित globसमर्थन पुनरावृत्ति। आप का उपयोग कर सकते हैं:glob.glob('/var/**', recursive=True)
adzenith

3

निम्न स्क्रिप्ट निर्दिष्ट निर्देशिका के लिए सभी उप-निर्देशिकाओं की निर्देशिका आकार प्रिंट करता है। यह एक पुनरावर्ती कार्यों की कॉल को कैशिंग से (यदि संभव हो) लाभान्वित करने की कोशिश करता है। यदि कोई तर्क छोड़ा जाता है, तो स्क्रिप्ट वर्तमान निर्देशिका में काम करेगी। आउटपुट को सबसे बड़े से लेकर छोटे तक डायरेक्टरी साइज़ द्वारा सॉर्ट किया जाता है। तो आप इसे अपनी आवश्यकताओं के लिए अनुकूलित कर सकते हैं।

पीएस i ने मानव-अनुकूल प्रारूप में निर्देशिका आकार दिखाने के लिए नुस्खा 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\t%s' %(bytes2human(size, format='%(value).2f%(symbol)s'), d))

    print('-' * 80)
    if sys.version_info >= (3,2,0):
        print(get_dir_size.cache_info())

नमूना उत्पादन:

37.61M  .\subdir_b
2.18M   .\subdir_a
2.17M   .\subdir_a\subdir_a_2
4.41K   .\subdir_a\subdir_a_1
----------------------------------------------------------
CacheInfo(hits=2, misses=4, maxsize=4096, currsize=4)

EDIT: उपर्युक्त null_decorator को स्थानांतरित किया गया, जैसा कि user2233949 ने सुझाया था


आपकी स्क्रिप्ट अच्छी तरह से काम करती है, लेकिन आपको 'if sys.version_info> = ...' लाइन के ऊपर null_decorator फ़ंक्शन को स्थानांतरित करने की आवश्यकता है। अन्यथा आपको 'null_decorator' परिभाषित अपवाद नहीं मिलेगा। हालांकि उसके बाद बढ़िया काम करता है।
user2233949

@ user2233949, धन्यवाद! I'me ने कोड को इसी प्रकार संशोधित किया।
23

3

लाइब्रेरी श का उपयोग करें : मॉड्यूल duइसे करता है:

pip install sh

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

यदि आप तारांकन पास करना चाहते हैं, तो यहांglob बताए अनुसार उपयोग करें

मानों को मानव पठनीय में बदलने के लिए, मानवीकरण का उपयोग करें :

pip install humanize

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

2

एक फ़ाइल का आकार पाने के लिए, os.path.getsize () है

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

बाइट्स में इसकी सूचना दी।


2

इसके लायक क्या है ... ट्री कमांड यह सब मुफ्त में करता है:

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

मैं अजगर से प्यार करता हूं, लेकिन अब तक समस्या के सबसे सरल समाधान के लिए किसी नए कोड की आवश्यकता नहीं है।


@ अब्दुर-रहमानजैंसेजर, यह सच है। यह सच है।
meh

2

यह आसान है:

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

1

मैं अजगर 2.7.13 उपयोग कर रहा हूँ के साथ scandir और यहाँ मेरी एक लाइनर पुनरावर्ती क्रिया एक फ़ोल्डर का कुल आकार पाने के लिए है:

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


1

जब उप-निर्देशिकाओं के आकार की गणना की जाती है, तो उसे अपने माता-पिता के फ़ोल्डर के आकार को अपडेट करना चाहिए और यह तब तक चलेगा जब तक यह मूल माता-पिता तक नहीं पहुंच जाता।

निम्न फ़ंक्शन फ़ोल्डर के आकार और उसके सभी उप-फ़ोल्डरों की गणना करता है।

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

1

यदि आप विंडोज ओएस में हैं, तो आप कर सकते हैं:

लॉन्च करके मॉड्यूल pywin32 स्थापित करें:

पाइप स्थापित pywin32

और फिर निम्नलिखित कोडिंग:

import win32com.client as com

def get_folder_size(path):
   try:
       fso = com.Dispatch("Scripting.FileSystemObject")
       folder = fso.GetFolder(path)
       size = str(round(folder.Size / 1048576))
       print("Size: " + size + " MB")
   except Exception as e:
       print("Error --> " + str(e))

1

यहाँ एक लाइनर है जो इसे पुनरावर्ती करता है (पायथन 3.5 के रूप में उपलब्ध पुनरावर्ती विकल्प) 1

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


0

यह स्क्रिप्ट आपको बताती है कि CWD में कौन सी फाइल सबसे बड़ी है और यह भी बताता है कि फाइल किस फोल्डर में है। यह स्क्रिप्ट मेरे लिए win8 और अजगर 3.3.3 शेल पर काम करती है

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

0

माना जाता है कि यह एक प्रकार का हैकिश है और केवल यूनिक्स / लिनक्स पर काम करता है।

यह मेल खाता है du -sb .क्योंकि वास्तव में यह पायथन बैश रैपर है जो du -sb .कमांड चलाता है ।

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

0

मैं यहाँ थोड़ी देर (और नया) हूँ, लेकिन मैंने एमबी में फ़ोल्डर आकार के लिए एक सटीक मान प्राप्त करने के लिए उपप्रोसेस मॉड्यूल और लिनक्स के साथ 'डु' कमांड लाइन का उपयोग करने का विकल्प चुना। मुझे रूट फ़ोल्डर के लिए if और elif का उपयोग करना पड़ा, क्योंकि अन्यथा उपप्रकार गैर-शून्य मान के कारण त्रुटि उठाता है।

import subprocess
import os

#
# get folder size
#
def get_size(self, path):
    if os.path.exists(path) and path != '/':
        cmd = str(subprocess.check_output(['sudo', 'du', '-s', path])).\
            replace('b\'', '').replace('\'', '').split('\\t')[0]
        return float(cmd) / 1000000
    elif os.path.exists(path) and path == '/':
        cmd = str(subprocess.getoutput(['sudo du -s /'])). \
            replace('b\'', '').replace('\'', '').split('\n')
        val = cmd[len(cmd) - 1].replace('/', '').replace(' ', '')
        return float(val) / 1000000
    else: raise ValueError

0

निर्देशिका आकार प्राप्त करें

समाधान के गुण:

  • दोनों लौटाता है: स्पष्ट आकार (फ़ाइल में बाइट्स की संख्या) और वास्तविक डिस्क स्थान जो फ़ाइलों का उपयोग करता है।
  • हार्ड लिंक की गई फाइलों को केवल एक बार गिना जाता है
  • सहानुभूति उसी तरह से मायने duरखती है
  • पुनरावृत्ति का उपयोग नहीं करता है
  • उपयोग की st.st_blocksगई डिस्क स्थान के लिए उपयोग करता है, इस प्रकार केवल यूनिक्स जैसी प्रणालियों पर काम करता है

कोड:

import os


def du(path):
    if os.path.islink(path):
        return (os.lstat(path).st_size, 0)
    if os.path.isfile(path):
        st = os.lstat(path)
        return (st.st_size, st.st_blocks * 512)
    apparent_total_bytes = 0
    total_bytes = 0
    have = []
    for dirpath, dirnames, filenames in os.walk(path):
        apparent_total_bytes += os.lstat(dirpath).st_size
        total_bytes += os.lstat(dirpath).st_blocks * 512
        for f in filenames:
            fp = os.path.join(dirpath, f)
            if os.path.islink(fp):
                apparent_total_bytes += os.lstat(fp).st_size
                continue
            st = os.lstat(fp)
            if st.st_ino in have:
                continue  # skip hardlinks which were already counted
            have.append(st.st_ino)
            apparent_total_bytes += st.st_size
            total_bytes += st.st_blocks * 512
        for d in dirnames:
            dp = os.path.join(dirpath, d)
            if os.path.islink(dp):
                apparent_total_bytes += os.lstat(dp).st_size
    return (apparent_total_bytes, total_bytes)

उदाहरण उपयोग:

>>> du('/lib')
(236425839, 244363264)

$ du -sb /lib
236425839   /lib
$ du -sB1 /lib
244363264   /lib

मानव पठनीय फ़ाइल आकार

समाधान के गुण:

कोड:

def humanized_size(num, suffix='B', si=False):
    if si:
        units = ['','K','M','G','T','P','E','Z']
        last_unit = 'Y'
        div = 1000.0
    else:
        units = ['','Ki','Mi','Gi','Ti','Pi','Ei','Zi']
        last_unit = 'Yi'
        div = 1024.0
    for unit in units:
        if abs(num) < div:
            return "%3.1f%s%s" % (num, unit, suffix)
        num /= div
    return "%.1f%s%s" % (num, last_unit, suffix)

उदाहरण उपयोग:

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


0

अजगर 3.6+ पुनरावर्ती फ़ोल्डर / फ़ाइल आकार का उपयोग कर os.scandir। @Blakev द्वारा उत्तर में शक्तिशाली , लेकिन कम और EAFP अजगर शैली में

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

0
def recursive_dir_size(path):
    size = 0

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

    return size

मैंने यह फ़ंक्शन लिखा था जो मुझे एक डायरेक्टरी का सटीक आकार प्रदान करता है, मैंने os.walk के साथ लूप समाधान के लिए अन्य की कोशिश की, लेकिन मुझे नहीं पता कि अंतिम परिणाम हमेशा वास्तविक आकार (ubuntu 18 env) से कम क्यों था। मैंने कुछ गलत किया होगा, लेकिन कौन परवाह करता है कि यह पूरी तरह से ठीक काम करता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.