Introduction pour savoir si les restrictions d'accès Python sont privées ou publiques (avec exemples)

Cet article vous explique si les restrictions d'accès Python sont privées ou publiques (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

1. Points de connaissances

Dans un module, on peut définir de nombreuses fonctions et variables. Mais nous espérons que certaines fonctions et variables pourront être utilisées par d'autres, et certaines fonctions et variables que nous espérons utiliser uniquement à l'intérieur du module, alors ?
Nous pouvons atteindre cet objectif en définissant si la fonction et la variable sont publiques ou privées.
En Python, ceci est réalisé grâce au préfixe de soulignement "_".

public : public. Les noms normaux de fonctions et de variables sont de ce type et peuvent être référencés directement. Par exemple, les variables abc, PI, etc. ;

Variables spéciales : Le format est __xxx__, commençant par __ et se terminant par __. Peut être référencé directement, mais a des utilisations particulières. Par exemple, __author__ et __name__ sont des variables spéciales. De manière générale, n'utilisez pas ce type de nom de variable pour les variables que vous définissez vous-même.

privé : privé, non public, format similaire à _xxx_ et __xxx, tel que __num.
ne doit pas être référencé directement, il n'est accessible qu'en interne, pas en externe.
L'état interne de l'objet ne peut pas être modifié à volonté, le code est donc plus robuste grâce à la protection des restrictions d'accès.

2. Exemple

À l'intérieur de la classe Class, il peut y avoir des attributs et des méthodes. Le code externe peut manipuler les données en appelant directement la méthode de variable d'instance, masquant ainsi la logique complexe interne. Cependant, le code externe est toujours libre de modifier les propriétés d'une instance. Par exemple :

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

Si vous souhaitez empêcher l'accès aux attributs internes par le monde extérieur, vous pouvez ajouter deux traits de soulignement "__" avant le nom de l'attribut pour en faire une variable privée, comme suit :

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

Lorsque vous essayez d'accéder aux propriétés de l'extérieur, vous constaterez qu'une erreur sera signalée car les variables privées ne sont pas accessibles de l'extérieur.

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

Mais que se passe-t-il si le code externe veut obtenir le nom et le score ?
Ajoutez des méthodes pour obtenir des attributs dans la classe Student : get_name() et get_score(), comme suit :

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

Et si un code externe modifie le score ? Vous pouvez ajouter des méthodes de paramétrage à la classe Student : set_score() :

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

Ensuite, les variables d'instance privées commençant par un double trait de soulignement ne doivent-elles pas être accessibles de l'extérieur ? Pas vraiment.
Vous ne pouvez pas accéder directement à __name car l'interpréteur Python modifie en externe la variable __name en _Student__name, vous pouvez donc toujours accéder à la variable __name via _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'

En apparence, le code externe définit "avec succès" la variable __name, mais en fait cette variable __name et la variable __name à l'intérieur de la classe ne sont pas la même variable ! La variable interne __name a été automatiquement remplacée par _Student__name par l'interpréteur Python, et le code externe ajoute une nouvelle variable __name à Bart.

Python n'a donc pas de moyen de restreindre complètement l'accès aux fonctions ou variables privées, il ne "ne peut donc pas être directement référencé". D'après les habitudes de programmation, les fonctions ou variables privées ne doivent pas être référencées. Quelle est leur utilité ?
Par exemple :

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)

expose la fonction Greeting() dans le module, mais masque la logique interne avec une fonction privée. De cette façon, appeler la fonction Greeting() n'a pas besoin de se soucier des détails de la fonction privée interne.
Il s'agit d'une méthode très utile d'encapsulation et d'abstraction de code, c'est-à-dire : toutes les fonctions qui n'ont pas besoin d'être référencées de l'extérieur sont définies comme privées, et seules les fonctions qui doivent être référencées de l'extérieur sont définies comme publiques. .

3. Code complet

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)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!