探討 :: 物件參照與資料項目
Objects are Python’s abstraction for data.
Every object has an identity, a type and a value. An object’s identity never changes once it has been created; you may think of it as the object’s address in memory. The ‘is‘ operator compares the identity of two objects; the id() function returns an integer representing its identity.
An object’s type determines the operations that the object supports. The type() function returns an object’s type (which is an object itself). Like its identity, an object’s type is also unchangeable.
The value of some objects can change. Objects whose value can change are said to be mutable; objects whose value is unchangeable once they are created are called immutable. (The value of an immutable container object that contains a reference to a mutable object can change when the latter’s value is changed; however the container is still considered immutable, because the collection of objects it contains cannot be changed. So, immutability is not strictly the same as having an unchangeable value, it is more subtle.) An object’s mutability is determined by its type; for instance, numbers, strings and tuples are immutable, while dictionaries and lists are mutable.
Objects are never explicitly destroyed; however, when they become unreachable they may be garbage-collected.
CPython implementation detail: CPython currently uses a reference-counting scheme with (optional) delayed detection of cyclically linked garbage, which collects most objects as soon as they become unreachable, but is not guaranteed to collect garbage containing circular references. Do not depend on immediate finalization of objects when they become unreachable (so you should always close files explicitly).
Note that the use of the implementation’s tracing or debugging facilities may keep objects alive that would normally be collectable. Also note that catching an exception with a ‘try...except‘ statement may keep objects alive.
Some objects contain references to “external” resources such as open files or windows. It is understood that these resources are freed when the object is garbage-collected, but since garbage collection is not guaranteed to happen, such objects also provide an explicit way to release the external resource, usually a close() method. Programs are strongly recommended to explicitly close such objects. The ‘try...finally‘ statement and the ‘with‘ statement provide convenient ways to do this.
Some objects contain references to other objects; these are called containers. Examples of containers are tuples, lists and dictionaries. The references are part of a container’s value. In most cases, when we talk about the value of a container, we imply the values, not the identities of the contained objects; however, when we talk about the mutability of a container, only the identities of the immediately contained objects are implied. So, if an immutable container (like a tuple) contains a reference to a mutable object, its value changes if that mutable object is changed.
Types affect almost all aspects of object behavior. Even the importance of object identity is affected in some sense: for immutable types, operations that compute new values may actually return a reference to any existing object with the same type and value, while for mutable objects this is not allowed. E.g., after a = 1; b = 1, a and b may or may not refer to the same object with the value one, depending on the implementation, but after c = []; d = [], c and d are guaranteed to refer to two different, unique, newly created empty lists. (Note that c = d = [] assigns the same object to both c and d.)
參考資料
物件 == 資料項目
變數名稱 == 物件參照名稱 == 識別字
在 Python 萬物皆物件 , 凡物件都有其型別
type(1) # <class 'int'>
type("string") # <class 'str'>
type(len) # <class 'builtin_function_or_method'>
type(int) # <class 'type'>
type(type) # <class 'type'>
type(list) # <class 'type'>
type([]) # <class 'list'>
x = 1
type(x) # <class 'int'>
x = "string"
type(x) # <class 'str'>
x = len
type(x) # <class 'builtin_function_or_method'>
x = int
type(x) # <class 'type'>
def f(): pass
type(f) # <class 'function'>
x = f
type(x) # <class 'function'>
x = [1,2]
type(x) # <class 'list'>
type(x[0]) # <class 'int'>
import collections
type(collections) # <class 'module'>
import numbers
type(numbers.Number) # <class 'abc.ABCMeta'>
資料項目都有一個看不見的物件參照計數器 , 紀錄有多少物件參照指向該資料項目 , 當計數器的值為零該資料項目就有可能被 Python 回收 .
x = 1 # 資料項目 1 的物件參照計數器增為一
y = x # 資料項目 1 的物件參照計數器增為二
y = 2 # 資料項目 1 的物件參照計數器減為一
x = x + 1 # 資料項目 1 的物件參照計數器減為零