python类object

Ⅰ python 的 type 和 object 之间是怎么一种关系

Python的object和type理解

1、节选自Python Documentation 3.5.2的部分解释

Objects are Python’s abstraction for data. All data in a Python program is represented by objects or by relations between objects. (In a sense, and in conformance to Von Neumann’s model of a “stored program computer,” code is also represented by objects.)

对象是Python对数据的抽象。 Python程序中的所有数据都由对象或对象之间的关系表示。（在某种意义上，并且符合冯·诺依曼的“存储程序计算机”的模型，代码也由对象表示的）。

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.

每个对象都有一个标识，一个类型和一个值。 对象的身份一旦创建就不会改变; 你可以把它看作内存中的对象地址。'is'运算符比较两个对象的标识; id()函数返回一个表示其身份的整数。

An object’s type determines the operations that the object supports (e.g., “does it have a length?”) and also defines the possible values for objects of that type. The type() function returns an object’s type (which is an object itself). Like its identity, an object’s type is also unchangeable.

对象的类型决定对象支持的操作（例如，“它有长度吗？”），并且还定义该类型对象的可能值。type()函数返回一个对象的类型（它是一个对象本身）。与它的身份一样，对象的类型也是不可改变的。

2、Pyhtml的解释：

object：

class object

The most base type

type：

class type(object)

type(object_or_name, bases, dict)

type(object) -> the object's type

type(name, bases, dict) -> a new type

从上面三个图可以看出，对象obeject是最基本的类型type，它是一个整体性的对数据的抽象概念。相对于对象object而言，类型type是一个稍微具体的抽象概念，说它具体，是因为它已经有从对象object细化出更具体抽象概念的因子，这就是为什么type(int)、type(float)、type(str)、type(list)、type(tuple)、type(set)等等的类型都是type，这也是为什么instance(type, object)和instance(object, type)都为True的原因，即类型type是作为int、float等类型的整体概念而言的。那么，为什么issubclass(type, object)为True，而issubclass(object, type)为Flase呢？从第二张图，即从继承关系可以看到，type是object的子类，因此前者为True，后者为False。若从Python语言的整体设计来看，是先有对象，后有相对具体的类型，即整体优先于部分的设计思想。

如果从更加本质的视角去看待这些问题的话，就要从Python Documentation-->3. Data Model-->3.1 Objects,values and types找原因了[请参考Python官方标准库]，从标准库里可以看到：

object是Python对数据的抽象，它是Python程序对数据的集中体现。

每个对象都有一个标识，一个类型和一个值。

对象的类型决定对象支持的操作。

某些对象的值可以更改。 其值可以改变的对象称为可变对象；对象的值在创建后不可更改的对象称为不可变对象。

因此，从Python整体设计体系来看的话，就是先有对象，再有标识、类型和值，接着是对对象的操作等等，这也就解释了图3的结果形成的原因了。

Ⅱ python 添加了这个奇怪的叫做 object 的 class，它究竟有什么含义

在Python里，有一句话叫，一切皆对象。而对象的英文单词就是object。
换句话这个object就代表了Python中的一切，开发Python的龟叔已经给object类定义常用的属性和方法供认识使用。
当在Python2中，你定义类的时候，加上object，用内置函数dir（你定义类的名字）查看属性和方法，你定义的类会默认继承object这个基类（父类）的属性和方法。如果不给object参数，dir时就只有你自己定义属性和方法，没有继承object的。
你可以下去动手试试（我是手机端回答的问题，抱歉无法演示截图）
然后，如果你使用的是Python3，当你定义类的时候，给了object参数就继承。不给object参数也会默认继承。不管你是
class
A：
还是
class
A（）：
都会自动的被Python识别为：
class
A（object）（这也是Python3更人性化的一点）

Ⅲ python的class中的object是什么意思

object 是指这个类继承的最顶级的对象。python3.x 中已经可以省略object，可直接

classSample():
pass

Ⅳ python中的object类有何作用

object是一个基类，或称之为元类。
在python2.x上，不继承object类的称之为经典类，继承了object类的称之为新式类
关于它们的区别，你可以阅读以下python2手册中的这个部分：

https://docs.python.org/2/reference/datamodel.html#new-style-and-classic-classes

Ⅳ python中object基类到底有什么用

基类
就是所有对象的跟，这样定义是有历史原因的。
继承了object的类是新式类，由于他们都是object的
派生类
，便于统一操作。py2由于一些类不继承object，就弄了一些内置函数，两种风格掺杂在一起很别扭。其实这点在动态语言里面看不出优势，在静态类型的语言比如java之中优势一目了然。

Ⅵ Python对象

众所周知，Python是一门面向对象的语言，在Python无论是数值、字符串、函数亦或是类型、类，都是对象。
对象是在 堆 上分配的结构，我们定义的所有变量、函数等，都存储于堆内存，而变量名、函数名则是一个存储于 栈 中、指向堆中具体结构的引用。

要想深入学习Python，首先需要知道Python对象的定义。

我们通常说的Python都是指CPython，底层由C语言实现，源码地址： cpython [GitHub]
Python对象的定义位于 Include/object.h ，是一个名为 PyObject 的结构体：

Python中的所有对象都继承自PyObejct，PyObject包含一个用于垃圾回收的双向链表，一个引用计数变量 ob_refcnt 和 一个类型对象指针 ob_type

从PyObejct的注释中，我们可以看到这样一句：每个指向 可变大小Python对象 的指针也可以转换为 PyVarObject* （可变大小的Python对象会在下文中解释）。 PyVarObejct 就是在PyObject的基础上多了一个 ob_size 字段，用于存储元素个数：

在PyObject结构中，还有一个类型对象指针 ob_type ，用于表示Python对象是什么类型，定义Python对象类型的是一个 PyTypeObject 接口体

实际定义是位于 Include/cpython/object.h 的 _typeobject ：

在这个类型对象中，不仅包含了对象的类型，还包含了如分配内存大小、对象标准操作等信息，主要分为：

以Python中的 int类型 为例，int类型对象的定义如下：

从PyObject的定义中我们知道，每个对象的 ob_type 都要指向一个具体的类型对象，比如一个数值型对象 100 ，它的ob_type会指向 int类型对象PyLong_Type 。

PyTypeObject结构体第一行是一个PyObject_VAR_HEAD宏，查看宏定义可知PyTypeObject是一个变长对象

也就是说，归根结底 类型对象也是一个对象 ，也有ob_type属性，那 PyLong_Type 的 ob_type 是什么呢？
回到PyLong_Type的定义，第一行 PyVarObject_HEAD_INIT(&PyType_Type, 0) ，查看对应的宏定义

由以上关系可以知道， PyVarObject_HEAD_INIT(&PyType_Type, 0) = { { _PyObject_EXTRA_INIT 1, &PyType_Type } 0} ，将其代入 PyObject_VAR_HEAD ，得到一个变长对象：

这样看就很明确了，PyLong_Type的类型就是PyType_Typ，同理可知， Python类型对象的类型就是PyType_Type ，而 PyType_Type对象的类型是它本身

从上述内容中，我们知道了对象和对象类型的定义，那么根据定义，对象可以有以下两种分类

Python对象定义有 PyObject 和 PyVarObject ，因此，根据对象大小是否可变的区别，Python对象可以划分为 可变对象（变长对象） 和 不可变对象（定长对象）

原本的对象a大小并没有改变，只是s引用的对象改变了。这里的对象a、对象b就是定长对象

可以看到，变量l仍然指向对象a，只是对象a的内容发生了改变，数据量变大了。这里的对象a就是变长对象

由于存在以上特性，所以使用这两种对象还会带来一种区别：
声明 s2 = s ，修改s的值： s = 'new string' ，s2的值不会一起改变，因为只是s指向了一个新的对象，s2指向的旧对象的值并没有发生改变
声明 l2 = l ，修改l的值： l.append(6) ，此时l2的值会一起改变，因为l和l2指向的是同一个对象，而该对象的内容被l修改了

此外，对于 字符串 对象，Python还有一套内存复用机制，如果两个字符串变量值相同，那它们将共用同一个对象：

对于 数值型 对象，Python会默认创建0~2 8 以内的整数对象，也就是 0 ~ 256 之间的数值对象是共用的：

按照Python数据类型，对象可分为以下几类：

Python创建对象有两种方式，泛型API和和类型相关的API

这类API通常以 PyObject_xxx 的形式命名，可以应用在任意Python对象上，如:

使用 PyObjecg_New 创建一个数值型对象：

这类API通常只能作用于一种类型的对象上，如：

使用 PyLong_FromLong 创建一个数值型对象：

在我们使用Python声明变量的时候，并不需要为变量指派类型，在给变量赋值的时候，可以赋值任意类型数据，如：

从Python对象的定义我们已经可以知晓造成这个特点的原因了，Python创建对象时，会分配内存进行初始化，然后Python内部通过 PyObject* 变量来维护这个对象，所以在Python内部各函数直接传递的都是一种泛型指针 PyObject* ，这个指针所指向的对象类型是不固定的，只能通过所指对象的 ob_type 属性动态进行判断，而Python正是通过 ob_type 实现了多态机制

Python在管理维护对象时，通过引用计数来判断内存中的对象是否需要被销毁，Python中所有事物都是对象，所有对象都有引用计数 ob_refcnt 。
当一个对象的引用计数减少到0之后，Python将会释放该对象所占用的内存和系统资源。
但这并不意味着最终一定会释放内存空间，因为频繁申请释放内存会大大降低Python的执行效率，因此Python中采用了内存对象池的技术，是的对象释放的空间会还给内存池，而不是直接释放，后续需要申请空间时，优先从内存对象池中获取。

Ⅶ Python类继承自object为什么要super自己的方法

super不是指向父类, 而是指向mro中的下一个类, 所以你继承的这个mixin子类, 他会去继承另外一个类, 源码里面是ListView, 所以super返回的是ListView.

class A(object):
def __init__(self):
print(self.__class__.__mro__)

def bark(self):
print("I'm A")
super(A, self).bark()

class B(object):
def bark(self):
print("I'm B")

class C(A, B):
def bark(self):
print("I'm C")
super(C, self).bark()

if __name__ == '__main__':
c = C()
c.bark()

运行结果:

(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'objec
t'>)
I'm C
I'm A
I'm B

因为源码里面是
class IndexView(BaseMixin,ListView):
所以BaseMixin里面调用的super(BaseMixin, self).get_context_data(**kwargs), 实际上是调用的ListView的方法

Ⅷ Python 为什么要继承 object 类

没有规定必须继承OBJECT类。OBJECT类只是面向对象语言继承精神的一种表现。例如OBJECTC，C++等语言在标准库中都将所有类的基类定义位OBJECT,这样的好处就是最大限度的利用代码重用的的精神。但是不通语言中的OBJECT类的作用又很不一样所以看看下面的介绍：回到PYTHON中为什么要集成OBJECT：low-levelconstructorsnamed__new__()–低级别的构造函数.Note:Python的class__init__并不是其他语言意义上的构造函数,在new创建实例后对实例属性初始化的函数.descriptors,–描述符.或者说描述符协议支持.descriptorprotocol__get__,__set__,__delete__等,可以阅读descriptor文档staticmethodsandclassmethods－静态方法和类方法properties(computedattributes)–属性访问settergetter.decorators(introcedinPython2.4)–装饰器.现在装饰器语法糖遍布各Python框架.slots–用户设置后可以限定实例的属性.在Python2中替代__dict__,可以节省近2/3内存,Python3中可以不因为优化内存使用率而使用slots,因为__dict__结构内存做了优化,Note:__dict__并不是Python意义上的内置的dict,其实是一个proxy类.anewMethodResolutionOrder(MRO)–MRO方法解析次序改变(由左递归改为C3算法)可能上面的你看着不太理解。通俗说一下py2.2后继承object的目的是使这个类成为newstyleclass,没有继承object的为传统classicclass,在本机进行了测试,环境为py2.7.3classFoo(object):passclassFoo1:passprinttype(Foo),type(Foo1)printdir(Foo)printdir(Foo1)printisinstance(Foo,object)printisinstance(Foo1,object)结果如下:['__class__','__delattr__','__dict__','__doc__','__format__','__getattribute__','__hash__','__init__','__mole__','__new__','__rece__','__rece_ex__','__repr__','__setattr__','__sizeof__','__str__','__subclasshook__','__weakref__']['__doc__','__mole__']TrueTrue(这个True有些疑问,Foo1不应是object的实例啊)

Ⅸ python 添加了这个奇怪的叫做 object 的 class，它究竟有什么含义

在Python里，有一句话叫，一切皆对象。而对象的英文单词就是object。

换句话这个object就代表了Python中的一切，开发Python的龟叔已经给object类定义常用的属性和方法供认识使用。

当在Python2中，你定义类的时候，加上object，用内置函数dir（你定义类的名字）查看属性和方法，你定义的类会默认继承object这个基类（父类）的属性和方法。如果不给object参数，dir时就只有你自己定义属性和方法，没有继承object的。

你可以下去动手试试（我是手机端回答的问题，抱歉无法演示截图）

然后，如果你使用的是Python3，当你定义类的时候，给了object参数就继承。不给object参数也会默认继承。不管你是

class A：

还是 class A（）：

都会自动的被Python识别为：

class A（object）（这也是Python3更人性化的一点）