人間が読めるバージョンのファイルサイズを取得するための再利用可能なライブラリ?


238

Webには、バイトサイズから人間が読み取れるサイズを返す関数を提供するさまざまなスニペットがあります。

>>> human_readable(2048)
'2 kilobytes'
>>>

しかし、これを提供するPythonライブラリはありますか?


2
これは「ライブラリーを必要とするタスクが小さすぎる」という見出しに該当すると思います。hurry.filesizeのソースを見ると、関数が1つしかなく、数十行のコードがあります。そして、それも圧縮することができました。
Ben Blank

8
ライブラリを使用する利点は、通常はテストされることです(編集によってバグが発生した場合に実行できるテストが含まれています)。テストを追加すると、「コードの数十行」ではなくなります:-)
Sridhar Ratnakumar 2009

Pythonコミュニティでホイールを再発明することの量は、ばかげて、ばかげています。ただls -h /path/to/file.extが仕事をします。そうは言っても、受け入れられた答えは良い仕事をしています。工藤。
エドワードアウン

回答:


522

上記の「ライブラリーを必要とするタスクは小さすぎる」という問題に、簡単な実装で対処します。

def sizeof_fmt(num, suffix='B'):
    for unit in ['','Ki','Mi','Gi','Ti','Pi','Ei','Zi']:
        if abs(num) < 1024.0:
            return "%3.1f%s%s" % (num, unit, suffix)
        num /= 1024.0
    return "%.1f%s%s" % (num, 'Yi', suffix)

サポート:

  • 現在知られているすべてのバイナリプレフィックス
  • 負の数と正の数
  • 1000ヨビバイトより大きい数値
  • 任意の単位(Gibibitsでカウントしたいかもしれません!)

例:

>>> sizeof_fmt(168963795964)
'157.4GiB'

フレッドCirera


4
数値と単位の間にスペースが必要です。あなたがhtmlまたはlatexを出力しているなら、それは非破壊スペースでなければなりません。
josch 2014年

3
ただの考えですが、任意の(?)サフィックス以外B(つまり、バイト以外の単位)の場合は、係数を「いいえ」1000.0ではなくむしろしたい1024.0ですか?
エントロピー2014

5
小数部の精度を上げたい場合は、14行目と6行目のを任意の精度に変更します。
マシューG

44
この「小さすぎるタスク」のすべての反復がキャプチャされ、テスト付きのライブラリにカプセル化されていれば、すばらしいでしょう。
フェス。

6
@ MD004逆です。プレフィックスは、1 KB = 1000 Bおよび1 KiB = 1024 Bとなるように定義されています
。–

116

あなたが探していると思われるすべての機能を備えたライブラリはhumanizeです。 humanize.naturalsize()あなたが探しているすべてを行うようです。


9
OPからのデータを使用したいくつかの例:humanize.naturalsize(2048) # => '2.0 kB'humanize.naturalsize(2048, binary=True) # => '2.0 KiB' humanize.naturalsize(2048, gnu=True) # => '2.0K'
RubenLaguna

32

これが私のバージョンです。forループは使用しません。これは一定の複雑さ、O(1)を持ち、理論的にはforループを使用するここでの回答よりも効率的です。

from math import log
unit_list = zip(['bytes', 'kB', 'MB', 'GB', 'TB', 'PB'], [0, 0, 1, 2, 2, 2])
def sizeof_fmt(num):
    """Human friendly file size"""
    if num > 1:
        exponent = min(int(log(num, 1024)), len(unit_list) - 1)
        quotient = float(num) / 1024**exponent
        unit, num_decimals = unit_list[exponent]
        format_string = '{:.%sf} {}' % (num_decimals)
        return format_string.format(quotient, unit)
    if num == 0:
        return '0 bytes'
    if num == 1:
        return '1 byte'

何が起こっているのかをより明確にするために、文字列フォーマットのコードを省略できます。実際に作業を行う行は次のとおりです。

exponent = int(log(num, 1024))
quotient = num / 1024**exponent
unit_list[exponent]

2
そのような短いコードの最適化について話している間、なぜif / elif / elseを使用しないのですか?最後のチェックnum == 1は、負のファイルサイズを想定しない限り不要です。それ以外の場合:素晴らしい仕事、私はこのバージョンが好きです。
2012

2
私のコードはきっともっと最適化されるでしょう。しかし、私の目的は、このタスクが一定の複雑さで解決できることを示すことでした。
joctee 2012

37
forループには制限があるため、forループの回答もO(1)です。その計算時間は入力のサイズに比例しません(無制限のSIプレフィックスはありません)。
Thomas Minor

1
おそらく、書式設定のためにコンマを追加する必要があるため、1000と表示され1,000 bytesます。
iTayb 2014年

3
Python 3を使用する場合、zipはイテレータを返すため、list()でラップする必要があることに注意してください。 unit_list = list(zip(['bytes', 'kB', 'MB', 'GB', 'TB', 'PB'], [0, 0, 1, 2, 2, 2]))
donarb 2018

30

以下はPython 3.6以降で動作し、私の意見では、ここでの答えを理解するのが最も簡単であり、使用する小数点以下の桁数をカスタマイズできます。

def human_readable_size(size, decimal_places=3):
    for unit in ['B','KiB','MiB','GiB','TiB']:
        if size < 1024.0:
            break
        size /= 1024.0
    return f"{size:.{decimal_places}f}{unit}"

26

私はこの質問が古いことを知っていますが、最近、ループを回避するバージョンを考え出しました。これを使用log2して、シフトとサフィックスリストへのインデックスを兼ねるサイズの順序を決定します。

from math import log2

_suffixes = ['bytes', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']

def file_size(size):
    # determine binary order in steps of size 10 
    # (coerce to int, // still returns a float)
    order = int(log2(size) / 10) if size else 0
    # format file size
    # (.4g results in rounded numbers for exact matches and max 3 decimals, 
    # should never resort to exponent values)
    return '{:.4g} {}'.format(size / (1 << (order * 10)), _suffixes[order])

ただし、読みやすさの点でunpythonicと見なすこともできます。


1
私はlog2が好きですが、サイズ== 0を処理する必要があります!
Marti

どちらsize(1 << (order * 10)float()最終行でラップする必要があります(python 2の場合)。
Harvey

参考までに:import mathそこに必要な人もいます。
monsto 2015

@monsto true、追加:)
akaIDIOT 2015

これがどれほどコンパクトかが大好きです!共有していただきありがとうございます。
John Crawford

17

いつもそれらの人の一人がいなければならない。さて、今日は私です。これが1行のソリューションです。関数のシグネチャを数える場合は2行です。

def human_size(bytes, units=[' bytes','KB','MB','GB','TB', 'PB', 'EB']):
    """ Returns a human readable string reprentation of bytes"""
    return str(bytes) + units[0] if bytes < 1024 else human_size(bytes>>10, units[1:])

>>> human_size(123)
123 bytes
>>> human_size(123456789)
117GB

1
参考までに、出力は常に切り捨てられます。
wp-overwatch.com 2017年

1
リストをデフォルトの引数として使用しないようにするには、メソッド内のユニットにデフォルトのリストを割り当てる方がよいのではないでしょうか。(およびunits=None代わりに使用)
イマノール2017年

3
@ImanolEizaguirreベストプラクティスでは、提案したとおりに実行することをお勧めします。そのため、プログラムに誤ってバグを導入することはありません。ただし、単位リストは決して操作されないため、この関数は記述されているとおり安全です。それが操作された場合、変更は永続的であり、後続の関数呼び出しは、リストの操作されたバージョンをunits引数のデフォルト引数として受け取ります。
wp-overwatch.com

Python 3では、小数点が必要な場合は、代わりに次を使用します。 `` `def human_size(fsize、units = ['bytes'、 'KB'、 'MB'、 'GB'、 'TB'、 'PB'、 'EB']):return "{:.2f} {}"。format(float(fsize)、units [0])if fsize <1024 else human_size(fsize / 1024、units [1:]) `` `
オメール

15

インストールされているDjangoを使用している場合は、filesizeformatを試すこともできます。

from django.template.defaultfilters import filesizeformat
filesizeformat(1073741824)

=>

"1.0 GB"

1
私にとってはこれに対する1つの欠点は、それが代わりにジブのGBを使用することで、それは1024で割るだにもかかわらず
Pepedou

9

そのようなライブラリの1つがhurry.filesizeです。

>>> from hurry.filesize import alternative
>>> size(1, system=alternative)
'1 byte'
>>> size(10, system=alternative)
'10 bytes'
>>> size(1024, system=alternative)
'1 KB'

3
ただし、このライブラリはあまりカスタマイズできません。>>> hurry.filesizeインポートサイズから>>> size(1031053)>>> size(3033053) '2M'たとえば、 '2.4M'または '2423K' .. 2M '。
Sridhar Ratnakumar、2009

依存関係システムなどを扱っている場合は、hurry.filesizeからコードを取得して自分のコードに直接配置するのが非常に簡単であることにも注意してください。人々がここで提供しているスニペットと同じくらい短いです。
mlissner 2011年

@SridharRatnakumar、過剰近似問題にいくらかインテリジェントに対処するには、私の数学的なハックを参照してください。アプローチをさらに改善できますか?
Acumenus 2015年

9

1000の累乗またはキビバイトのどちらかを使用すると、より標準に適合します。

def sizeof_fmt(num, use_kibibyte=True):
    base, suffix = [(1000.,'B'),(1024.,'iB')][use_kibibyte]
    for x in ['B'] + map(lambda x: x+suffix, list('kMGTP')):
        if -base < num < base:
            return "%3.1f %s" % (num, x)
        num /= base
    return "%3.1f %s" % (num, x)

PS K(大文字)接尾辞を付けて何千も印刷するライブラリを信頼しないでください:)


P.S. Never trust a library that prints thousands with the K (uppercase) suffix :)何故なの?コードは完全に健全である可能性があり、作者はキロのケーシングを考慮しませんでした。ルールに基づいてコードを自動的に却下するのはかなりおかしいようです...
Douglas Gaskell

7

これは、ほとんどすべての状況で必要なことを実行し、オプションの引数を使用してカスタマイズできます。また、ご覧のとおり、かなり自己文書化されています。

from math import log
def pretty_size(n,pow=0,b=1024,u='B',pre=['']+[p+'i'for p in'KMGTPEZY']):
    pow,n=min(int(log(max(n*b**pow,1),b)),len(pre)-1),n*b**pow
    return "%%.%if %%s%%s"%abs(pow%(-pow-1))%(n/b**float(pow),pre[pow],u)

出力例:

>>> pretty_size(42)
'42 B'

>>> pretty_size(2015)
'2.0 KiB'

>>> pretty_size(987654321)
'941.9 MiB'

>>> pretty_size(9876543210)
'9.2 GiB'

>>> pretty_size(0.5,pow=1)
'512 B'

>>> pretty_size(0)
'0 B'

高度なカスタマイズ:

>>> pretty_size(987654321,b=1000,u='bytes',pre=['','kilo','mega','giga'])
'987.7 megabytes'

>>> pretty_size(9876543210,b=1000,u='bytes',pre=['','kilo','mega','giga'])
'9.9 gigabytes'

このコードは、Python 2とPython 3の両方に互換性があります。PEP8への準拠は、読者の課題です。きれいなのは出力です。

更新:

数千のカンマが必要な場合は、明白な拡張子を適用するだけです。

def prettier_size(n,pow=0,b=1024,u='B',pre=['']+[p+'i'for p in'KMGTPEZY']):
    r,f=min(int(log(max(n*b**pow,1),b)),len(pre)-1),'{:,.%if} %s%s'
    return (f%(abs(r%(-r-1)),pre[r],u)).format(n*b**pow/b**float(r))

例えば:

>>> pretty_units(987654321098765432109876543210)
'816,968.5 YiB'


6

hurry.filesize()の代替として提供されるスニペットを比較すると、使用される接頭辞に基づいてさまざまな精度の数値を提供するスニペットがここにあります。一部のスニペットほど簡潔ではありませんが、結果は気に入っています。

def human_size(size_bytes):
    """
    format a size in bytes into a 'human' file size, e.g. bytes, KB, MB, GB, TB, PB
    Note that bytes/KB will be reported in whole numbers but MB and above will have greater precision
    e.g. 1 byte, 43 bytes, 443 KB, 4.3 MB, 4.43 GB, etc
    """
    if size_bytes == 1:
        # because I really hate unnecessary plurals
        return "1 byte"

    suffixes_table = [('bytes',0),('KB',0),('MB',1),('GB',2),('TB',2), ('PB',2)]

    num = float(size_bytes)
    for suffix, precision in suffixes_table:
        if num < 1024.0:
            break
        num /= 1024.0

    if precision == 0:
        formatted_size = "%d" % num
    else:
        formatted_size = str(round(num, ndigits=precision))

    return "%s %s" % (formatted_size, suffix)


4

これまでのすべての回答から、ここに私の見解を示します。これは、ファイルサイズをバイト単位で整数として格納するオブジェクトです。しかし、オブジェクトを印刷しようとすると、人間が読めるバージョンが自動的に表示されます。

class Filesize(object):
    """
    Container for a size in bytes with a human readable representation
    Use it like this::

        >>> size = Filesize(123123123)
        >>> print size
        '117.4 MB'
    """

    chunk = 1024
    units = ['bytes', 'KB', 'MB', 'GB', 'TB', 'PB']
    precisions = [0, 0, 1, 2, 2, 2]

    def __init__(self, size):
        self.size = size

    def __int__(self):
        return self.size

    def __str__(self):
        if self.size == 0: return '0 bytes'
        from math import log
        unit = self.units[min(int(log(self.size, self.chunk)), len(self.units) - 1)]
        return self.format(unit)

    def format(self, unit):
        if unit not in self.units: raise Exception("Not a valid file size unit: %s" % unit)
        if self.size == 1 and unit == 'bytes': return '1 byte'
        exponent = self.units.index(unit)
        quotient = float(self.size) / self.chunk**exponent
        precision = self.precisions[exponent]
        format_string = '{:.%sf} {}' % (precision)
        return format_string.format(quotient, unit)

3

センデルの10進数バージョンの固定精度が好きなので、上記のjocteeの回答とのハイブリッドの一種です(整数以外のベースでログを取得できることをご存知でしたか?):

from math import log
def human_readable_bytes(x):
    # hybrid of https://stackoverflow.com/a/10171475/2595465
    #      with https://stackoverflow.com/a/5414105/2595465
    if x == 0: return '0'
    magnitude = int(log(abs(x),10.24))
    if magnitude > 16:
        format_str = '%iP'
        denominator_mag = 15
    else:
        float_fmt = '%2.1f' if magnitude % 3 == 1 else '%1.2f'
        illion = (magnitude + 1) // 3
        format_str = float_fmt + ['', 'K', 'M', 'G', 'T', 'P'][illion]
    return (format_str % (x * 1.0 / (1024 ** illion))).lstrip('0')



2

シンプルな2ライナーはどうですか:

def humanizeFileSize(filesize):
    p = int(math.floor(math.log(filesize, 2)/10))
    return "%.3f%s" % (filesize/math.pow(1024,p), ['B','KiB','MiB','GiB','TiB','PiB','EiB','ZiB','YiB'][p])

これが内部でどのように機能するかを次に示します。

  1. ログ2(ファイルサイズ)を計算します
  2. 10で割って、最も近い単位を取得します。(たとえば、サイズが5000バイトの場合、最も近い単位はKbなので、答えはX KiBになります)
  3. file_size/value_of_closest_unitユニットと一緒に戻ります。

ただし、filesizeが0または負の場合は機能しません(0と-veの数値に対してログが定義されていないため)。それらに追加のチェックを追加できます。

def humanizeFileSize(filesize):
    filesize = abs(filesize)
    if (filesize==0):
        return "0 Bytes"
    p = int(math.floor(math.log(filesize, 2)/10))
    return "%0.2f %s" % (filesize/math.pow(1024,p), ['Bytes','KiB','MiB','GiB','TiB','PiB','EiB','ZiB','YiB'][p])

例:

>>> humanizeFileSize(538244835492574234)
'478.06 PiB'
>>> humanizeFileSize(-924372537)
'881.55 MiB'
>>> humanizeFileSize(0)
'0 Bytes'

-KbとKiBには違いがあります。KBは1000バイトを意味し、KiBは1024バイトを意味します。KB、MB、GBはすべて1000の倍数ですが、KiB、MiB、GiBなどはすべて1024の倍数です。詳細はこちら


1
def human_readable_data_quantity(quantity, multiple=1024):
    if quantity == 0:
        quantity = +0
    SUFFIXES = ["B"] + [i + {1000: "B", 1024: "iB"}[multiple] for i in "KMGTPEZY"]
    for suffix in SUFFIXES:
        if quantity < multiple or suffix == SUFFIXES[-1]:
            if suffix == SUFFIXES[0]:
                return "%d%s" % (quantity, suffix)
            else:
                return "%.1f%s" % (quantity, suffix)
        else:
            quantity /= multiple

1

以下で見つけようとしているのは、既に投稿されているソリューションの中で、最もパフォーマンスが高い、または最も短いソリューションではありません。代わりに、他の回答の多くが見逃している特定の問題に焦点を当てています。

つまり、次のような入力999_995が与えられた場合:

Python 3.6.1 ...
...
>>> value = 999_995
>>> base = 1000
>>> math.log(value, base)
1.999999276174054

これは、最も近い整数に切り捨てられ、入力に戻されて与えられます

>>> order = int(math.log(value, base))
>>> value/base**order
999.995

これは、出力精度を制御する必要があるまで、私たちが期待するとおりのことです。そして、これは物事が少し難しくなり始める時です。

精度を2桁に設定すると、次のようになります。

>>> round(value/base**order, 2)
1000 # K

の代わりに1M

どうすればこれに対抗できますか?

もちろん、それを明示的に確認できます。

if round(value/base**order, 2) == base:
    order += 1

しかし、もっとうまくできるだろうか?order最後のステップを実行する前に、どのようにカットする必要があるかを知ることができますか?

できることがわかりました。

10進数の丸め規則を0.5とすると、上記のif条件は次のようになります。

ここに画像の説明を入力してください

その結果

def abbreviate(value, base=1000, precision=2, suffixes=None):
    if suffixes is None:
        suffixes = ['', 'K', 'M', 'B', 'T']

    if value == 0:
        return f'{0}{suffixes[0]}'

    order_max = len(suffixes) - 1
    order = log(abs(value), base)
    order_corr = order - int(order) >= log(base - 0.5/10**precision, base)
    order = min(int(order) + order_corr, order_max)

    factored = round(value/base**order, precision)

    return f'{factored:,g}{suffixes[order]}'

与える

>>> abbreviate(999_994)
'999.99K'
>>> abbreviate(999_995)
'1M'
>>> abbreviate(999_995, precision=3)
'999.995K'
>>> abbreviate(2042, base=1024)
'1.99K'
>>> abbreviate(2043, base=1024)
'2K'

0

Sridhar Ratnakumarの回答を参照してください:

def formatSize(sizeInBytes, decimalNum=1, isUnitWithI=False, sizeUnitSeperator=""):
  """format size to human readable string"""
  # https://en.wikipedia.org/wiki/Binary_prefix#Specific_units_of_IEC_60027-2_A.2_and_ISO.2FIEC_80000
  # K=kilo, M=mega, G=giga, T=tera, P=peta, E=exa, Z=zetta, Y=yotta
  sizeUnitList = ['','K','M','G','T','P','E','Z']
  largestUnit = 'Y'

  if isUnitWithI:
    sizeUnitListWithI = []
    for curIdx, eachUnit in enumerate(sizeUnitList):
      unitWithI = eachUnit
      if curIdx >= 1:
        unitWithI += 'i'
      sizeUnitListWithI.append(unitWithI)

    # sizeUnitListWithI = ['','Ki','Mi','Gi','Ti','Pi','Ei','Zi']
    sizeUnitList = sizeUnitListWithI

    largestUnit += 'i'

  suffix = "B"
  decimalFormat = "." + str(decimalNum) + "f" # ".1f"
  finalFormat = "%" + decimalFormat + sizeUnitSeperator + "%s%s" # "%.1f%s%s"
  sizeNum = sizeInBytes
  for sizeUnit in sizeUnitList:
      if abs(sizeNum) < 1024.0:
        return finalFormat % (sizeNum, sizeUnit, suffix)
      sizeNum /= 1024.0
  return finalFormat % (sizeNum, largestUnit, suffix)

出力例は次のとおりです。

def testKb():
  kbSize = 3746
  kbStr = formatSize(kbSize)
  print("%s -> %s" % (kbSize, kbStr))

def testI():
  iSize = 87533
  iStr = formatSize(iSize, isUnitWithI=True)
  print("%s -> %s" % (iSize, iStr))

def testSeparator():
  seperatorSize = 98654
  seperatorStr = formatSize(seperatorSize, sizeUnitSeperator=" ")
  print("%s -> %s" % (seperatorSize, seperatorStr))

def testBytes():
  bytesSize = 352
  bytesStr = formatSize(bytesSize)
  print("%s -> %s" % (bytesSize, bytesStr))

def testMb():
  mbSize = 76383285
  mbStr = formatSize(mbSize, decimalNum=2)
  print("%s -> %s" % (mbSize, mbStr))

def testTb():
  tbSize = 763832854988542
  tbStr = formatSize(tbSize, decimalNum=2)
  print("%s -> %s" % (tbSize, tbStr))

def testPb():
  pbSize = 763832854988542665
  pbStr = formatSize(pbSize, decimalNum=4)
  print("%s -> %s" % (pbSize, pbStr))


def demoFormatSize():
  testKb()
  testI()
  testSeparator()
  testBytes()
  testMb()
  testTb()
  testPb()

  # 3746 -> 3.7KB
  # 87533 -> 85.5KiB
  # 98654 -> 96.3 KB
  # 352 -> 352.0B
  # 76383285 -> 72.84MB
  # 763832854988542 -> 694.70TB
  # 763832854988542665 -> 678.4199PB

0

この解決策は、あなたの心の働き方にもよりますが、魅力的なものになるでしょう。

from pathlib import Path    

def get_size(path = Path('.')):
    """ Gets file size, or total directory size """
    if path.is_file():
        size = path.stat().st_size
    elif path.is_dir():
        size = sum(file.stat().st_size for file in path.glob('*.*'))
    return size

def format_size(path, unit="MB"):
    """ Converts integers to common size units used in computing """
    bit_shift = {"B": 0,
            "kb": 7,
            "KB": 10,
            "mb": 17,
            "MB": 20,
            "gb": 27,
            "GB": 30,
            "TB": 40,}
    return "{:,.0f}".format(get_size(path) / float(1 << bit_shift[unit])) + " " + unit

# Tests and test results
>>> get_size("d:\\media\\bags of fun.avi")
'38 MB'
>>> get_size("d:\\media\\bags of fun.avi","KB")
'38,763 KB'
>>> get_size("d:\\media\\bags of fun.avi","kb")
'310,104 kb'
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.