Get human readable version of file size

Question

A function to return human readable size from bytes size   gt  gt  gt  human readable 2048   2 kilobytes   gt  gt  gt   How to do this

User · Answer

The following works in Python 3 6   is  in my opinion  the easiest to understand answer on here  and lets you customize the amount of decimal places used  def human readable size size  decimal places 2       for unit in   B    KiB    MiB    GiB    TiB    PiB            if size  lt  1024 0 or unit     PiB               break         size    1024 0     return f quot  size   decimal places f   unit  quot

User · Answer

Drawing from all the previous answers  here is my take on it  It s an object which will store the file size in bytes as an integer  But when you try to print the object  you automatically get a human readable version   class Filesize object               Container for a size in bytes with a human readable representation     Use it like this             gt  gt  gt  size   Filesize 123123123           gt  gt  gt  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

User · Answer

Using either powers of 1000 or kibibytes would be more standard-friendly   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  lt  num  lt  base              return   3 1f  s     num  x          num    base     return   3 1f  s     num  x    P S  Never trust a library that prints thousands with the K  uppercase  suffix

User · Answer

You should use  humanize     gt  gt  gt  humanize naturalsize 1000000   1 0 MB   gt  gt  gt  humanize naturalsize 1000000  binary True   976 6 KiB   gt  gt  gt  humanize naturalsize 1000000  gnu True   976 6K       Reference       https   pypi org project humanize

User · Answer

Modern Django have self template tag filesizeformat   Formats the value like a human-readable file size  i e   13 KB    4 1 MB    102 bytes   etc     For example      value filesizeformat      If value is 123456789  the output would be 117 7 MB   More info  https   docs djangoproject com en 1 10 ref templates builtins  filesizeformat

User · Answer

Here s my version  It does not use a for-loop  It has constant complexity  O 1   and is in theory more efficient than the answers here that use a for-loop   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  gt  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    To make it more clear what is going on  we can omit the code for the string formatting  Here are the lines that actually do the work   exponent   int log num  1024   quotient   num   1024  exponent unit list exponent

User · Answer

A library that has all the functionality that it seems you re looking for is humanize   humanize naturalsize   seems to do everything you re looking for

User · Answer

I like the fixed precision of senderle s decimal version  so here s a sort of hybrid of that with joctee s answer above  did you know you could take logs with non-integer bases     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  gt  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

User · Answer

Referencing Sridhar Ratnakumar s answer  updated to  def formatSize sizeInBytes  decimalNum 1  isUnitWithI False  sizeUnitSeperator  quot  quot       quot  quot  quot format size to human readable string quot  quot  quot      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  gt   1          unitWithI     i        sizeUnitListWithI append unitWithI         sizeUnitListWithI        Ki   Mi   Gi   Ti   Pi   Ei   Zi       sizeUnitList   sizeUnitListWithI      largestUnit     i     suffix    quot B quot    decimalFormat    quot   quot    str decimalNum     quot f quot     quot  1f quot    finalFormat    quot   quot    decimalFormat   sizeUnitSeperator    quot  s s quot     quot   1f s s quot    sizeNum   sizeInBytes   for sizeUnit in sizeUnitList        if abs sizeNum   lt  1024 0          return finalFormat    sizeNum  sizeUnit  suffix        sizeNum    1024 0   return finalFormat    sizeNum  largestUnit  suffix   and example output is  def testKb      kbSize   3746   kbStr   formatSize kbSize    print  quot  s - gt   s quot     kbSize  kbStr    def testI      iSize   87533   iStr   formatSize iSize  isUnitWithI True    print  quot  s - gt   s quot     iSize  iStr    def testSeparator      seperatorSize   98654   seperatorStr   formatSize seperatorSize  sizeUnitSeperator  quot   quot     print  quot  s - gt   s quot     seperatorSize  seperatorStr    def testBytes      bytesSize   352   bytesStr   formatSize bytesSize    print  quot  s - gt   s quot     bytesSize  bytesStr    def testMb      mbSize   76383285   mbStr   formatSize mbSize  decimalNum 2    print  quot  s - gt   s quot     mbSize  mbStr    def testTb      tbSize   763832854988542   tbStr   formatSize tbSize  decimalNum 2    print  quot  s - gt   s quot     tbSize  tbStr    def testPb      pbSize   763832854988542665   pbStr   formatSize pbSize  decimalNum 4    print  quot  s - gt   s quot     pbSize  pbStr     def demoFormatSize      testKb     testI     testSeparator     testBytes     testMb     testTb     testPb        3746 - gt  3 7KB     87533 - gt  85 5KiB     98654 - gt  96 3 KB     352 - gt  352 0B     76383285 - gt  72 84MB     763832854988542 - gt  694 70TB     763832854988542665 - gt  678 4199PB

User · Answer

This will do what you need in almost any situation  is customizable with optional arguments  and as you can see  is pretty much self-documenting   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    Example output    gt  gt  gt  pretty size 42   42 B    gt  gt  gt  pretty size 2015   2 0 KiB    gt  gt  gt  pretty size 987654321   941 9 MiB    gt  gt  gt  pretty size 9876543210   9 2 GiB    gt  gt  gt  pretty size 0 5 pow 1   512 B    gt  gt  gt  pretty size 0   0 B    Advanced customizations    gt  gt  gt  pretty size 987654321 b 1000 u  bytes  pre      kilo   mega   giga     987 7 megabytes    gt  gt  gt  pretty size 9876543210 b 1000 u  bytes  pre      kilo   mega   giga     9 9 gigabytes    This code is both Python 2 and Python 3 compatible  PEP8 compliance is an exercise for the reader  Remember  it s the output that s pretty   Update    If you need thousands commas  just apply the obvious extension   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     For example    gt  gt  gt  pretty units 987654321098765432109876543210   816 968 5 YiB

User · Answer

If you re using Django installed you can also try filesizeformat   from django template defaultfilters import filesizeformat filesizeformat 1073741824     gt    1 0 GB

User · Answer

One such library is hurry filesize    gt  gt  gt  from hurry filesize import alternative  gt  gt  gt  size 1  system alternative   1 byte   gt  gt  gt  size 10  system alternative   10 bytes   gt  gt  gt  size 1024  system alternative   1 KB

User · Answer

The HumanFriendly project helps with this   import humanfriendly humanfriendly format size 1024    The above code will give 1KB as answer  Examples can be found here

User · Answer

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  lt  multiple or suffix    SUFFIXES -1               if suffix    SUFFIXES 0                   return   d s     quantity  suffix              else                  return    1f s     quantity  suffix          else              quantity    multiple

User · Answer

What you re about to find below is by no means the most performant or shortest solution among the ones already posted  Instead  it focuses on one particular issue that many of the other answers miss   Namely the case when input like 999 995 is given   Python 3 6 1          gt  gt  gt  value   999 995  gt  gt  gt  base   1000  gt  gt  gt  math log value  base  1 999999276174054   which  being truncated to the nearest integer and applied back to the input gives   gt  gt  gt  order   int math log value  base    gt  gt  gt  value base  order 999 995   This seems to be exactly what we d expect until we re required to control output precision  And this is when things start to get a bit difficult   With the precision set to 2 digits we get    gt  gt  gt  round value base  order  2  1000   K   instead of 1M   How can we counter that   Of course  we can check for it explicitly   if round value base  order  2     base      order    1   But can we do better  Can we get to know which way the order should be cut before we do the final step   It turns out we can   Assuming 0 5 decimal rounding rule  the above if condition translates into     resulting in  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   gt   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      giving   gt  gt  gt  abbreviate 999 994   999 99K   gt  gt  gt  abbreviate 999 995   1M   gt  gt  gt  abbreviate 999 995  precision 3   999 995K   gt  gt  gt  abbreviate 2042  base 1024   1 99K   gt  gt  gt  abbreviate 2043  base 1024   2K

User · Answer

Riffing on the snippet provided as an alternative to hurry filesize    here is a snippet that gives varying precision numbers based on the prefix used  It isn t as terse as some snippets  but I like the results   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  lt  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

User · Answer

How about a simple 2 liner   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     Here is how it works under the hood    Calculates log2 filesize  Divides it by 10 to get the closest unit   eg if size is 5000 bytes  the closest unit is Kb  so the answer should be X KiB  Returns file size value of closest unit along with unit    It however doesn t work if filesize is 0 or negative  because log is undefined for 0 and -ve numbers   You can add extra checks for them   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     Examples    gt  gt  gt  humanizeFileSize 538244835492574234   478 06 PiB   gt  gt  gt  humanizeFileSize -924372537   881 55 MiB   gt  gt  gt  humanizeFileSize 0   0 Bytes      NOTE - There is a difference between Kb and KiB  KB means 1000 bytes  whereas KiB means 1024 bytes  KB MB GB are all multiples of 1000  whereas KiB  MiB  GiB etc are all multiples of 1024  More about it here

User · Answer

Here is an option using while  def number format n      n2  n3   n  0    while n2  gt   1e3        n2    1e3       n3    1    return    3f    n2          k     M     G   n3   s   number format 9012345678  print s     9 012 G    https   docs python org reference compound stmts html while

User · Answer

Addressing the above  too small a task to require a library  issue by a straightforward implementation   def sizeof fmt num  suffix  B        for unit in      Ki   Mi   Gi   Ti   Pi   Ei   Zi            if abs num   lt  1024 0              return   3 1f s s     num  unit  suffix          num    1024 0     return    1f s s     num   Yi   suffix    Supports    all currently known binary prefixes negative and positive numbers numbers larger than 1000 Yobibytes arbitrary units  maybe you like to count in Gibibits     Example    gt  gt  gt  sizeof fmt 168963795964   157 4GiB    by Fred Cirera

User · Answer

I recently came up with a version that avoids loops  using log2 to determine the size order which doubles as a shift and an index into the suffix list  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  lt  lt   order   10     suffixes order    Could well be considered unpythonic for its readability  though

User · Answer

This feature if available in Boltons which is a very handy library to have for most projects   gt  gt  gt  bytes2human 128991   126K   gt  gt  gt  bytes2human 100001221   95M   gt  gt  gt  bytes2human 0  2   0 00B

User · Answer

This solution might also appeal to you  depending on how your mind works   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  lt  lt  bit shift unit            unit    Tests and test results  gt  gt  gt  get size  d   media  bags of fun avi    38 MB   gt  gt  gt  get size  d   media  bags of fun avi   KB    38 763 KB   gt  gt  gt  get size  d   media  bags of fun avi   kb    310 104 kb

User · Answer

There s always got to be one of those guys  Well today it s me  Here s a one-liner -- or two lines if you count the function signature  def human size bytes  units    bytes   KB   MB   GB   TB    PB    EB          quot  quot  quot  Returns a human readable string representation of bytes  quot  quot  quot      return str bytes    units 0  if bytes  lt  1024 else human size bytes gt  gt 10  units 1        gt  gt  gt  human size 123  123 bytes  gt  gt  gt  human size 123456789  117GB   If you need sizes bigger than an Exabyte  it s a little bit more gnarly  def human size bytes  units    bytes   KB   MB   GB   TB    PB    EB         return str bytes    units 0  if bytes  lt  1024 else human size bytes gt  gt 10  units 1    if units 1   else f  bytes gt  gt 10 ZB

[python] Get human readable version of file size?

Examples related to python

Examples related to code-snippets

Examples related to filesize