见PEP8指南:

方法名称和实例变量

Use the function naming rules: lowercase with words separated by underscores as necessary to improve readability. Use one leading underscore only for non-public methods and instance variables. To avoid name clashes with subclasses, use two leading underscores to invoke Python’s name mangling rules. Python mangles these names with the class name: if class Foo has an attribute named __a, it cannot be accessed by Foo.__a. (An insistent user could still gain access by calling Foo._Foo__a.) Generally, double leading underscores should be used only to avoid name conflicts with attributes in classes designed to be subclassed.

为传承而设计

Always decide whether a class’s methods and instance variables (collectively: “attributes”) should be public or non-public. If in doubt, choose non-public; it’s easier to make it public later than to make a public attribute non-public. Public attributes are those that you expect unrelated clients of your class to use, with your commitment to avoid backwards incompatible changes. Non-public attributes are those that are not intended to be used by third parties; you make no guarantees that non-public attributes won’t change or even be removed. We don’t use the term “private” here, since no attribute is really private in Python (without a generally unnecessary amount of work).

对于方法:(我不确定这是否是你想要的)

print_thrice.py

def private(method):
    def methodist(string):
        if __name__ == "__main__":
            method(string)
    return methodist
    
@private
def private_print3(string):
    print(string * 3)

private_print3("Hello ") # output: Hello Hello Hello

other_file.py

from print_thrice import private_print3
private_print3("Hello From Another File? ") # no output

这可能不是一个完美的解决方案，因为您仍然可以“看到”和/或“调用”该方法。不管怎样，它不会执行。

可能会混淆类私有和模块私有。

模块私有以一个下划线开始 当使用import命令的from <module_name> import *形式时，不会复制这样的元素;但是，如果使用import <moudule_name>语法，则会导入它(参见Ben Wilhelm的回答) 只要从问题示例的a.__num中删除一个下划线，它就不会在使用from a import *语法导入a.py的模块中显示出来。

A class private starts with two underscores (aka dunder i.e. d-ouble under-score) Such a variable has its name "mangled" to include the classname etc. It can still be accessed outside of the class logic, through the mangled name. Although the name mangling can serve as a mild prevention device against unauthorized access, its main purpose is to prevent possible name collisions with class members of the ancestor classes. See Alex Martelli's funny but accurate reference to consenting adults as he describes the convention used in regards to these variables.

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

你可以添加一个内部函数:

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

如果你真的需要那种程度的隐私的话。

抱歉我回答晚了，但是在一个模块中，你可以像这样定义包来“导出”:

mymodule
  __init__.py
  library.py
main.py

我的模块/库.py

# 'private' function
def _hello(name):
    return f"Hello {name}!"

# 'public' function which is supposed to be used instead of _hello
def hello():
    name = input('name: ')
    print(_hello(name))

mymodule里/ __init__ . py

# only imports certain functions from library
from .library import hello

main.py

import mymodule
mymodule.hello()

尽管如此，函数仍然可以被访问，

from mymodule.library import _hello
print(_hello('world'))

但这种方法使其不那么明显

这个问题没有得到完全的回答，因为模块私密性并不完全是常规的，而且使用import可能会识别模块私密性，也可能不会，这取决于它的使用方式。

如果你在一个模块中定义了私有名称，这些名称将被导入到任何使用'import module_name'语法的脚本中。因此，假设您在示例中正确定义了模块private， _num，在a.py中，如下所示..

#a.py
_num=1

．．你可以在b.py中使用模块名符号来访问它:

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

要从a.py中只导入非私有对象，你必须使用from语法:

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

然而，为了清晰起见，在从模块中导入名称时最好显式，而不是用'*'导入它们:

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