

Javascript-Style Objects in Python - eatonphil
https://gist.github.com/eatonphil/4fc6d081f53eedb9a4c4

======
AnkhMorporkian
"The only visible difference is that you cannot simply access the members
using the dot syntax (cat.sayHi)."

There's also the lack of inheritance, the lack of class specific methods,
isinstance and issubclass checking, the different type, no possible way to
define a custom iteration method, no way to use it as a decorator or a context
manager, no static methods, and probably a dozen other things I haven't
thought about.

~~~
thalesmello
Most of this issues could be walked around:

\- For the dot syntax, all you have to do is define the __call__ method. You
could do that by creating an object that encapsulates the dictionary, defines
a __call__ method, and repasses the method calls to the underlying dictionary.

\- For inheritance, just create another constructor function that calls the
parent constructor, adds the desired methods, and returns the new function. In
JavaScript, it's called parasithic inheritance.

\- For the iteration method, you just have to define the __iter__ method.

\- For the isinstance and issubclass method, maybe you could create new
conventions (and thus reinvent the wheel)

\- About static method... should we be using them anyway?

Those are just some thoughts. This alternative way of creating objects is
probably useless, nevertheless fun.

~~~
icebraining
_You could do that by creating an object that encapsulates the dictionary,
defines a __call__ method, and repasses the method calls to the underlying
dictionary._

That's what a Python object is... The underlying dictionary is called
__dict__.

------
orf
Not to be mean but I don't see anything interesting here, just a function that
returns a dictionary with some keys that happen to be functions. Welcome to
Python I guess?

~~~
hasenj
Yea I have no idea why this is on the homepage. It's so mundane.

~~~
eatonphil
Replicating class functionality using only closures is mundane? At the very
least it's cute.

I didn't realize all beginning Python programmers knew what they could do with
closures.

My point is, why have a class syntax at all? It's such a mess, "self" isn't
even implicit. You don't even need to declare class methods inside the class.
You just have to make sure you pass self to the class method.

This seems very loosely wrapped around what I did. Except class syntax is
native. Why? I just really don't care for how sloppy the python class syntax
is.

/rant

~~~
hasenj
It's mundane because there's nothing special about it. Everyone knows python
has dictionaries. Everyone knows python has functional features. Everyone
knows you can attach functions as properties of objects.

There's really nothing new or interesting about it. Except maybe for
beginners. Which is fine. Nothing wrong with being a beginner. It's just not
what I expect to see on the frontpage of HackerNews.

That's almost like someone saying: look wow, 2+2 and 2*2 and 2^2 all return
the same result! Sure, amusing when you realize it for the first time, but
hardly interesting for anyone but a first grader.

~~~
eatonphil
When have you seen this pattern shown in a Python beginners tutorial? ... or
anywhere? I have never seen this pattern before and for that reason it is
interesting.

~~~
hasenj
Why would it show in beginner tutorials?

It's just not pythonic.

> There should be one-- and preferably only one --obvious way to do it.

Not to mention that the object['field'] syntax is rather annoying.

------
publicfig
Correct me if I'm wrong, but isn't this pretty much Python 101? I don't see
anything happening here that is incredibly novel. It's slightly less Pythonic
than it could be, but not even that far off.

------
jupake
I like Javascript. And I like Python. But, writing Javascript code in Python
syntax is as bad as writing Java code in Python syntax. Or writing Python code
in Java syntax.

If you like Javascript that much.. then write in Javascript. Just my 2c. :-)

Edit: Forgot to capitalize.

------
jaimebuelta
I'd be much more interested in using Python-Style Objects in Javascript...

------
icebraining
Look, ma, dots!

    
    
      >>> def Cat(name):
            def hello():
              print "I'm "+name
            hello.__dict__ = {
              'hello': hello,
            }
            return hello
      >>> c = Cat('snuffels')
      >>> c.hello()
      I'm snuffels

------
eatonphil
Responses seem to think this is Python 101. I think of it more as post-OOP
Python. I have never seen this pattern before, so I was interested. Gave it a
shot and it worked.

My question remains, why use Python objects vs these style objects? Sure you
can say this doesn't have "support" for class-related functionality
_natively_. But just like in Javascript, most of these can be implemented
anyway.

Support inheritance by passing in the parent Function/Class and copying the
attributes/values. Check the type by storing type name or check the function
name via reflective programming.

My point is, I can see most of the functionality of Python classes replicated
without the Python class syntax. So... why is there native class syntax when I
can replicate most of the functionality with just functions.

At least from a devil's advocate perspective, why should I use classes? Is
memory management better? That is the only topic I can imagine mattering if
there is a library for creating objects from just functions per the example.

~~~
jmilloy
It seems to me like pre-OOP Python. I'm not a fan of overusing classes, and a
lot can be accomplished in Python without them. But from one perspective,
you're just reimplementing (a subset of) classes and preferring to type out
the underlying dictionary instead of letting the existing syntax do it for
you. So one answer is _because easier to type and read_.

Another answer is that you are, in fact, using classes, you're just not using
the 'class' identifier and syntax (assuming you're library was fleshed out to
include all the missing features that your toy example is missing). Why
doesn't Python offer three different class implementations and syntax? Why did
you use a dictionary in your example, instead of implementing your own key-
value object with hashing functions? Why are you using Python at all, instead
of writing directly machine code?

------
jpetersonmn
For those that didn't see, the original title of this post was "Why use
classes at all in python" and not what it is now. Apparently the author
thought a dictionary was as useful and could do anything a class object can.

~~~
eatonphil
No, I think a _closure_ is as useful and can do anything a "class object"
can...

What exactly do you think a class can do that you can't replicate in this
pattern? Inheritance? Pass the parent function in. Typeof? Store a type value
or get the function name reflectively.

------
wbkang
I thought this was something implemented using metaclasses to not have to use
dictionary-style field access... (e.g., obj.field instead of obj['field'] )

~~~
voyou
I don't think you need to use metaclasses, you can just define the relevant
magic methods, something like:

    
    
        class JSLikeObject(dict):
            __getattr__ = dict.__getitem__
            __setattr__ = dict.__setitem__
    

ETA: That gets you JavaScript-style equivalence between attribute and index
lookup, but it doesn't get you JavaScript-like binding of "this". I think you
could probably do that with descriptors (and maybe it would require writing a
metaclass).

~~~
icebraining
Yeap: [http://code.activestate.com/recipes/473786-dictionary-
with-a...](http://code.activestate.com/recipes/473786-dictionary-with-
attribute-style-access/)

------
serve_yay
Write JS in JS, and Python in Python. :)

~~~
theVirginian
agreed. JS is not a language I personally want encroaching into Python.

