[Learning Python] Chapter 6: The Dynamic Typing Interlude

1, 在Python中，类型永远跟随object，而非variable。Variable没有类型。

2，在下面的三个式子中，a首先被赋予整形3，再被赋予字符串‘spam’,后再被赋予float型数值1.23. 这在Python中是可行的，而在C语言中不行。

>>> a = 3 # It's an integer
>>> a = 'spam' # Now it's a string
>>> a = 1.23 # Now it's a floating point

3，在Python中，variable和object的这种关系称为引用（reference）：

每一次a被赋予一个新的值，这个箭头就被指向新的object。

4，每一个object除了有足够的内存空间来存储它的值，还有2个标题字段（header fields）：
A，type designator用来标记这个object的类型
B，reference counter 用来确定是否可以回收这个object了。
比如，3这个object内的type designator就告诉Python，其类型是integer。

5，Python可以对对象进行自动地回收。这就是reference counter做的事情。如果指向这个object的reference个数为零，这个object就被立刻回收。所以，程序员无需自己对其回收。如上面的a，当其被从3，指向字符串‘spam’的时候，如果3没有在被其他的variable所引用，3这个object将立即被Python回收。既其reference counter 从 1 降至0.

6，share reference: 如下的代码表示object 3被a和b同时引用了：

如果a被重新赋值为‘spam’，则表示a的引用变成新的object，即‘spam’，而b仍然指向3这个object。这告诉我们，b不是指向a，而是指向object。所有的variable都不是指向variable，而是指向object。

7，share reference and in-place changes.
何为in-place changes ? in-place changes 指的是针对mutable类型的type，是可以对其修改内容的，包括：dictionary、list、set。改变这种type的某个位，并不是构造一个新的object，而是修改原先的object。如下，这种情况的发生表示L2随L1改变了，programmer应该意识到这个问题。

>>> L1 = [2, 3, 4] # A mutable object
>>> L2 = L1 # Make a reference to the same object
>>> L1[0] = 24 # An in-place change
>>> L1 # L1 is different
[24, 3, 4]
>>> L2 # But so is L2!
[24, 3, 4]

8，如果不想影响L2，则应该将本来的L1复制一份，在让L2指向这个复制的object。
对于list，可以用切片的方法复制以个新的list。

>>> L1 = [2, 3, 4]
>>> L2 = L1[:] # Make a copy of L1 (or list(L1), copy.copy(L1), etc.)
>>> L1[0] = 24
>>> L1
[24, 3, 4]
>>> L2 # L2 is not changed
[2, 3, 4]

而set、dictionary没有切片的方法，则需要用copy的方法，当然，copy同样适用于list：

import copy
X = copy.copy(Y) # Make top-level "shallow" copy of any object Y
X = copy.deepcopy(Y) # Make deep copy of any object Y: copy all nested parts

9, == 代表值相同则返回True，否则，返回False。
is代表引用相同则返回True，否则，返回Flase。这个判断会更加严格。is的值为True的两个量，其==必定也是True。

>>> L = [1, 2, 3]
>>> M = [1, 2, 3] # M and L reference different objects
>>> L == M # Same values
True
>>> L is M # Different objects ， L 和M 指向了不同的object。
False 

10，由于Python会存储一些小的integer和小的string以方便重新利用。故有些时候，本该被回收的object（小的integer或者小的string）并没有被及时地回收，而是仍然存储在内存里。

>>> X = 42
>>> Y = 42 # Should be two different objects
>>> X == Y
True
>>> X is Y # Same object anyhow: caching at work!
True