Preserve Encapsulation while Displaying Information

[QueenSvetlana]

Suppose I've got the following class to represent a Car and Tire

class Tire:

    def __init__(self, id, name, type):
        self.id = id
        self.name = name
        self.type = type

    @property
    def getID(self):
        return self.id
    
    @property
    def getName(self):
        return self.name

    @property
    def getType(self):
        return self.Type

    def __str__(self):
        return "ID: {0} Name: {1} Type: {2}".format(self.id, self.name, self.type)

class Car:

    def __init__(self, ID, name, tire, engine):
        self.ID = ID
        self.name = name
        self.tire = tire
        self.engine = engine

    @property
    def getID(self):
        return self.ID

    @property
    def getName(self):
        return self.name

    @property
    def getTire(self):
        return self.tire

    @property
    def getEngine(self):
        return self.engine

    def __str__(self):
        return "ID: {0} Name:{1} Tire: {2} Engine: {3}".format(self.ID, self.name, self.tire, self.engine)

Suppose I want to follow OOP principals, given that Tire is an attribute of a Car, how would I return the details of my Tire object?

If I had GUI with fields for each Car attribute, so calling the __str__ is not applicable, I would need to use my getters, would providing a getter for Tire be appropriate or should I expose the tire attributes in Car? or to put it in code:

This:

class Car:

    def __init__(self, ID, name, tire, engine):
        self.ID = ID
        self.name = name
        self.tire = tire
        self.engine = engine

    @property
    def getID(self):
        return self.ID

    @property
    def getName(self):
        return self.name

    @property
    def getTire(self):
        return self.tire

    @property
    def getEngine(self):
        return self.engine
    
    @property
    def getTire(self):
        return self.tire

    def __str__(self):
        return "ID: {0} Name:{1} Tire: {2} Engine: {3}".format(self.ID, self.name, self.tire, self.engine)

Or:

class Car:

    def __init__(self, ID, name, tire, engine):
        self.ID = ID
        self.name = name
        self.tire = tire
        self.engine = engine

    @property
    def getID(self):
        return self.ID

    @property
    def getName(self):
        return self.name

    @property
    def getTire(self):
        return self.tire

    @property
    def getEngine(self):
        return self.engine

    @property
    def getTireID(self):
        return self.tire.getID
    
    @property
    def getTireName(self):
        return self.tire.getName
    
    @property
    def getTireType(self):
        return self.tire.getType

    def __str__(self):
        return "ID: {0} Name:{1} Tire: {2} Engine: {3}".format(self.ID, self.name, self.tire, self.engine)

In the real world, I can open the hood of my car and see all the details I want, the engine, the tires, etc.. I can even get the ID, and Google it if I wanted too. So the second approach seems approiate, but if I update my Tire class with an attribute that the customer/buyer should know about then that means I need to update car as well. I like the first option, but I'm unsure. What is the appropriate(OOP) way to handle this?

[Mekire]

This is not Java.  As far as python goes, we don't code this way.  Unless a getter/setter actually does work, you don't write one.

So your car should just be:

class Car:
    def __init__(self, ID, name, tire, engine):
        self.ID = ID
        self.name = name
        self.tire = tire
        self.engine = engine
 
    def __str__(self):
        template = "ID: {ID} Name: {name} Tire: {tire} Engine: {engine}"
        return template.format(**vars(self))

If someone wants to access an attribute of tire they just do so using mycar.tire.name for example.
Python has a "we are all consenting adults" philosophy on data  access.  There are no private/public attributes so not only is writing getters/setters not recommended; it is actually pointless.  I can access all those attributes if I want to.

Basically, Python doesn't enforce encapsulation (and if you are trying to enforce it you are writing bad python).  You still use encapsulation by coding responsibly.

[snippsat]

I would need to use my getters, would providing a getter for

As mention over Python Is Not Java

Getters and setters are evil. Evil, evil, I say! Python objects are not Java beans.
Do not write getters and setters.
This is what the 'property' built-in is for. And do not take that to mean that you should write getters and setters, and then wrap them in 'property'.
That means that until you prove that you need anything more than a simple attribute access,
don't write getters and setters.
They are a waste of CPU time, but more important, they are a waste of programmer time.
Not just for the people writing the code and tests, but for the people who have to read and understand them as well.

Car should usually be first and Tire a subclass.
Example:

class Car:
    def __init__(self, id, name, type):
        self.id = id
        self.name = name
        self.type = type

    def __str__(self):
        return "ID: {0} Name: {1} Type: {2} Tire: {3} Engine: {4} ".\
           format(self.id, self.name, self.type, self.tire, self.engine)

class Tire(Car):
    def __init__(self, id, name, type, tire, engine):
        super().__init__(id, name, type)
        self.tire = tire
        self.engine = engine

Use:

Output:
>>> car = Tire(100, 'Opel', 'Astra', 'Goodyear', 1.9)
>>> car.type
'Astra'
>>> car.id
100
>>> car.tire
'Goodyear'
>>> print(car)
ID: 100 Name: Opel Type: Astra Tire: Goodyear Engine: 1.9 

[Mekire]

The article is good.  Tire being a subclass of Car is insane though.  Maybe a language issue.

[Windspar]

python does have private class variables

class MyClass:
    def __init__(self, value):
        self.__value = value

a = MyClass(1)
try:
    print(a.__value)
except:
    print("Sorry variable is private")

[Mekire]

python does have private class variables

That variable is absolutely not private.  It is what is called "name mangled" and can still be accessed with effort.  It is also highly discouraged in python.

class Car:
    def __init__(self, name):
        self.__name = name


mycar = Car("Stratus")
print(mycar._Car__name)

Output:
Stratus

https://docs.python.org/3/tutorial/class...-variables

[Windspar]

@QueenSvetlana
1. You break python style.

def get_id

2. Not a proper name for variables. getID or get_id are methods names. But you are always free to do what you want.

[snippsat]

Tire being a subclass of Car is insane though.  Maybe a language issue.

Yes was not the best example,engine and tire could be sub-classes of car if there where detailed l information about these parts.
But as you show is the more normal way for basic information. 

python does have private class variables

Double underscore(__) is used for name mangling,and are not private.

[QueenSvetlana]

I think @Mekire provided the answer I was looking for. Which brings me to another question, if getter/setters shouldn't be used, how do I indicate to someone using my code that they should treat a variable as "cannot be set after construction, but you can get it"? or In other words, it's initialized when you create the object, but can't be changed afterward(so no setters), but you can get the value that you gave in the constructor.

I don't think Tire should be a subclass of Car. Inheritance indicates a "is-a" relationship. A Tire is not Car, an Engine is not a Car, but they're components of a Car. A Car has an Engine, A Car has a set of Tires.

[Windspar]

@Mekire @snippsat
docs says 1 underscore for non public variables. section 9.6
So it is python way of support private class variables.