<p>1)是:</p>
<pre><code>>>> def f():
print(type(f))
>>> f()
>>> <class 'function'>
</code></pre>
<p>2)<code>function</code>类没有新属性,但对象<code>f</code>有。向对象添加或删除属性不会影响该类的其他对象将具有哪些属性:</p>
^{pr2}$
Python在Python中比java或C++更灵活。对象可以具有未在其类中定义的属性,甚至可能缺少在其类中定义的属性!看看这个:</p>
<pre><code>>>> class A:
def __init__(self, a):
self.var = a
>>> obj = A(7)
>>> del obj.var #deletes the var attribute from obj, does not change the A class
>>> obj.var
Traceback (most recent call last):
File "<pyshell#28>", line 1, in <module>
obj.var
AttributeError: 'A' object has no attribute 'var'
>>> obj2 = A(6)
>>> obj2.var #obj2 is a new object, so the fact we deleted var from obj doesn't affect it
6
</code></pre>
<p>编辑:经过一段时间的搜索,我找到了一个解释为什么选择这个行为(<a href="http://python-history.blogspot.com/2009/02/adding-support-for-user-defined-classes.html" rel="nofollow noreferrer">source</a>):</p>
<blockquote>
<p>To implement user-defined objects, I settled on the simplest possible
design; a scheme where objects were represented by a new kind of
built-in object that stored a class reference pointing to a "class
object" shared by all instances of the same class, and a dictionary,
dubbed the "instance dictionary", that contained the instance
variables.</p>
<p>In this implementation, the instance dictionary would contain the
instance variables of each individual object whereas the class object
would contain stuff shared between all instances of the same class in
particular, methods. In implementing class objects, I again chose the
simplest possible design; the set of methods of a class were stored in
a dictionary whose keys are the method names. This, I dubbed the class
dictionary. To support inheritance, class objects would additionally
store a reference to the class objects corresponding to the base
classes. At the time, I was fairly naïve about classes, but I knew
about multiple inheritance, which had recently been added to C++. I
decided that as long as I was going to support inheritance, I might as
well support a simple-minded version of multiple inheritance. Thus,
every class object could have one or more base classes.</p>
<p>In this implementation, the underlying mechanics of working with
objects are actually very simple. Whenever changes are made to
instance or class variables, those changes are simply reflected in the
underlying dictionary object. For example, setting an instance
variable on an instance updates its local instance dictionary.
Likewise, when looking up the value of a instance variable of an
object, one merely checks its instance dictionary for the existence of
that variable. If the variable is not found there, things become a
little more interesting. In that case, lookups are performed in the
class dictionary and then in the class dictionaries of each of the
base classes.</p>
</blockquote>