The perfect Python

Jean-François Ménard jeanfrancoismenard at
Wed Aug 28 17:00:02 CEST 2002

First, a warning:
    - I'm very poor in english.
    - I woke up way too early this morning.
    - It's a long post... (Sorry!)
    - I *love* python. This is not a troll, or anything like that.

Ok. Here we go.

I would like to share my impressions and my comments on Python.  At the end,
I will propose what would be for me the *perfect* Python interpreter.


I'm working on a fairly big Python (Zope) project since a year and a half.
It's a content management system for a big (19 000 employees) entreprise.
At first, I was the sole developper for the project.  My orders were: "Ok,
choose what you want, do what you want.  We just want one thing: results..."
Lucky, hey? ;)

I had experience in Object Pascal (Delphi), Vb (...), C++ and Java.  I was
new in the company, and wanted to impress my bosses.  After some research, I
narrowed my choices to two options: EJB (Java) and Zope (Python).

I gave a serious look at EJB, but in the end, I chose Python.  I took a
risk.  I don't regret it.  After only 2 months, I had already produced a
working system.  Alone... :)

Opinions, impressions:

At first, I was amazed by the simplicity and the clarity of the syntax. I
*love* the indentation style.  It gives clean and standardized source code.
We are now three developpers on the project, and it's easy for anyone of us
to understand the code of the others.


As project grew up, I started to see some of the limitations of the
language.  I understand that Python was not designed for such big projects.
But it's so powerfull, so clean, that I just wonder what Python could become
with just some (ok, not so minors...) improvements.

I understand that backward compatibility is important too, but the latests
extensions to Python begin to seem locked by past decisions.  I don't like
this tendency to __this__ and __that__ everything.  We loose in readability,
accessibility and clarity, in my opinion...

The Perfect Python (c):

What is missing ?  Well, I'm not a language designer, but I can say what *I*

    - Interfaces.  Behavior checking is not enough.
    - Private and Public scopes.  Explicitly.  No more __name_mangling
    - Design by contract. Pre and Post conditions.  Could save hours of
    - Block comments.  """ """ should be for documentation.
    - Class variables.
    - A cleaner Property declaration.  No separate _variable. Saw too many
newbie posts about that.
    - No more self in functions declarations.  In OOP, this *can* be
implicit. (I know, this is controversial stuff)
    - Standard GUI library.  AnyGui seems to be the solution, but
development seems to have stalled recently...

I tried to write an example of what Perfect Python(c) could look like.  It's
not valid code (duh!),  and it does'nt try to do anything unless give a
sample syntax:
from package1.package2 import module1, module2

public interface MyInterface implements (OtherInterface1, OtherInterface2):
    """ Comments """
    private PrivateClassVariable
    public property MyProperty
    public MyFunction(param1, param2)

public class MyClass(Class1, Class2) implements MyInterface, Interface2:
    """ Comments """

    # Instance Variable
    private InstanceVariable = "Default"

    # Class Variable - Public by default
    static PublicClassVariable = "Default"

    # Class Variable - Private
    static private PrivateClassVariable = "Default"

    public initialize(param1, param2="", param3=None):
        """ Comments """
        # OtherInstanceVariable is Public by default
        self.OtherInstanceVariable = "rien"

        # OtherInstanceVariable2 - Private
        private self.OtherInstanceVariable = "rien"

    private MyFunction(MyParameter1, MyParameter1):
        """ Comments """
        return "Result"

        Block comment

        function Foo():

    public property MyProperty:
        """ Comments """
            """ Comments """
            return self.MyProperty
            """ Comments """
            self.MyProperty = newValue

    private testInterface(otherObject):
        """ Interface checking  """
        # Check for interface implementation
        if otherObject implements MyInterface:
            return true

        # Check for multiple interface implementation
        if otherObject implements (OtherInterface1 or OtherInterface2):
            return true

        # Check for class inheritance
        if otherObject implements MyInterface:
            return true

        return false

    private testInheritence(otherObject):
        """ Inheritence checking """
        # Check for class inheritance
        if otherObject implements MyInterface:
            return true

    private propertyCall():
        """ Uniform call """
        return self.MyProperty

    private propertySet(newValue):
        """ Uniform call """
        self.MyProperty = "new value"

    public functionWithAssertion(Param1):
        """ Design by Contract """
            """ Precondition """
            Param1 < 1000000
            """ Function body """
            """ Poscondition """
            Param1 < 1000000

I have no idea how this could be implemented.  Maybe a PerfectPython
interpretor could be developped on top of the standard interpretor?

Any comments?  Anybody interested to start the project? ;)

More information about the Python-list mailing list