Python 3, but with proper encapsulation.
Project description
Python++
Python 3, but with proper encapsulation.
PythonPP stands for Python Plus Plus.
Python++ allows Python programmers to use object oriented programming principles in Python. Similar to Java, variables and methods can be encapsulated, or made private.
Encapsulation is useful when storing sensitive persistent data within instances of objects. For example, a programmer may want to hold a user's password in a variable - however, in vanilla Python, the password variable can be manipulated by any external code in possession of the object instance. Python++ prevents such behavior by introducing private variables and methods to Python.
Installation
The package is available on PyPI. You can install the package with the following command:
pip install --upgrade pythonpp
Usage
A PythonPP class must extend PythonPP's objpp
class.
The constructor must also call the __init__
method of the parent objpp
class.
When no
__init__
method is defined,super().__init__()
will be executed automatically.
Example:
from pythonpp import *
# Class extends pythonpp's ObjPP class.
class Test(ObjPP):
# Class constructor
def __init__(self):
# Call ObjPP's constructor.
super().__init__()
def namespace(public, private):
# public: the public scope.
# private: the private scope.
pass
Alternatively, you can create your class without using a wildcard import.
import pythonpp as ppp
class Test(ppp.ObjPP):
def __init__(self):
super().__init__()
def namespace(public, private):
pass
All variable and method declarations must be done in the
namespace
method.
The namespace method has two parameters.
Parameter | Value |
---|---|
public |
The public scope. All variables in this scope can be accessed externally. |
private |
The private scope. All variables in this scope can only be accessed internally. |
You can define public and private variables using these scopes.
All variables and methods are declared private by default when the scope is not specified. When you create a variable or method, it is highly recommended that you declare it private unless absolutely necessary.
Example:
# public variable
public.hello = "hello"
# private variable
private.world = "world"
You can also use the public and private scopes to declare methods.
Example:
# public method
@method(public)
def publicMethod():
print("Called publicMethod")
# private method
@method(private)
def privateMethod():
print("Called privateMethod")
Public variables and methods can be accessed as usual.
Example:
test = Test()
# works as normal
print(test.hello)
# also works as normal
test.publicMethod()
However, private variables and methods cannot be accessed externally.
Example:
test = Test()
# results in an error
print(test.world)
# also results in an error
test.privateMethod()
Inheritance
All Python++ classes must extend the ObjPP
class. You can also create Python++ classes that extend other classes using multiple inheritance.
For Python++ to work properly, you must call
ObjPP
's constructor at some point in the__init__
method.
Example:
# parent class
class Parent():
# Parent constructor
def __init__(self):
print("Parent constructor")
# child class
class Child(ObjPP, Parent):
# Child constructor
def __init__(self):
print("Child constructor")
super(ObjPP, self).__init__()
super(Parent, self).__init__()
def namespace(public, private):
pass
Alternatively, you can call the superclass constructors like so:
# child class
class Child(ObjPP, Parent):
def __init__(self):
# Same as super(ObjPP, self).__init__()
ObjPP.__init__(self)
# Same as super(Parent, self).__init__()
Parent.__init__(self)
def namespace(public, private):
pass
Example Class
View the full Jupyter notebook here.
from pythonpp import *
class Test(ObjPP):
# Class constructor
def __init__(self):
# Call ObjPP's constructor.
super().__init__()
# Place all methods and field declerations here.
def namespace(public, private):
# public variable
public.hello = "hello"
# private variable
private.world = "world"
# public method
@method(public)
def publicMethod():
print("Called publicMethod")
# private method
@method(private)
def privateMethod():
print("Called privateMethod")
# public method to call the private method.
@method(public)
def callPrivateMethod():
print("Calling privateMethod()")
# Call the private method
private.privateMethod()
Contributors
Project details
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.