一切皆对象

如题所示，在Python中一切都是对象，包括你的代码，函数，类，方法，都是对象，但是函数和类相对来说比较高级，属于Python的一等公民，具有如下特性：

1. 可以赋值给一个变量
2. 可以添加到集合对象中
3. 可以作为参数传递给函数
4. 可以当作函数的返回值

概念往往是枯燥的，下面用实例演示即可明白

def test():
    print('浪子666')
run = test
run()

这里把test函数赋值给变量run，然后run直接运行test函数，就是第一点的概念

def test1():
    print('浪子666')
def test2():
    print('浪子777')
def test3():
    print('浪子888')
a = []
a.append(test1)
a.append(test2)
a.append(test3)
for x in a:
    x()

输出结果：

浪子666
浪子777
浪子888

当然可以添加到集合对象中，意思就是多个函数可以放到列表集合中，并且循环调用，这就是第二点。

def test1(x):
    return (x)
def test2():
    return test1

a = test2()
print(a('浪子666'))

这属于第三点，可以作为函数的传参，说白了就是a作为test2函数运行，因为返回test1函数，所以变成了test1函数，接受参数。

这个说白了就是和类属性一样的调用方法，赋值给一个变量，通过这个变量来操作函数对象。

def test1():
    return ('浪子666')
def test2():
    return test1()

print(test2())

可以当作函数的返回值，这个往后面走就是装饰器的原理，这个比较简单容易理解。

type class object 三者关系

type

type方法很常见，它常用于获取数据类型，或者函数类的类型。

a = 1
b = 'a'
print(type(a))
print(type(b))

返回的结果：

<class 'int'>
<class 'str'>

基操勿6，接下来看看如果获取int和str的type类型会是什么呢？

print(type(int))
print(type(str))

返回结果：

<class 'type'>
<class 'type'>

int和str的类型是type？什么操作…

确实不好理解对吧，下面引申一个例子你就明白了

class test:
    pass
print(type(test))
print(type(test()))

首先定义一个类，然后打印这个类的类型。然后打印这个类实例化对象的类型，结果如下：

<class 'type'>
<class '__main__.test'>

可以看到一个类的类型就是type，也就是说str和int是定义好的一个class类。

是不是说，我们平时使用的实例比如len，list，dict等等方法都是定义好的类呢？

看看实例

print(type(list))
print(type(float))
print(type(dict))
print(type(print()))

返回结果：

<class 'type'>
<class 'type'>
<class 'type'>

<class 'NoneType'>

果然~细心发信中间空了一行，其实就是print()函数执行了，打印一个空值。因为print()是函数，并不是类，我们可以ctrl+alt+b到源代码中看看这个函数。

def print(self, *args, sep=' ', end='n', file=None): # known special case of print
    """
    print(value, ..., sep=' ', end='n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
    """
    pass

使用type获取对象的类型，同样可以使用如下方法达到相同的目的

type(int) == int.__class__

作用是查看对象的类型

class

class类应该很熟悉了吧，这里不多解释。通过上文介绍可以看到，type是属于class的父层。

object

objet(对象)，这个单词很少见，他是所有类都要继承的一个最顶层的基础类。

所有的类的最顶层类都是object类。

父类这个概念大家以前听说过，但是不明就里，这里解读一下：

class test:
    def __init__(self):
        print(666)

class test1(test):
    # test1继承test
    pass

a = test1
# 实例化test1
print(a.__bases__)
# 获取a的父类
print(type(a()))
# 执行a，执行后a的类型

返回的结果如下：

(<class '__main__.test'>,)
666
<class '__main__.test1'>

可以看到a的父类(就是继承的类)是test

父类有多种叫法，父类也叫基类也叫超类。

如何查看一个类的基类是什么呢？可以使用下面的方法

.__bases__

比如：

print(int.__bases__)

返回结果：

(<class 'object'>,)

继续查看type的基类是啥

print(type.__bases__)

返回结果：

(<class 'object'>,)

这里是不是就可以推断，任何类的基类都是object。

在python中有一个函数issubclass(a,b)，该作用是判断继承关系，判断a是否继承b，和isinstance(666,int)判断数据类型是否一样相关。举个例子

class a:
    pass

class b(a):
    pass

这里b继承a

print(issbuclass(b,a))

返回结果：

True

那么可以推断出type和class与object的关系了

print(issubclass(int,object))
print(issubclass(type,object))
print(issubclass(type,type))

返回结果：

true
true
true

这里说明int继承object，type继承object，type继承本身，这一点在最后有介绍

梳理

现在我们梳理一下知识，我们一开始就说明，一切皆对象。type，class，object也是对象，那么父类基类超类是什么意思呢？

父类：你继承的类

如何查看一个类的父类呢？使用bases方法，比如：

print(int.__bases__)

可以看到int的父类是object

如何查看一个类的类型是什么呢？使用type方法，没错：

print(type(int))

可以看到int的父类是type

那么有意思的来了：

print(type(type))
# 获取type的类型
print(type(object))
# 获取object的类型

print(type.__bases__)
# 获取type的基类
print(object.__bases__)
# 获取object的基类

结果如下：

<class 'type'>
<class 'type'>
(<class 'object'>,)
()

object的继承的基类就是空

就好像如下

type-->class-->object

实例化对象来表示就是

type-->int-->1

这里的int其实就是定义好的类class，数字1就是实例化的对象object，在python中任何对象都符合这个。

他们的基类(被继承的类，其实就是type类)都是object，type的基类是object这点没问题，因为所有的类的最顶层基类都是object，但是object的基类确是空？

这里偷一张图

举例子，字符串abc属于str的实例，str其实就是一个class类，str继承object，因为object是所有类的最顶层，object和type的相互关系有点复杂。

object是最顶层基类，object是type的实例，而type又继承object，type是自身的实例。

type也是自身的实例化，object创造type，type创造一切和他自己，有点像道生一，一生三，三生万物…..type连自己都不放过，把自己都变成了自己的对象。type自己实例化自己。

object是父子关系的顶端，所有的数据类型的父类都是它；type是类型实例关系的顶端，所有对象都是它的实例的。它们两个的关系可以这样描述：

1. object是一个type，object is and instance of type。即Object是type的一个实例。

2. type是一种object， type is kind of object。即Type是object的子类。

再总结一下：

第一列，元类列（元编程中），type是所有元类的父亲。我们可以通过继承type来创建元类

第二列，TypeObject列（内置数据类型中），也称类列，object是所有类的父亲，大部份我们直接使用的数据类型都存在这个列的。

第三列，实例列（自己写的类），实例是对象关系链的末端，不能再被子类化和实例化

Python中内置的数据类型

说起数据类型，你可能想起int，string，folat，bool，list，set，dict等等，但是对这些还是需要做一个整理归纳。

对象的三个特征

1. 身份（对象在内存的地址，使用id()函数查看）

2. 类型（int，string，bool等等）

3. 值（比如a=1，那个a的值就是1）

None类型

None代表一个空，在全局中固定唯一一个，任何为None的对象在内存的地址都是指向同一个。

数值类型

1. int 整数类型

2. float 浮点数类型

3. string 字符串类型

4. complex 复数类型

迭代类型

1. 可以用for循环的任何对象

序列类型

1. list 列表

2. range 区间

3. tuple 元祖

4. str 字符串

5. array 数组

6. bytes，bytearray，memoryview 二进制序列

映射类型

1. dict 字典类型

集合类型

1. set 集合

2. frozenset 不可变集合

上下文管理类型

1. with 类型

其他

1. 模块类型

2. class与实例

3. 函数类型

4. 方法类型

5. 代码类型(代码本身会被解释器作为类型)

6. object类型

7. type类型

8. ellipsis类型(省略号)

本文始发于微信公众号（安全研发）：Python 一切皆对象