Hướng dẫn python convert bytes to human readable - python chuyển đổi byte thành con người có thể đọc được

Question

Giải quyết vấn đề "Một nhiệm vụ quá nhỏ để yêu cầu thư viện" bằng cách triển khai đơn giản (sử dụng F-Strings, vì vậy Python 3.6+):

Nội dung chính Show

Tệp nào có thể đọc được trong Python?
Làm thế nào lớn là một con trăn terabyte?
Làm thế nào để kiểm tra kích thước tệp trong GB trong Python?

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

Supports:

Tất cả các tiền tố nhị phân hiện đang được biết đến
Số âm và dương
Số lượng lớn hơn 1000 yobibyte
Các đơn vị tùy ý (có thể bạn thích đếm trong Gibibits!)

Example:

>>> sizeof_fmt(168963795964)
'157.4GiB'

bởi Fred Cirera

Nico Schlömer

49.5K25 Huy hiệu vàng186 Huy hiệu bạc230 Huy hiệu đồng25 gold badges186 silver badges230 bronze badges

Đã trả lời ngày 7 tháng 7 năm 2009 lúc 21:15Jul 7, 2009 at 21:15

Hướng dẫn python convert bytes to human readable - python chuyển đổi byte thành con người có thể đọc được

16

Một thư viện có tất cả các chức năng mà dường như bạn đang tìm kiếm là

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

2.

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

3 dường như làm mọi thứ bạn đang tìm kiếm.

Mã ví dụ (

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

4)

import humanize

disk_sizes_list = [1, 100, 999, 1000,1024, 2000,2048, 3000, 9999, 10000, 2048000000, 9990000000, 9000000000000000000000]
for size in disk_sizes_list:
    natural_size = humanize.naturalsize(size)
    binary_size = humanize.naturalsize(size, binary=True)
    print(f" {natural_size} \t| {binary_size}\t|{size}")

Đầu ra

 1 Byte     | 1 Byte    |1
 100 Bytes  | 100 Bytes |100
 999 Bytes  | 999 Bytes |999
 1.0 kB     | 1000 Bytes    |1000
 1.0 kB     | 1.0 KiB   |1024
 2.0 kB     | 2.0 KiB   |2000
 2.0 kB     | 2.0 KiB   |2048
 3.0 kB     | 2.9 KiB   |3000
 10.0 kB    | 9.8 KiB   |9999
 10.0 kB    | 9.8 KiB   |10000
 2.0 GB     | 1.9 GiB   |2048000000
 10.0 GB    | 9.3 GiB   |9990000000
 9.0 ZB     | 7.6 ZiB   |9000000000000000000000

Jayan

17.6K15 Huy hiệu vàng86 Huy hiệu bạc139 Huy hiệu đồng15 gold badges86 silver badges139 bronze badges

Đã trả lời ngày 18 tháng 3 năm 2013 lúc 19:29Mar 18, 2013 at 19:29

1

Các tác phẩm sau đây trong Python 3.6+, theo tôi, là câu trả lời dễ hiểu nhất ở đây và cho phép bạn tùy chỉnh số lượng các vị trí thập phân được sử dụng.

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

Đã trả lời ngày 29 tháng 4 năm 2017 lúc 0:13Apr 29, 2017 at 0:13

1

Luôn luôn có một trong những kẻ đó. Hôm nay là tôi. Đây là một lớp-hoặc hai dòng nếu bạn đếm chữ ký chức năng.

def human_size(bytes, units=[' bytes','KB','MB','GB','TB', 'PB', 'EB']):
    """ Returns a human readable string representation 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

Nếu bạn cần kích thước lớn hơn một exabyte, thì đó là một chút sởn gai ốc:

def human_size(bytes, units=[' bytes','KB','MB','GB','TB', 'PB', 'EB']):
    return str(bytes) + units[0] if bytes < 1024 else human_size(bytes>>10, units[1:]) if units[1:] else f'{bytes>>10}ZB'

Đã trả lời ngày 3 tháng 5 năm 2017 lúc 3:09May 3, 2017 at 3:09

7

Đây là phiên bản của tôi. Nó không sử dụng một vòng lặp. Nó có độ phức tạp liên tục, O (1), và về mặt lý thuyết hiệu quả hơn so với các câu trả lời ở đây sử dụng vòng lặp.

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'

Để làm cho nó rõ ràng hơn những gì đang diễn ra, chúng ta có thể bỏ qua mã cho định dạng chuỗi. Dưới đây là những dòng thực sự làm công việc:

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

Đã trả lời ngày 16 tháng 4 năm 2012 lúc 9:16Apr 16, 2012 at 9:16

Jocteejocteejoctee

2.3331 Huy hiệu vàng22 Huy hiệu bạc19 Huy hiệu đồng1 gold badge22 silver badges19 bronze badges

6

Gần đây tôi đã đưa ra một phiên bản tránh các vòng lặp, sử dụng

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

5 để xác định thứ tự kích thước tăng gấp đôi như một sự thay đổi và chỉ mục vào danh sách hậu tố:

>>> sizeof_fmt(168963795964)
'157.4GiB'

0

Tuy nhiên, cũng có thể được coi là không có khả năng đọc.

Jules G.M.

3,5061 Huy hiệu vàng20 Huy hiệu bạc 34 Huy hiệu đồng1 gold badge20 silver badges34 bronze badges

Đã trả lời ngày 1 tháng 9 năm 2014 lúc 21:23Sep 1, 2014 at 21:23

AkaidiotakaidiotakaIDIOT

9.1313 Huy hiệu vàng26 Huy hiệu bạc 30 Huy hiệu Đồng3 gold badges26 silver badges30 bronze badges

2

Nếu bạn đang sử dụng cài đặt Django, bạn cũng có thể thử FileSizeFormat:

>>> sizeof_fmt(168963795964)
'157.4GiB'

1

Đã trả lời ngày 27 tháng 8 năm 2014 lúc 12:47Aug 27, 2014 at 12:47

Jon Tirsenjon TirsenJon Tirsen

4.4904 Huy hiệu vàng27 Huy hiệu bạc27 Huy hiệu đồng4 gold badges27 silver badges27 bronze badges

3

Bạn nên sử dụng "Nhân hóa".

>>> sizeof_fmt(168963795964)
'157.4GiB'

2

Reference:
https://pypi.org/project/humanize/

Đã trả lời ngày 6 tháng 9 năm 2018 lúc 4:56Sep 6, 2018 at 4:56

Một thư viện như vậy là vội vàng.filesize.

>>> sizeof_fmt(168963795964)
'157.4GiB'

3

Đã trả lời ngày 7 tháng 7 năm 2009 lúc 21:00Jul 7, 2009 at 21:00

3

Sử dụng năng lượng của 1000 hoặc kibibyte sẽ thân thiện với tiêu chuẩn hơn:

>>> sizeof_fmt(168963795964)
'157.4GiB'

4

P.S. Không bao giờ tin tưởng một thư viện in hàng ngàn với hậu tố K (chữ hoa) :)

Đã trả lời ngày 21 tháng 5 năm 2014 lúc 2:49May 21, 2014 at 2:49

1

Dự án thân thiện với con người giúp với điều này.

>>> sizeof_fmt(168963795964)
'157.4GiB'

5

Mã trên sẽ đưa ra 1kb như câu trả lời. Ví dụ có thể được tìm thấy ở đây.
Examples can be found here.

zx485

27.7K28 Huy hiệu vàng52 Huy hiệu bạc59 Huy hiệu đồng28 gold badges52 silver badges59 bronze badges

Đã trả lời ngày 1 tháng 11 năm 2018 lúc 21:00Nov 1, 2018 at 21:00

1

Riff trên đoạn trích được cung cấp như một giải pháp thay thế để vội vàng. Filesize (), đây là một đoạn trích cung cấp các số chính xác khác nhau dựa trên tiền tố được sử dụng. Nó không phải là ngắn gọn như một số đoạn trích, nhưng tôi thích kết quả.

>>> sizeof_fmt(168963795964)
'157.4GiB'

6

Đã trả lời ngày 1 tháng 7 năm 2011 lúc 11:40Jul 1, 2011 at 11:40

MarkltBakerMarkltBakermarkltbaker

4515 Huy hiệu bạc6 Huy hiệu Đồng5 silver badges6 bronze badges

Điều này sẽ làm những gì bạn cần trong hầu hết mọi tình huống, có thể tùy chỉnh với các đối số tùy chọn và như bạn có thể thấy, là khá nhiều tự ghi chép:

>>> sizeof_fmt(168963795964)
'157.4GiB'

7

Ví dụ đầu ra:

>>> sizeof_fmt(168963795964)
'157.4GiB'

8

Tùy chỉnh nâng cao:

>>> sizeof_fmt(168963795964)
'157.4GiB'

9

Mã này là cả Python 2 và Python 3 tương thích. Tuân thủ PEP8 là một bài tập cho người đọc. Hãy nhớ rằng, đó là đầu ra đẹp.

Update:

Nếu bạn cần hàng ngàn dấu phẩy, chỉ cần áp dụng tiện ích mở rộng rõ ràng:

import humanize

disk_sizes_list = [1, 100, 999, 1000,1024, 2000,2048, 3000, 9999, 10000, 2048000000, 9990000000, 9000000000000000000000]
for size in disk_sizes_list:
    natural_size = humanize.naturalsize(size)
    binary_size = humanize.naturalsize(size, binary=True)
    print(f" {natural_size} \t| {binary_size}\t|{size}")

0

Ví dụ:

import humanize

disk_sizes_list = [1, 100, 999, 1000,1024, 2000,2048, 3000, 9999, 10000, 2048000000, 9990000000, 9000000000000000000000]
for size in disk_sizes_list:
    natural_size = humanize.naturalsize(size)
    binary_size = humanize.naturalsize(size, binary=True)
    print(f" {natural_size} \t| {binary_size}\t|{size}")

1

Đã trả lời ngày 2 tháng 7 năm 2015 lúc 7:53Jul 2, 2015 at 7:53

Gojomogojomogojomo

49.5K12 Huy hiệu vàng82 Huy hiệu bạc108 Huy hiệu đồng12 gold badges82 silver badges108 bronze badges

Vẽ từ tất cả các câu trả lời trước đó, đây là tôi đảm nhận nó. Đó là một đối tượng sẽ lưu trữ kích thước tệp tính bằng byte dưới dạng số nguyên. Nhưng khi bạn cố gắng in đối tượng, bạn sẽ tự động nhận được một phiên bản có thể đọc được của con người.

import humanize

disk_sizes_list = [1, 100, 999, 1000,1024, 2000,2048, 3000, 9999, 10000, 2048000000, 9990000000, 9000000000000000000000]
for size in disk_sizes_list:
    natural_size = humanize.naturalsize(size)
    binary_size = humanize.naturalsize(size, binary=True)
    print(f" {natural_size} \t| {binary_size}\t|{size}")

2

Đã trả lời ngày 17 tháng 4 năm 2012 lúc 15:47Apr 17, 2012 at 15:47

XapplexApplexApple

5,8629 Huy hiệu vàng45 Huy hiệu bạc48 Huy hiệu đồng9 gold badges45 silver badges48 bronze badges

0

Tôi thích độ chính xác cố định của phiên bản thập phân của Senderle, vì vậy đây là một loại lai với câu trả lời của Joctee ở trên (bạn có biết bạn có thể lấy nhật ký với các cơ sở không phải là số nguyên không?):

import humanize

disk_sizes_list = [1, 100, 999, 1000,1024, 2000,2048, 3000, 9999, 10000, 2048000000, 9990000000, 9000000000000000000000]
for size in disk_sizes_list:
    natural_size = humanize.naturalsize(size)
    binary_size = humanize.naturalsize(size, binary=True)
    print(f" {natural_size} \t| {binary_size}\t|{size}")

3

Đã trả lời ngày 19 tháng 7 năm 2013 lúc 19:36Jul 19, 2013 at 19:36

Làm thế nào về một lớp lót 2 đơn giản:

import humanize

disk_sizes_list = [1, 100, 999, 1000,1024, 2000,2048, 3000, 9999, 10000, 2048000000, 9990000000, 9000000000000000000000]
for size in disk_sizes_list:
    natural_size = humanize.naturalsize(size)
    binary_size = humanize.naturalsize(size, binary=True)
    print(f" {natural_size} \t| {binary_size}\t|{size}")

4

Đây là cách nó hoạt động dưới mui xe:

Tính toán log2 (FileSize)

Chia nó cho 10 để có được đơn vị gần nhất. (ví dụ: nếu kích thước là 5000 byte, đơn vị gần nhất là

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

6, vì vậy câu trả lời phải là x kib)

Trả về

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

7 cùng với đơn vị.

Tuy nhiên, nó không hoạt động nếu Tệp là 0 hoặc âm (vì nhật ký không được xác định cho các số 0 và -ve). Bạn có thể thêm kiểm tra thêm cho họ:

import humanize

disk_sizes_list = [1, 100, 999, 1000,1024, 2000,2048, 3000, 9999, 10000, 2048000000, 9990000000, 9000000000000000000000]
for size in disk_sizes_list:
    natural_size = humanize.naturalsize(size)
    binary_size = humanize.naturalsize(size, binary=True)
    print(f" {natural_size} \t| {binary_size}\t|{size}")

5

Examples:

import humanize

disk_sizes_list = [1, 100, 999, 1000,1024, 2000,2048, 3000, 9999, 10000, 2048000000, 9990000000, 9000000000000000000000]
for size in disk_sizes_list:
    natural_size = humanize.naturalsize(size)
    binary_size = humanize.naturalsize(size, binary=True)
    print(f" {natural_size} \t| {binary_size}\t|{size}")

6

Lưu ý - Có một sự khác biệt giữa KB và KIB. KB có nghĩa là 1000 byte, trong khi kib có nghĩa là 1024 byte. KB, MB, GB đều là bội số của 1000, trong khi KIB, MIB, GIB, vv đều là bội số của 1024. Thông tin thêm về nó ở đây - 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

Đã trả lời ngày 23 tháng 11 năm 2014 lúc 21:39Nov 23, 2014 at 21:39

Jerrymousejerrymousejerrymouse

16.1K16 Huy hiệu vàng72 Huy hiệu bạc90 Huy hiệu Đồng16 gold badges72 silver badges90 bronze badges

Những gì bạn sắp tìm thấy dưới đây không có nghĩa là giải pháp hiệu suất hay ngắn nhất trong số những người đã được đăng. Thay vào đó, nó tập trung vào một vấn đề cụ thể mà nhiều câu trả lời khác bỏ lỡ.one particular issue that many of the other answers miss.

Cụ thể là trường hợp khi đầu vào như

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

8 được đưa ra:

import humanize

disk_sizes_list = [1, 100, 999, 1000,1024, 2000,2048, 3000, 9999, 10000, 2048000000, 9990000000, 9000000000000000000000]
for size in disk_sizes_list:
    natural_size = humanize.naturalsize(size)
    binary_size = humanize.naturalsize(size, binary=True)
    print(f" {natural_size} \t| {binary_size}\t|{size}")

7

trong đó, bị cắt ngắn đến số nguyên gần nhất và được áp dụng trở lại đầu vào

import humanize

disk_sizes_list = [1, 100, 999, 1000,1024, 2000,2048, 3000, 9999, 10000, 2048000000, 9990000000, 9000000000000000000000]
for size in disk_sizes_list:
    natural_size = humanize.naturalsize(size)
    binary_size = humanize.naturalsize(size, binary=True)
    print(f" {natural_size} \t| {binary_size}\t|{size}")

8

Đây dường như chính xác là những gì chúng tôi mong đợi cho đến khi chúng tôi được yêu cầu kiểm soát độ chính xác đầu ra. Và đây là khi mọi thứ bắt đầu hơi khó khăn.output precision. And this is when things start to get a bit difficult.

Với độ chính xác được đặt thành 2 chữ số chúng tôi nhận được:

import humanize

disk_sizes_list = [1, 100, 999, 1000,1024, 2000,2048, 3000, 9999, 10000, 2048000000, 9990000000, 9000000000000000000000]
for size in disk_sizes_list:
    natural_size = humanize.naturalsize(size)
    binary_size = humanize.naturalsize(size, binary=True)
    print(f" {natural_size} \t| {binary_size}\t|{size}")

9

thay vì

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

9.

Làm thế nào chúng ta có thể chống lại điều đó?

Tất nhiên, chúng tôi có thể kiểm tra nó một cách rõ ràng:

 1 Byte     | 1 Byte    |1
 100 Bytes  | 100 Bytes |100
 999 Bytes  | 999 Bytes |999
 1.0 kB     | 1000 Bytes    |1000
 1.0 kB     | 1.0 KiB   |1024
 2.0 kB     | 2.0 KiB   |2000
 2.0 kB     | 2.0 KiB   |2048
 3.0 kB     | 2.9 KiB   |3000
 10.0 kB    | 9.8 KiB   |9999
 10.0 kB    | 9.8 KiB   |10000
 2.0 GB     | 1.9 GiB   |2048000000
 10.0 GB    | 9.3 GiB   |9990000000
 9.0 ZB     | 7.6 ZiB   |9000000000000000000000

0

Nhưng chúng ta có thể làm tốt hơn không? Chúng ta có thể biết cách nào mà

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

0 nên được cắt trước khi chúng ta thực hiện bước cuối cùng không?

Hóa ra chúng ta có thể.

Giả sử quy tắc làm tròn thập phân 0,5, điều kiện

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

1 ở trên chuyển thành:

dẫn đến

 1 Byte     | 1 Byte    |1
 100 Bytes  | 100 Bytes |100
 999 Bytes  | 999 Bytes |999
 1.0 kB     | 1000 Bytes    |1000
 1.0 kB     | 1.0 KiB   |1024
 2.0 kB     | 2.0 KiB   |2000
 2.0 kB     | 2.0 KiB   |2048
 3.0 kB     | 2.9 KiB   |3000
 10.0 kB    | 9.8 KiB   |9999
 10.0 kB    | 9.8 KiB   |10000
 2.0 GB     | 1.9 GiB   |2048000000
 10.0 GB    | 9.3 GiB   |9990000000
 9.0 ZB     | 7.6 ZiB   |9000000000000000000000

1

cho đi

 1 Byte     | 1 Byte    |1
 100 Bytes  | 100 Bytes |100
 999 Bytes  | 999 Bytes |999
 1.0 kB     | 1000 Bytes    |1000
 1.0 kB     | 1.0 KiB   |1024
 2.0 kB     | 2.0 KiB   |2000
 2.0 kB     | 2.0 KiB   |2048
 3.0 kB     | 2.9 KiB   |3000
 10.0 kB    | 9.8 KiB   |9999
 10.0 kB    | 9.8 KiB   |10000
 2.0 GB     | 1.9 GiB   |2048000000
 10.0 GB    | 9.3 GiB   |9990000000
 9.0 ZB     | 7.6 ZiB   |9000000000000000000000

2

Đã trả lời ngày 14 tháng 4 năm 2019 lúc 22:57Apr 14, 2019 at 22:57

Ayorgoayorgoayorgo

2.6231 Huy hiệu vàng24 Huy hiệu bạc33 Huy hiệu đồng1 gold badge24 silver badges33 bronze badges

1

Để có được kích thước tệp ở dạng người có thể đọc được, tôi đã tạo chức năng này:

 1 Byte     | 1 Byte    |1
 100 Bytes  | 100 Bytes |100
 999 Bytes  | 999 Bytes |999
 1.0 kB     | 1000 Bytes    |1000
 1.0 kB     | 1.0 KiB   |1024
 2.0 kB     | 2.0 KiB   |2000
 2.0 kB     | 2.0 KiB   |2048
 3.0 kB     | 2.9 KiB   |3000
 10.0 kB    | 9.8 KiB   |9999
 10.0 kB    | 9.8 KiB   |10000
 2.0 GB     | 1.9 GiB   |2048000000
 10.0 GB    | 9.3 GiB   |9990000000
 9.0 ZB     | 7.6 ZiB   |9000000000000000000000

3

 1 Byte     | 1 Byte    |1
 100 Bytes  | 100 Bytes |100
 999 Bytes  | 999 Bytes |999
 1.0 kB     | 1000 Bytes    |1000
 1.0 kB     | 1.0 KiB   |1024
 2.0 kB     | 2.0 KiB   |2000
 2.0 kB     | 2.0 KiB   |2048
 3.0 kB     | 2.9 KiB   |3000
 10.0 kB    | 9.8 KiB   |9999
 10.0 kB    | 9.8 KiB   |10000
 2.0 GB     | 1.9 GiB   |2048000000
 10.0 GB    | 9.3 GiB   |9990000000
 9.0 ZB     | 7.6 ZiB   |9000000000000000000000

4

user3840170

25.1k3 Huy hiệu vàng25 Huy hiệu bạc58 Huy hiệu Đồng3 gold badges25 silver badges58 bronze badges

Đã trả lời ngày 12 tháng 1 lúc 14:07Jan 12 at 14:07

Jak Binjak Binjak bin

1331 Huy hiệu bạc6 Huy hiệu đồng1 silver badge6 bronze badges

 1 Byte     | 1 Byte    |1
 100 Bytes  | 100 Bytes |100
 999 Bytes  | 999 Bytes |999
 1.0 kB     | 1000 Bytes    |1000
 1.0 kB     | 1.0 KiB   |1024
 2.0 kB     | 2.0 KiB   |2000
 2.0 kB     | 2.0 KiB   |2048
 3.0 kB     | 2.9 KiB   |3000
 10.0 kB    | 9.8 KiB   |9999
 10.0 kB    | 9.8 KiB   |10000
 2.0 GB     | 1.9 GiB   |2048000000
 10.0 GB    | 9.3 GiB   |9990000000
 9.0 ZB     | 7.6 ZiB   |9000000000000000000000

5

Đã trả lời ngày 2 tháng 2 năm 2010 lúc 2:29Feb 2, 2010 at 2:29

Matt tham gia tham giaMatt Joiner

108K106 Huy hiệu vàng363 Huy hiệu bạc519 Huy hiệu Đồng106 gold badges363 silver badges519 bronze badges

Tính năng này nếu có sẵn trong Boltons là một thư viện rất tiện dụng để có hầu hết các dự án.

 1 Byte     | 1 Byte    |1
 100 Bytes  | 100 Bytes |100
 999 Bytes  | 999 Bytes |999
 1.0 kB     | 1000 Bytes    |1000
 1.0 kB     | 1.0 KiB   |1024
 2.0 kB     | 2.0 KiB   |2000
 2.0 kB     | 2.0 KiB   |2048
 3.0 kB     | 2.9 KiB   |3000
 10.0 kB    | 9.8 KiB   |9999
 10.0 kB    | 9.8 KiB   |10000
 2.0 GB     | 1.9 GiB   |2048000000
 10.0 GB    | 9.3 GiB   |9990000000
 9.0 ZB     | 7.6 ZiB   |9000000000000000000000

6

Đã trả lời ngày 21 tháng 10 năm 2020 lúc 20:15Oct 21, 2020 at 20:15

cmcintycmcgintycmcginty

Huy hiệu vàng 110K4040 gold badges158 silver badges160 bronze badges

Đây là một cái gì đó tôi đã viết cho một câu hỏi khác ...

Giống như câu trả lời của Xapple, đối tượng này sẽ luôn in ở định dạng có thể đọc được của con người. Sự khác biệt là nó cũng là một

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

2 thích hợp, vì vậy bạn có thể làm toán với nó! Nó chuyển trình xác định định dạng thẳng đến định dạng số và xử lý trên hậu tố, do đó, khá nhiều đảm bảo rằng độ dài được yêu cầu sẽ bị vượt quá hai hoặc ba ký tự. Tôi chưa bao giờ sử dụng mã này, vì vậy tôi không bận tâm để sửa nó!

 1 Byte     | 1 Byte    |1
 100 Bytes  | 100 Bytes |100
 999 Bytes  | 999 Bytes |999
 1.0 kB     | 1000 Bytes    |1000
 1.0 kB     | 1.0 KiB   |1024
 2.0 kB     | 2.0 KiB   |2000
 2.0 kB     | 2.0 KiB   |2048
 3.0 kB     | 2.9 KiB   |3000
 10.0 kB    | 9.8 KiB   |9999
 10.0 kB    | 9.8 KiB   |10000
 2.0 GB     | 1.9 GiB   |2048000000
 10.0 GB    | 9.3 GiB   |9990000000
 9.0 ZB     | 7.6 ZiB   |9000000000000000000000

7

Usage:

 1 Byte     | 1 Byte    |1
 100 Bytes  | 100 Bytes |100
 999 Bytes  | 999 Bytes |999
 1.0 kB     | 1000 Bytes    |1000
 1.0 kB     | 1.0 KiB   |1024
 2.0 kB     | 2.0 KiB   |2000
 2.0 kB     | 2.0 KiB   |2048
 3.0 kB     | 2.9 KiB   |3000
 10.0 kB    | 9.8 KiB   |9999
 10.0 kB    | 9.8 KiB   |10000
 2.0 GB     | 1.9 GiB   |2048000000
 10.0 GB    | 9.3 GiB   |9990000000
 9.0 ZB     | 7.6 ZiB   |9000000000000000000000

8

Đã trả lời ngày 17 tháng 10 lúc 22:41Oct 17 at 22:41

Terry Davisterry DavisTerry Davis

3912 Huy hiệu bạc7 Huy hiệu đồng2 silver badges7 bronze badges

Tham khảo câu trả lời của Sridhar Ratnakumar, được cập nhật đến:

 1 Byte     | 1 Byte    |1
 100 Bytes  | 100 Bytes |100
 999 Bytes  | 999 Bytes |999
 1.0 kB     | 1000 Bytes    |1000
 1.0 kB     | 1.0 KiB   |1024
 2.0 kB     | 2.0 KiB   |2000
 2.0 kB     | 2.0 KiB   |2048
 3.0 kB     | 2.9 KiB   |3000
 10.0 kB    | 9.8 KiB   |9999
 10.0 kB    | 9.8 KiB   |10000
 2.0 GB     | 1.9 GiB   |2048000000
 10.0 GB    | 9.3 GiB   |9990000000
 9.0 ZB     | 7.6 ZiB   |9000000000000000000000

9

và đầu ra ví dụ là:

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

0

Tylerh

20.3k60 Huy hiệu vàng75 Huy hiệu bạc94 Huy hiệu đồng60 gold badges75 silver badges94 bronze badges

Đã trả lời ngày 1 tháng 12 năm 2018 lúc 2:02Dec 1, 2018 at 2:02

Crifancrifancrifan

Huy hiệu vàng 11.8K11 gold badge66 silver badges49 bronze badges

Giải pháp này cũng có thể hấp dẫn bạn, tùy thuộc vào cách thức hoạt động của tâm trí bạn:

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

1

Đã trả lời ngày 21 tháng 5 năm 2019 lúc 18:51May 21, 2019 at 18:51

Peter fpeter fPeter F

7338 Huy hiệu bạc10 Huy hiệu đồng8 silver badges10 bronze badges

Tệp nào có thể đọc được trong Python?

con người có thể đọc được 0.1.0 con người có thể đọc được là một thư viện Python để chuyển đổi từ các giá trị có thể đọc được của con người sang các giá trị python. 0 humanreadable is a Python library to convert from human-readable values to Python values.

Làm thế nào lớn là một con trăn terabyte?

Một terabyte là 1012 hoặc 1, 000, 000, 000, 000 byte và được viết tắt là TB TB.10¹² or 1, 000, 000, 000, 000 bytes and is abbreviated as “TB”.

Làm thế nào để kiểm tra kích thước tệp trong GB trong Python?

Trong bài viết này, chúng tôi sẽ sử dụng ba phương thức sau của mô -đun HĐH và PATHLIB để có được kích thước tệp ...

Đầu tiên, nhập mô -đun HĐH ..

Tiếp theo, sử dụng hệ điều hành.Phương thức STAT ('File_Path') để lấy số liệu thống kê tệp ..

Cuối cùng, sử dụng thuộc tính ST_SIZE để có được kích thước tệp ..

programming python Size in Python Humanfriendly

Hướng dẫn python convert bytes to human readable - python chuyển đổi byte thành con người có thể đọc được

Tệp nào có thể đọc được trong Python?

Làm thế nào lớn là một con trăn terabyte?

Làm thế nào để kiểm tra kích thước tệp trong GB trong Python?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội