（一）python进阶之一切皆对象

python中一切皆对象

python中所看见的一切皆为对象，变量是对象，函数也是对象，类还是对象，你所写的整个代码，也是对象。

---

1.什么是对象？

一种好理解的方式：对象就是类的实例化
show you code:

# 输入
num = 1
print(type(num))
print(type(int))

# 输出
<class 'int'>
<class 'type'>

type() 可以查看对象的类型，对于变量a，它是int类的一个实例；对于int类，它是type类的一个实例。
即：type->class->int

对于函数：

# 输入
def Dog(name):
    print("{}使劲的汪汪叫".format(name))

print(Dog("旺财"))
print(type(Dog))
print(type(None))
# 输出
旺财使劲的汪汪叫
None
<class 'function'>
<class 'NoneType'>

没有设定返回值，默认返回None，返回值None是NoneType类 的一个实例;可以看出定义的Dog函数也是function类的一个实例。

对于类：

# 输入
class Cat():
    print("喵喵")

print(type(Cat))
print(Cat.__base__)

# 输出
喵喵
<class 'type'>
<class 'object'>

定义的Cat类是type类的一个实例，定义时没有显式继承别的类，但Cat类的基类默认为object类

所以请再次理解这句话：对象就是类的实例化。

---

2.对象有哪些特征和操作？

对象有三个特征：

• 身份： 作为对象的唯一标识，即内存地址，可用id()来查看。

• 类型： 不同类型有不同的属性和方法，可用type()来查看，python有丰富的内置类型，后面的章节会逐一讲解。

• 值： 内存中存放的具体数据。

这三者有什么联系？

来看下 a = 1这句代码，python会将数据1用int类来封装，并用变量a来指向它，即变量a保存的是数据1的内存地址，这种方式也叫作引用。

---

对象的通用操作有以下四个：

• 1.赋值给一个变量，比如类的实例化

• 2.可以添加到集合对象中：

# 输入
def say(name="neko"):
    print("你好，我叫{}".format(name))

class Person(object):
    def __init__(self):
        print("这是一个类")

obj_list = [say, Person]
for item in obj_list:
    print(item())

# 输出
你好，我叫neko
None
这是一个类
<__main__.Person object at 0x000001630EA99320>

对于最后一个输出，类实例化时会返回一个对象，print直接输出对象的内存地址。

• 3.可以作为参数传递给函数

• 4.可以作为函数的返回值，这也是装饰器的原理。

# 输入
def say(name="neko"):
    print("你好，我叫{}".format(name))

def decorator_func():
    print("要开始了哦！")
    return say
    
tom = decorator_func()
tom()
# 输出
要开始了哦！
你好，我叫neko

---

3.type、object和class的关系

结论先行：

• 1.object类以及所有以object类为基类的派生类，均为type类的实例。

• 2.object类为所有内置类以及外建类的最顶层基类。

• 3.type类继承自object类。

• 4.最绕的来了：type类能将自身实例化，也就是说type类是type类自身的实例

之前应该看得都挺爽，但看到第4点是不是有种要被type支配感觉，比如：

诸君莫慌，粮草已到：

图中虚线指向表示实例，比如虚线从object类指向type类，表示object类是type类的实例。

实线指向表示继承，比如实线从str类指向object类，表示object类是str类的基类。

纵向来看，python中所有类大致分为三种，能自我实例化的type类自成一类，它能创建所有对象，也成称为元类；python内置类有很多，比如数值类int、float，序列类list、range、tuple，映射类dic等等，它们都继承object类；外建类的最顶级基类也为object类。

至此，请结合上图再把结论好好斟酌一下，关于第4点，可以想象下只有单个节点的循环单链表，感觉挺像的…

用代码做下验证：

• 1.object类以及所有以object类为基类的派生类，均为type类的实例

# 输入
class Cat():
    print("喵喵")

print("Cat的基类是{}".format(Cat.__base__))
print("Cat类是{}的实例！".format(type(Cat)))
print("object类是{}的实例！".format(type(object)))

# 输出
喵喵
Cat的基类是<class 'object'>
Cat类是<class 'type'>的实例！
object类是<class 'type'>的实例！

• 2.object类为所有内置类以及外建类的最顶层基类。

# 输入
class Cat():
    print("喵喵")

print("Cat的基类是{}!".format(Cat.__base__))
print("list的基类是{}!".format(list.__base__))

# 输出
喵喵
Cat的基类是<class 'object'>!
list的基类是<class 'object'>!

• 3.type类继承自object类。

# 输入
print("type类的基类是{}!".format(type.__base__))

# 输出
type类的基类是<class 'object'>!

• 4.type类是type类自身的实例。

# 输入
print("type类是{}的实例！".format(type(type)))

# 输出
type类是<class 'type'>的实例！

如有疑问或发现有误，欢迎留言交流！