Here's a utility function based on a (now-deleted) comment made by "Tiran" in a weblog discussion @Hophat Abc references in his own answer that will work in both Python 2 and 3.

Disclaimer: If you read the the linked discussion, you'll find that some folks think this is so unsafe that it should never be used (as likewise mentioned in some of the comments below). I don't agree with that assessment but feel I should at least mention that there's some debate about using it.

import _ctypes

def di(obj_id):
    """ Inverse of id() function. """
    return _ctypes.PyObj_FromPtr(obj_id)

if __name__ == '__main__':
    a = 42
    b = 'answer'
    print(di(id(a)))  # -> 42
    print(di(id(b)))  # -> answer

To simplify, when you do b = deepcopy(a), that means that nested dictionaries in b are not identical to the nested dictionaries in a, but it doesn't break the internal structure. Dictionaries accessible via different keys are still identical, and cyclical dictionaries (for example a[some_key] is a) remain cyclical.

The best way to deal with this is to make sure your dictionary doesn't have any unwanted shared references in the first place, for example by doing:

    return {
        "main_key": {
            "x": d2,
            "y": deepcopy(d2),
        }
    }

But if you don't control the way the data arrives, you could use a recursive function like this one:

def copy_tree(original):
    '''Creates a deep copy of a dictionary, but the copy will
    be a tree, so no shared references. Cyclic dictionaries will
    cause a recursion error.
    All keys, and all non-dictionary values are not copied but used
    as-is.'''
    if isinstance(original, dict):
        return {key: copy_tree(value) for key, value in original.items()}
    return original

Am I right in thinking that you want to be able to call the constructor with keyword arguments, but use the value of the variable as the argument name, rather than the variable name itself?

It can't be done with that precise syntax, but here are a couple of other syntaxes you could use:

name = 'bin'
obj = Directory(**{name: dict()})

If you're happy with that syntax, you can just use it without having to change the class (it will just work).

Another syntax, if you only want to set a single value:

name = 'bin'
obj = Directory(name, dict())

If you're happy with that syntax, you can support it by rewriting the class like this:

class Directory:
    def __init__(self, name, value):
        self.__dict__[name] = value

For Q2, __slots__ isn't what you're looking for. It lets you specify "all members of this class have the same fields" (thus avoiding the need to have a dictionary). You have a prime example of where you can't use __slots__ because all instances of your class may have different members.

You need to hold a reference to an object (i.e. assign it to a variable or store it in a list).

There is no language support for going from an object address directly to an object (i.e. pointer dereferencing).