Definiowanie funkcji modułu prywatnego w Pythonie

Według http://www.faqs.org/docs/diveintopython/fileinfo_private.html :

Podobnie jak większość języków, Python ma pojęcie elementów prywatnych:

• Funkcje prywatne, których nie można wywołać spoza modułu

Jeśli jednak zdefiniuję dwa pliki:

#a.py
__num=1

i:

#b.py
import a
print a.__num

po uruchomieniu b.pydrukuje się 1bez żadnego wyjątku. Czy diveintopython jest zły, czy coś źle zrozumiałem? A czy jest jakiś sposób, aby nie definiować funkcje modułu jako prywatny?

W Pythonie „prywatność” zależy od poziomu „zgody dorosłych” - nie można tego narzucić (bardziej niż w prawdziwym życiu ;-). Jeden wiodący znak podkreślenia oznacza, że ​​nie powinieneś uzyskiwać do niego dostępu „z zewnątrz” - dwa wiodące znaki podkreślenia (bez podkreślenia końcowego) przenoszą komunikat jeszcze mocniej ... ale ostatecznie zależy to od społeczności konwencja i konsensus: introspekcja Pythona jest na tyle silna, że ​​nie możesz kajdanek każdego innego programisty na świecie, aby uszanować twoje życzenia.

((Btw, jeśli jest to ściśle utrzymywane w tajemnicy, tak samo odnosi się do C ++: z większością kompilatorów, prosta #define private publiclinia przed #includeing swoje .h! Plik jest potrzebny dla przebiegłych koderów zrobić skrót swojej „prywatności” ... -) )

Pomiędzy szeregowymi szeregowymi a prywatnymi modułowymi może być zamieszanie .

A Moduł prywatne zaczyna się od jednego podkreślenia
taki element nie zostanie skopiowany razem podczas korzystania z from <module_name> import *formularza polecenia importu; jest jednak importowany, jeśli używa się import <moudule_name>składni ( patrz odpowiedź Bena Wilhelma )
Po prostu usuń jeden znak podkreślenia z a .__ przykładu pytania i nie będzie on wyświetlany w modułach, które importują a.py przy użyciu from a import *składni.

A klasa prywatne rozpoczyna się dwoma podkreśleniami (aka Dunder czyli d-ouble pod-score)
Taka zmienna ma nazwę „zniekształcone” zawierać nazwę klasy itd.
To może nadal być dostępne poza logiką klasowej, poprzez zniekształconej nazwy.
Chociaż zmiana nazwy może służyć jako łagodne urządzenie zapobiegające nieautoryzowanemu dostępowi, jej głównym celem jest zapobieganie możliwym kolizjom nazw z członkami klas klas przodków. Zobacz zabawne, ale dokładne odniesienie Alexa Martellego do wyrażających zgodę dorosłych, gdy opisuje konwencję stosowaną w odniesieniu do tych zmiennych.

>>> class Foo(object):
...    __bar = 99
...    def PrintBar(self):
...        print(self.__bar)
...
>>> myFoo = Foo()
>>> myFoo.__bar  #direct attempt no go
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Foo' object has no attribute '__bar'
>>> myFoo.PrintBar()  # the class itself of course can access it
99
>>> dir(Foo)    # yet can see it
['PrintBar', '_Foo__bar', '__class__', '__delattr__', '__dict__', '__doc__', '__
format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__
', '__subclasshook__', '__weakref__']
>>> myFoo._Foo__bar  #and get to it by its mangled name !  (but I shouldn't!!!)
99
>>>

Na to pytanie nie udzielono pełnej odpowiedzi, ponieważ prywatność modułu nie jest czysto konwencjonalna, a ponieważ importowanie może, ale nie musi, rozpoznać prywatność modułu, w zależności od tego, w jaki sposób jest używany.

Jeśli zdefiniujesz prywatne nazwy w module, nazwy te zostaną zaimportowane do dowolnego skryptu korzystającego ze składni „import nazwa_modułu”. Tak więc, zakładając, że poprawnie zdefiniowałeś w swoim przykładzie moduł private, _num, w a.py, tak jak ...

#a.py
_num=1

.. będziesz mógł uzyskać do niego dostęp w b.py z symbolem nazwy modułu:

#b.py
import a
...
foo = a._num # 1

Aby zaimportować tylko nieprywatne z a.py, musisz użyć składni from :

#b.py
from a import *
...
foo = _num # throws NameError: name '_num' is not defined

Ze względu na przejrzystość lepiej jest jednak wyraźnie powiedzieć podczas importowania nazw z modułów, zamiast importować je wszystkie za pomocą „*”:

#b.py
from a import name1 
from a import name2
...

Python pozwala członkom klasy prywatnej z podwójnym prefiksem podkreślenia. Ta technika nie działa na poziomie modułu, więc myślę, że jest to błąd w Dive Into Python.

Oto przykład funkcji klasy prywatnej:

class foo():
    def bar(self): pass
    def __bar(self): pass

f = foo()
f.bar()   # this call succeeds
f.__bar() # this call fails

Możesz dodać funkcję wewnętrzną:

def public(self, args):
   def private(self.root, data):
       if (self.root != None):
          pass #do something with data

Coś takiego, jeśli naprawdę potrzebujesz takiego poziomu prywatności.

To starożytne pytanie, ale zmienne zniekształcone zarówno w module prywatnym (jeden podkreślnik), jak i prywatnym (dwa podkreślenia) są teraz objęte standardową dokumentacją:

Samouczek języka Python » Klasy » Zmienne prywatne

osadzone z zamknięciami lub funkcjami to jeden sposób. Jest to powszechne w JS, chociaż nie jest wymagane w przypadku platform innych niż przeglądarki lub pracowników przeglądarki.

W Pythonie wydaje się to trochę dziwne, ale jeśli coś naprawdę musi być ukryte, może to być droga. Bardziej do rzeczy przy użyciu API Pythona i trzymanie rzeczy, które wymagają ukrycia w C (lub innym języku) jest prawdopodobnie najlepszym sposobem. W przeciwnym razie wybrałbym wstawienie kodu do funkcji, wywołanie go i zwrócenie elementów, które chcesz wyeksportować.

Python ma trzy tryby:., Prywatny, publiczny i chroniony. Podczas importowania modułu dostępny jest tylko tryb publiczny. Takich prywatnych i chronionych modułów nie można wywoływać z zewnątrz modułu, tj. Kiedy jest importowany.