PythonPP

Python ++

Un robusto sistema OOP de estilo Java para Python, con apoyo a la estadística, la encapsulación y la herencia.

Vista sobre Pypi / construido por Kento Nishi y Ronak Badhe

Python ++ permite a los programadores de Python usar principios de programación orientados a objetos en Python.

Instalación

El paquete está disponible en PYPI. Puede instalar el paquete con el siguiente comando:

pip install pythonpp

Uso

Importando la biblioteca

Puede importar Python ++ utilizando una declaración de importación comodín.

 from pythonpp import *

Declaración de clase

Declare las clases de Python ++ con el decorador @PythonPP .

 @ PythonPP
class MyClass :
    pass # class code here

Espacio de nombres

Declarar variables y métodos para las clases de Python ++ dentro namespace .

 @ PythonPP
class MyClass :
    def namespace ( public , private ):
        pass # methods and variables here

El código dentro namespace tiene acceso a los siguientes ámbitos:

Alcance	Descripción
public	El alcance de la instancia pública.
private	El alcance de la instancia privada.
public.static	El alcance estático público.
private.static	El alcance estático privado.

Inicializadores estáticos

Declare inicializadores estáticos para las clases de Python ++ usando el decorador @staticinit . Los inicializadores estáticos no tienen acceso a variables y métodos de instancia. Los inicializadores estáticos no pueden tener parámetros de entrada.

 @ PythonPP
class MyClass :
    def namespace ( public , private ):
        @ staticinit
        def StaticInit ():
            public . static . publicStaticVar = "Static variable (public)"
            private . static . privateStaticVar = "Static variable (private)"

Alternativamente, las variables estáticas se pueden declarar en el namespace desnudo si las asignaciones de variables son constantes . No se recomiendan las declaraciones variables estáticas desnudas.

Constructores

Los constructores se pueden declarar utilizando el decorador @constructor . Los constructores pueden tener parámetros de entrada.

 @ PythonPP
class MyClass :
    def namespace ( public , private ):
        @ constructor
        def Constructor ( someValue ):
            public . publicInstanceVar = "Instance variable (public)"
            public . userDefinedValue = someValue

Declaraciones de método

Los métodos se declaran utilizando el decorador @method(scope) con los alcances public y private en namespace .

 @ PythonPP
class MyClass :
    def namespace ( public , private ):
        @ method ( public )
        def publicMethod ():
            pass # public instance method here
        
        @ method ( private )
        def privateMethod ():
            pass # private instance method here
        
        @ method ( public . static )
        def publicStaticMethod ():
            pass # public static method here
        
        @ method ( private . static )
        def privateStaticMethod ():
            pass # private static method here

Métodos especiales

Declare métodos incorporados especiales utilizando el decorador @special .

 @ PythonPP
class MyClass :
    def namespace ( public , private ):
        @ special
        def __str__ ():
            return "Some string value"

Herencia

Las clases pueden extender otras clases utilizando la herencia de clase Python estándar.

 @ PythonPP
class ParentClass :
    def namespace ( public , private ):
        @ staticinit
        def StaticInit ():
            public . static . staticVar = "Static variable"

        @ constructor
        def Constructor ( param ):
            print ( "Parent constructor" )
            public . param = param

@ PythonPP
class ChildClass ( ParentClass ): # ChildClass extends ParentClass
    def namespace ( public , private ):
        @ staticinit
        def StaticInit ():
            ParentClass . staticinit () # Call parent static initializer
            public . static . staticVar2 = "Static variable 2"

        @ constructor
        def Constructor ( param ):
            # Call parent constructor
            ParentClass . constructor ( param )

Ejemplo rápido

 from pythonpp import *

@ PythonPP
class ParentClass :
    def namespace ( public , private ):
        @ staticinit
        def StaticInit ():
            public . static . publicStaticVar = "Public static variable"
            private . static . privateStaticVar = "Private static variable"

        @ constructor
        def Constructor ( parameter ):
            private . privateVariable = parameter

@ PythonPP
class ChildClass ( ParentClass ):
    def namespace ( public , private ):
        @ staticinit
        def StaticInit ():
            ParentClass . staticinit ()

        @ constructor
        def Constructor ( parameter ):
            ParentClass . constructor ( parameter )
            public . publicVariable = "Public variable"
            private . privateVariable = "Private variable"
        
        @ method ( public )
        def getPrivateVariable ():
            return private . privateVariable
        
        @ method ( public . static )
        def getPrivateStaticVar ():
            return private . static . privateStaticVar

        @ special
        def __str__ ():
            return "ChildClass object" 

 print ( ChildClass . publicStaticVar )
# > Private static variable
print ( ChildClass . getPrivateStaticVar ())
# > Private static variable

obj = ChildClass ( "Parameter value" )
print ( obj )
# > ChildClass object
print ( obj . publicVariable )
# > Public variable
print ( obj . getPrivateVariable ())
# > Parameter value
try :
    obj . privateVariable # results in an error
except Exception as e :
    print ( e )
# > 'ChildClass' object has no attribute 'privateVariable' 

Ejemplo completo

Puede ver el ejemplo completo del cuaderno Jupyter aquí.