blocks|key|776772|text|首先:类属性，还是实例属性？或者两者兼而有之|type|unstyled|depth|inlineStyleRanges|entityRanges|data|776773|通常您只需在__init__中添加实例属性，在类定义中添加类属性，通常在方法定义之前添加.这可能涵盖90%25的用例。|offset|length|style|CODE|776774|如果代码动态添加属性，它可能(希望:-)有很好的理由这样做.利用动态特性、内省等等，除此之外，以这种方式添加属性可能不像您想象的那么常见。|776775|entityMap^0|0|6|8|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

First of all: class attributes, or instance attributes? Or both? =)

Usually you just add instance attributes in <code>__init__</code>, and class attributes in the class definition, often before method definitions... which should probably cover 90% of use cases.

If code adds attributes on the fly, it probably (hopefully :-) has good reasons for doing so... leveraging dynamic features, introspection, etc. Other than that, adding attributes this way is probably less common than you think.

blocks|key|2020552|text|我想说的是，避免这种情况的标准做法是，不要在离任何东西1000行的地方编写类！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2020553|说真的，对于任何有用的类来说，这都太过分了，尤其是在像Python这样具有表现力的语言中。使用标准库提供的更多内容，并将代码抽象到单独的模块中，将有助于降低LOC的数量。|2020554|标准库中最大的类有远低于100行的！|2020555|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I would say, the standard practice to avoid this is to not write classes where you can be 1000 lines away from anything!

Seriously, that's way too much for just about any useful class, especially in a language that is as expressive as Python. Using more of what the Standard Library offers and abstracting away code into separate modules should help keeping your LOC count down.

The largest classes in the standard library have well below 100 lines!

blocks|key|776894|text|匹林特可以静态地检测__init__中没有检测到的属性，以及许多其他潜在的bug。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|776895|我还建议编写单元测试并经常运行代码，以检测这些类型的"whoopsie“编程错误。|776896|entityMap|0|LINK|mutability|MUTABLE|url|http://www.logilab.org/project/pylint^0|A|8|0|3|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

<a href="http://www.logilab.org/project/pylint" rel="noreferrer">pylint</a> can statically detect attributes that aren't detected in <code>__init__</code>, along with many other potential bugs.

I'd also recommend writing unit tests and running your code often to detect these types of "whoopsie" programming mistakes.

blocks|key|2020497|text|实例变量应该在类的__init__()方法中初始化。(一般情况)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2020498|如果不可能的话。您可以在运行时使用__dict__获取对象的所有实例变量的字典。如果您确实需要在文档中跟踪这一点，那么在类的docstring中添加一个实例变量列表。|2020499|entityMap^0|9|A|0|H|8|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

Instance variables should be initialized in the class's <code>__init__()</code> method. (In general)

If that's not possible. You can use <code>__dict__</code> to get a dictionary of all instance variables of an object during runtime. If you really need to track this in documentation add a list of instance variables you are using into the docstring of the class.

blocks|key|777809|text|听起来你说的是实例变量，而不是类变量。注意，在下面的代码中，a是类变量，b是实例变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|777810|class+foo:
++a+=+0+#class+variable

++def+__init__(self):
++++self.b+=+0+#instance+variable|code-block|syntax|javascript|777811|假设您创建了一个不需要的实例变量，因为另一个变量大约在1000行之外:最好的解决方案是不要有1000行长的类。如果您无法避免长度，那么您的类应该有一个明确的目标，这将使您能够立即将所有的复杂性都保留在头脑中。|777812|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

It sounds like you're talking about instance variables and not class variables. Note that in the following code a is a class variable and b is an instance variable.

<pre><code>class foo:
 a = 0 #class variable

 def __init__(self):
 self.b = 0 #instance variable
</code></pre>

Regarding the hypothetical where you create an unneeded instance variable because the other one was about one thousand lines away: The best solution is to not have classes that are one thousand lines long. If you can't avoid the length, then your class should have a well defined purpose and that will enable you to keep all of the complexities in your head at once.

blocks|key|487674|text|文档生成系统(如艾比多克+)可以用作引用对象的实例/类变量，如果担心通过键入意外创建新变量，可以使用PyChecker检查代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|487675|entityMap|0|LINK|mutability|MUTABLE|url|http://epydoc.sourceforge.net/|1|http://pychecker.sourceforge.net/^0|8|4|0|1E|9|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

A documentation generation system such as <a href="http://epydoc.sourceforge.net/" rel="nofollow noreferrer">Epydoc</a> can be used as a reference for what instance/class variables an object has, and if you're worried about accidentally creating new variables via typos you can use <a href="http://pychecker.sourceforge.net/" rel="nofollow noreferrer">PyChecker</a> to check your code for this.

blocks|key|487764|text|这是许多来自C、C%2B%2B或其他静态类型语言的程序员共同关心的问题，在这些语言中，变量是预先声明的。事实上，当我们说服组织中的程序员放弃C，转而使用Python时，这是我们听到的最大的担忧之一。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|487765|理论上，是的，您可以在任何时候向对象添加实例变量。是的，它可以发生在打字等。在实践中，它很少导致一个错误。如果是这样的话，通常不难找到bug。|487766|只要您的类不膨胀(1000行是相当大的！)而且你有足够的单元测试，你很少会遇到真正的问题。如果您这样做了，那么在几乎任何时候都可以很容易地放到Python控制台上，并根据您的意愿检查所有内容。|487767|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

This is a common concern I hear from many programmers who come from a C, C++, or other statically typed language where variables are pre-declared. In fact it was one of the biggest concerns we heard when we were persuading programmers at our organization to abandon C for high-level programs and use Python instead.

In theory, yes you can add instance variables to an object at any time. Yes it can happen from typos, etc. In practice, it rarely results in a bug. When it does, the bugs are generally not hard to find. 

As long as your classes are not bloated (1000 lines is pretty huge!) and you have ample unit tests, you should rarely run in to a real problem. In case you do, it's easy to drop to a Python console at almost any time and inspect things as much as you wish.

blocks|key|2020750|text|在我看来，这里的主要问题是，您在使用python时考虑的是C%2B%2B。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2020751|在python中，拥有1000行类并不是非常明智的事情(我知道在C%2B%2B中经常发生这种情况)，|2020752|学习如何利用python提供的动态，例如，您可以以非常有创意的方式组合列表和字典，并节省数百行无用的代码。|2020753|例如，如果要将字符串映射到函数(用于调度)，则可以利用以下事实:函数是第一类对象，并具有如下所示的字典：|2020754|d+=+{'command1'+:+func1,+'command2':+func2,+'command3'+:+func3}
#then+somewhere+else+use+this+list+to+dispatch
#given+a+string+`str`
func+=+d[str]
func()+#call+the+function!|code-block|syntax|javascript|2020755|在C%2B%2B中这样的东西会占用很多代码行！|2020756|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

It seems to me that the main issue here is that you're thinking in terms of C++ when you're working in python.

Having a 1000 line class is not a very wise thing anyway in python, (I know it happens alot in C++ though), 

Learn to exploit the dynamism that python gives you, for instance you can combine lists and dictionaries in very creative ways and save your self hundreds of useless lines of code.

For example, if you're mapping strings to functions (for dispatching), you can exploit the fact that functions are first class objects and have a dictionary that goes like:

<pre><code>d = {'command1' : func1, 'command2': func2, 'command3' : func3}
#then somewhere else use this list to dispatch
#given a string `str`
func = d[str]
func() #call the function!
</code></pre>

Something like this in C++ would take up sooo many lines of code!

blocks|key|2020399|text|最简单的方法是使用IDE。PyDev是eclipse的插件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2020400|在所有方面我都不是专家，但一般来说，我在python中的类定义下定义了类成员，所以如果我添加成员，它们都是相对的。|2020401|我个人的意见是，由于这个具体原因，应该在一节中宣布班级成员。|2020402|局部变量otoh应该在使用时定义得最接近(除了C--我认为C中仍然需要在方法开始时声明变量)。|2020403|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

The easiest is to use an IDE. PyDev is a plugin for eclipse.

I'm not a full on expert in all ways pythonic, but in general I define my class members right under the class definition in python, so if I add members, they're all relative.

My personal opinion is that class members should be declared in one section, for this specific reason.

Local scoped variables, otoh, should be defined closest to when they are used (except in C--which I believe still requires variables to be declared at the beginning of a method).

I'm a C++ programmer just starting to learn Python. I'd like to know how you keep track of instance variables in large Python classes. I'm used to having a <code>.h</code> file that gives me a neat list (complete with comments) of all the class' members. But since Python allows you to add new instance variables on the fly, how do you keep track of them all?

I'm picturing a scenario where I mistakenly add a new instance variable when I already had one - but it was 1000 lines away from where I was working. Are there standard practices for avoiding this?

Edit: It appears I created some confusion with the term "member variable." I really mean instance variable, and I've edited my question accordingly.

What's a good way to keep track of class instance variables in Python?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我是一个C++程序员，刚刚开始学习Python。我想知道如何跟踪大型Python类中的实例变量。我习惯于拥有一个.h文件，它为我提供了一个完整的类成员列表(包括注释)。但是既然Python允许动态添加新的实例变量，那么如何跟踪它们呢？我设想了一个场景，当我已经有一个实例变量时，我错误地添加了一个新的实例变量--但是它离我工作的地方还有1000行。是否有避免这种情况的标准做法？编辑：--似乎我用“成

问在Python中跟踪类实例变量的好方法是什么？
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Python中跟踪类实例变量的好方法是什么？EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Python中跟踪类实例变量的好方法是什么？
EN