Addressing instance name string in __init__(self) in Python.

Question

I am doing something like this:

class Class(object):
    def __init__(self):
        self.var=#new instance name string#

How do I make the __ init __ method of my instance to use the instance name string for 'c'? Say in case:

c=Class()

I want c.var equal to 'c'.

Thanks for your replies, I am implementing persistence and Class is persistent object's class. I want __ init __ to add an entry to the database when:

c=Class()

Then, suppose:

del c

Later on:

c=Class()

sholuld create an instance using data from database if there already is an entry 'c', otherwise create new entry.

Answer 1

That isn't possible. You seem to be confusing variables and objects.

In any case there may well not be a variable:

e.g.

foo(Class())

Class().arbitraryMethod()

Or multiple:

a = b = Class()

Answer 2

I am unaware of a way to access a variable's name programmatically without using deep reflection and a debugger. I do not think the information is available at runtime.

If you want to give instances a (unique?) name, you should probably make the initializer accept an extra argument.

def __init__(self, name):
    self.name = name

And the caller should pass in the appropriate name:

c = Class("c")

Answer 3

You can't (short of incredible hacks like examining the stack frame and inspecting the bytecode). There may not even be a name, or there could be multiple such names. What should be given for the following code fragments for instance:

l = [Class(), Class()]
a=b=c=d=Class()

Answer 4

I don't think this would be possible because the assignment to the variable of your new instance occours after the object is fully constructed and initialized and so you don't know the variable name it will be assigned to within init method

Answer 5

You can't do this. The reason for this is that the object of the class is created first, and only afterwards is this object bound to the name of the instance.

Answer 6

This is a scope issue, you can't do what you're asking. Because c would be declared outside your class' scope, your instance is unaware of what its been named in code.

Perhaps if you can provide a broader explanation of what you're trying to accomplish a better solution can be suggested.

Answer 7

Python doesn't have variables, it has objects and names. When you do

c = Class()

you're doing two things:

1. Creating a new object of type Class
2. Binding the object to the name c in the current scope.

The object you created doesn't have any concept of a "variable name" -- If later you do

a = c

then the same object is accessible in exactly the same way using the names a and c. You can delete the name a, and the object would still exist.

If the objects you create need to have a name, the best way is to pass it to them explicitly,

class Class(object):
    def __init__(self, name):
        self.name = name

var = Class('var')

Answer 8

Thanks for your replies, I am implementing persistence and Class is persistent object's class. I want __ init __ to add an entry to the database when:

c=Class()

Then, suppose:

del c

Later on:

c=Class()

sholuld create an instance using data from database if there already is an entry 'c', otherwise create new entry.

Answer 9

To persist data objects you need to use the database record's unique ID.

pesudo code because I don't know what database module you're using

import db # assume this is your db module

class Class(object):
    def __init__(self):
        self.id = None
        self.name = None

    def get_by_id(self, id):
        records = db.execute('select * from table where id=%s' % str(id))
        if records:
            self.id = records[0]['id']
            self.name = records[0]['name']

    def save(self):
        db.execute('update table set name=%s where id=%s' % (self.name, str(self.id)))

Again, this is pseudo code, the string injection technique I'm using is NOT advised as its fairly insecure, its just there to illustrate how to persist using classes with a db.

Answer 10

I have the same thought several years ago. This is somekind of neat feature, but the language creator doesn't provide it. And I thought they are all fool to not discover this great feature.

But then come to think about that. I think the logic is impossible. say:

class Class(object): def init(self): self.instance_name.move() # self.instance_name refer to var def move(self): print "move"

var = Class()

now if the var is an array is that possible too ?

var[0] = Class() # i think it will get confused a bit

that's what i think of, i don't think that assigning the instance into itself is possible. and in some language I just sent the instance string into the object then using eval to execute the function