Understanding data encapsulation in Python

问题

I am reading up on how we ensure data encapsulation in python.One of the blog says "Data Encapsulation means, that we should only be able to access private attributes via getters and setters"

Consider the following snippets from the blog:

class Robot:
    def __init__(self, name=None, build_year=None):
        self.name = name
        self.build_year = build_year

Now, if i create the object of the class as below:

obj1=Robot()
obj1.name('Robo1")
obj1.build_year("1978")

Currently, i can access the attributes directly as i have defined them public(without the __notation)

Now to ensure data encapsulation, i need to define the attributes as privates using the __ notation and access private attributes via getters and setters.

So the new class definition is as follows:

class Robot:

    def __init__(self, name=None, build_year=2000):
        self.__name = name
        self.__build_year = build_year            
    def set_name(self, name):
        self.__name = name

    def get_name(self):
        return self.__name    

    def set_build_year(self, by):
        self.__build_year = by

    def get_build_year(self):
        return self.__build_year

Now i instantiate the class as below:

x = Robot("Marvin", 1979)
x.set_build_year(1993)

This way, i achive data encapsulation as private data members are no longer accessed directly and they can only be accessed via the class methods.

Q1:Why are we doing this? Who are we protecting the code from? Who is outside world?Anyone who has the source code can tweak it as per their requirement, so why at all do we add extra methods(get/set) to modify/tweak the attributes?

Q2:Is the above example considered data encapsulation?

回答1:

About source code: sometimes you supply others with compiled python files that does not present the source, and you don't want people to get in mess with direct attribute assignments.

Now, consider data encapsulation as safe guards, last point before assigning or supplying values:

You may want to validate or process assignments using the sets, to make sure the assignment is valid for your needs or enters to the variable in the right format, (e.g. you want to check that attribute __build_year is higher than 1800, or that the name is a string). Very important in dynamic languages like python where a variable is not declared with a specific type.

Same goes for gets. You might want to return the year as a decimal, but use it as an integer in the class.

Yes, your example is a basic data encapsulation.

回答2:

Data encapsulation is slightly more general than access protection. name and build_year are encapsulated by the class Robot regardless of how you define the attributes. Python takes the position that getters and setters that do nothing more than access or assign to the underlying attribute are unnecessary.

Even using the double-underscore prefix is just advisory, and is more concerned with preventing name collisions in subclasses. If you really wanted to get to the __build_year attribute directly, you still could with

# Prefix attribute name with _Robot
x._Robot__build_year = 1993

A better design in Python is to use a property, which causes Python to invoke a defined getter and/or setter whenever an attribute is defined directly. For example:

class Robot(object):
    def __init__(self, name, by):
        self.name = name
        self.build_year = by

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

    @name.setter
    def name(self, newname):
        self._name = newname

    @property
    def build_year(self):
        return self._build_year

    @build_year.setter
    def build_year(self, newby):
        self._build_year = newby

You wouldn't actually define these property functions so simply, but a big benefit is that you can start by allowing direct access to a name attribute, and if you decide later that there should be more logic involved in getting/setting the value and you want to switch to properties, you can do so without affecting existing code. Code like

x = Robot("bob", 1993)
x.build_year = 1993

will work the same whether or not x.build_year = 1993 assigns to build_year directly or if it really triggers a call to the property setter.

来源：https://stackoverflow.com/questions/41086827/understanding-data-encapsulation-in-python

标签

python

class

object