Python高级编程-Python一切皆对象

第一章：Python高级编程-Python一切皆对象

Python3高级核心技术97讲 笔记

目录

• 第一章：Python高级编程-Python一切皆对象
  • 1. Python一切皆对象
    • 1.1 函数和类也是对象，属于Python的一等公民
    • 1.2 type、object和class的关系
    • 1.3 Python中的常见内置类型
      • 1.3.1 对象的三个特征
      • 1.3.2 None(全局只有一个)
      • 1.3.3 数值
      • 1.3.4 迭代类型
      • 1.3.5 序列类型
      • 1.3.6 映射(dict)
      • 1.3.7 集合
      • 1.3.8 上下文管理类型(with)
      • 1.3.9 其他

1. Python一切皆对象

1.1 函数和类也是对象，属于Python的一等公民

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

def ask(name="coder"):
    print(name)

class Person:
    def __init__(self):
        print("coder")

def print_type(item):
    print(type(item))

def decorator_func():
    print("dec start")
    return ask  # 作为函数的返回值，Python装饰器的部分实现原理

# 函数赋值给变量后执行
my_func = ask
my_func("王尼玛") # 输出”王尼玛“

# 类作为变量赋值给变量后实例化
my_class = Person
my_class() # 会执行__init__()方法，输出“coder”

# 类和函数增加到集合对象
obj_list = []
obj_list.append(ask)
obj_list.append(Person)
for item in obj_list:
    print(item())
    print_type(item)  # 作为参数传入函数

1.2 type、object和class的关系

"""
原来type并没有那么简单。
"""

>>> a = 1
>>> type(1)
<class 'int'>
>>> type(int)
<class 'type'>
>>> b = "abc"
>>> type(b)
<class 'str'>
>>> type(str)
<class 'type'>

"""
wow, 得出来一个现象 type->int->1和type->str->"abc"，
那么猜测我们自己定义的类是不是也是这样关系呢？
"""

>>> class Student():
...    pass
...
>>> stu = Student()
>>> type(stu)
<class '__main__.Student'>
>>> type(Student)
<class 'type'>

"""
soga, 我们可以得出一个结论： type->class->obj,
也就是说，我们所定义的类是type类的一个实例化对象，
而我们的stu是我们自己定义类Student的一个实例化对象。
也就是说的<class 'type'>是用来生成类的。

看的课程的这里，我仿佛感受到了Python一切皆对象的魅力所在，
哈哈哈。
"""

# object是所有类默认的一个基类, 即object是最顶层基类。
>>> Student.__bases__
(<class 'object'>,)
>>> class MyStudent(Student):
...    pass
...
>>> MyStudent.__bases__
(<class '__main__.Student'>,)

"""
问题来了：type也是一个类，同时type也是一个对象，那么type的基类是谁？
"""

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

# 好玩的来喽，如果执行type(object)看看object类是谁生成的呢？
>>> type(object)
<class 'type'>
>>> type(type)
<class 'type'>

# 再来好玩的！来看看object类基类谁呢？
>>> object.__bases__
()

# 结论：type继承了object，而object又是type的实例。

# 老师画了关系图，如下。

这张图给我展现了<class 'type'>是个厉害的家伙啊，他把一切都变成了对象，连自己都不放过。所以，有了<class 'type'>你就不缺对象啦，哈哈哈哈。

<class 'object'>是所有类的祖先哦，从图上看来，<class 'type'>与<class 'object'>有着不伦的关系啊！！！

好啦，课程老师告诉我们，其实上面一系列的不伦关系都是指针这个东西干的，嘿嘿嘿........

总结：类都是type的实例 (object也是type的实例，type本身也是自己的实例)，所有的类的顶层基类都是object (type的基类也是object)。Python一切皆对象的哲学就是玩起来的。

Python一切皆对象这么做就是为了一切都可以轻易的修改，使得Python非常灵活。C++/Java中的类一旦加载到内存后就不能修改（不绝对，修改很困难）。Python把类都搞成对象了，这样修改起来就很方便。

再次梳理：一切类都是由<class 'type'>所生出来的，<class 'object'>很特别，它虽是<class 'type'>的爸爸但也是由<class 'type'>生出来的。

咦？<class 'type'>和<class 'object'>那个先出来的？

怎么我越想越乱？

难道？<class 'type'>在把<class 'object'>生出来的同时，<class 'object'>又做了<class 'type’>的爸爸？？？WTF？？？

求评论区解释，遇到的问题就是：type需要继承object，但是object又是type的实例，这样的关系有矛盾啊？

1.3 Python中的常见内置类型

1.3.1 对象的三个特征

(1) 身份

>>> a = 1
"""
这里的1是值由<class 'int'>进行封装，最后变量a指向这个obj
"""
>>> id(a)
5656454878 # 不同机器不同结果

(2) 类型

(3) 值

1.3.2 None(全局只有一个)

"""
解释器启动时None对象被创建，且全局只有一个。
"""

>>> a = None
>>> b = None
>>> id(a) == id(b)  # 通过对比两个变量所指向内存地址相同，可见None对象全局只有一个。
True

1.3.3 数值

(1) int

(2) float

(3) complex (复数)

(4) bool

1.3.4 迭代类型

1.3.5 序列类型

(1) list

(2) bytes、bytearray、memoryview (二进制序列)

(3) range

(4) tuple

(5) str

(6) array

1.3.6 映射(dict)

1.3.7 集合

(1) set

与dict实现原理相似，性能高。

(2) frozenset

frozen

adj. 冻结的；冷酷的

v. 结冰；凝固；变得刻板

1.3.8 上下文管理类型(with)

1.3.9 其他

对于Python，一切皆对象啦。那么就会有一下类型。

(1) 模板类型

(2) class和实例

(3) 函数对象

(4) 方法类型

(5) 代码类型

(6) object类型

(7) type 类型

(8) ellipsis 类型

(9) notimplemented 类型

Python 的灵活性就使得它的严谨性有一定损失，但是其带给我们开发效率上的提升是显然的。