Introduction to whether Python access restrictions are private or public (with examples)

This article brings you an introduction to whether Python access restrictions are private or public (with examples). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

1. Knowledge points

In a module, we may define many functions and variables. But some functions and variables we hope can be used by others, and some functions and variables we hope to only be used inside the module, so?
We can achieve this goal by defining whether the function and variable are public or private.
In Python, this is achieved through the underscore "_" prefix.

public: public. Normal function and variable names are of this type and can be referenced directly. For example, variables abc, PI, etc.;

Special variables: The format is __xxx__, starting with __ and ending with __. Can be referenced directly, but has special uses. For example, __author__ and __name__ are special variables. Generally, do not use this type of variable name for variables you define yourself.

private: private, non-public, format similar to _xxx_ and __xxx, such as __num.
should not be referenced directly, only internally accessible, not externally accessible.
The internal state of the object cannot be modified at will, so the code is more robust through the protection of access restrictions.

2. Example

Inside the Class class, there can be attributes and methods. External code can manipulate data by directly calling the instance variable method, hiding the internal complex logic. However, external code is still free to modify an instance's properties. For example:

>>>b.score
99
>>>b.score = 59
>>>b.score
59

If you want to prevent internal attributes from being accessed externally, you can add two underscores "__" before the name of the attribute to turn it into a private variable, as follows:

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))

Try to When accessing properties from outside, an error will be reported because private variables cannot be accessed externally.

>>> bart = Student('Bart Simpson', 98) 
>>> bart.__name  # 私有变量：不能被外部访问
Traceback (most recent call last):   
File "<stdin>", line 1, in <module> 
AttributeError: 'Student' object has no attribute '__name'

But what if the external code wants to get the name and score?
Add methods to obtain attributes to the Student class: get_name() and get_score(), as follows:

class Student(object):
    ...
    def get_name(self):          
        return self.__name      
    def get_score(self):          
        return self.__score

What if external code modifies the score? You can add a setting method to the Student class: set_score():

...
def set_score(self, score):  
    # 避免传入无效参数  
    if 0 <= score <= 100:  
        self.__score = score 
    else:              
        raise ValueError(&#39;bad score&#39;)

Then must the private instance variables starting with a double underscore not be accessible from the outside? Not really.
You cannot access __name directly because the Python interpreter externally changes the __name variable to _Student__name, so you can still access the __name variable through _Student__name.

>>> bart = Student('Bart Simpson', 98)
>>> bart.get_name() 
'Bart Simpson' 
>>> bart.__name = 'New Name'  # 给bart新增的__name变量 
>>> bart.__name               # ！与class内部的__name变量不是一个变量！
'New Name'  
>>> bart.get_name()           # get_name()内部返回self.__name (_Student__name)
'Bart Simpson'

On the surface, the external code "successfully" sets the __name variable, but in fact this __name variable and the __name variable inside the class are not the same variable! The internal __name variable has been automatically changed to _Student__name by the Python interpreter, and the external code adds a new __name variable to bart.

So Python does not have a way to completely restrict access to private functions or variables, so it is not "cannot be directly referenced". From programming habits, private functions or variables should not be referenced. What's their use?
For example:

def _private_1 (name):
    return 'hello,%s ' % name
def _private_2 (name):
    return 'hi , %s ' % name
def greeting(name):
    if len(name) > 3:
        return _private_1 (name)
    else:
        return _private_2 (name)

The greeting() function is exposed in the module, but the internal logic is hidden using the private function. In this way, calling the greeting() function does not need to worry about the details of the internal private function.
This is a very useful method of code encapsulation and abstraction, that is: all functions that do not need to be referenced from the outside are defined as private, and only functions that need to be referenced from the outside are defined as public.

3. Complete code

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_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;)   
            
    def _private_1 (name):
        return &#39;hello,%s &#39; % name
    def _private_2 (name):
        return &#39;hi , %s &#39; % name
    def greeting(name):
        if len(name) > 3:
            return _private_1 (name)
        else:
            return _private_2 (name)

The above is the detailed content of Introduction to whether Python access restrictions are private or public (with examples). For more information, please follow other related articles on the PHP Chinese website!