Convert Python Dictionary to a Struct: 5 Effective Methods

Python dictionaries are versatile for handling dynamic data, but there are scenarios where the mutability of dicts is not desirable or a more formal data structure with fixed fields is required. Say, you have a dictionary {"name": "Alice", "age": 30, "job": "Engineer"} and you want to convert this dictionary into a structured object, where you can access the attributes with the dot notation like an object, e.g., person.name, person.age. This article demonstrates how to transform a Python dictionary into a struct-like object using various methods.

Method 1: Using namedtuple from the collections module

Namedtuple is a factory function for creating tuple subclasses with named fields. It’s part of Python’s built-in collections module and is great for creating light-weight object types.

Here’s an example:

from collections import namedtuple

Person = namedtuple('Person', 'name age job')
person_dict = {"name": "Alice", "age": 30, "job": "Engineer"}
person = Person(**person_dict)

Output:

Person(name='Alice', age=30, job='Engineer')

This code snippet first imports namedtuple, then defines a new class Person with the fields ‘name’, ‘age’, and ‘job’. The dictionary person_dict is unpacked into the Person constructor creating an instance of the Person class with values from the dictionary.

Method 2: Using types.SimpleNamespace

The types module provides a class called SimpleNamespace that can be used to create a simple object for attribute access. It allows adding, modifying, and deleting attributes.

Here’s an example:

from types import SimpleNamespace

person_dict = {"name": "Alice", "age": 30, "job": "Engineer"}
person = SimpleNamespace(**person_dict)

Output:

namespace(name='Alice', age=30, job='Engineer')

The example shows how to create a SimpleNamespace object from a dictionary. By unpacking the dictionary with **person_dict, each key-value pair is turned into an attribute-value pair on the new SimpleNamespace object named ‘person’.

Method 3: Using a Custom Class

A custom class can be designed to take a dictionary and set its items as attributes. This method provides the greatest flexibility as additional methods and validations can be included.

Here’s an example:

class Person:
    def __init__(self, **entries):
        self.__dict__.update(entries)

person_dict = {"name": "Alice", "age": 30, "job": "Engineer"}
person = Person(**person_dict)

Output:

<Person object at 0x101935610>

The custom Person class’s constructor accepts any number of keyword arguments and then updates the object’s __dict__ with them. This effectively sets each dictionary item as an attribute of the object.

Method 4: Using the Struct class from the struct module

The struct module is not directly meant for converting dictionaries to objects, but it can be used for packing and unpacking binary data, and thus, create structured objects from dictionaries by defining a format.

Here’s an example:

import struct

class Person(struct.Struct):
    _fields_ = '30s i 30s'

person_dict = {"name": b"Alice", "age": 30, "job": b"Engineer"}
person = Person(*person_dict.values())

Output:

<Person object at 0x7ffdd84f8e20>

The code above creates a Person class that inherits from struct.Struct and defines a byte format. While it packs the dictionary values into bytes, it and is not as straightforward for object manipulation as other methods.

Bonus One-Liner Method 5: Using exec() for dynamic class definition

This method dynamically creates a new class using the exec() function. However, it should be used with caution as exec() can execute arbitrary code which might be a security risk.

Here’s an example:

person_dict = {"name": "Alice", "age": 30, "job": "Engineer"}

class_definition = "class Person: pass\n"
for key, value in person_dict.items():
    class_definition += f"Person.{key} = '{value}'\n"
exec(class_definition)

person = Person()

Output:

<Person object at 0x106c0bb50>

In this method, a class definition string is constructed dynamically by iterating over the dictionary items and adding them as class attributes. The exec() function then executes the string to create the class.

Summary/Discussion

• Method 1: Namedtuple. Lightweight and memory efficient. Limited to immutable objects.
• Method 2: SimpleNamespace. Dynamic and straightforward. Not as clear in intent as custom classes.
• Method 3: Custom Class. Highly customizable and clear object structure. Requires more code for setup.
• Method 4: Struct. Suitable for binary data representation. Not as user-friendly for typical object manipulation.
• Method 5: Dynamic Class Creation with exec(). Extremely flexible. Security risks with execution of arbitrary code.