468,252 Members | 1,475 Online
Bytes | Developer Community
New Post

Home Posts Topics Members FAQ

Post your question to a community of 468,252 developers. It's quick & easy.

Class definition within function

Hi,

With the following function definition, is it possible to
create an instance of class C outside the function f (and if
it is, how)? And yes, I think this is one of those times
when the real question is why :)
>>def f():
class C(object):
def __init__(self):
self.a = 'a'
return C()
>>x = f()
x.a
'a'
>>y=f.C()
Traceback (most recent call last):
File "<pyshell#22>", line 1, in -toplevel-
y=f.C()
AttributeError: 'function' object has no attribute 'C'
>>>
--
Tomi Lindberg
Aug 2 '06 #1
9 7474
Tomi Lindberg wrote:
Hi,

With the following function definition, is it possible to
create an instance of class C outside the function f (and if
it is, how)? And yes, I think this is one of those times
when the real question is why :)
>>def f():
class C(object):
def __init__(self):
self.a = 'a'
return C()
>>x = f()
>>x.a
'a'
>>y=f.C()

Traceback (most recent call last):
File "<pyshell#22>", line 1, in -toplevel-
y=f.C()
AttributeError: 'function' object has no attribute 'C'
No, its not. Only inside of it. And the question really is: why? If you need
a class that can be instantiated regardless of the execution of f, make it
a globally visible class. If it depends on something f computes, make it a
function-local one (if you like)

Diez
Aug 2 '06 #2

Tomi Lindberg wrote:
Hi,

With the following function definition, is it possible to
create an instance of class C outside the function f (and if
it is, how)?
def f():
class C(object):
def __init__(self):
self.a = 'a'
f.C = C
return C()
>>f.C
<class '__main__.C'>
And yes, I think this is one of those times
when the real question is why :)
Definitely ;)

Aug 2 '06 #3
Diez B. Roggisch wrote:
No, its not. Only inside of it. And the question really is: why?
Thanks. And no need to worry, the question was intended as
fully theoretical.

--
Tomi Lindberg
Aug 2 '06 #4
Tomi Lindberg wrote:
With the following function definition, is it possible to
create an instance of class C outside the function f (and if
it is, how)? And yes, I think this is one of those times
when the real question is why :)

*>>>*def*f():
********class C(object):
****************def __init__(self):
************************self.a = 'a'
********return C()

*>>>*x*=*f()
*>>>*x.a
'a'
y = type(x)()

By the way you get an instance of a different class C every time you call f,
so that

isinstance(f(), type(f())

is False.

Peter
Aug 2 '06 #5
Tomi Lindberg wrote:
With the following function definition, is it possible to
create an instance of class C outside the function f (and if
it is, how)? And yes, I think this is one of those times
when the real question is why :)
>def f():
class C(object):
def __init__(self):
self.a = 'a'
return C()
>x = f()
x.a
'a'
>y=f.C()

Traceback (most recent call last):
File "<pyshell#22>", line 1, in -toplevel-
y=f.C()
AttributeError: 'function' object has no attribute 'C'
>>
Well, you could use 'type(x)()', or object.__subclasses__() will include C
for as long as the class actually exists. Choosing the correct C from
object's subclasses could prove somewhat tricky though: remember you'll get
a new C class every time you call 'f'.
Aug 2 '06 #6
Peter Otten wrote:
By the way you get an instance of a different class C every time you call f,
so that

isinstance(f(), type(f())

is False.
That I didn't know. Well, that theory won't be seeing much
practice I guess.

--
Tomi Lindberg
Aug 2 '06 #7
Kay Schluehr wrote:
>
Tomi Lindberg wrote:
>Hi,

With the following function definition, is it possible to
create an instance of class C outside the function f (and if
it is, how)?

def f():
class C(object):
def __init__(self):
self.a = 'a'
f.C = C
return C()
>>>f.C
<class '__main__.C'>
Not working, unless f has been called at least once. But what I didn't know
(and always wondered) if the classdefinition inside a function can use the
outer scope - and apparently, it can! Cool.
def f(baseclass):
class C(baseclass):
def __init__(self):
self.a = 'a'
f.C = C
def foo(self):
print baseclass
return C()

c = f(object)
print f.C

c.foo()
Diez
Aug 2 '06 #8
Diez B. Roggisch wrote:
Kay Schluehr wrote:

Tomi Lindberg wrote:
Hi,

With the following function definition, is it possible to
create an instance of class C outside the function f (and if
it is, how)?
def f():
class C(object):
def __init__(self):
self.a = 'a'
f.C = C
return C()
>>f.C
<class '__main__.C'>

Not working, unless f has been called at least once.
Right.
But what I didn't know
(and always wondered) if the classdefinition inside a function can use the
outer scope - and apparently, it can! Cool.
Yes, the bytecode simply refers to a global name f in the scope of
__init__. Fortunately the Python compiler is too stupid to guess what f
might be but simply expects that f exists at runtime. I use this
"snake is eating itself" pattern very often for passing a module as a
reference to another module inside of itself:

--------------------- Module M
import B

def eatMe():
import M
B.m = M

if __name__ == '__main__':
eatMe()

-----------------------------------

One might consider M as a component which is definig stuff. Once you
select such a component it can be used to configure a framework F of
which B is a part ( B doesn't import M ! ) So F is essentially
parametrized by M. You ere entering the next level when different
parametrizations F(M1), F(M2),... can coexist or even refer to each
other. This isn't just a mental exercise but it's going to be the way
EasyExtend will support multiple extension languages at the same time
in the fist beta version of the program. Yes, I know ... everything is
heavily cyclic and we should do hierarchies instead ;)

Aug 2 '06 #9
Duncan Booth <du**********@invalid.invalidwrote in
news:Xn*************************@127.0.0.1:
>>def f():
class C(object):
def __init__(self):
self.a = 'a'
return C()
>>x = f()
x.a
'a'
>>y=f.C()
Of course there's this:
>>def f():
.... class C(object):
.... def __init__(self):
.... self.a = 'a'
.... return C()
....
>>x = f()
x.a
'a'
>>y=x.__class__()
y.a
'a'
>>type(y) == type(x)
True

Aug 2 '06 #10

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

12 posts views Thread by Gaurav Veda | last post: by
2 posts views Thread by Victor Liu | last post: by
30 posts views Thread by Neil Zanella | last post: by
2 posts views Thread by franklini | last post: by
2 posts views Thread by joe t. | last post: by
4 posts views Thread by subramanian100in | last post: by
6 posts views Thread by Dan Smithers | last post: by
5 posts views Thread by hurricane_number_one | last post: by
28 posts views Thread by cpluslearn | last post: by
reply views Thread by kermitthefrogpy | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.