Question

I am from PHP and quick learn OOP Python base PHP ‘s knowledge
for example I have a class

<?php
class Cat{
    private $name;
    private $age;
    private $color;

    public function getName()
    {
        return $this->name;
    }

    public function setName($value)
    {
        $this->name = $value;
    }

    public function getAge()
    {
        return $this->age;
    }

    public function setAge($value)
    {
        $this->age = $value;
    }

    public function getColor()
    {
        return $this->color;
    }

    public function setColor($value)
    {
        $this->color = $value;
    }

}
?>

What is equivalence to python OOP code?

Answer 1

An exact equivalent would be this:

class Cat(object):
    def __init__(self, name...):
        self.__name = name # __ make the var private
        ...

    def getName(self):
        return self.__name

    def setName(self, name):
        self.__name = name

    ...

It will work, but you would never do that in Python. Here is why:

• Nothing is really private in Python, and you can always bypass restrictions using some tricks in this language. So you usually value more communication, doc and API that enforcing a behaviour.
• Accessing directly attribute is perfectly fine in Python. If you don’t something special while getting or setting, then you don’t write getters and setters. The best Python libs do this.
• You have something called ‘properties’ allowing you to change your mind after the fact. If in 1 month, you decide to do something while getting and setting a var, you can do it without changing you API.

Here is how you would to it in proper Python:

class Cat(object):
    def __init__(self, name):
        self.name = name

c = Cat('billy')
print c.name
# billy
c.name = 'kit'
print c.name
# kit

Now, what if suddenly you want to change your mind and ensure the name is always capitalize on when you store it ? You just add a property:

class Cat(object):

    def __init__(self, name):
        self._name = name # '_' is just a convention and does nothing

    @property # when you do cat.name, it will call this function
    def name(self):
        return self._name

    @name.setter # when you do cat.name = x, it will call this function
    def name(self, name):
        """ Make the name uppercase when setting it """
        self._name = name.upper()

The code change, but from outside, it looks exactly the same:

c = Cat('billy')
print c.name
# BILLY
c.name = 'kit'
print c.name
# KIT

What are the main benefits?

• You don’t have to write getter and setter most of the time, it same times and make the code shorter, hence easier to read.
• If you change your mind, you can always write ONE getter/setter. Only the one you need, not all the other ones. The API keeps looking consistent.