Python object-oriented access restrictions

The content shared with you in this article is about Python object-oriented access restrictions. It has certain reference value. Friends in need can refer to it.

Inside a Class, there can be attributes and methods, and External code can manipulate data by directly calling methods on instance variables, thus hiding the complex internal logic.

However, judging from the previous definition of the Student class, external code can still freely modify the name and score attributes of an instance:

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def print_score(self):
        print('%s:%s'%(self.name,self.score))
    def get_grade(self):
        if self.score >=90:
            return 'A'
        elif self.score>=600:
            return  'B'
        else:
            return  'C'
bart = Student('Boyuan Zhou',100)
print(bart.score)
bart.score=120
print(bart.score)

100
120

If you want the internal properties not to be accessed externally, you can Add two underscores __ before the name of the attribute. In Python, if the variable name of the instance starts with __, it becomes a private attribute (private), which can only be accessed internally and not externally. Therefore, we Change the Student class:

class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score
    def print_score(self):
        print('%s:%s'%(self.__name,self.__score))
    def get_grade(self):
        if self.__score >=90:
            return 'A'
        elif self.__score>=600:
            return  'B'
        else:
            return  'C'

改完后，对于外部代码来说，没什么变动，但是已经无法从外部访问实例变量.__name和实例变量.__score了：

bart = Student('Boyuan Zhou',100)
print(bart.__name)Traceback (most recent call last):
  File "F:/mycompany/mycompany/schooldemo.py", line 16, in <module>
    print(bart.__name)
AttributeError: &#39;Student&#39; object has no attribute &#39;__name&#39;

This ensures that external code cannot modify the internal state of the object at will, so that the code is more robust through the protection of access restrictions.

But what if the external code wants to get the name and score? You can add methods like get_name and get_score to the Student class:

class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score
    
bart = Student('Boyuan Zhou',100)
print(bart.get_name())
#Boyuan Zhou

What if you want to allow external code to modify the score? You can add the set_score method to the Student class:

class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score
    def get_name(self):
        return self.__name    def get_score(self):
        return self.__score
    def set_score(self,score):
        self.__score=score

You may ask, the original method can be modified directly through bart.score = 59. Why bother to define a method? Because in the method, you can check the parameters to avoid passing in invalid parameters:

class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score
    def set_score(self,score):
        if 0 <=score <= 100:
            self.__score=score
        else:
            raise ValueError(&#39;bad score&#39;)

It should be noted that in Python, variable names are similar to __xxx___, that is, they start with double underscores. And those ending with a double underscore are special variables. Special variables can be accessed directly and are not private variables. Therefore, variable names such as __name__ and __score__ cannot be used.

Sometimes, you will see an instance variable name starting with an underscore, such as _name. Such instance variables can be accessed externally. However, according to the convention, when you see such a variable , meaning, 'Although I may be accessed, please treat me as a private variable and do not access it at will.'

Are instance variables starting with double underscores necessarily not accessible from the outside? In fact, not . The reason why __name cannot be accessed directly is because the Python interpreter externally changes the __name variable to _Student__name. Therefore, you can still access the __name variable through _Student_name:

class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score
    def set_score(self,score):
        if 0 <=score <= 100:
            self.__score=score
        else:
            raise ValueError(&#39;bad score&#39;)
bart = Student('Boyuan Zhou',100)print(bart._Student__name)
print(bart.get_name())
#Boyuan Zhou
#Boyuan Zhou

However, it is strongly recommended not to do this, because Different versions of Python interpreters may change __name to different variable names

#Related recommendations:

Python-oriented. Object classes and instances

##

The above is the detailed content of Python object-oriented access restrictions. For more information, please follow other related articles on the PHP Chinese website!