在 Python 中解构字典和对象

Question

在 Javascript 中，我可以使用 destructuring 从一个 javascript 对象中提取我想要的属性。例如：

currentUser = {
  "id": 24,
  "name": "John Doe",
  "website": "http://mywebsite.com",
  "description": "I am an actor",
  "email": "example@example.com",
  "gender": "M",
  "phone_number": "+12345678",
  "username": "johndoe",
  "birth_date": "1991-02-23",
  "followers": 46263,
  "following": 345,
  "like": 204,
  "comments": 9
}

let { id, username } = this.currentUser;
console.log(id) // 24
console.log(username) //johndoe

对于 Python 字典和 Python 对象，我们在 Python 中有类似的东西吗？ Python对象的Python方式示例：

class User:
    def __init__(self, id, name, website, description, email, gender, phone_number, username):
        self.id = id
        self.name = name
        self.website = website
        self.description = description
        self.email = email
        self.gender = gender
        self.phone_number = phone_number
        self.username = username
  
current_user = User(24, "Jon Doe", "http://mywebsite.com", "I am an actor", "example@example.com", "M", "+12345678", "johndoe")
    
# This is a pain
id = current_user.id
email = current_user.email
gender = current_user.gender
username = current_user.username
    
print(id, email, gender, username)

写这 4 行（如上例所述）与写一行（如下所述）从对象中获取我需要的值是一个真正的痛点。

(id, email, gender, username) = current_user

Answer 1

Python 的import 功能可以重新用于以方便（尽管可能不推荐）的方式解构字典和对象：

import sys, types

mydict = {'a':1,'b':2}

sys.modules["mydict"] = types.SimpleNamespace(**mydict)

from mydict import a, b

更严重的 hack 是上下文管理器，它临时将模块添加到 sys.modules，并确保模块的 __getattr__ 方法指向对象/dict 的 __getattribute__/__getitem__ 方法问题。

我们可以这样做：

with obj_as_module(mydict, "mydict_module"):
    from mydict_module import a, b

实施：

import sys, types
from contextlib import contextmanager

@contextmanager
def obj_as_module(obj, name):
    "Temporarily load an object/dict as a module, to import its attributes/values"
    module = types.ModuleType(name)
    get = obj.__getitem__ if isinstance(obj, dict) else obj.__getattribute__
    module.__getattr__ = lambda attr: get(attr) if attr != "__path__" else None
    try:
        if name in sys.modules:
            raise Exception(f"Name '{name}' already in sys.modules")
        else:
            sys.modules[name] = module
            yield module
    finally:
        if sys.modules[name] == module:
            del sys.modules[name]

测试：

mydict = {"a": 1, "b": 2}

with obj_as_module(mydict, "mydict"):
    from mydict import a, b

assert a + b == 3, "mydict" not in sys.modules

注意我不知道这会造成多大的破坏。

这是我第一次使用导入系统，只是一个有趣的练习。但我认为import 语句允许通过名称查找内容以及将结果绑定到该名称是一个有价值的观察。

---

以下是一些可能的扩展：

关键字参数

通过使用关键字参数，我们可以节省输入字符串引号以及一次性加载多个模块：

from contextlib import ExitStack

class kwargs_as_modules(ExitStack):
    "If you like 'obj_as_module', but want to save even more typing"
    def __init__(self, **kwargs):
        super().__init__()
        for name, obj in kwargs.items():
            self.enter_context(obj_as_module(obj, name))

测试：

myobj = types.SimpleNamespace(x=1, y=2)
mydict = {"a": 1, "b": 2}

with kwargs_as_modules(myobj=myobj, mydict=mydict):
    from mydict import a, b
    from myobj import x, y

assert a == x, b == y

类装饰器

为了处理类，我们可以使用装饰器：

def self_as_module(cls):
    "For those who like to write selfless methods"
    cls.as_module = lambda self: obj_as_module(self, "self")
    return cls

允许我们写self.as_module()：

@self_as_module
class MyClass:
    def __init__(self):
        self.a = 1
        self.b = 2

    def check(self):
        with self.as_module():
            from self import a, b
        assert a + b == 3

MyClass().check()

Answer 2

通过这种方式，JavaScript 比 Python 拥有更好的对象域。您也可以构建一个方法或函数来复制功能，但 JavaScript 很容易做到。

Python 上类似的东西可能是应用于字典（JSON 对象）的“打包/解包”功能。

您可以在互联网上找到相关文档： https://www.geeksforgeeks.org/packing-and-unpacking-arguments-in-python/

Answer 3

您可以使用.values() 方法解压并提取属性：

 currentUser = {
  "id": 24,
  "name": "John Doe",
  "website": "http://mywebsite.com",
  "description": "I am an actor",
  "email": "example@example.com",
  "gender": "M",
  "phone_number": "+12345678",
  "username": "johndoe",
  "birth_date": "1991-02-23",
  "followers": 46263,
  "following": 345,
  "like": 204,
  "comments": 9
}

id, _, _, _, _, _, _, username, *other = currentUser.values()

print('distructuring:', { 'id': id, 'username': username })

Answer 4

基于其他答案，我建议还使用 Python 的 dataclasses 并使用 __getitem__ 获取特定字段：

from dataclasses import astuple, dataclass

@dataclass
class User:
    id: int
    name: str
    website: str
    description: str
    email: str
    gender: str
    phone_number: str
    username: str
    
    def __iter__(self):
        return iter(astuple(self))
    
    def __getitem__(self, keys):
        return iter(getattr(self, k) for k in keys)
        

current_user = User(id=24, name="Jon Doe", website="http://mywebsite.com", description="I am an actor", email="example@example.com", gender="M", phone_number="+12345678", username="johndoe")

# Access fields sequentially:
id, _, email, *_ = current_user
# Access fields out of order:
id, email, gender, username = current_user["id", "email", "gender", "username"]

Answer 5

您可以使用标准库中的operator 模块，如下所示：

from operator import attrgetter
id, email, gender, username = attrgetter('id', 'email', 'gender', 'username')(current_user)
print(id, email, gender, username)

如果你有一个像你的例子一样的字典

currentUser = {
  "id": 24,
  "name": "John Doe",
  "website": "http://mywebsite.com",
  "description": "I am an actor",
  "email": "example@example.com",
  "gender": "M",
  "phone_number": "+12345678",
  "username": "johndoe",
  "birth_date": "1991-02-23",
  "followers": 46263,
  "following": 345,
  "like": 204,
  "comments": 9
}

只需使用itemgetter 而不是attrgetter：

from operator import itemgetter
id, email, gender, username = itemgetter('id', 'email', 'gender', 'username')(currentUser)
print(id, email, gender, username)

Answer 6

首先不要把论点弄平。当您像使用 User 那样编写一个 8 元函数时，您肯定会犯错误，例如以错误的顺序传递参数。

以下哪项会产生您想要的用户？

1. User(24, "Jon Doe", "http://mywebsite.com", "I am an actor", "example@example.com", "M", "+12345678", "johndoe")
2. User(24, "Jon Doe", "http://mywebsite.com", "I am an actor", "example@example.com", "+12345678", "M", "johndoe")

不可能知道！如果你的函数需要一个描述符，你就没有这个问题 -

class User:
  def __init__ (self, desc = {}):
    self.desc = desc # whitelist items, if necessary
  
  def __str__ (self):
    # invent our own "destructuring" syntax
    [ name, age, gender ] = \
      destructure(self.desc, 'name', 'age', 'gender')

    return f"{name} ({gender}) is {age} years old"

# create users with a "descriptor"
u = User({ 'age': 2, 'gender': 'M' })
v = User({ 'gender': 'F', 'age': 3 })
x = User({ 'gender': 'F', 'name': 'Alice', 'age': 4 })

print(u) # None (M) is 2 years old
print(v) # None (F) is 3 years old
print(x) # Alice (F) is 4 years old

我们可以将自己的destructure定义为-

def destructure (d, *keys):
  return [ d[k] if k in d else None for k in keys ]

这仍然可能导致长链，但顺序取决于调用者，因此它不像原始问题中的 8 元函数那样脆弱 -

[ name, age, gender ] = \
  destructure(self.desc, 'name', 'age', 'gender')

# works the same as

[ gender, name, age ] = \
  destructure(self.desc, 'gender', 'name', 'age')

---

另一种选择是使用关键字参数 -

class User:
  def __init__ (self, **desc):
    self.desc = desc # whitelist items, if necessary

  def __str__ (self):
    [ name, age, gender ] = \
      destructure(self.desc, 'name', 'age', 'gender')

    return f"{name} ({gender}) is {age} years old"

# create users with keyword arguments
u = User(age = 2, gender = 'M')
v = User(gender = 'F', age = 3)
x = User(gender = 'F', name = 'Alice', age = 4)

print(u) # None (M) is 2 years old
print(v) # None (F) is 3 years old
print(x) # Alice (F) is 4 years old

Answer 7

您可以实现__iter__ 方法来启用解包：

class User:
  def __init__(self, **data):
    self.__dict__ = data
  def __iter__(self):
    yield from [getattr(self, i) for i in ('id', 'email', 'gender', 'username')]

current_user = User(**currentUser)
id, email, gender, username = current_user
print([id, email, gender, username])

输出：

[24, 'example@example.com', 'M', 'johndoe']

编辑：Python2 解决方案：

class User:
  def __init__(self, **data):
    self.__dict__ = data
  def __iter__(self):
    for i in ('id', 'email', 'gender', 'username'):
      yield getattr(self, i)

编辑 2：

获取选择属性：

class User:
  def __init__(self, **data):
     self.__dict__ = data
  def __getattr__(self, _vals):
     yield from [getattr(self, i) for i in _vals.split('_')]

current_user = User(**currentUser)
id, email, gender, username = current_user.id_email_gender_username
id, gender = current_user.id_gender