Object's nesting scope

Z

zaur

Hi folk!

What do you think about idea of "object's nesting scope" in python?

Let's imaging this feature, for example, in this syntax:

obj=<expression>:
<body>

or

<expression>:
<body>

That's means that result object of <expression> evaluation is used as
nested scope for <body> evaluation.

So is this idea useful?

Zaur
 
D

Diez B. Roggisch

zaur said:
Hi folk!

What do you think about idea of "object's nesting scope" in python?

Let's imaging this feature, for example, in this syntax:

obj=<expression>:
<body>

or

<expression>:
<body>

That's means that result object of <expression> evaluation is used as
nested scope for <body> evaluation.

So is this idea useful?
Click to expand...

Whom am we to judge? Sure if you propose this, you have some usecases in
mind - how about you present these?

Diez
 
Z

zaur

Whom am we to judge? Sure if you propose this, you have some usecases in
mind - how about you present these
Click to expand...

Ok. Here is a use case: object initialization.

For example,

person = Person():
name = "john"
age = 30
address = Address():
street = "Green Street"
no = 12

vs.

person = Person()
person.name = "john"
person.age = 30
address = person.address = Address()
address.street = "Green Street"
address.no = 12

In this example any assignment is an equivalence of setting
attribute's address of the parent object.
 
R

Rami Chowdhury

person = Person():
name = "john"
age = 30
address = Address():
street = "Green Street"
no = 12
Click to expand...

Can you clarify what you mean? Would that define a Person class, and an
Address class?

If you are expecting those classes to be already defined, please bear in
mind that if you want, you can do this:
def __init__(self, name='Nemo', age=0, address=None):
self.name = name
self.age = age
self.address = address
def __init__(self, street=None, no=None):
self.street = street
self.no = no
name = 'Bob',
age = 26,
address = Address(
street = 'Blue Street',
no = 1
)
)
 
M

MRAB

zaur said:
I suppose that someone already define classes Person ans Address.
For example, in this stupid way in a foreign module:

class Person(object):
pass

class Address(object):
pass

and the following statements

person = Person():
name = "john"
age = 30
address = Address():
street = "Green Street"
no = 12

are constructing an instance as follows:

person = Person()
person.name = "john"
person.age = 30
address = person.address = Address()
address.street = "Green Street"
address.no = 12
Click to expand...
[snip]

Create factory functions:

def new_address(**kwargs):
address = Address()
address.__dict__.update(kwargs)
return address

def new_person(**kwargs):
person = Person()
person.__dict__.update(kwargs)
return person

person = new_person(name="john", age=30,
address=new_address(street="Green Street", no=12))
 
R

ryles

Hi folk!

What do you think about idea of "object's nesting scope" in python?

Let's imaging this feature, for example, in this syntax:

obj=<expression>:
     <body>

or

<expression>:
   <body>

That's means that result object of <expression> evaluation is used as
nested scope for <body> evaluation.

So is this idea useful?

Zaur
Click to expand...

FYI, there was recently a similar idea being discussed on the python-
ideas list:

http://groups.google.com/group/python-ideas/browse_thread/thread/1a13cd9a5189b01c?hl=en
 
Z

zaur

zaur said:
I suppose that someone already define classes Person ans Address.
For example, in this stupid way in a foreign module:
Click to expand...
class Person(object):
   pass
Click to expand...
class Address(object):
   pass
Click to expand...
and the following statements
Click to expand...
person = Person():
   name = "john"
   age = 30
   address = Address():
      street = "Green Street"
      no = 12
Click to expand...
are constructing an instance as follows:
Click to expand...
person = Person()
person.name = "john"
person.age = 30
address = person.address = Address()
address.street = "Green Street"
address.no = 12
Click to expand...

[snip]

Create factory functions:

def new_address(**kwargs):
     address = Address()
     address.__dict__.update(kwargs)
     return address

def new_person(**kwargs):
     person = Person()
     person.__dict__.update(kwargs)
     return person

person = new_person(name="john", age=30,
address=new_address(street="Green Street", no=12))
Click to expand...

Original idea isn't about how to organize my code in order to
initialize these custom objects.
The idea is about to use object's dictionary as nested scope.
 
C

Carl Banks

Hi folk!

What do you think about idea of "object's nesting scope" in python?

Let's imaging this feature, for example, in this syntax:

obj=<expression>:
     <body>

or

<expression>:
   <body>

That's means that result object of <expression> evaluation is used as
nested scope for <body> evaluation.

So is this idea useful?
Click to expand...

It might be marginally useful to save typing. The idea has been
discussed in various forms here quite a bit over the years. I doubt
there's any chance it'll be accepted into Python, because it goes
against one of the main design points of Python: that attributes
should always be accessed explicitly.

Having said that, the syntax you propose is awful. :) Normally when
this is proposed they use a keyword such as "using":

p = Person()
using p:
name = "Carl Banks"
location = "Los Angeles"

or, perhaps to save a line (even though it'd be a minor syntax abuse):

using Person() as p:
name = "Carl Banks"
location = "Los Angeles"


Carl Banks
 
Z

zaur

It might be marginally useful to save typing.
Click to expand...
It also allow to structure the code.
The idea has been
discussed in various forms here quite a bit over the years.  I doubt
there's any chance it'll be accepted into Python, because it goes
against one of the main design points of Python: that attributes
should always be accessed explicitly.
Click to expand...
I don't in general consider this idea as a way for implicit access to
object's attributes.
Idea is about to use in some way object's dictionary as nested scope
in a code block.

I agree though that using this only for saving typing or implicit
attribute access isn't a good idea.
Having said that, the syntax you propose is awful. :) Normally when
this is proposed they use a keyword such as "using":

p = Person()
using p:
    name = "Carl Banks"
    location = "Los Angeles"

or, perhaps to save a line (even though it'd be a minor syntax abuse):

using Person() as p:
    name = "Carl Banks"
    location = "Los Angeles"
Click to expand...
I don't propose concrete syntax for using object's dictionary as
nested scope.
I used current only to explain the idea.
 
C

Carl Banks

I don't in general consider this idea as a way for implicit access to
object's attributes.
Click to expand...

That's what is it regardless of what you consider it.
Idea is about to use in some way object's dictionary as nested scope
in a code block.
Click to expand...

Which is implicitly accessing the object's attributes.


Carl Banks
 
Z

zaur

That's what is it regardless of what you consider it.


Which is implicitly accessing the object's attributes.

Carl Banks
Click to expand...

In my opinion idea of using object's dictionary as nested scope is
more about structuring code blocks rather than just saving typing and
implicit attribute access.
 
B

Bruno Desthuilliers

zaur a écrit :
Ok. Here is a use case: object initialization.

For example,

person = Person():
name = "john"
age = 30
address = Address():
street = "Green Street"
no = 12

vs.

person = Person()
person.name = "john"
person.age = 30
address = person.address = Address()
address.street = "Green Street"
address.no = 12
Click to expand...

Err... Looks like you really should read the FineManual(tm) -
specifically, the parts on the __init__ method.

class Person(object):
def __init__(self, name, age, address):
self.name = name
self.age = age
self.address = address

class Address(object):
def __init__(self, street, no):
self.no = no
self.street = street


person = Person(
name="john",
age=30,
address = Address(
street="Green Street",
no=12
)
)
 
Z

zaur

zaur a écrit :







Err... Looks like you really should read the FineManual(tm) -
specifically, the parts on the __init__ method.

class Person(object):
    def __init__(self, name, age, address):
        self.name = name
        self.age = age
        self.address = address

class Address(object):
    def __init__(self, street, no):
        self.no = no
        self.street = street

person = Person(
    name="john",
    age=30,
    address = Address(
        street="Green Street",
        no=12
    )
)
Click to expand...

What are you doing if 1) classes Person and Address imported from
foreign module 2) __init__ method is not defined as you want?
 
M

Mel

zaur said:
What are you doing if 1) classes Person and Address imported from
foreign module 2) __init__ method is not defined as you want?
Click to expand...

My work-around would be:

p = person = Person()
p.name = "john"
p.age = age # assuming, for a moment, that the age I wanted to set
# happened to be in another variable
a = p.address = Address()
a.street = "Green Street"
a.no = 12

del a, p # optional, for a tidier namespace

Slightly verbose, but, saying what it means, it avoids having to guess which
age of several ages might have to be used in various places; the same would
go for other input variables. Actually, I probably wouldn't use p as a
stand-in for person unless person were a global name and p could be local.

Mel.
 
G

Gabriel Genellina

En Fri said:
What are you doing if 1) classes Person and Address imported from
foreign module 2) __init__ method is not defined as you want?
Click to expand...

Welcome to dynamic languages! It doesn't matter *where* the class was
defined. You may add new attributes to the instance (even methods to the
class) at any time.

1)
person = Person()
vars(person).update(name="john",age=30,address=Address())
vars(person.Address).update(street="Green Street",no=12)

2)
def the_initializer_i_would_like(person, name, age):
person.name = name
person.age = age

person = Person()
the_initializer_i_would_like(person, name="john", age=30)

3)
def the_initializer_i_would_like(self, name, age):
self.name = name
self.age = age

Person.init = the_initializer_i_would_like
person = Person()
person.init(name="john", age=30)

4)
def a_generic_updater(obj, **kw):
try: ns = vars(obj)
except Exception: ns = None
if ns is not None:
ns.update(kw)
else:
for name in kw:
setattr(obj, name, kw[name])

person = Person()
a_generic_updater(person, name="john", age=30)
 
Z

zaur

En Fri, 28 Aug 2009 15:25:55 -0300, zaur <[email protected]> escribió:


What are you doing if 1) classes Person and Address imported from
foreign module 2) __init__ method is not defined as you want?
Click to expand...

Welcome to dynamic languages! It doesn't matter *where* the class was  
defined. You may add new attributes to the instance (even methods to the  
class) at any time.

1)
person = Person()
vars(person).update(name="john",age=30,address=Address())
vars(person.Address).update(street="Green Street",no=12)

2)
def the_initializer_i_would_like(person, name, age):
   person.name = name
   person.age = age

person = Person()
the_initializer_i_would_like(person, name="john", age=30)

3)
def the_initializer_i_would_like(self, name, age):
   self.name = name
   self.age = age

Person.init = the_initializer_i_would_like
person = Person()
person.init(name="john", age=30)

4)
def a_generic_updater(obj, **kw):
   try: ns = vars(obj)
   except Exception: ns = None
   if ns is not None:
     ns.update(kw)
   else:
     for name in kw:
       setattr(obj, name, kw[name])

person = Person()
a_generic_updater(person, name="john", age=30)
Click to expand...

I know about these ways of object initializing. What I said is about
using object's dictionary as nested scope in code block. Object
initialization is just one use case.
So we say about different things.
 
G

Gabriel Genellina

En Sat said:
En Fri said:
On 28 авг, 16:07, Bruno Desthuilliers <bruno.
(e-mail address removed)> wrote:
zaur a écrit :
Click to expand...
Ok. Here is a use case: object initialization.
Click to expand...
Err... Looks like you really should read the FineManual(tm) -
specifically, the parts on the __init__ method.
Click to expand...
What are you doing if 1) classes Person and Address imported from
foreign module 2) __init__ method is not defined as you want?
Click to expand...

Welcome to dynamic languages! It doesn't matter *where* the class was  
defined. You may add new attributes to the instance (even methods to
the class) at any time. [...4 examples...]
Click to expand...

I know about these ways of object initializing. What I said is about
using object's dictionary as nested scope in code block. Object
initialization is just one use case.
So we say about different things.
Click to expand...

Well, you asked how to proceed in certain cases and I showed several ways
it can be done right now, without requiring a new scope. You'll have to
think of another use case.

Attribute lookup is explicit in Python, and that's a very good thing. If
you follow the python-ideas thread posted earlier, you'll see the kind of
problems an implicit attribute lookup would cause. The "with" statement is
necesary (and a good thing) in Pascal, but not in Python.

Zope2 departs from this explicitness: it has a <dtml-with> construct
(similar to what you propose), and I hate it profoundly every time I have
to edit a DTML file - I can never tell *where* an attribute comes from.
Another related "feature" is acquisition, a stack of namespaces where
objects "inherit" attributes from their containers. Same thing, a complete
waste of time every time I have to track a bug.

Unless you can find a very compeling use case, I don't think this feature
will become part of the language anytime soon...
 
Z

zaur

En Sat, 29 Aug 2009 04:34:48 -0300, zaur <[email protected]> escribió:


En Fri, 28 Aug 2009 15:25:55 -0300, zaur <[email protected]> escribió:
On 28 авг, 16:07, Bruno Desthuilliers <bruno.
(e-mail address removed)> wrote:
zaur a écrit :
Ok. Here is a use case: object initialization.
Err... Looks like you really should read the FineManual(tm) -
specifically, the parts on the __init__ method.
What are you doing if 1) classes Person and Address imported from
foreign module 2) __init__ method is not defined as you want?
Welcome to dynamic languages! It doesn't matter *where* the class was  
defined. You may add new attributes to the instance (even methods to  
the class) at any time. [...4 examples...]
Click to expand...
Click to expand...
I know about these ways of object initializing. What I said is about
using object's dictionary as nested scope in code block. Object
initialization is just one use case.
So we say about different things.
Click to expand...

Well, you asked how to proceed in certain cases and I showed several ways  
it can be done right now, without requiring a new scope. You'll have to  
think of another use case.

Attribute lookup is explicit in Python, and that's a very good thing. If  
you follow the python-ideas thread posted earlier, you'll see the kind of  
problems an implicit attribute lookup would cause. The "with" statement is  
necesary (and a good thing) in Pascal, but not in Python.

Zope2 departs from this explicitness: it has a <dtml-with> construct  
(similar to what you propose), and I hate it profoundly every time I have  
to edit a DTML file - I can never tell *where* an attribute comes from.  
Another related "feature" is acquisition, a stack of namespaces where  
objects "inherit" attributes from their containers. Same thing, a complete  
waste of time every time I have to track a bug.

Unless you can find a very compeling use case, I don't think this feature  
will become part of the language anytime soon...
Click to expand...


The same can be said about multiple inheritance.
However, multiple inheritance is a powerful tool in the hands of
someone who can properly and effectively use it.
 
B

Bruno Desthuilliers

zaur a écrit :
What are you doing if 1) classes Person and Address imported from
foreign module 2) __init__ method is not defined as you want?
Click to expand...

Either 1/write an alternate initializer and bind it to the appropriate
classes or 2/write factory functions:

1/

from foreign_module import Person, Address

def my_init(self, **kw):
for k, v in kw.items():
setattr(self, k, v)
return self

Person.init = my_init
Address.init = my_init

person = Person().init(
name="john",
age=30,
address = Address().init(
street="Green Street",
no=12
)
)


2/

from functools import partial
import foreign_module

def my_factory(cls, **kw):
obj = cls()
for k, v in kw.items():
setattr(obj, k, v)
return obj

Person = partial(my_factory, foreign_module.Person)
Address = partial(my_factory, foreign_module.Address)

person = Person(
name="john",
age=30,
address = Address(
street="Green Street",
no=12
)
)
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Similar Threads

C Python: Running Python code within function scope 1
Default scope of variables 55
regular expressions, stack and nesting 2
PyWart: Packages (oh how thou art lacking!) 0
Argument scope 55
building "path expressions" 11
Why do only callable objects get a __name__? 10
nesting for statements? 3

Members online

Total: 24 (members: 2, guests: 22)
Robots: 152

Forum statistics

Threads
473,756
Messages
2,569,533
Members
45,007
Latest member
OrderFitnessKetoCapsules

Latest Threads

Top