Python format de la taille de l'application (la conversion de B en KO, MO, GO, TO)

Je suis en train d'écrire une application pour convertir des octets ko mo go à la tuberculose.
Voici ce que j'ai à ce jour:

def size_format(b):
    if b < 1000:
              return '%i' % b + 'B'
    elif 1000 <= b < 1000000:
        return '%.1f' % float(b/1000) + 'KB'
    elif 1000000 <= b < 1000000000:
        return '%.1f' % float(b/1000000) + 'MB'
    elif 1000000000 <= b < 1000000000000:
        return '%.1f' % float(b/1000000000) + 'GB'
    elif 1000000000000 <= b:
        return '%.1f' % float(b/1000000000000) + 'TB'

Le problème c'est que quand j'essaie de l'application je reçois tout ce qui est après la virgule zéro.
exemple
size_format(623) rendements
'623B'
mais avec size_format(6200),
au lieu d'être "6.2 kb'
Je me fais '6.0 kb'.
Des idées pourquoi?

Un indice pour l'avenir: lorsque vous collez le dans le code, sélectionnez tout et utiliser le {} bouton pour les mettre en forme dans le code.

OriginalL'auteur user1687654 | 2012-09-21

Version fixe de Bryan_Rch réponse:

def format_bytes(size):
    # 2**10 = 1024
    power = 2**10
    n = 0
    power_labels = {0 : '', 1: 'kilo', 2: 'mega', 3: 'giga', 4: 'tera'}
    while size > power:
        size /= power
        n += 1
    return size, power_labels[n]+'bytes'

OriginalL'auteur Pietro Battiston

def humanbytes(B):
   'Return the given bytes as a human friendly KB, MB, GB, or TB string'
   B = float(B)
   KB = float(1024)
   MB = float(KB ** 2) # 1,048,576
   GB = float(KB ** 3) # 1,073,741,824
   TB = float(KB ** 4) # 1,099,511,627,776

   if B < KB:
      return '{0} {1}'.format(B,'Bytes' if 0 == B > 1 else 'Byte')
   elif KB <= B < MB:
      return '{0:.2f} KB'.format(B/KB)
   elif MB <= B < GB:
      return '{0:.2f} MB'.format(B/MB)
   elif GB <= B < TB:
      return '{0:.2f} GB'.format(B/GB)
   elif TB <= B:
      return '{0:.2f} TB'.format(B/TB)

tests = [1, 1024, 500000, 1048576, 50000000, 1073741824, 5000000000, 1099511627776, 5000000000000]

for t in tests: print '{0} == {1}'.format(t,humanbytes(t))

De sortie:

1 == 1.0 Byte
1024 == 1.00 KB
500000 == 488.28 KB
1048576 == 1.00 MB
50000000 == 47.68 MB
1073741824 == 1.00 GB
5000000000 == 4.66 GB
1099511627776 == 1.00 TB
5000000000000 == 4.55 TB

et pour l'avenir, moi, ici, il est en Perl:

sub humanbytes {
   my $B = shift;
   my $KB = 1024;
   my $MB = $KB ** 2; # 1,048,576
   my $GB = $KB ** 3; # 1,073,741,824
   my $TB = $KB ** 4; # 1,099,511,627,776

   if ($B < $KB) {
      return "$B " . (($B == 0 || $B > 1) ? 'Bytes' : 'Byte');
   } elsif ($B >= $KB && $B < $MB) {
      return sprintf('%0.02f',$B/$KB) . ' KB';
   } elsif ($B >= $MB && $B < $GB) {
      return sprintf('%0.02f',$B/$MB) . ' MB';
   } elsif ($B >= $GB && $B < $TB) {
      return sprintf('%0.02f',$B/$GB) . ' GB';
   } elsif ($B >= $TB) {
      return sprintf('%0.02f',$B/$TB) . ' TB';
   }
}

OriginalL'auteur whereisalext

J'ai tout à fait lisible de la fonction de convertir des octets en plus de parts:

def bytes_2_human_readable(number_of_bytes):
    if number_of_bytes < 0:
        raise ValueError("!!! number_of_bytes can't be smaller than 0 !!!")

    step_to_greater_unit = 1024.

    number_of_bytes = float(number_of_bytes)
    unit = 'bytes'

    if (number_of_bytes / step_to_greater_unit) >= 1:
        number_of_bytes /= step_to_greater_unit
        unit = 'KB'

    if (number_of_bytes / step_to_greater_unit) >= 1:
        number_of_bytes /= step_to_greater_unit
        unit = 'MB'

    if (number_of_bytes / step_to_greater_unit) >= 1:
        number_of_bytes /= step_to_greater_unit
        unit = 'GB'

    if (number_of_bytes / step_to_greater_unit) >= 1:
        number_of_bytes /= step_to_greater_unit
        unit = 'TB'

    precision = 1
    number_of_bytes = round(number_of_bytes, precision)

    return str(number_of_bytes) + ' ' + unit

OriginalL'auteur Grzegorz Bazior

2

Plutôt que de modifier votre code, vous pouvez modifier le comportement de la division:
```
from __future__ import division
```
Cette offre "vrai" de la division sur le style "classique" que Python 2.x utilise. Voir PEP 238 - la Modification de l'Opérateur de Division pour plus de détails.

C'est maintenant le comportement par défaut de Python 3.x

Je suis tellement habitué à la façon dont les autres langues de travail que j'oublie à ce sujet. Il va vraiment me mordre un jour, quand j'ai commencer à utiliser Python 3 plus.

OriginalL'auteur Matthew Trevor

C'est une version compacte qui convertit B (octets) pour tout ordre supérieur tels MO, GO, sans l'aide de beaucoup de if...else en python. J'utilise bit-wise. Cela permet aussi de retour d'une sortie float si vous déclenchez le paramètre return_output dans la fonction comme Vrai:

import math

def bytes_conversion(number, return_float=False):

    def _conversion(number, return_float=False):

        length_number = int(math.log10(number))

        if return_float:

           length_number = int(math.log10(number))
           return length_number // 3, '%.2f' % (int(number)/(1 << (length_number//3) *10))

        return length_number // 3, int(number) >> (length_number//3) * 10

    unit_dict = {
        0: "B",  1: "kB",
        2: "MB", 3: "GB",
        4: "TB", 5: "PB",
        6: "EB"
    }

    if return_float:

        num_length, number = _conversion(number, return_float=return_float)

    else:
        num_length, number = _conversion(number)

    return "%s %s" % (number, unit_dict[num_length])

#Example usage:
#print(bytes_conversion(491266116, return_float=True))

Ce n'est que quelques-uns de mes posts dans StackOverflow. S'il vous plaît laissez-moi savoir si j'ai des erreurs ou des violations.

OriginalL'auteur Mobieus Jay

Encore un autre humanbytes version, sans boucles/if..else, en python3 syntaxe.

Test numéros de vol de @whereisalext de réponse.

Vous l'esprit, c'est encore une esquisse, par exemple, si les numéros sont assez grand il sera traceback.

import math as m


MULTIPLES = ["B", "k{}B", "M{}B", "G{}B", "T{}B", "P{}B", "E{}B", "Z{}B", "Y{}B"]


def humanbytes(i, binary=False, precision=2):
    base = 1024 if binary else 1000
    multiple = m.trunc(m.log2(i) / m.log2(base))
    value = i / m.pow(base, multiple)
    suffix = MULTIPLES[multiple].format("i" if binary else "")
    return f"{value:.{precision}f} {suffix}"


if __name__ == "__main__":
    sizes = [
        1, 1024, 500000, 1048576, 50000000, 1073741824, 5000000000,
        1099511627776, 5000000000000]

    for i in sizes:
        print(f"{i} == {humanbytes(i)}, {humanbytes(i, binary=True)}")

Résultats:

1 == 1.00 B, 1.00 B
1024 == 1.02 kB, 1.00 kiB
500000 == 500.00 kB, 488.28 kiB
1048576 == 1.05 MB, 1.00 MiB
50000000 == 50.00 MB, 47.68 MiB
1073741824 == 1.07 GB, 1.00 GiB
5000000000 == 5.00 GB, 4.66 GiB
1099511627776 == 1.10 TB, 1.00 TiB
5000000000000 == 5.00 TB, 4.55 TiB

OriginalL'auteur petre

1

Lorsque vous divisez la valeur que vous utilisez une division d'entier, car les deux valeurs sont des nombres entiers. Vous avez besoin de convertir l'un d'eux à flotteur première:
```
return '%.1f' % float(b)/1000 + 'KB'
```
ou même juste
```
return '%.1f' % b/1000.0 + 'KB'
```
OriginalL'auteur Mark Ransom
0

Ne float(b) avant de faire la division, par exemple, ne float(b)/1000 au lieu de float(b/1000), parce que les deux b et 1000 sont des nombres entiers, b/1000 est toujours un entier sans partie décimale.

OriginalL'auteur Marcus

Ici est de convertir les octets en kilo, mega, tera.

#From bytes to kilo, mega, tera
def  get_(size):

    #2**10 = 1024
    power = 2**10
    n = 1
    Dic_powerN = {1:'kilobytes', 2:'megabytes', 3:'gigabytes', 4:'Terabytes'}

    if size <= power**2 :
        size /=  power
        return size, Dic_powerN[n]

    else: 
        while size   >  power :
            n  += 1
            size /=  power**n

        return size, Dic_powerN[n]

C'est sympa mais) mal - essayer get_(1.1 * 10**9)

OriginalL'auteur Bryan_Rch

bonne idée pour moi:

def convert_bytes(num):
    """
    this function will convert bytes to MB.... GB... etc
    """
    step_unit = 1000.0 #1024 bad the size

    for x in ['bytes', 'KB', 'MB', 'GB', 'TB']:
        if num < step_unit:
            return "%3.1f %s" % (num, x)
        num /= step_unit

OriginalL'auteur iHTCboy

Une sortie avec pas de décimale:

>>> format_file_size(12345678)
'11 MiB, 792 KiB, 334 bytes'

format_file_size(
    def format_file_size(fsize):
        result = []
        units = {s: u for s, u in zip(reversed([2 ** n for n in range(0, 40, 10)]), ['GiB', 'MiB', 'KiB', 'bytes'])}
        for s, u in units.items():
            t = fsize // s
            if t > 0:
                result.append('{} {}'.format(t, u))
            fsize = fsize % s
        return ', '.join(result) or '0 bytes'

OriginalL'auteur Helio Santos

Vous devez vous connecter pour publier un commentaire.