Чи є в Python "приватні" змінні в класах?

Я приїжджаю зі світу Java та читаю « Шаблони, рецепти та ідіоми» Брюса Екклса « Пітон 3» .

Читаючи про класи, далі йдеться про те, що в Python не потрібно оголошувати змінні екземпляра. Ви просто використовуєте їх у конструкторі, і бум, вони там є.

Так, наприклад:

class Simple:
    def __init__(self, s):
        print("inside the simple constructor")
        self.s = s

    def show(self):
        print(self.s)

    def showMsg(self, msg):
        print(msg + ':', self.show())

Якщо це правда, то будь-який об’єкт класу Simpleможе просто змінити значення змінної sза межами класу.

Наприклад:

if __name__ == "__main__":
    x = Simple("constructor argument")
    x.s = "test15" # this changes the value
    x.show()
    x.showMsg("A message")

На Java нас вчили про публічні / приватні / захищені змінні. Ці ключові слова мають сенс, оскільки час від часу вам потрібні змінні в класі, до якого ніхто з класу не має доступу.

Чому цього не потрібно в Python?

Це культурно. У Python ви не записуєте до змінних екземплярів або класів інших класів. У Java нічого не заважає зробити те саме, якщо ви дійсно хочете - адже ви завжди можете редагувати джерело самого класу, щоб досягти того ж ефекту. Python упускає цей вигляд безпеки та спонукає програмістів до відповідальності. На практиці це працює дуже добре.

Якщо ви хочете чомусь імітувати приватні змінні, ви завжди можете використовувати __префікс з PEP 8 . Python маніпулює іменами змінних на зразок, __fooщоб їх не було легко видно коду поза класом, який їх містить (хоча ви можете обійти його, якщо ви досить визначені, як і ви можете обійти захист Java, якщо працюєте на ньому ).

За цією ж умовою, _префікс означає триматися подалі, навіть якщо технічно вам це не заважають . Ви не граєте зі змінними іншого класу, схожими на __fooабо _bar.

Приватні змінні в python - це більш-менш хак: інтерпретатор навмисно перейменовує змінну.

class A:
    def __init__(self):
        self.__var = 123
    def printVar(self):
        print self.__var

Тепер, якщо ви спробуєте отримати доступ __varпоза визначенням класу, це не вдасться:

 >>>x = A()
 >>>x.__var # this will return error: "A has no attribute __var"

 >>>x.printVar() # this gives back 123

Але ви можете легко піти з цього:

 >>>x.__dict__ # this will show everything that is contained in object x
               # which in this case is something like {'_A__var' : 123}

 >>>x._A__var = 456 # you now know the masked name of private variables
 >>>x.printVar() # this gives back 456

Ви, мабуть, знаєте, що методи в OOP викликаються так:, x.printVar() => A.printVar(x)якщо A.printVar()можна отримати доступ до якогось поля в x, до цього поля можна отримати доступ і зовні A.printVar() ... врешті-решт, функції створюються для повторного використання, особливих повноважень не надається заявам всередині.

Гра відрізняється, коли бере участь компілятор ( конфіденційність - це концепція рівня компілятора ). Він знає про визначення класу з модифікаторами контролю доступу, тому може помилитися, якщо правила не дотримуються під час компіляції

Як правильно зазначено у багатьох коментарях вище, не забуваймо про головну мету модифікаторів доступу: допомогти користувачам коду зрозуміти, що слід змінити, а що не слід. Коли ви бачите приватне поле, з ним не заплутаєтесь. Отже, це здебільшого синтаксичний цукор, який легко досягти в Python за допомогою _ та __.

У конвенції підкреслення є різні приватні змінні.

In [5]: class Test(object):
   ...:     def __private_method(self):
   ...:         return "Boo"
   ...:     def public_method(self):
   ...:         return self.__private_method()
   ...:     

In [6]: x = Test()

In [7]: x.public_method()
Out[7]: 'Boo'

In [8]: x.__private_method()
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-8-fa17ce05d8bc> in <module>()
----> 1 x.__private_method()

AttributeError: 'Test' object has no attribute '__private_method'

Є деякі тонкі відмінності, але заради програмування ідеологічної чистоти, її достатньо.

Існують приклади декораторів @private, які більш чітко реалізують цю концепцію, але YMMV. Можливо, можна також написати визначення класу, яке використовує мета

"У java нас вчили про публічні / приватні / захищені змінні"

"Чому це не потрібно в python?"

З тієї ж причини це не потрібно в Java.

Ви можете вільно користуватися - або не використовувати privateі protected.

Як програміст Python і Java, я виявив , що privateі protectedдуже, дуже важливі концепції дизайну. Але як практична справа, у десятках тисяч рядків Java та Python я ніколи фактично не використовував privateабо protected.

Чому ні?

Ось моє запитання "захищений від кого?"

Інші програмісти в моїй команді? У них є джерело. Що означає захищений, коли вони можуть його змінити?

Інші програмісти інших команд? Вони працюють в одній компанії. Вони можуть - за допомогою телефонного дзвінка - отримати джерело.

Клієнти? Це програмування на роботу (як правило). Клієнти (як правило) володіють кодом.

Отже, від кого саме я захищаю?

Як було сказано раніше, ви можете вказати, що змінна чи метод є приватними, префіксуючи її підкресленням. Якщо вам здається, що цього недостатньо, ви завжди можете використовувати propertyдекоратор. Ось приклад:

class Foo:

    def __init__(self, bar):
        self._bar = bar

    @property
    def bar(self):
        """Getter for '_bar'."""
        return self._bar

Таким чином, хтось або щось, на що посилається bar, насправді посилається на повернене значення barфункції, а не на саму змінну, і тому до неї можна отримати доступ, але не змінити її. Однак, якщо хтось дійсно цього хотів, він може просто використати _barі призначити йому нове значення. Немає надійного способу заборонити комусь отримати доступ до змінних та методів, які ви хочете приховати, як уже було сказано неодноразово. Однак, використовуючи propertyнайяскравіше повідомлення, яке ви можете надіслати, що змінну не слід редагувати. propertyможе також використовуватися для більш складних шляхів доступу до getter / setter / deleter, як пояснено тут: https://docs.python.org/3/library/functions.html#property

Python має обмежену підтримку приватних ідентифікаторів через функцію, яка автоматично передує назву класу до будь-яких ідентифікаторів, починаючи з двох підкреслень. Це здебільшого прозоро для програміста, але чистий ефект полягає в тому, що будь-які змінні, названі таким чином, можуть використовуватися як приватні змінні.

Дивіться тут докладніше про це.

Загалом, реалізація орієнтації на об'єкт Python є трохи примітивною порівняно з іншими мовами. Але я насолоджуюся цим, власне. Це дуже концептуально проста реалізація і добре поєднується з динамічним стилем мови.

Єдиний раз, коли я коли-небудь використовую приватні змінні, це коли мені потрібно робити інші речі під час запису чи читання із змінної, і як таке мені потрібно змусити використовувати сеттер та / або геттер.

Знову це стосується культури, як уже було сказано. Я працював над проектами, де читання та запис змінних інших класів було безкоштовним для всіх. Коли одна реалізація застаріла, знадобилося набагато більше часу, щоб визначити всі кодові шляхи, які використовували цю функцію. Коли використання сеттерів та getters було вимушене, запрошення про налагодження можна було легко написати, щоб визначити, що застарілий метод був викликаний та шлях коду, який його викликає.

Коли ви працюєте над проектом, де кожен може написати розширення, сповіщення користувачів про застарілі методи, які повинні зникнути в декількох випусках, отже, життєво важливо мінімізувати злам модуля як мінімум при оновленнях.

Отже, моя відповідь; якщо ви та ваші колеги підтримуєте простий набір коду, захист змінних класу не завжди необхідний. Якщо ви пишете розширювану систему, тоді стає вкрай необхідним, коли будуть внесені зміни до ядра, які повинні бути зафіксовані всіма розширеннями за допомогою коду.

Вибачте, хлопці, що "воскресили" нитку, але, сподіваюся, це допоможе комусь:

У Python3, якщо ви просто хочете "інкапсулювати" атрибути класу, як у Java, ви можете просто зробити те саме, що і таке:

class Simple:
    def __init__(self, str):
        print("inside the simple constructor")
        self.__s = str

    def show(self):
        print(self.__s)

    def showMsg(self, msg):
        print(msg + ':', self.show())

Щоб створити це, виконайте такі дії:

ss = Simple("lol")
ss.show()

Зауважте, що: print(ss.__s)призведе до помилки.

На практиці Python3 придушить ім'я глобального атрибута. Повернення цього як "приватний" атрибут, як у Java. Ім'я атрибута все ще є глобальним, але недоступним чином, як приватний атрибут іншими мовами.

Але не бійтеся цього. Це не має значення. Це теж робить свою роботу. ;)

приватні та захищені поняття дуже важливі. Але python - просто інструмент для складання прототипів та швидкого розвитку з обмеженими ресурсами, доступними для розвитку, тому деякі рівні захисту не так суворо дотримуються в python. Ви можете використовувати "__" для учасника класу, він працює належним чином, але виглядає недостатньо добре - кожен доступ до такого поля містить ці символи.

Крім того, ви можете помітити, що концепція python OOP не є ідеальною, маленький малюнок або рубін набагато ближче до чистої концепції OOP. Навіть C # або Java ближче.

Python - дуже хороший інструмент. Але це спрощена мова OOP. Синтаксично та концептуально спрощено. Основна мета існування python - забезпечити розробникам можливість дуже швидко читати код з високим рівнем абстракції.

У Python немає приватних змінних, таких як C ++ або Java. Ви можете отримати доступ до будь-якої змінної члена в будь-який час, якщо захочете, також. Однак приватні змінні в Python вам не потрібні, тому що в Python непогано розкривати змінні учасників класів. Якщо у вас є необхідність інкапсулювати змінну члена, ви можете зробити це, використовуючи пізніше "@property", не порушуючи існуючий код клієнта.

У python єдине підкреслення "_" використовується для вказівки, що метод або змінна не вважається частиною загальнодоступних api класу і що ця частина api може змінюватися між різними версіями. Ви можете використовувати ці методи / змінні, але ваш код може порушитися, якщо використовувати нову версію цього класу.

Подвійне підкреслення "__" не означає "приватну змінну". Ви використовуєте його для визначення змінних, які є "класовими локальними" і які не можна легко перекрити підкласами. Він маніпулює назвою змінних.

Наприклад:

class A(object):
    def __init__(self):
        self.__foobar = None # will be automatically mangled to self._A__foobar

class B(A):
    def __init__(self):
        self.__foobar = 1 # will be automatically mangled to self._B__foobar

Ім'я .__ ім'я foobar автоматично привласнюється до self._A__foobar в класі A. У класі B воно перетворюється на self._B__foobar. Таким чином, кожен підклас може визначити власну змінну __foobar, не змінюючи змінну (ів) своїх батьків. Але ніщо не заважає вам отримати доступ до змінних, починаючи з подвійних підкреслень. Однак керування іменами не дозволяє випадково викликати ці змінні / методи.

Я настійно рекомендую дивитися, як Реймонд Хеттінгерс розмовляє "Інструментарій розробки класів Pythons" від Pycon 2013 (має бути доступний на Youtube), що дає хороший приклад, чому і як слід використовувати @property та "__" - змінні екземплярів.

Насправді ви можете імітувати C#геттера та сетера за допомогою цього простого трюку:

class Screen(object):

    def getter_setter_y(self, y, get=True):
        if get is True:
            Screen.getter_setter_y.value = y
        else:
            return Screen.getter_setter_y.value

     def getter_setter_x(self, x, get=True):
         if get is True:
             Screen.getter_setter_x.value = x
         else:
             return Screen.getter_setter_x.value

Потім використовуйте його аналогічно C#:

scr = Screen()
scr.getter_setter_x(100)
value =  scr.getter_setter_x(0, get=False)
print (value)

Це просто оголошення статичної локальної змінної у функції, яка буде грати роль get / set, оскільки це єдиний спосіб ділитися змінною методами get і set, не роблячи її глобальним для класу чи файлу.