一切皆对象

基本数据类型

在 Python 中，可以使用内置的 type 函数来获取一个对象所对应的类。使用 mro 方法可以查看一个类的所有祖先 (包括自己)。例如，NoneType 是 None 的类型，bool 是 int 的子类，这意味着布尔值实际上是整数的特殊表现形式，True 等价于 1，False 等价于 0。其他基本数据类型如 int、float、complex 和 str 也都继承自 object。

In [1]:
type(False).mro()
Out[1]:
[bool, int, object]
In [2]:
type(2).mro()
Out[2]:
[int, object]
In [3]:
type(3.14).mro()
Out[3]:
[float, object]
In [4]:
type(1 + 2j).mro()
Out[4]:
[complex, object]
In [5]:
type("Hello world!").mro()
Out[5]:
[str, object]
In [6]:
type(None).mro()
Out[6]:
[NoneType, object]

数据结构

In [7]:
type([1, 2, 3]).mro()  # 列表 list
Out[7]:
[list, object]
In [8]:
type((1, 2, 3)).mro()  # 元组 tuple
Out[8]:
[tuple, object]
In [9]:
type(range(3)).mro()  # 范围 range
Out[9]:
[range, object]
In [10]:
type({"a": 1, "b": 2}).mro()  # 字典 dict
Out[10]:
[dict, object]
In [11]:
type({1, 2, 3}).mro()  # 集合 set
Out[11]:
[set, object]

模块

In [12]:
import math
type(math).mro()
Out[12]:
[module, object]

函数

函数是 function 类的对象，这意味着函数本身可以像其他对象一样被操作。你可以将一个函数赋值给一个变量，从而通过这个变量来调用该函数。此外，函数还可以作为参数传递给其他函数，允许你在函数内部动态地处理和调用其他函数，这使得高阶函数的实现成为可能。函数还可以作为返回值返回，这种特性使得你可以创建工厂函数或闭包等高级编程模式。

In [13]:
def to_upper_case(text: str) -> str:
    return text.upper()
to_upper_case("Hello world!")
Out[13]:
'HELLO WORLD!'
In [14]:
upper = to_upper_case
upper("Hello world!")
Out[14]:
'HELLO WORLD!'
In [15]:
type(to_upper_case).mro()
Out[15]:
[function, object]

类

在 Python 中，一切皆对象，包括类本身。类可以用来创建对象，而这些类本身也是对象，它们是 type 类的实例。事实上，所有的类都是 type 的实例。而更有趣的是，type 自身也是一个对象，属于 type 类。类是对象，类的实例也是对象，而 type 是所有类的元类。

In [16]:
class Dog:
    def bark(self):
        return "Woof!"
d = Dog()
d.bark()
Out[16]:
'Woof!'
In [17]:
type(d).mro()
Out[17]:
[__main__.Dog, object]
In [18]:
print(type(Dog))

<class'type'>
In [19]:
print(type(type(Dog)))

<class'type'>

相关推荐