Cpython-Object对象概述

1.Object

>>>a=1
>>>a.__class__
<class 'int'>
>>>int.__class__
<class 'type'>
>>>int.__base
<class 'object'>
>>>

#一切继承于Object

在Python中，对象就是为C中的结构体在堆上申请一堆内存，不能被静态初始化，不能在栈空间上生存。但 Python中的类型对象是例外，都是被静态初始化的。

一个对象被创建，在内存中大小是不变的，所以维护容纳一个可变长度数据的对象(如：List类型），就必须在对象内维护一个指向一块可变大小区域的指针。

 1.1PyObject

PyObject是整个Python对象机制的核心。

在Python的世界，一切都是对象，数字、字符串、数据类型、函数等

 /*Inlcude/object.h*/
typedef struct _object{
/*1.release下是NULL，debug下是两个链表指针*/
_PyObject_HEAD_EXTRA

/*2.内存管理机制：引用计数，垃圾收集机制
  对象A的引用计数减至0，A就会从堆上被删除以释放内存
   long：在linux64下是8字节，其余是4字节
在_PyNewReference(PyObject *op)接口中初始化为1
*/
Py_ssize_t ob_refcnt;

/*类型对象：该类型的信息存放在类型对象中*/
struct _typrobject *ob_type;

}Pyobject;

ob_refcnt：Py_INCREF  /Py_DECREF
内存池--缓冲效果

比如：10作为对象，int就是其类型对象

思考：创建一个对象会发生什么？

1.通过C API创建，称为抽象对象层(AOL)：pyobject_**

2.通过类型对象创建，称为混合对象层(COL)，内建对象的API，比如PyInt_FromLong

3.直接内存分配(pyA_new())

4.通过设计的类型对象创建实例对象：class A(OBJECT)-->new A()

1.2PyVarObject

// Include/object.h
typedef struct {

    PyObject ob_base;

    Py_ssize_t ob_size; /* 可变部分的项数 */

} PyVarObject;

1.3定长对象与变长对象

各个对象都拥有相同的对象头部，因此只需要一个PyObject*指针就可以引用任意一个对象

思考：

1.怎么理解整型LongObject是边长对象

2.整型在内存中的字节数是多少？

1.4可变对象与不可变对象

总：不可变数据类型更改后 地址发生改变，可变数据类型更改 地址不发生改变

不可变数据：Number、String、Tuple、None

如果改变Number数据类型的值，将重新分配内存空间，而Number数据类型用于存储数据，类型是不允许改变的。

对象不可变，多任务环境下同时读取对象不需要加锁，同时读也行。

可变数据类型：List、Dictionary、Set

1.5PyLongObject

//Include/cpython/longobject
typedef struct _longobject PyLongObject;

struct _longobject {
    PyObject_HEAD
    _PyLongValue long_value;
};

typedef struct _PyLongValue {
    uintptr_t lv_tag; /* Number of digits, sign and flags */
    digit ob_digit[1];
} _PyLongValue;

/* PyObject_HEAD defines the initial segment of every PyObject. */
#define PyObject_HEAD                   PyObject ob_base;

/*等价于以下表达*/
typedef struct{
Py_ssize_t ob_refcnt;//引用计数
PyTypeObject *ob_type;//变量类型
uintptr_t lv_tag//位、标志的数
digit ob_digit[1];//默认长度为1
}PyLongObject；

注：V3.12源码中PyLongObject是不可变长对象

思考：

1.如何实现整数相加而内存不溢出

2.不可变对象指什么

3.与可变对象有关联吗

1.6PyTypeObject

python中类型本身也是对象，类型对象。

每个PyObject因为有ob_type存在，才能显示出不同的对象，也就是多态。

比如对象的内存分配大小之类的元信息，隐含于PyObject

思考：类型对象的类型对象是什么：是PyType_Type，tp_name就是type

typedef struct _typeobject PyTypeObject;

struct _typeobject {
    PyObject_VAR_HEAD
    const char *tp_name; /* 类型名字 */
    Py_ssize_t tp_basicsize, tp_itemsize; /* 申请内存大小 */

    /* Methods to implement standard operations */

    destructor tp_dealloc; //析构函数
    Py_ssize_t tp_vectorcall_offset;
    getattrfunc tp_getattr;//获取方法
    setattrfunc tp_setattr;//设置方法
    PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2)
                                    or tp_reserved (Python 3) */
    reprfunc tp_repr;

    /* Method suites for standard classes */
    //任意python类型都实现了以下三种方法
    PyNumberMethods *tp_as_number; //数值对象
    PySequenceMethods *tp_as_sequence; //序列对象
    PyMappingMethods *tp_as_mapping; //映射对象

    /* More standard operations (here for binary compatibility) */

    hashfunc tp_hash; //哈希方法
    ternaryfunc tp_call; //调用方法
    reprfunc tp_str;
    getattrofunc tp_getattro;
    setattrofunc tp_setattro;

    /* Functions to access object as input/output buffer */
    PyBufferProcs *tp_as_buffer;

    /* Flags to define presence of optional/expanded features */
    unsigned long tp_flags;

    const char *tp_doc; /* 文档字符串 */

    /* Assigned meaning in release 2.0 */
    /* call function for all accessible objects */
    traverseproc tp_traverse;

    /* delete references to contained objects */
    inquiry tp_clear;

    /* Assigned meaning in release 2.1 */
    /* rich comparisons */
    richcmpfunc tp_richcompare;

    /* weak reference enabler */
    Py_ssize_t tp_weaklistoffset;

    /* Iterators */
    getiterfunc tp_iter;
    iternextfunc tp_iternext;

    /* Attribute descriptor and subclassing stuff */
    PyMethodDef *tp_methods;
    PyMemberDef *tp_members;
    PyGetSetDef *tp_getset;
    // Strong reference on a heap type, borrowed reference on a static type
    PyTypeObject *tp_base;
    PyObject *tp_dict;
    descrgetfunc tp_descr_get;
    descrsetfunc tp_descr_set;
    Py_ssize_t tp_dictoffset;
    initproc tp_init;
    allocfunc tp_alloc;
    newfunc tp_new;
    freefunc tp_free; /* Low-level free-memory routine */
    inquiry tp_is_gc; /* For PyObject_IS_GC */
    PyObject *tp_bases;
    PyObject *tp_mro; /* method resolution order */
    PyObject *tp_cache; /* no longer used */
    void *tp_subclasses;  /* for static builtin types this is an index */
    PyObject *tp_weaklist; /* not used for static builtin types */
    destructor tp_del;

    /* Type attribute cache version tag. Added in version 2.6 */
    unsigned int tp_version_tag;

    destructor tp_finalize;
    vectorcallfunc tp_vectorcall;

    /* bitset of which type-watchers care about this type */
    unsigned char tp_watched;
};

//PyVarObject继承PyObject并做了扩展，表示可变对象的元素数量-->可变对象
#define PyObject_VAR_HEAD      PyVarObject ob_base;

typedef struct {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;

存储的信息分为四类：

1.类型名

2.占用内存空间大小

3.与该类型对象相关联的操作信息

4.类型（一个对象）的类型信息，PyType_Type被称为metaclass元类

1.6.1