blocks|key|1359105|text|import+inspect


class+Number:
++++def+__init__(self,+value):
++++++++self.my_private+=+value

++++def+set_private(self,+value):
++++++++self.my_private+=+value

++++def+__setattr__(self,+my_private,+value):
++++++++f+=+inspect.stack()[1][3]
++++++++if+f+not+in+['__init__',+'set_private']:
++++++++++++raise+Exception("can't+access+private+member-my_private")
++++++++#+the+default+behavior
++++++++self.__dict__[my_private]+=+value


def+main():
++++n+=+Number(2)
++++print(n.my_private)
++++n.set_private(3)
++++print(n.my_private)


if+__name__+==+'__main__':+
++++main()|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1359106|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import inspect


class Number:
 def __init__(self, value):
 self.my_private = value

 def set_private(self, value):
 self.my_private = value

 def __setattr__(self, my_private, value):
 f = inspect.stack()[1][3]
 if f not in ['__init__', 'set_private']:
 raise Exception(&quot;can't access private member-my_private&quot;)
 # the default behavior
 self.__dict__[my_private] = value


def main():
 n = Number(2)
 print(n.my_private)
 n.set_private(3)
 print(n.my_private)


if __name__ == '__main__': 
 main()
</code></pre>

blocks|key|1359129|text|这可能会起作用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1359130|import+sys,+functools

def+private(member):
++++@functools.wraps(member)
++++def+wrapper(*function_args):
++++++myself+=+member.__name__
++++++caller+=+sys._getframe(1).f_code.co_name
++++++if+(not+caller+in+dir(function_args[0])+and+not+caller+is+myself):
+++++++++raise+Exception("%25s+called+by+%25s+is+private"%25(myself,caller))
++++++return+member(*function_args)
++++return+wrapper

class+test:
+++def+public_method(self):
++++++print('public+method+called')

+++@private
+++def+private_method(self):
++++++print('private+method+called')

t+=+test()
t.public_method()
t.private_method()|code-block|syntax|javascript|1359131|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This might work:

<pre><code>import sys, functools

def private(member):
 @functools.wraps(member)
 def wrapper(*function_args):
 myself = member.__name__
 caller = sys._getframe(1).f_code.co_name
 if (not caller in dir(function_args[0]) and not caller is myself):
 raise Exception("%s called by %s is private"%(myself,caller))
 return member(*function_args)
 return wrapper

class test:
 def public_method(self):
 print('public method called')

 @private
 def private_method(self):
 print('private method called')

t = test()
t.public_method()
t.private_method()
</code></pre>

blocks|key|1144109|text|这是一种l-o-n-g的答案，但我认为它切中了真正问题的根源--可见性的范围。你只要坚持住，我就会吃力地解决这个问题！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1144110|简单地导入一个模块并不一定要让应用程序开发人员访问它的所有类或方法；如果我实际上看不到模块源代码，我怎么知道有什么可用呢？有些人(或某些东西)必须告诉我可以做什么，并解释如何使用那些我被允许使用的功能，否则整个事情对我来说是无用的。|1144111|那些通过导入的模块开发基于基础类和方法的高级抽象的开发人员使用规范文档呈现，而不是实际的源代码。|1144112|模块规范描述了客户端开发人员可见的所有功能。在处理大型项目和软件项目团队时，模块的实际实现应该始终对使用它的人隐藏--它是一个带有到外部世界的接口的黑匣子。对于OOD纯化论者，我认为技术术语是“解耦”和“一致性”。模块用户只需要知道接口方法，而不需要了解实现的细节。|1144113|如果不首先更改其底层规范文档，就不应该更改模块，这可能需要在某些组织中进行审查/批准，然后才能更改代码。|1144114|作为业余程序员(现在已经退休了)，我开始了一个新的模块，规范文档实际上是写在模块顶部的一个巨大的注释块，这将是用户在规范库中实际看到的部分。由于只有我，我还没有建立一个库，但这将是很容易做到的。|1144115|然后，我开始编写各种类和方法，但没有函数体--只有"+print+()“这样的null+print语句--足以让模块编译时没有语法错误。当这一步完成后，我编译完成的null-module+--这是我的规范。如果我在一个项目团队中工作，在继续充实正文之前，我会将这个规范/接口提交给审查和注释。|1144116|我一次一个地充实每个方法的主体，并进行相应的编译，确保语法错误立即得到即时修复。这也是开始在底部编写一个临时的“主”执行部分的好时机，以便在编写代码时测试每个方法。当编码/测试完成时，所有的测试代码都会被注释掉，直到您再次需要它时才需要更新。|1144117|在实际的开发团队中，spec注释块也会出现在文档控件库中，但那是另一回事了。重点是:作为模块客户，您只能看到此规范，而不能看到源代码。|1144118|PS:在时间开始之前很久，我在国防航空社区工作，我们做了一些很酷的事情，但是像专有算法和敏感的系统控制逻辑这样的东西被紧密地保护和加密在超级安全的软件库中。我们可以访问模块/包接口，但不能访问blackbox实现主体。有一个处理所有系统级设计、软件规格、源代码和测试记录的文档管理工具--它们都同步在一起。政府对软件质量保证标准有严格的要求。有人记得一种叫"Ada“的语言吗？这就是我的年龄！|1144119|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|11|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|12|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|13|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|14|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|U|$]]

This is kinda a l-o-n-g answer but I think it gets to the root of the real problem here -- scope of visibility. Just hang in there while I slog through this!

Simply importing a module need not necessarily give the application developer access to all of its classes or methods; if I can't actually SEE the module source code how will I know what's available? Some one (or some THING) has to tell me what I can do and explain how to use those features I'm allowed to use, otherwise the whole thing is useless to me.

Those developing higher-level abstractions based on fundamental classes and methods via imported modules are presented with a specification DOCUMENT -- NOT the actual source code. 

The module spec describes all the features intended to be visible to the client developer. When dealing with large projects and software project teams, the actual implementation of a module should ALWAYS remain hidden from those using it -- it's a blackbox with an interface to the outside world. For OOD purists, I believe the techie terms are "decoupling" and "coherence". The module user need only know the interface methods without being burden with the details of implementation. 

A module should NEVER be changed without first changing its underlying spec document, which may require review / approval in some organizations prior to changing the code.

As hobby programmer (retired now), I start a new module with the spec doc actually written out as a giant comment block at the top of the module, this will be the part the user actually sees in the spec library. Since it's just me, I've yet to set up a library, but it would be easy enough to do. 

Then I begin coding by writing the various classes and methods but without functional bodies -- just null print statements like "print()" -- just enough to allow the module to compile without syntax errors. When this step is complete I compile the completed null-module -- this is my spec. If I were working on a project team, I would present this spec/interface for review &amp; commentary before proceeding with fleshing out the body.

I flesh out the bodies of each method one at a time and compile accordingly, ensuring syntax errors are fixed immediately on-the-fly. This is also a good time to start writing a temporary "main" execution section at the bottom to test each method as you code it. When the coding/testing are complete, all of the test code is commented out until you need it again should updates become necessary. 

In a real-world development team, the spec comment block would also appear in a document control library, but that's another story. The point is: you, as the module client, see only this spec and NOT the source code.

PS: long before the beginning of time, I worked in the defense aerospace community and we did some pretty cool stuff, but things like proprietary algorithms and sensitive systems control logic were tightly vaulted and encrypted in super-duper secure software libraries. We had access to module / package interfaces but NOT the blackbox implementation bodies. There was a document management tool that handled all system-level designs, software specs, source code and test records -- it was all synched together. The government had strict requirements software quality assurance standards. Anyone remember a language called "Ada"? That's how old I am!

How can I make methods and data members private in Python? Or doesn't Python support private members?

Private members in Python

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

如何在Python中使方法和数据成员成为私有的？或者Python不支持私有成员？

问Python中的私有成员
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中的私有成员EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中的私有成员
EN