Hướng dẫn how many bytes is a dictionary in python? - bao nhiêu byte là một từ điển trong python?

Mới! Lưu câu hỏi hoặc câu trả lời và sắp xếp nội dung yêu thích của bạn. Tìm hiểu thêm.
Learn more.

Cách tính thủ công kích thước của từ điển [số byte mà nó chiếm trong bộ nhớ]. Tôi đọc rằng ban đầu nó là 280 byte, ở khóa thứ 6, nó tăng lên và sau đó ở vị trí thứ 86. Tôi muốn tính toán kích thước nó sẽ chiếm khi tôi có hơn 10000 phím.

hỏi ngày 29 tháng 7 năm 2017 lúc 20:21Jul 29, 2017 at 20:21

from itertools import zip_longest
dct = dict[zip_longest[range[N], [], fillvalue=None]]
# {0: None, 1: None, 2: None, ....}

2 sẽ giúp trong trường hợp đó:

from sys import getsizeof

dct = {'a': 5, 'b': 7}

print[getsizeof[dct]]

Đặc biệt đối với từ điển, kích thước sẽ phụ thuộc vào phiên bản Python của bạn [việc triển khai đã thay đổi gần đây].

Một cách nhanh chóng để tạo từ điển ____ 13 có kích thước là:

from itertools import zip_longest
dct = dict[zip_longest[range[N], [], fillvalue=None]]
# {0: None, 1: None, 2: None, ....}

Điều này sẽ giúp kiểm tra các giả định của bạn cho phiên bản Python cụ thể của bạn.

Câu hỏi này có thể liên quan.

Đã trả lời ngày 29 tháng 7 năm 2017 lúc 20:28Jul 29, 2017 at 20:28

Nhân vật chính Hirohiro protagonist

42.1K13 Huy hiệu vàng81 Huy hiệu bạc103 Huy hiệu đồng13 gold badges81 silver badges103 bronze badges

from itertools import zip_longest
dct = dict[zip_longest[range[N], [], fillvalue=None]]
# {0: None, 1: None, 2: None, ....}

2 không hoạt động với Dict lồng nhau, như thể hiện trong ví dụ Guble.

>>> import sys
>>> d = { "onj1": {"name":"object 01", "id": "123"},"onj2": {"name":"object 02", "id": "124"}}
>>> d0 = {}
>>> sys.getsizeof[d0]
240
>>> sys.getsizeof[d]
240

Vì vậy, giải pháp được tìm thấy là chức năng được cung cấp bởi trang web này: bài hoặc github

Thực hiện theo chức năng:

import sys

def get_size[obj, seen=None]:
    """Recursively finds size of objects"""
    size = sys.getsizeof[obj]
    if seen is None:
        seen = set[]
    obj_id = id[obj]
    if obj_id in seen:
        return 0
    # Important mark as seen *before* entering recursion to gracefully handle
    # self-referential objects
    seen.add[obj_id]
    if isinstance[obj, dict]:
        size += sum[[get_size[v, seen] for v in obj.values[]]]
        size += sum[[get_size[k, seen] for k in obj.keys[]]]
    elif hasattr[obj, '__dict__']:
        size += get_size[obj.__dict__, seen]
    elif hasattr[obj, '__iter__'] and not isinstance[obj, [str, bytes, bytearray]]:
        size += sum[[get_size[i, seen] for i in obj]]
    return size

Đã trả lời ngày 8 tháng 9 năm 2020 lúc 20:09Sep 8, 2020 at 20:09

DevbushdevbushDevBush

1931 Huy hiệu vàng2 Huy hiệu bạc10 Huy hiệu đồng1 gold badge2 silver badges10 bronze badges

Bạn có thể kiểm tra nhanh với

from itertools import zip_longest
dct = dict[zip_longest[range[N], [], fillvalue=None]]
# {0: None, 1: None, 2: None, ....}

5 [nó sẽ trả về kích thước của một đối tượng trong byte]:

>>> import sys, itertools
>>> sys.getsizeof[dict[zip[range[1], itertools.cycle[[1]]]]]
280
>>> sys.getsizeof[dict[zip[range[5], itertools.cycle[[1]]]]]
280
>>> sys.getsizeof[dict[zip[range[6], itertools.cycle[[1]]]]]
1048
>>> sys.getsizeof[dict[zip[range[85], itertools.cycle[[1]]]]]
3352
>>> sys.getsizeof[dict[zip[range[86], itertools.cycle[[1]]]]]
12568
>>> sys.getsizeof[dict[zip[range[87], itertools.cycle[[1]]]]]
12568
>>> sys.getsizeof[dict[zip[range[10000], itertools.cycle[[1]]]]]
786712

Nếu bạn quan tâm đến các hoạt động bên trong thực tế của từ điển Python,

from itertools import zip_longest
dct = dict[zip_longest[range[N], [], fillvalue=None]]
# {0: None, 1: None, 2: None, ....}

6 là tài nguyên dứt khoát [ở đây cho nhánh Python 3.6 mới nhất]. Ngoài ra, hãy xem

from itertools import zip_longest
dct = dict[zip_longest[range[N], [], fillvalue=None]]
# {0: None, 1: None, 2: None, ....}

Đã trả lời ngày 29 tháng 7 năm 2017 lúc 20:28Jul 29, 2017 at 20:28

Nhân vật chính Hirorandomir

42.1K13 Huy hiệu vàng81 Huy hiệu bạc103 Huy hiệu đồng1 gold badge39 silver badges54 bronze badges

from itertools import zip_longest
dct = dict[zip_longest[range[N], [], fillvalue=None]]
# {0: None, 1: None, 2: None, ....}

2 không hoạt động với Dict lồng nhau, như thể hiện trong ví dụ Guble.

Vì vậy, giải pháp được tìm thấy là chức năng được cung cấp bởi trang web này: bài hoặc githubJul 29, 2017 at 20:29

Thực hiện theo chức năng:Hariom Singh

Đã trả lời ngày 8 tháng 9 năm 2020 lúc 20:095 gold badges26 silver badges50 bronze badges

Giới thiệu

Trong bài viết này, chúng ta sẽ xem xét cách tìm kích thước của một từ điển trong Python.

Kích thước từ điển có thể có nghĩa là chiều dài của nó, hoặc không gian nó chiếm trong bộ nhớ. Để tìm số lượng các phần tử được lưu trữ trong từ điển, chúng ta có thể sử dụng hàm

from itertools import zip_longest
dct = dict[zip_longest[range[N], [], fillvalue=None]]
# {0: None, 1: None, 2: None, ....}

Để tìm kích thước của một từ điển trong byte, chúng ta có thể sử dụng hàm

>>> import sys
>>> d = { "onj1": {"name":"object 01", "id": "123"},"onj2": {"name":"object 02", "id": "124"}}
>>> d0 = {}
>>> sys.getsizeof[d0]
240
>>> sys.getsizeof[d]
240

0 của mô -đun

>>> import sys
>>> d = { "onj1": {"name":"object 01", "id": "123"},"onj2": {"name":"object 02", "id": "124"}}
>>> d0 = {}
>>> sys.getsizeof[d0]
240
>>> sys.getsizeof[d]
240

Để đếm các yếu tố của từ điển lồng nhau, chúng ta có thể sử dụng hàm đệ quy.

Tìm kích thước của từ điển

Hàm

from itertools import zip_longest
dct = dict[zip_longest[range[N], [], fillvalue=None]]
# {0: None, 1: None, 2: None, ....}

9 được sử dụng rộng rãi để xác định kích thước của các đối tượng trong Python. Trong trường hợp của chúng tôi, việc chuyển một đối tượng từ điển cho hàm này sẽ trả về kích thước của từ điển, tức là số lượng các cặp giá trị khóa có trong từ điển.

Bởi vì các đối tượng này theo dõi độ dài của chúng, hoạt động này có độ phức tạp thời gian O [1]:

my_dict = {1: "a", 2: "b"}
print["The length of the dictionary is {}".format[len[my_dict]]]

Đoạn trích trên trả về đầu ra này:

The length of the dictionary is 2

Tìm kích thước của từ điển trong byte

Kích thước bộ nhớ của đối tượng từ điển trong byte có thể được xác định bởi hàm

>>> import sys
>>> d = { "onj1": {"name":"object 01", "id": "123"},"onj2": {"name":"object 02", "id": "124"}}
>>> d0 = {}
>>> sys.getsizeof[d0]
240
>>> sys.getsizeof[d]
240

0. Hàm này có sẵn từ mô -đun

>>> import sys
>>> d = { "onj1": {"name":"object 01", "id": "123"},"onj2": {"name":"object 02", "id": "124"}}
>>> d0 = {}
>>> sys.getsizeof[d0]
240
>>> sys.getsizeof[d]
240

1. Giống như

from itertools import zip_longest
dct = dict[zip_longest[range[N], [], fillvalue=None]]
# {0: None, 1: None, 2: None, ....}

9, nó có thể được sử dụng để tìm kích thước của bất kỳ đối tượng Python nào.

Điều này đặc biệt hữu ích khi chúng ta cần mã cần phải thực hiện và/hoặc yêu cầu giám sát thường xuyên. Hãy lấy ví dụ trước của chúng tôi và có được kích thước từ điển tính bằng byte thay vì số lượng các phần tử:

import sys

my_dict = {1: "a", 2: "b"}
print["The size of the dictionary is {} bytes".format[sys.getsizeof[my_dict]]]

Đầu ra kết quả là:

The size of the dictionary is 232 bytes

Tìm kích thước của từ điển lồng nhau

Một từ điển lồng nhau là một từ điển bên trong một từ điển, hoặc một từ điển với nhiều cấp độ của các cặp giá trị khóa. Những từ điển lồng nhau này giúp đơn giản hóa các cấu trúc phức tạp như phản hồi JSON từ API.

Chúng trông một cái gì đó dọc theo dòng của:

{"dict1": {"dict2": "value 1"}}

Sử dụng

from itertools import zip_longest
dct = dict[zip_longest[range[N], [], fillvalue=None]]
# {0: None, 1: None, 2: None, ....}

9 để có được số lượng của tất cả các cặp có giá trị khóa sẽ không hoạt động vì nó chỉ cung cấp kích thước của đối tượng cho cấp độ đầu tiên của các phím. Để tìm số lượng của tất cả các khóa lồng nhau, chúng ta có thể viết một hàm đệ quy tùy chỉnh để đếm các khóa. Hàm này sẽ lấy một từ điển và một bộ đếm làm đối số và lặp lại thông qua từng khóa.

Đối với mỗi lần lặp, chức năng kiểm tra xem ví dụ của khóa được xem xét là từ điển. Nếu đó là sự thật, hàm được gọi lại một lần nữa bằng cách nối lại biến bộ đếm vào

>>> import sys
>>> d = { "onj1": {"name":"object 01", "id": "123"},"onj2": {"name":"object 02", "id": "124"}}
>>> d0 = {}
>>> sys.getsizeof[d0]
240
>>> sys.getsizeof[d]
240

7 và truyền từ điển theo đánh giá làm đối số.

Hàm đệ quy này thoát ra khi lặp hoàn chỉnh, trả về độ dài của từ điển là biến:

>>> import sys
>>> d = { "onj1": {"name":"object 01", "id": "123"},"onj2": {"name":"object 02", "id": "124"}}
>>> d0 = {}
>>> sys.getsizeof[d0]
240
>>> sys.getsizeof[d]
240

Kiểm tra hướng dẫn thực hành của chúng tôi, thực tế để học Git, với các thực hành tốt nhất, các tiêu chuẩn được công nghiệp chấp nhận và bao gồm bảng gian lận. Ngừng các lệnh git googling và thực sự tìm hiểu nó!

Nếu khóa không phải là một thể hiện từ điển, bộ đếm chỉ được thêm vào

>>> import sys
>>> d = { "onj1": {"name":"object 01", "id": "123"},"onj2": {"name":"object 02", "id": "124"}}
>>> d0 = {}
>>> sys.getsizeof[d0]
240
>>> sys.getsizeof[d]
240

7. Hàm trả về giá trị

>>> import sys
>>> d = { "onj1": {"name":"object 01", "id": "123"},"onj2": {"name":"object 02", "id": "124"}}
>>> d0 = {}
>>> sys.getsizeof[d0]
240
>>> sys.getsizeof[d]
240

8 do kết quả của phép lặp mang lại kích thước của từ điển đang được đánh giá.

Do đó, số lượng của các phím lồng nhau được đánh giá bằng cách sử dụng chức năng này như được hiển thị bên dưới:

from itertools import zip_longest
dct = dict[zip_longest[range[N], [], fillvalue=None]]
# {0: None, 1: None, 2: None, ....}

Và khi đoạn trích được thực thi, chúng tôi sẽ nhận được đầu ra sau tương ứng với số lượng khóa có trong từ điển:

from itertools import zip_longest
dct = dict[zip_longest[range[N], [], fillvalue=None]]
# {0: None, 1: None, 2: None, ....}

Sự kết luận

Trong bài viết này, chúng tôi đã khám phá các phương pháp để tính toán kích thước và độ dài của từ điển và từ điển lồng nhau.

Các chức năng này có thể rất hữu ích trong việc phục vụ các đối tượng JSON trên API: có những giới hạn được áp đặt bởi các máy chủ cho kích thước của các đối tượng JSON được phục vụ trên API và các chức năng này có thể được sử dụng để kiểm tra độ dài và kích thước.

Kích thước của một từ điển trong Python là gì?

Kích thước từ điển có thể có nghĩa là chiều dài của nó, hoặc không gian nó chiếm trong bộ nhớ. Để tìm số lượng các phần tử được lưu trữ trong từ điển, chúng ta có thể sử dụng hàm Len []. Để tìm kích thước của một từ điển trong byte, chúng ta có thể sử dụng hàm getSizeof [] của mô -đun SYS.its length, or space it occupies in memory. To find the number of elements stored in a dictionary we can use the len[] function. To find the size of a dictionary in bytes we can use the getsizeof[] function of the sys module.

Bao nhiêu bộ nhớ là một từ điển Python?

Nói cách khác, từ điển của chúng tôi, không có gì trong đó, tiêu thụ 240 byte.Không tệ;Với tần suất từ điển được sử dụng trong Python, thật tốt khi biết rằng chúng thường không tiêu thụ nhiều bộ nhớ đó.240 bytes. Not bad; given how often dictionaries are used in Python, it's good to know that they don't normally consume that much memory.

Có giới hạn kích thước trên từ điển Python không?

Nó sẽ không hiển thị đầu ra vì máy tính hết bộ nhớ trước khi đạt 2^27.Vì vậy, không có giới hạn kích thước trong từ điển.there is no size limitation in the dictionary.

Làm thế nào là một từ điển Python được lưu trữ trong bộ nhớ?

Từ điển được lưu trữ trong bộ nhớ dưới dạng bảng băm với một mảng phạm vi được đặt hàng và các giá trị tương ứng của chúng.Khóa từ điển có loại UInt64.Phương pháp lưu trữ này hoạt động giống như băm và cho phép sử dụng các phạm vi ngày/giờ [loại số tùy ý] ngoài khóa.in the form of a hash table with an ordered array of ranges and their corresponding values. The dictionary key has the UInt64 type. This storage method works the same way as hashed and allows using date/time [arbitrary numeric type] ranges in addition to the key.

Giới thiệu

Tìm kích thước của từ điển

Tìm kích thước của từ điển trong byte

Tìm kích thước của từ điển lồng nhau

Sự kết luận

Kích thước của một từ điển trong Python là gì?

Bao nhiêu bộ nhớ là một từ điển Python?

Có giới hạn kích thước trên từ điển Python không?

Làm thế nào là một từ điển Python được lưu trữ trong bộ nhớ?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề