Hướng dẫn python cast dict to class - python cast dict đến lớp

Question

Có ít nhất năm sáu cách. Cách ưa thích phụ thuộc vào trường hợp sử dụng của bạn là gì.

Nội dung chính Show

Lựa chọn 1:
Tùy chọn 1A:
Lựa chọn 2:
Tùy chọn 3:
Tùy chọn 4:
Tùy chọn 5:
Tùy chọn 6:
Bạn có thể đặt một từ điển trong một lớp python?
Bản thân __ dict __ python là gì?
Munch Python là gì?
Bạn có thể tạo một từ điển các đối tượng trong Python không?

Lựa chọn 1:

Chỉ cần thêm một phương thức

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

5.

Dựa trên mô tả vấn đề, tôi sẽ xem xét rất nhiều cách làm những việc được đề xuất bởi các câu trả lời khác. Điều này là do nó không xuất hiện rằng đối tượng của bạn thực sự là một bộ sưu tập:

class Wharrgarbl(object):

    ...

    def asdict(self):
        return {'a': self.a, 'b': self.b, 'c': self.c}

Sử dụng các tùy chọn khác dưới đây có thể gây nhầm lẫn cho người khác trừ khi chính xác chính xác các thành viên đối tượng nào sẽ và sẽ không được lặp lại hoặc được chỉ định là các cặp giá trị khóa.

Tùy chọn 1A:

Kế thừa lớp của bạn từ

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

7 (hoặc tương đương

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

8) và sử dụng phương thức

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

9 được cung cấp cho bạn.

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

Sử dụng một bộ tuple có tên là một cách rất thuận tiện để thêm nhiều chức năng cho lớp của bạn với nỗ lực tối thiểu, bao gồm cả phương thức

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

9. Tuy nhiên, một hạn chế là, như được hiển thị ở trên, NT sẽ bao gồm tất cả các thành viên trong

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

9 của nó.

Nếu có các thành viên mà bạn không muốn đưa vào từ điển của mình, bạn sẽ cần chỉ định kết quả thành viên nào bạn muốn có kết quả Tuple

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

9. Để làm điều này, bạn có thể kế thừa từ một lớp cơ sở có tênTuple bằng API

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

3 cũ hơn:

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

... Hoặc bạn có thể tạo một lớp cơ sở bằng API mới hơn và kế thừa từ đó, chỉ sử dụng các thành viên từ điển trong lớp cơ sở:

from typing import NamedTuple

class Basegarbl(NamedTuple):
    a: str
    b: str
    c: str

class Wharrgarbl(Basegarbl):
    sum: int = 6
    version: str = 'old'

Một hạn chế khác là NT chỉ đọc. Điều này có thể hoặc không thể mong muốn.

Lựa chọn 2:

Thực hiện

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

4.

Như thế này, ví dụ:

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

Bây giờ bạn chỉ có thể làm:

dict(my_object)

Điều này hoạt động vì hàm tạo

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

5 chấp nhận một cặp

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

6 để xây dựng một từ điển. Trước khi làm điều này, hãy tự đặt câu hỏi liệu việc lặp lại đối tượng như một loạt các khóa, giá trị theo cách này- trong khi thuận tiện để tạo ra một hành vi thực sự đáng ngạc nhiên trong các bối cảnh khác. Ví dụ: tự hỏi mình câu hỏi "Hành vi của

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

8 nên là gì ...?"

Ngoài ra, lưu ý rằng việc truy cập các giá trị trực tiếp bằng cách sử dụng Cú pháp GET

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

9 sẽ không hoạt động và đối số từ khóa Giải nén sẽ không hoạt động. Đối với những người đó, bạn cần phải thực hiện giao thức ánh xạ.

Tùy chọn 3:

Thực hiện giao thức ánh xạ. Điều này cho phép hành vi truy cập bằng phím, đúc lên

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

7 mà không cần sử dụng

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

4 và cũng cung cấp hai loại hành vi giải nén:

Ánh xạ hành vi giải nén:

from typing import NamedTuple

class Basegarbl(NamedTuple):
    a: str
    b: str
    c: str

class Wharrgarbl(Basegarbl):
    sum: int = 6
    version: str = 'old'

2

Từ khóa hành vi giải nén, nhưng chỉ khi tất cả các khóa là chuỗi:

from typing import NamedTuple

class Basegarbl(NamedTuple):
    a: str
    b: str
    c: str

class Wharrgarbl(Basegarbl):
    sum: int = 6
    version: str = 'old'

3

Giao thức ánh xạ yêu cầu bạn cung cấp (tối thiểu) hai phương pháp cùng nhau:

from typing import NamedTuple

class Basegarbl(NamedTuple):
    a: str
    b: str
    c: str

class Wharrgarbl(Basegarbl):
    sum: int = 6
    version: str = 'old'

4 và

from typing import NamedTuple

class Basegarbl(NamedTuple):
    a: str
    b: str
    c: str

class Wharrgarbl(Basegarbl):
    sum: int = 6
    version: str = 'old'

5.

class MyKwargUnpackable:
    def keys(self):
        return list("abc")
    def __getitem__(self, key):
        return dict(zip("abc", "one two three".split()))[key]

Bây giờ bạn có thể làm những việc như:

>>> m=MyKwargUnpackable()
>>> m["a"]
'one'
>>> dict(m)  # cast to dict directly
{'a': 'one', 'b': 'two', 'c': 'three'}
>>> dict(**m)  # unpack as kwargs
{'a': 'one', 'b': 'two', 'c': 'three'}

Như đã đề cập ở trên, nếu bạn đang sử dụng một phiên bản Python đủ mới, bạn cũng có thể giải nén đối tượng bản đồ của mình thành một sự hiểu biết từ điển như vậy (và trong trường hợp này không bắt buộc là các khóa của bạn là chuỗi):

>>> {**m}
{'a': 'one', 'b': 'two', 'c': 'three'}

Lưu ý rằng giao thức ánh xạ được ưu tiên hơn phương thức

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

4 khi chuyển một đối tượng lên trực tiếp

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

7 (mà không sử dụng việc giải nén kwarg, tức là

from typing import NamedTuple

class Basegarbl(NamedTuple):
    a: str
    b: str
    c: str

class Wharrgarbl(Basegarbl):
    sum: int = 6
    version: str = 'old'

8). Vì vậy, có thể- và đôi khi có thể thuận tiện- để khiến đối tượng có hành vi khác nhau khi được sử dụng như một điều đáng kể (ví dụ:

from typing import NamedTuple

class Basegarbl(NamedTuple):
    a: str
    b: str
    c: str

class Wharrgarbl(Basegarbl):
    sum: int = 6
    version: str = 'old'

9) so với khi được đúc đến

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

7 (

from typing import NamedTuple

class Basegarbl(NamedTuple):
    a: str
    b: str
    c: str

class Wharrgarbl(Basegarbl):
    sum: int = 6
    version: str = 'old'

8).

Nhưng cũng lưu ý rằng với các từ điển thông thường, nếu bạn chọn vào một danh sách, nó sẽ trả lại các phím, chứ không phải các giá trị như bạn yêu cầu. Nếu bạn thực hiện một hành vi phi tiêu chuẩn khác cho

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

4 (trả về giá trị thay vì các khóa), có thể đáng ngạc nhiên cho người khác sử dụng mã của bạn trừ khi điều đó rất rõ ràng tại sao điều này sẽ xảy ra.

Nhấn mạnh: Chỉ vì bạn có thể sử dụng giao thức ánh xạ, không có nghĩa là bạn nên làm như vậy. Liệu nó có thực sự có ý nghĩa đối với đối tượng của bạn được truyền xung quanh như một tập hợp các cặp giá trị khóa, hoặc là đối số và giá trị từ khóa? Có phải truy cập nó bằng khóa- giống như một từ điển- thực sự có ý nghĩa? Bạn cũng có thể mong đợi đối tượng của mình có các phương pháp ánh xạ tiêu chuẩn khác như

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

3,
def __iter__(self): yield 'a', self.a yield 'b', self.b yield 'c', self.c
4,
def __iter__(self): yield 'a', self.a yield 'b', self.b yield 'c', self.c
5 không? Bạn có muốn hỗ trợ kiểm tra từ khóa và bình đẳng
def __iter__(self): yield 'a', self.a yield 'b', self.b yield 'c', self.c
6 (
def __iter__(self): yield 'a', self.a yield 'b', self.b yield 'c', self.c
7) không?: Just because you CAN use the mapping protocol, does NOT mean that you SHOULD do so. Does it actually make sense for your object to be passed around as a set of key-value pairs, or as keyword arguments and values? Does accessing it by key- just like a dictionary- really make sense? Would you also expect your object to have other standard mapping methods such as

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

3,

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

4,

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

5? Do you want to support the

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

6 keyword and equality checks (

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

7)?

Nếu câu trả lời cho những câu hỏi này là có, có lẽ không nên dừng lại ở đây và thay vào đó hãy xem xét tùy chọn tiếp theo.

Tùy chọn 4:

Nhìn vào bằng cách sử dụng mô -đun

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

8 '.

Kế thừa lớp của bạn từ tín hiệu

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

9 hoặc

dict(my_object)

0 cho người dùng khác, với tất cả ý định và mục đích, lớp của bạn là một bản đồ * và có thể được dự kiến sẽ hành xử theo cách đó. Nó cũng cung cấp các phương thức

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

3,

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

4,

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

5 và hỗ trợ kiểm tra từ khóa và bình đẳng

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

6 (

def __iter__(self):
    yield 'a', self.a
    yield 'b', self.b
    yield 'c', self.c

7) "miễn phí".

Bạn vẫn có thể chuyển đối tượng của mình lên

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

7 giống như bạn yêu cầu, nhưng có lẽ sẽ có rất ít lý do để làm như vậy. Vì việc gõ vịt, bận tâm đến việc đúc đối tượng ánh xạ của bạn đến

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

7 sẽ chỉ là một bước không cần thiết trong phần lớn thời gian.

Câu trả lời này từ tôi về cách sử dụng

dict(my_object)

8s cũng có thể hữu ích.

Như đã lưu ý trong các ý kiến dưới đây: Điều đáng nói là thực hiện việc này theo cách ABC về cơ bản biến lớp đối tượng của bạn thành một lớp giống như ____ 27 (giả sử bạn sử dụng

class MyKwargUnpackable:
    def keys(self):
        return list("abc")
    def __getitem__(self, key):
        return dict(zip("abc", "one two three".split()))[key]

0 chứ không phải lớp cơ sở

class MyKwargUnpackable:
    def keys(self):
        return list("abc")
    def __getitem__(self, key):
        return dict(zip("abc", "one two three".split()))[key]

1 chỉ đọc). Tất cả mọi thứ bạn có thể làm với

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

7, bạn có thể làm với đối tượng lớp của riêng bạn. Điều này có thể, hoặc có thể không, mong muốn.

Cũng xem xét việc xem xét các ABC số trong mô -đun

class MyKwargUnpackable:
    def keys(self):
        return list("abc")
    def __getitem__(self, key):
        return dict(zip("abc", "one two three".split()))[key]

3:

https://docs.python.org/3/library/numbers.html

Vì bạn cũng đang chuyển đối tượng của mình lên

class MyKwargUnpackable:
    def keys(self):
        return list("abc")
    def __getitem__(self, key):
        return dict(zip("abc", "one two three".split()))[key]

4, nên về cơ bản, việc biến lớp học của bạn thành một

class MyKwargUnpackable:
    def keys(self):
        return list("abc")
    def __getitem__(self, key):
        return dict(zip("abc", "one two three".split()))[key]

4 có thể có ý nghĩa hơn để đúc không cần thiết.

Tùy chọn 5:

Nhìn vào sử dụng mô -đun

class MyKwargUnpackable:
    def keys(self):
        return list("abc")
    def __getitem__(self, key):
        return dict(zip("abc", "one two three".split()))[key]

6 (chỉ Python 3.7+), bao gồm phương pháp tiện ích

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

5 thuận tiện.

from dataclasses import dataclass, asdict, field, InitVar

@dataclass
class Wharrgarbl(object):
    a: int
    b: int
    c: int
    sum: InitVar[int]  # note: InitVar will exclude this from the dict
    version: InitVar[str] = "old"

    def __post_init__(self, sum, version):
        self.sum = 6  # this looks like an OP mistake?
        self.version = str(version)

Bây giờ bạn có thể làm điều này:

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

0

Tùy chọn 6:

Sử dụng

class MyKwargUnpackable:
    def keys(self):
        return list("abc")
    def __getitem__(self, key):
        return dict(zip("abc", "one two three".split()))[key]

8, đã được thêm vào trong Python 3.8.

Lưu ý: Tùy chọn 6 có thể không phải là những gì OP, hoặc các độc giả khác dựa trên tiêu đề của câu hỏi này, đang tìm kiếm. Xem thêm bình luận dưới đây.NOT what the OP, or other readers based on the title of this question, are looking for. See additional comments below.

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

1

Sử dụng tùy chọn này, đối tượng kết quả là

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

7 (nhấn mạnh: nó không phải là

>>> m=MyKwargUnpackable()
>>> m["a"]
'one'
>>> dict(m)  # cast to dict directly
{'a': 'one', 'b': 'two', 'c': 'three'}
>>> dict(**m)  # unpack as kwargs
{'a': 'one', 'b': 'two', 'c': 'three'}

0). Không có lý do gì để "đúc" nó theo một dict (trừ khi bạn đang tạo một bản sao).

Và vì đối tượng là

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

7, chữ ký khởi tạo giống hệt với

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

7 và do đó, nó chỉ chấp nhận các đối số từ khóa hoặc từ điển khác.

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

2

Nhấn mạnh: "lớp" "trên

>>> m=MyKwargUnpackable()
>>> m["a"]
'one'
>>> dict(m)  # cast to dict directly
{'a': 'one', 'b': 'two', 'c': 'three'}
>>> dict(**m)  # unpack as kwargs
{'a': 'one', 'b': 'two', 'c': 'three'}

0 thực sự hoàn toàn không phải là một lớp mới. Nó chỉ đơn giản là đường cú pháp để tạo các đối tượng

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

7 được đánh máy chỉ với các khóa cụ thể và các trường giá trị của các loại khác nhau cho trình kiểm tra loại. Vào thời điểm chạy, nó vẫn không có gì khác hơn là

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

7.

Vì vậy, tùy chọn này có thể khá thuận tiện để báo hiệu cho người đọc mã của bạn (và cũng với trình kiểm tra loại như MyPy) rằng đối tượng

from collections import namedtuple as nt

class Wharrgarbl(nt("Basegarble", "a b c")):
    # note that the typing info below isn't needed for the old API
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

7 như vậy dự kiến sẽ có các khóa cụ thể với các loại giá trị cụ thể.

Nhưng điều này có nghĩa là bạn không thể, ví dụ, thêm các phương thức khác, mặc dù bạn có thể thử:

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

3

... Nhưng nó sẽ không hoạt động:

from typing import NamedTuple

class Wharrgarbl(NamedTuple):
    a: str
    b: str
    c: str
    sum: int = 6
    version: str = 'old'

4

* "Ánh xạ" đã trở thành "Tên" tiêu chuẩn của loại vịt giống như ____ 27

Bạn có thể đặt một từ điển trong một lớp python?

Nếu bạn muốn sử dụng từ điển trên toàn cầu trong một lớp, thì bạn cần xác định nó trong phần nơi bạn sử dụng lớp của mình.Nếu bạn đang sử dụng lớp học của mình trong chính, thì hãy xác định nó ở đó.Một danh sách từ điển hoặc o là toàn cầu theo mặc định.Cửa hàng lớp: ...you need to define it in section where you use your class. if you are using your class in main, then define it there. A dictionary or o list are global by default. class Store: ...

Bản thân dict python là gì?

__dict__ trong Python đại diện cho một từ điển hoặc bất kỳ đối tượng ánh xạ nào được sử dụng để lưu trữ các thuộc tính của đối tượng.Chúng còn được gọi là các đối tượng lập bản đồ.represents a dictionary or any mapping object that is used to store the attributes of the object. They are also known as mappingproxy objects.

Munch Python là gì?

Một munch là một từ điển Python cung cấp quyền truy cập kiểu thuộc tính (một đối tượng LA JavaScript).github.com/infinidat/munch.a Python dictionary that provides attribute-style access (a la JavaScript objects). github.com/Infinidat/munch.

Bạn có thể tạo một từ điển các đối tượng trong Python không?

Tất cả các đối tượng trong Python có một thuộc tính __dict__, là một đối tượng từ điển chứa tất cả các thuộc tính được xác định cho chính đối tượng đó.Việc ánh xạ các thuộc tính với các giá trị của nó được thực hiện để tạo ra một từ điển.The mapping of attributes with its values is done to generate a dictionary.

programming python Python dict __Dict__ Python