Я бы не сказал, что практика дает лучший код. Модификаторы видимости только отвлекают вас от текущей задачи, и в качестве побочного эффекта заставляют ваш интерфейс использоваться так, как вы намеревались. Вообще говоря, обеспечение видимости предотвращает программистов от беспорядка, если они не прочитали документацию должным образом.

гораздо лучшим решением является маршрут, который поощряет Python: ваши классы и переменные должны быть хорошо документированы, а их поведение ясно. Источник должны предоставлять. Это гораздо более расширяемый и надежный способ написания кода.

моя стратегия в Python это:

1. просто напишите эту чертову вещь, не делайте никаких предположений о том, как ваши данные должны быть защищены. Это предполагает, что вы пишете, чтобы создать идеальные интерфейсы для ваших проблем.
2. используйте начальное подчеркивание для вещей, которые наверное не будет использоваться внешне и не является частью обычного " клиентского кода" взаимодействие.
3. использовать двойное подчеркивание только для вещей, которые являются чисто удобство внутри класса, или причинит значительный ущерб, если случайно.

прежде всего, должно быть ясно, что все делает. Документируйте его, если кто-то другой будет использовать его. Документ если вы хотите, чтобы быть полезным в течение года.

в качестве примечания, вы должны на самом деле идти с защищенный в других языках: Вы никогда не знаете свой класс может быть унаследован позже и для чего он может быть использован. Лучше всего защищать только те переменные, которые, как вы уверены, не могут или не должны использоваться внешним кодом.

во - первых- что такое коверканье имени?

имя искажения вызывается, когда вы находитесь в определении класса и использовать __any_name или __any_name_, то есть два (или более) начальные подчеркивания и не более одного конечного подчеркивания.

class Demo:
    __any_name = "__any_name"
    __any_other_name_ = "__any_other_name_"

и так:

>>> [n for n in dir(Demo) if 'any' in n]
['_Demo__any_name', '_Demo__any_other_name_']
>>> Demo._Demo__any_name
'__any_name'
>>> Demo._Demo__any_other_name_
'__any_other_name_'

когда сомневаешься, что делать?

очевидное использование состоит в том, чтобы запретить подклассам использовать атрибут, который использует класс.

A потенциальное значение заключается в том, чтобы избежать конфликтов имен с подклассами, которые хотят переопределить поведение, чтобы функциональность родительского класса продолжала работать должным образом. Тем не менее,пример в документации Python не является Лисков заменяемым, и никакие примеры не приходят на ум, где я нашел это полезным.

недостатками являются то, что он увеличивает когнитивную нагрузку для чтения и понимания базы кода, и особенно при отладке, где вы видите двойной имя подчеркивания в источнике и искаженное имя в отладчике.

мой личный подход заключается в том, чтобы намеренно избегать его. Я работаю на очень большой кодовой базе. Редкое использование его торчит как больной палец и не кажется оправданным.

вы должны быть в курсе этого, так что вы знаете, когда вы видите его.

PEP 8

PEP 8, руководство по стилю стандартной библиотеки Python, в настоящее время говорит (сокращенно):

существуют некоторые разногласия по поводу использования __names.

если ваш класс предназначен для подклассов, и у вас есть атрибуты, которые вы не хотите использовать подклассы, рассмотрите возможность их именования с двойными начальными подчеркиваниями и без конечных подчеркиваний.

1. обратите внимание, что в искаженном имени используется только простое имя класса, поэтому если подкласс выбирает одно и то же имя класса и имя атрибута, вы все еще можете получить имя столкновения.

2. имя искажение может сделать определенные виды использования, такие как отладка и __getattr__() , менее удобно. Однако алгоритм искажения имени хорошо документирован и легко выполняется вручную.

3. не все любят имя калечить. Постарайтесь сбалансировать необходимость избегать случайных столкновений имен с потенциальным использованием продвинутыми абонентами.

как это работает?

если вы добавляете два подчеркивания (без окончания двойных подчеркиваний) в определении класса имя будет искажено, и подчеркивание, за которым следует имя класса, будет добавлено к объекту:

>>> class Foo(object):
...     __foobar = None
...     _foobaz = None
...     __fooquux__ = None
... 
>>> [name for name in dir(Foo) if 'foo' in name]
['_Foo__foobar', '__fooquux__', '_foobaz']

обратите внимание, что имена будут искажены только при анализе определения класса:

>>> Foo.__test = None
>>> Foo.__test
>>> Foo._Foo__test
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'Foo' has no attribute '_Foo__test'

кроме того, новички в Python иногда испытывают проблемы с пониманием того, что происходит, когда они не могут вручную получить доступ к имени, которое они видят в определении класса. Это не является веской причиной против этого, но это то, что нужно учитывать, если у вас есть обучающаяся аудитория.

Один Символ Подчеркивания?

если конвенция должна использовать только одно подчеркивание, я также хотел бы знать обоснование.

когда мое намерение состоит в том, чтобы пользователи держали свои руки подальше от атрибута, я обычно использую только одно подчеркивание, но это потому, что в моей ментальной модели подклассы будут иметь доступ к имени (которое у них всегда есть, поскольку они может легко обнаружить искореженное имя в любом случае).

если бы я просматривал код, который использует __ префикс, я бы спросил, почему они вызывают искажение имен, и если они не могут сделать это так же хорошо с одним подчеркиванием, имея в виду, что если подклассы выбирают одни и те же имена для класса и атрибута класса, несмотря на это, будет столкновение имен.

вы не должны начинать с личных данных и делать их общедоступными по мере необходимости. Скорее, вы должны начать с выяснения интерфейса вашего объекта. То есть вы должны начать с выяснения того, что видит мир (общественные вещи), а затем выяснить, какие личные вещи необходимы для этого.

другой язык затрудняет сделать частным то, что когда-то было публичным. Т. е. я сломаю много кода, если сделаю свою переменную закрытой или защищенной. Но со свойствами в python это не тот случай. Вернее, я могу поддерживать тот же интерфейс, даже с перестановкой внутренних данных.

разница между _ и __ заключается в том, что python фактически пытается применить последнее. Конечно, это не очень трудно, но это делает его трудным. Имея _ просто говорит другим программистам, что намерение, они могут игнорировать на свой страх и риск. Но игнорирование этого правила иногда полезно. Примеры включают отладку, временные хаки и работу с ними сторонний код, который не был предназначен для использования так, как вы его используете.

тут уже много хороших ответов, но я хочу предложить еще один. Это также частично ответ людям, которые продолжают говорить, что двойное подчеркивание не является частным (это действительно так).

Если вы посмотрите на Java/C#, оба они имеют private/protected / public. Все это -во время компиляции конструкции. Они применяются только во время компиляции. Если бы вы использовали отражение в Java / C#, вы могли бы легко получить доступ к private метод.

теперь каждый раз, когда вы вызываете функцию в Python, вы по своей сути используете отражение. Эти части кода одинаковы в Python.

lst = []
lst.append(1)
getattr(lst, 'append')(1)

синтаксис "точки" - это только синтаксический сахар для последнего фрагмента кода. В основном потому, что использование getattr уже уродливо только с одним вызовом функции. Дальше будет только хуже.

Так что, есть не могу быть Java / C# версия private, так как Python не компилирует код. Java и C# не удается проверить, является ли функция частной или общедоступной во время выполнения, поскольку эта информация отсутствует (и она не знает, откуда вызывается функция).

теперь с этой информацией имя искажения двойного подчеркивания имеет наибольший смысл для достижения "приватности". Теперь, когда функция вызывается из экземпляра 'self' и он замечает, что он начинается с'__', он просто выполняет имя mangling прямо там. Это просто синтаксический сахар. Что синтаксический сахар позволяет эквивалент 'private' на языке, который использует отражение только для доступа к элементам данных.

отказ от ответственности: я никогда не слышал, чтобы кто-нибудь из разработки Python говорил что-то подобное. Настоящая причина отсутствия "частного" - это культура, но вы также заметите, что большинство скриптовых/интерпретируемых языков не имеют частного. Строго принудительное частное не является практичным ни в чем, кроме времени компиляции.

во-первых: почему вы хотите скрыть свои данные? Почему это так важно?

большую часть времени вы действительно не хотите сделать это, но вы делаете, потому что другие делают.

Если вы действительно действительно не хотите, чтобы люди что-то использовали, добавьте один подчеркивание перед ним. Вот и все... Питонисты знают, что вещи с одним подчеркиванием не гарантированно работают каждый раз и могут меняться без вашего ведома.

вот как мы живем, и мы ну и ладно.

использование двух подчеркиваний сделает ваш класс настолько плохим для подкласса, что даже вы не захотите работать таким образом.

выбранный ответ хорошо объясняет, как свойства устраняют необходимость частная атрибутами, но я бы также добавил, что функции на уровне модуля устраняют необходимость частные методы.

Если вы превращаете метод в функцию на уровне модуля, вы удаляете возможность для подклассов переопределить его. Перемещение некоторых функций на уровне модуля является более подходящие для Python, чем пытаться скрыть методы коверкая имя.

на первый взгляд он должен быть таким же, как и для других языков (под "другим" я имею в виду Java или C++), но это не так.

в Java вы сделали закрытыми все переменные, которые не должны быть доступны снаружи. В то же время в Python вы не можете этого достичь, так как нет "приватности" (как говорит один из принципов Python - "мы все взрослые"). Поэтому двойное подчеркивание означает только "ребята, не используйте это поле напрямую". То же самое значение имеет подчеркивание паленого, которое в то же время не имеет вызовите любую головную боль, когда вам нужно наследовать от рассматриваемого класса (просто пример возможной проблемы, вызванной двойным подчеркиванием).

Итак, я бы рекомендовал вам использовать один символ подчеркивания по умолчанию для "частных" членов.

следующий фрагмент кода объяснит все различные случаи:

• два ведущих подчеркивания (__a)
• одно начальное подчеркивание (_a)

• без подчеркивания (a)

  class Test:
  
  def __init__(self):
      self.__a = 'test1'
      self._a = 'test2'
      self.a = 'test3'
  
  def change_value(self,value):
      self.__a = value
      return self.__a
  

печать всех допустимых атрибутов тестового объекта

testObj1 = Test()
valid_attributes = dir(testObj1)
print valid_attributes

['_Test__a', '__doc__', '__init__', '__module__', '_a', 'a', 
'change_value']

здесь вы можете видеть, что имя __a было изменено на _Test__a, чтобы предотвратить переопределение этой переменной любым из подклассов. Это понятие известно как " имя Калечить " в python. Вы можете получить доступ к этому следующим образом:

testObj2 = Test()
print testObj2._Test__a

test1

аналогично, в случае _a переменная просто уведомляет разработчика о том, что она должна использоваться в качестве внутренней переменной этого класса, интерпретатор python ничего не сделает, даже если вы получите к нему доступ, но это не очень хорошая практика.

testObj3 = Test()
print testObj3._a

test2

переменная может быть доступ из любого места это как переменная открытого класса.

testObj4 = Test()
print testObj4.a

test3

надеюсь, что ответ помог вам :)