使用 tf.placeholder 来创建一个占位符，创建时需要指定它的类型。 比如我们要建立一个数学公式 2x² + 3x + 1，此时就需要将x定义为一个占位符。这样我们才能在求解公式的值时，动态地指定x的值。

import tensorflow as tf

x = tf.placeholder(tf.int32)    1
y = 2*x*x + 3*x + 1   2

sess = tf.Session()
r = sess.run(y, feed_dict={x:2})   3

• 1 ：创建一个占位符，其类型为int32
• 2 ：定义数学公式。其中自变量为x，函数值为y
• 3 ：求解给定自变量x为2时，函数值y的值。通过 feed_dict 参数指定一个占位符的值。 运行过后，r的值为15（2*2² + 3*2 + 1）

占位符有点像编程语言中变量的概念，但关键不同为：占位符不会保存值，当指定一个值给它后，它并不会将这个值保存起来，以便下次使用。而是你每次使用它时，都必须为它指定一个新值。而变量则会将上次的值一直保存，下次使用时你不必再指定新值，它会直接使用上次保存的值。

一个数学公式中的自变量正好需要这样：它本身没有状态（即不会保存上次的值），你每次求解公式的值时，都必须指定自变量的值。所以，占位符的作用为：

占位符提供了一种给模型指定自变量值的机制

一个基本规则为，在使用Tensorflow建模时，将模型的自变量和因变量定义为占位符，这就对了。

如果一个模型中包含了占位符，则在求解这个模型值时，Tensorflow会强制必须指定所有占位符的值，通过 feed_dict 。如上面例子所示，在求解y时，必须指定x的值。

如果没有指定x的值，如下所示：

r = sess.run(y)

则会报一个错误：

You must feed a value for placeholder tensor \'Placeholder\' with dtype

使用tf.Variable创建一个变量。变量跟编程语言中的变量的概念非常相似，表示一个存储空间，能够保存一个值。变量在使用必须有一个初始值，你可以改变一个变量的值。

使用Tensoflow创建机器学习模型时，变量被用于表示模型的参数。一般来说，训练机器学习模型的过程，就是寻找模型参数的过程。在训练开始前，都会给参数一个初始值，然后逐渐修改变量的值，使得模型能够逼近训练数据。

以下是使用变量的一个例子。

a = tf.Variable(3, name='my_a')
b = tf.constant(3)
c = a*b

# a variable must be initilized
init = tf.global_variables_initializer()
self.sess.run(init)
r = self.sess.run(c) # r=9

变量在使用必须被初始化，通过调用 tf.global_{variablesinitializer}() 来实现。如果没有初始化，则会报下面的错误。

Attempting to use uninitialized value my_a

当使用占位符和变量构造好模型及目标函数后，便可使用优化来求解模型的参数。使用占位符表示模型的自变量和因变量（即模型的X，Y），使用变量表示模型的参数。

使用Tenforflow建模时，将模型的自变量和因变量定义为占位符（Placeholder），这样我们可以动态地指定自变量和因变量的值。

将模型的参数指定为变量（Variable），并给定一个初值，这样Tensorflow在求解模型参数过程中，其可以不断修改参数的值，直到模型能够和数据点吻合。

优化器是Tensorflow求解模型的工具，梯度下降是一种常用的优化器。

要实现并行化，最简单的方法是为每一个子任务创建一个thread，thread处理完后退出。

from threading import Thread
from time import sleep

def T(dir, pattern):
  "This is just a stub that simulate a dir operation"
  sleep(1)
  print('searching pattern %s in dir %s' % (pattern, dir))

threads = []
dirs = ['a/b/c', 'a/b/d', 'b/c', 'd/f']
pattern = 'hello'

for dir in dirs:
  thread = Thread(target=T, args=(dir, pattern))   1
  thread.start()   2
  threads.append(thread)

for thread in threads:
  thread.join()   3

print('Main thread end here')

• 1 ：创建一个Thread对象，target参数指定这个thread待执行的函数，args参数指定target函数的输入参数
• 2 ：启动这个thread。 T(dir, pattern)将被调用
• 3 ：等待，直到这个thread结束。整个for循环表示主进程会等待所有子线程结束后再退出

程序的运行结果为：

searching pattern hello in dir a/b/csearching pattern hello in dir d/f
searching pattern hello in dir b/c
 searching pattern hello in dir a/b/d

Main thread end here

可以看出由于线程是并行运行的，部分输出会交叠。但主进程的打印总在最后。

以上例子中对于每个dir都需要创建一个thread。如果dir的数目较多，则会创建太多的thread，影响运行效率。 较好的方式是限制总线程的数目。

可以使用信号量（semaphore）来限制同时运行的最大线程数目。如下所示：

from threading import Thread, BoundedSemaphore
from time import sleep

def T(dir, pattern):
  "This is just a stub that simulate a dir operation"
  sleep(1)
  print('searching pattern %s in dir %s' % (pattern, dir))

threads = []
dirs = ['a/b/c', 'a/b/d', 'b/c', 'd/f']
pattern = 'hello'

maxjobs = BoundedSemaphore(2)   1
def wrapper(dir, pattern):
  T(dir, pattern)
  maxjobs.release()   2

for dir in dirs:
  maxjobs.acquire()   3
  thread = Thread(target=wrapper, args=(dir, pattern))
  thread.start()
  threads.append(thread)

for thread in threads:
  thread.join() 

print('Main thread end here')

• 1 ：创建一个有2个资源的信号量。一个信号量代表总的可用的资源数目，这里表示同时运行的最大线程数目为2。
• 2 ：在线程结束时释放资源。运行在子线程中。
• 3 ：在启动一个线程前，先获取一个资源。如果当前已经有2个线程在运行，则会阻塞，直到其中一个线程结束。 运行在主线程中。

当限制了最大运行线程数为2后，由于只有2个线程同时运行，程序的输出更加有序，几乎总是为：

searching pattern hello in dir a/b/c
searching pattern hello in dir a/b/d
searching pattern hello in dir b/c
searching pattern hello in dir d/f
Main thread end here

以上实现中为每个子任务创建一个线程进行处理，然后通过信号量限制同时运行的线程的数目。如果子任务很多，这种方法会创建太多的线程。更好的方法 是使用线程池。

即预先创建一定数目的线程，形成一个线程池。每个线程持续处理多个子任务（而不是处理一个就退出）。这样做的好处是：创建的线程数目会比较固定。

那么，每个线程处理哪些子任务呢？一种方法为：预先将所有子任务均分给每个线程。如下所示：

from threading import Thread
from time import sleep

def T(dir, pattern):
  "This is just a stub that simulate a dir operation"
  sleep(1)
  print('searching pattern %s in dir %s' % (pattern, dir))

dirs = ['a/b/c', 'a/b/d', 'b/c', 'd/f']
pattern = 'hello'

def wrapper(dirs, pattern):   1
  for dir in dirs:
    T(dir, pattern)

threadsPool = [   2
  Thread(target=wrapper, args=(dirs[0:2], pattern)),
  Thread(target=wrapper, args=(dirs[2:], pattern)),
]

for thread in threadsPool:   3
  thread.start()

for thread in threadsPool:
  thread.join()

print('Main thread end here')

• 1 ：这个函数能够处理多个dir，将作为线程的target函数
• 2 ：创建一个有2个线程的线程池。并事先分配子任务给每个线程。线程1处理前两个dir，线程2处理后两个dir
• 3 ：启动线程池中所有线程

程序的输出结果为：

searching pattern hello in dir a/b/csearching pattern hello in dir b/c

searching pattern hello in dir d/f
 searching pattern hello in dir a/b/d
Main thread end here

这种方法存在以下问题：

1. 子任务分配可能不均。导致每个线程运行时间差别可能较大，则整体运行时长可能被拖长
2. 只能处理所有子任务都预先知道的情况，无法处理子任务实时出现的情况

如果有一种方法，能够让线程知道当前所有的待处理子任务，线程一旦空闲，便可以从中获取一个任务进行处理，则以上问题都可以解决。任务队列便是解决方案。

可以使用Queue实现一个任务队列，用于在线程间传递子任务。主线程将所有待处理子任务放置在队列中，子线程从队列中获取子任务去处理。 如下所有（注：以下代码只运行于Python 2，因为Queue只存在于Python 2） ：

from threading import Thread
from time import sleep
import Queue

def T(dir, pattern):
  "This is just a stub that simulate a dir operation"
  sleep(1)
  print('searching pattern %s in dir %s' % (pattern, dir))

dirs = ['a/b/c', 'a/b/d', 'b/c', 'd/f']
pattern = 'hello'

taskQueue = Queue.Queue()   1

def wrapper():
  while True:
    try:
      dir = taskQueue.get(True, 0.1)   2
      T(dir, pattern)
    except Queue.Empty:
	continue

threadsPool = [Thread(target=wrapper) for i in range(2)]   3

for thread in threadsPool: 
  thread.start()    4

for dir in dirs:
  taskQueue.put(dir)   5

for thread in threadsPool:
  thread.join()
print('Main thread end here')

• 1 ：创建一个任务队列
• 2 ：子线程从任务队列中获取一个任务。第一个参数为True，表示如果没有任务，会等待。第二个参数表示最长等待0.1秒 如果在0.1秒后仍然没有任务，则会抛出一个Queue.Empty的异常
• 3 ：创建有2个线程的线程池。注意target函数wrapper没有任何参数
• 4 ：启动所有线程
• 5 ：主线程将所有子任务放置在任务队列中，以供子线程获取处理。由于子线程已经被启动，则子线程会立即获取到任务并处理

程序的输出为：

searching pattern hello in dir a/b/c
searching pattern hello in dir a/b/d
searching pattern hello in dir b/c
 searching pattern hello in dir d/f

从中可以看出主进程的打印结果并没有出来，程序会一直运行，而不退出。这个问题的原因是：目前的实现中，子线程为一个无限循环， 因此其永远不会终止。因此，必须有一种机制来结束子进程。

一种简单方法为，可以在任务队列中放置一个特殊元素，作为终止符。当子线程从任务队列中获取这个终止符后，便自行退出。如下所示，使用None作为终止符。

from threading import Thread
from time import sleep
import Queue

def T(dir, pattern):
  "This is just a stub that simulate a dir operation"
  sleep(1)
  print('searching pattern %s in dir %s' % (pattern, dir))

dirs = ['a/b/c', 'a/b/d', 'b/c', 'd/f']
pattern = 'hello'

taskQueue = Queue.Queue()

def wrapper():
  while True:
    try:
      dir = taskQueue.get(True, 0.1)
      if dir is None:   1
	taskQueue.put(dir)   2
	break

      T(dir, pattern)
    except Queue.Empty:
	continue

threadsPool = [Thread(target=wrapper) for i in range(2)]

for thread in threadsPool:
  thread.start()

for dir in dirs:
  taskQueue.put(dir)

taskQueue.put(None)   3

for thread in threadsPool:
  thread.join()
print('Main thread end here')

• 1 ：如果任务为终止符（此处为None），则退出
• 2 ：将这个终止符重新放回任务队列。因为只有一个终止符，如果不放回，则其它子线程获取不到，也就无法终止
• 3 ：将终止符放在任务队列。注意必须放置在末尾，否则终止符后的任务无法得到处理

修改过后，程序能够正常运行，主进程能够正常退出了。

searching pattern hello in dir a/b/csearching pattern hello in dir a/b/d

searching pattern hello in dir b/c
 searching pattern hello in dir d/f
Main thread end here

要并行化处理子任务，最简单的方法是为每个子任务创建一个线程去处理。这种方法的缺点是：如果子任务非常多，则需要创建的线程数目会非常多。 并且同时运行的线程数目也会较多。通过使用信号量来限制同时运行的线程数目，通过线程池来避免创建过多的线程。

与每个线程处理一个任务不同，线程池中每个线程会处理多个子任务。这带来一个问题：每个子线程如何知道要处理哪些子任务。 一种方法是预先将所有子任务均分给每个线程，而更灵活的方法则是通过任务队列，由子线程自行决定要处理哪些任务。

使用线程池时，线程主函数通常实现为一个无限循环，因此需要考虑如何终止线程。可以在任务队列中放置一个终止符来告诉线程没有更多任务， 因此其可以终止。

语句块

@atexit.register
def goodbye():
  print('Goodbye!')

等价于

def goodbye():
  print('Goodbye!')
goodbye = atexit.register(goodbye)

这两种写法在作用上完全等价。

从第二种写法，更容易看出装饰器的原理。装饰器实际上是一个函数（或callable），其输入、返回值为：

返回值会被赋值给原来指向输入函数的变量，如示例中的 goodbye 。此时变量 goodbye 将指向装饰器的返回值，而不是原来的函数定义。返回值一般为一个函数，这个函数是在输入参数函数添加了一些额外操作的版本。

如下面这个装饰器对原始函数添加了一个操作：每次调用这个函数时，打印函数的输入参数及返回值。

def trace(func):
  def wrapper(*args, **kwargs):   1
    print('Enter. Args: %s, kwargs: %s' % (args, kwargs))   2
    rv = func(*args, **kwargs)   3
    print('Exit. Return value: %s' % (rv))   4
    return rv

  return wrapper

@trace
def area(height, width):
  print('area called')
  return height * width

area(2, 3)   5

1. 1 ：定义一个新函数，这个函数将作为装饰器的返回值，来替换原函数
2. 2, 4 ： 打印输入参数、返回值。这是这个装饰器所定义的操作
3. 3 ：调用原函数
4. 5 ：此时 area 实际上是 1 处定义的 wrapper 函数

程序的运行结果为：

Enter. Args: (2, 3), kwargs: {}
area called
Exit. Return value: 6

如果不使用装饰器，则必须将以上打印输入参数及返回值的语句直接写在 area 函数里，如：

def area(height, width):
  print('Enter. Args: %s, %s' % (height, width))
  print('area called')
  rv = height * width
  print('Exit. Return value: %s' % (rv))
  return rv

area(2, 3)

程序的运行结果与使用装饰器时相同。但使用装饰器的好处为：

1. 打印输入参数及返回值这个操作可被重用

   如对于一个新的函数 foo ，装饰器 trace 可以直接拿来使用，而无须在函数内部重复写两条 print 语句。

   @trace
   def foo(val):
     return 'return value'
   

   一个装饰器实际上定义了一种可重复使用的操作

2. 函数的功能更单纯

   area 函数的功能是计算面积，而调试语句与其功能无关。使用装饰器可以将与函数功能无关的语句提取出来。 因此函数可以写地更小。

   使用装饰器，相当于将两个小函数组合起来，组成功能更强大的函数

以上例子中有一个缺陷，函数 area 被 trace 装饰后，其名称变为 wrapper ，而非 area 。 print(area) 的结果为：

<function wrapper at 0x10df45668>

wrapper 这个名称来源于 trace 中定义的 wrapper 函数。

可以通过 functools.wraps 来修正这个问题。

from functools import wraps 

def trace(func):
  @wraps(func) 
  def wrapper(*args, **kwargs):
    print('Enter. Args: %s, kwargs: %s' % (args, kwargs))
    rv = func(*args, **kwargs)
    print('Exit. Return value: %s' % (rv))
    return rv

  return wrapper

@trace
def area(height, width):
  print('area called')
  return height * width

即使用 functools.wraps 来装饰 wrapper 。此时 print(area) 的结果为：

<function area at 0x10e8371b8>

函数的名称能够正确显示。

以上例子中 trace 这个装饰器在使用时不接受参数。如果想传入参数，如传入被装饰函数的名称，可以这么做：

from functools import wraps

def trace(name):
  def wrapper(func):
    @wraps(func)
    def wrapped(*args, **kwargs):
      print('Enter %s. Args: %s, kwargs: %s' % (name, args, kwargs))
      rv = func(*args, **kwargs)
      print('Exit %s. Return value: %s' % (name, rv))
      return rv

    return wrapped
  return wrapper

@trace('area')
def area(height, width):
  print('area called')
  return height * width

area(2, 3)

程序的运行结果为：

Enter area. Args: (2, 3), kwargs: {}
area called
Exit area. Return value: 6

将函数名称传入后，在日志同时打印出函数名，日志更加清晰。

@trace('area') 是如何工作的？

这里其实包含了两个步骤。 @trace('area') 等价于：

dec = trace('area')
@dec
def area(height, width): ...

即先触发函数调用 trace('area') ，得到一个返回值，这个返回值为 wrapper 函数。 而这个函数才是真正的装饰器，然后使用这个装饰器装饰函数。

装饰器可以叠加使用，如：

@dec1
@dec2
def foo():pass

等价的代码为：

def foo():pass
foo = dec2(foo)
foo = dec1(foo)

即装饰器依次装饰函数，靠近函数定义的装饰器优先。相当于串联起来。

任何实现了描述符协议的类都可以作为描述符类。描述符协议为一组成员函数定义，包括：

如果一个类实现了以上成员函数，则它便是一个描述符类，其实例对象便是一个描述符

下面是一个自定义的描述符的实现。

class MyDescriptor:
  def __init__(self):
    self.data = None
  def __get__(self, obj, type):
    print('get called')
    return self.data
  def __set__(self, obj, value):
    print('set called')
    self.data = value
  def __delete__(self, obj):
    print('delete called')
    del self.data

class Foo:
  attr = MyDescriptor()

foo = Foo()

示例中 MyDescriptor 实现了描述符协议（也即实现了 __get__, __set__, __delete__ 函数），因此其为一个描述符类。 Foo 的 attr 属性为 MyDescriptor 类的实例对象，因此它是一个描述符。

print(foo.attr) 的输出为：

get called
None

可见当访问 foo 的 attr 属性时， MyDescriptor 的 __get__ 函数被调用。

foo.attr = 'new value' 的输出为：

set called

可见当为 attr 设置一个新值时， MyDescriptor 的 __set__ 函数被调用。

再运行 print(foo.attr) ，输出为：

get called
new value

可见新值已被设置。

del foo.attr 的输出为：

delete called

可见当为删除属性 attr 时， MyDescriptor 的 __delete__ 函数被调用。

再执行 print(foo.attr) ， AttributeError 被抛出：

get called
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "1.py", line 6, in __get__
    return self.data
AttributeError: 'MyDescriptor' object has no attribute 'data'

可见属性 attr 已被删除。

__get__(self, obj, type) 函数各个参数的意义为：

__set__(self, obj, value) 函数的self和obj参数的意义同 __get__ ，value的意义为：

__delete__(self, obj) 函数的self和obj参数的意义同 __get__ 。

（全文完）

以上第2条规则提到：查询y是否为x的类C（及其父类）的属性。即为了获取x.y，去查询C.y，其中C为x的类型。C.y具体是如何查询的呢？

C.y与x.y的查询机制相同，此时C便是一个当前的对象（事实上Python类本身是一个类型为type的对象实例）。 所以查询C.y，将以上步骤中x替换为C，则得到C.y的具体步骤：

1. 查询y是否存在于 C.__dict__ 。 存在则返回
2. 查询y是否为C的类CC（此时为type）的属性。 存在则返回
3. 查询失败，抛出 AttributeError。

以下例子可以验证。

class Foo:
  attr1 = 'value1'
  def __init__(self, attr2):
    self.attr2 = attr2

print(type(Foo)) # <type 'classobj'>
assert(Foo.attr1 is Foo.__dict__['attr1'])    # True

type(Foo) 的结果为 <type 'classobj'> 。所以Foo是类型type的一个对象实例。attr1是Foo的一个属性，保存在 Foo.__dict__ 中（这一点，跟其它自定义对象实例一致）。

由此可见，Foo（类本身）及foo（Foo的一个对象实例）在属性查询上，并没有什么不同。他们的不同点为Foo由Python解析器自动创建（当其解析class Foo语句时），而foo一般由程序自己创建（foo = Foo('value2'))。

对于x.y，当属性y是一个描述符时， Python2和Python3的处理规则有所不同。对于Python2，查询规则变为：

1. 查询y是否存在于 x.__dict__ 。 存在则返回
2. 查询y是否为描述符。若是则通过描述符来处理属性获取
3. 查询y是否为x的类C（及其父类）的属性。 存在则返回
4. 查询失败，抛出 AttributeError。

对于Python3，查询规则为：

1. 查询y是否为描述符。若是则通过描述符来处理属性获取
2. 查询y是否存在于 x.__dict__ 。 存在则返回
3. 查询y是否为x的类C（及其父类）的属性。 存在则返回
4. 查询失败，抛出 AttributeError。

区别在于描述符属性与对象级属性（通过 x.__dict__ 获取的属性）的优先级不同。在Python2中，对象级属性优先级更高，而在Python3中，描述符属性优先级更高。

先来看一个例子。

class Foo:
  attr1 = 'value1'
  def __init__(self, attr2):
    self.__dict__['attr2'] = attr2

  @property
  def attr2(self):
    return 'value2, descriptor attr'

foo = Foo('value2, instance attr')
# Python2的输出为: value2, instance attr
# Python3的输出为: value2, descriptor attr
print(foo.attr2) 

通过@property修饰后，函数attr2变为一个描述符。当通过foo.attr2获取attr2这个属性时，函数attr2会被调用，其返回值即为这个属性的值。

同时在 __init__ 函数中，创建了一个同名的attr2实例级属性。需要注意此时不能使用语句 self.attr2 = attr2 来创建这个实例级属性，因为此时描述符已发生作用，attr2不会被保存在 self.__dict__ 中，而是直接通过描述符函数处理。

对于语句x.y，记对象x的类型为C， C.y的类型为D。如果

1. C.y存在，即hasattr(C, 'y') 为True
2. 且 D包含一个 __get__ 属性， 即hasattr(D, '__get__' )为True

则可判定y为一个描述符。

第1个条件表示y为x的一个类级属性，即y为C的属性。第2个条件表示这个属性的类型包含一个 __get__ 属性。 等价的Python代码如下：

is_descriptor = False
C = x.__class__
if hasattr(C, 'y'):
  D = C.y.__class__
  if hasattr(D, '__get__'):
    is_descriptor = True

如果一个描述符仅包含 __get__ 属性，而没有 __set__ 属性，则它为一个非数据描述符，也即只能获取这个属性的值，而不能修改它的值。

如果一个描述符同时包含 __get__ 和 __set__ 属性，则它为一个数据描述符，此时即可获取属性值，也可修改它的值。

对于Python3，之前提到的规则只适用于数据描述符。如果一个属性是一个非数据描述符，则实例级属性（ x.__dict__['attr'] ）的优先级高于描述符的优先级，所以查询规则变为：

1. 查询y是否为数据描述符。若是则通过描述符来处理属性获取
2. 查询y是否存在于 x.__dict__ 。 存在则返回
3. 查询y是否为非数据描述符。若是则通过描述符来处理属性获取
4. 查询y是否为x的类C（及其父类）的属性。 存在则返回
5. 查询失败，抛出 AttributeError。

通过以下例子，可以看出这样做的逻辑。假设y是一个非数据描述符，且y不存在于 x.__dict__ 中。

1. 执行语句 x.y，第1、2条规则均不满足条件，因此第3条规则发生作用，属性值通过描述符来得到。
2. 执行语句 x.y = 'new value'， 由于y为一个非数据描述符，因此无法通过这个描述符修改这个属性的值。因此y会被保存在 x.__dict__ 中。
3. 再次执行 x.y，第2条规则满足条件，此时返回 x.__dict__ 中保存的值

逻辑在于，当为属性设置一个新值后（第2步），再获取这个属性的值时（第3步），这个值应该与之前设置的值相同，而不是仍然为之前通过描述符返回的值。所以在这种情况下， x.__dict__ 的优先级需要更高。

类成员函数的实现为一个非数据描述符。根据以上规则，对象的属性会覆盖对象的同名成员函数。

以下为一个例子。

# encoding:utf8
class Foo:
  def __init__(self, value):
    self.attr = value

  def attr(self):
    print('attr method')

  def attr2(self):
    print('attr2 method')

foo = Foo('attr value')
assert(foo.attr is foo.__dict__['attr'])
foo.attr() # 错误，attr不是成员函数，无法调用
foo.attr2() # 正确，输出为 attr2 method

对象foo包含一个属性attr，同时包含一个同名函数attr。assert 语句为True表明foo.attr为属性值，而非那个同名函数。

根据属性保存位置的不同，可以将属性分类为特殊属性和自定义属性。先来看一个例子。

class Foo:
    pass

f = Foo()
print(f.__dict__)
f.name = "Tom"
print(f.__dict__)
print(f.__dict__['name'] is f.name)
print(f.__class__)
f.__dict__['__class__'] = 'My class'
print(f.__class__)

f.__dict__['bar'] = 'xxx'
print(f.bar)

结果为：

{}
{'name': 'Tom'}
True
<class '__main__.Foo'>
<class '__main__.Foo'>
xxx

从这个例子中，我们可以看出：

• 我们为一个对象新添加的属性都会被保存在 'dict' 这个特殊属性中，'dict'的类型是字典。如在添加了 name 这个属性后， dict 的值变为 {'name': 'Tom'}，添加前为一个空字典。
• 对于我们自己新添加的属性，可以通过两种方式来访问这个属性： f.name 和 f.__dict__['name']。这两种方式的效果完全相同，因为它们代表的是同一个变量。因此可认为 f.name 是 f.__dict__['name'] 的一种简写方式。
• 对于任意的属性，f.xyz 的解析过程为：1. 首先检查xyz这个属性在对象中是否存在，如存在，则返回这个属性。2. 否则再检查 xyz这个属性在f.__dict__是否存在，如存在，则返回这个属性。 如上面代码里，尽管我们通过直接在__dict__为对象添加一个名为__class__的属性，但由于这个属性对象本身就定义了，因此它还是原来的值。也即在以上第一步中即找到了这个属性。 而对于'bar' 属性，添加后再查询就是我们添加的值，在以上第2步中找到这个属性。

因此可将一个python对象理解为一个C语言中的结构体，这个结构体的成员在对象创建后，就固定了，无法再添加新的成员。在本文中我们称这些属性为特殊属性。但实际上我们又是可以为一个对象添加新的属性的，这是怎么做到的呢？答案是每个对象都有一个名为__dict__的特殊属性，这个属性的类型为字典，所有新添加的属性都会被保存在这个字典里，在本文中我们称新添加的属性为自定义属性。但python向用户屏蔽两种属性的差别，提供了统一的语法来访问它们，也即通过 obj.name 。这个在大多数情况下会带来便利性，但有时会带来含混，此时我们需要弄清楚到底一个属性是一个特殊属性还是自定义属性。

class Foo:
    def __init__(self):
	self.id = 1
	self.name = 'Tom'

    def foo(self):
	pass

f = Foo()
print(f.__dict__)
print(f.foo)

结果为：

{'id': 1, 'name': 'Tom'}
<bound method Foo.foo of <__main__.Foo object at 0x000000B2509ECFD0>>

• 可见一个类的__init__函数对self添加的属性，都将成为这个类实例对象的自定义属性，如例子中的id 和name两个属性。
• 类中定义的函数，将成为类实例的特殊属性，如例子中的foo这个属性，它的类型是method.

对于任何对象，其属性可分为两种(以下说的都是自己的属性，不包括父类的属性)：

1. 用户自定义属性。
2. 语言定义属性

对于一个class object，其两种属性可能包含：

那么如何为一个class object添加自定义属性？ 在定义一个类时，一个def 语句将添加一个类函数到自定义属性; 一个赋值语句将添加一个类变量到自定义属性。

注：其实对于class object, 它也是type class object 的instance

对于一个instance object, 其两种属性可能包含：

问题： str.__class__ 是一个语言定义属性还是继承自 其父类 object 的__class__ 用户自定义属性（也即object.__dict__['class'], 这个是一个'attribute'）？ 应该是一个语言定义属性，应该来自于 object.__dict__['class']， 也可能是

问题二： str.__mro__ 的结果是： (str, object). 但我不知道这个成员来自于何处。 str.__dict__和object.__dict__里都没有。

__dict__属性是一个语言定义属性，它用来保存所有的用户自定义属性。

x.name 等价于 getattr(x, 'name')，