java - val - user class python

JavaBean equivalent in Python (3)

I am fairly new to using Python as a OOP. I am coming from a Java background. How would you write a javabean equivalent in python? Basically, I need a class that:

  1. Implements serializable.
  2. Has getters and setters -> private properties
  3. dummy constructor

Any inputs? I am looking for a sample code!

Implements serializable.

Pick your favorite format, and write a function that will serialize it for you. JSON, Pickle, YAML, any work. Just decide!

Has getters and setters -> private properties

We don't do that here, those are attributes of bondage languages, we are all adults in this language.

dummy constructor

Again not something we really worry about as our constructors are a little bit smarter than other languages. So you can just define one __init__ and it can do all your initialization, if you must then write a factory or subclass it.

  1. You can serialize most object via the pickle module;
  2. There are no such things as private attributes in Python (see also:
  3. Classes that do not define a constructor will use a default (according to the method resolution order).

Example for constructor 'chain':

>>> class A(object):
...     def __init__(self):
...         print("A")
>>> class B(A): pass # has no explicit contructor
>>> b = B()

And - as @delnan wrote - you might want to read: -- Java and Python have quite different cultures, it takes some time to dive into (and appreciate) both.

Also, after writing some code, it might be helpful to compare it to common idioms, as listed here (I certainly learned a lot this way):

You don't, because Python is not Java. Most likely you should just write a less trivial class, construct a namedtuple, pass a dictionary, or something like that. But to answer the question:

  1. Neither serializable nor "implementing an interface" makes sense in Python (well, in some frameworks and advanced use cases it does, but not here). Serialization modules, such as pickle, work without implementing or inheriting anything special (you can customize the process in other ways, but you almost never need to).
  2. You don't write getters and setters. You just use public attributes. Should you later require a nontrivial getter/setter, you can turn it into a property transparently.
  3. There's no need for a dummy constructor, unless you want to create the attributes and set default values for them. But that's probably a bad idea (for a bean-ish class), as not assigning values to those attributes is most likely an error, and dubious even when it isn't. So just let Python catch those errors for you (it raises AttributeError when a non-existent attribute is accessed).