在python中创建对象object

共计 7027 个字符，预计需要花费 18 分钟才能阅读完成。

该系列文章：

《python 入门，编程基础概念介绍（变量，条件，函数，循环）》
《python 中的数据类型（list，tuple，dict，set，None）》
《在 python 中创建对象（object）》

在上一篇文章《python 中的数据类型（list，tuple，dict，set，None）》的 1.2 小节里我们就简要介绍过对象（object）跟类（class）的概念。也知道了 python 中内置的所有数据类型都是对象，拥有自己的方法。那么当这些内置的数据类型无法满足我们的需求时，我们如何创建我们自己的类型（type）呢？答案就是通过创建我们自己的类（class）。通过我们自己动手实现的类，我们就可以创建以这个类为模板的对象。从这样的流程来看，面向对象的编程方式是自顶而下，首先需要全盘考虑，才能创建一个足够好的模板，也即类。然后才能将类实例化为对象，通过对象中的属性来解决问题或者与其他对象互动。

创建一个最简单的类可以通过下面这样的写法：

class User:
    pass
    #更多代码
    #更多代码

上面的代码中 class 是关键字，表明我们要创建一个类了，User 是我们要创建的类的名称。通过“:”和缩进来表明所有缩进的代码将会是这个类里的内容。从 User 类中创建一个该类的实例通过下面的写法：

"""创建一个实例，通过类名加括号的形式，类似调用函数"""
u=User()

对象（客体）有自己的特征和自己可以做到的事，对应到程序里就是 字段（field） 和 方法（method） , 这两个都是对象的 属性（attribute）。对象的字段类似于普通变量，所不同的是对象的字段是对象独有的。对象的方法类似于普通函数，所不同的是对象的方法是对象独有的。上篇文章中我们已经见到过如何使用字段跟方法，那就是通过 . 操作符。

在类中定义对象的方法（method）比较简单，跟实现普通函数类似，只有一点不同，那就是不管方法需不需要参数，你都需要把 self 作为一个参数名传进去，self这个参数在我们调用方法时我们可以直接忽略，不赋值给它。举个例子：

class User:
    def hi(self):
        print("hi!")

u=User()
u.hi()

"""
程序输出:
hi!
"""

self这个参数名是约定俗成的。在 User 类的代码块里定义 hi 方法时，传入的参数 self 将会是某个实例（对象）本身。当 u 作为 User 类的实例被创建，并且通过 u.hi() 调用 hi 方法时，python 解释器会自动将其转换成User.hi(u)。通过传入实例（对象）本身，也即self，方法（method）就能够访问实例的字段（filed），并对其进行操作，我们之后可以从新的例子中看到。

要在类中声明对象的字段，有一个特殊的方法（method）可以做到，那就是 __init__ 方法，这个方法在 init 前后都要写上两个下划线 __。__init__ 方法会在实例一开始创建的时候就被调用，init是 initialization 的缩写，顾名思义，就是初始化的意思。__init__方法在创建对象的时候由 python 解释器自动调用，不需要我们手动来调用。看个例子：

class User:
    """注意 self 总是在括号里的最左边"""
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def hi(self):
        print("hi!I'm {}".format(self.name))

u=User("li",32)
u.hi()
print(u.name+","+str(u.age))

"""
程序输出:
hi!I'm li
li,32
"""

上面的代码里，在 User 类的 __init__ 方法中 self 被传入，那么就可以通过 self.name 跟self.age来声明对象的两个字段，并将传入该方法的参数 name 跟age赋值给它们。当我们创建类型为 User 的对象的时候，传入实际的参数 "li" 跟32，这两个参数被 python 解释器传入 __init__ 方法中，"li"对应 name，32 对应 age，__init__ 方法立即被调用，将实例 u 的字段一一建立。

self.name=name粗看貌似都是 name 变量，但 self.name 是实例的字段，专属于实例，name是创建对象时将要传入的一个参数，将它赋值给 self.name 是没有歧义的。

事实上，字段除了独属于实例之外，跟普通变量没有什么差别，所以实例的字段也被称为 实例变量 。在类的定义中，与实例变量对应的还有 类变量 ，类变量与实例变量类似，通过. 操作符来访问。类变量是任何实例共享的，可以理解为是该类型所共有的特征，比如，在 User 类中，我们可以计算一共有多少被实例化了的用户：

class User:
    """计算被实例化的用户数量"""
    count=0

    def __init__(self,name,age):
        """每次创建一个对象，用户数量在原有基础上加 1"""
        User.count=User.count+1
        self.name=name
        self.age=age

    def hi(self):
        print("hi!I'm {}".format(self.name))

    def die(self):
        print("I'm {}, dying...".format(self.name))
        User.count=User.count-1
        del self
    
    @classmethod
    def print_count(cls):
        print("共有 {} 名用户".format(cls.count))


u=User("li",32)
User.print_count()
u.hi()

u1=User("ma",30)
u1.__class__.print_count()
u1.hi()

u.die()
User.print_count()
u1.die()
User.print_count()

"""
程序输出：共有 1 名用户
hi!I'm li
共有 2 名用户
hi!I'm ma
I'm li, dying...
共有 1 名用户
I'm ma, dying...
共有 0 名用户
"""

上面代码中的 count 就是类变量，可以通过 User.count 来访问。python 通过 @classmethod 来表明它下面定义的方法是类的方法（method），类的方法中的 cls 是类本身，跟 self 使用方法类似，调用类方法时可以直接忽略。类变量跟类的方法（method)都可以被称为类的成员。除了使用类似 User.count 这样的方式来访问和使用之外，该类的实例还可以通过 __class__ 属性来访问和使用类成员，比如上面代码中的u1.__class__.print_count()。

上面代码中定义的字段跟方法都是公开的，可以通过 . 操作符访问。但如果属性是以形如 __name 这样以双下划线为开头的名称，则 python 会自动将名称换成 _classname__name，其中classname 就是类的名称，这样，通过 an_object.__name 是访问不到的。

现实世界里，某一类相似客体的类型被抽象为一个概念（名称），同时又有另一类相似客体的类型被抽象为一个概念（名称），这时候我们可能会发现，这两个概念（名称）之间很相似，于是我们把这两个相似概念再抽象成一个概念（名称），这样的过程可以重复多次。举个例子，我们有幼儿园，同时有小学，这时候我们可以把幼儿园跟小学抽象成学校。那跟现实类似，对象的类型跟类型之间，可以抽象成另一个类型。在文章最开头我们说面向对象编程是自顶而下，这跟一层层向上抽象的过程正好相反，我们会在一开始思考如何创建某个类，然后把这个类作为 基类（父类），更具体的创建一（几）个新类，这一（几）个新类不仅拥有基类的属性，还会增加自己独有的属性。我们把这样的新类（class）叫做子类，是从基类继承而来的。

从 1.2 小节的代码例子中，我们创建了一个 User（用户）类，假如我们现在需要区分免费用户和付费用户，免费用户跟付费用户都具有name、age、hi 属性，同时免费用户跟付费用户还具有自己独有的一些属性。如果我们直接分别创建免费用户类跟付费用户类，那么这两个类之间共同的属性就会被定义两次，需要复制粘贴同样的代码，这样的代码质量不高并且不够简洁。相反，我们可以让免费用户跟付费用户都从 User 类继承下来，这样就可以 重用（reuse） User类的代码，并且让代码相对简洁高效一点。还有一个好处就是，当免费用户跟付费用户之间共同的属性有了变化（增减），我们可以直接修改父类User，而不用分别修改，当子类的数量很多时，这种好处会显得非常明显。修改父类之后，各子类的独有属性不会受到影响。

1.2 小节的代码例子中，我们对实例的数量进行统计，当子类从 User 类继承下来后，在子类实例化对象的时候，父类的实例数量在 python 中默认也会增多，这说明我们可以把子类的实例看做是父类的实例，这被称为 多态性（polymorphism）。免费用户类跟付费用户类如何从父类继承，如下：

class User:
    """计算被实例化的用户数量"""
    count=0

    def __init__(self,name,age):
        """每次创建一个对象，用户数量在原有基础上加 1"""
        User.count=User.count+1
        self.name=name
        self.age=age

    def hi(self):
        print("hi!I'm {}".format(self.name))

    def die(self):
        print("I'm {}, dying...".format(self.name))
        User.count=User.count-1
        del self
    
    @classmethod
    def print_count(cls):
        print("共有 {} 名用户".format(cls.count))

class  Free_user(User):
    
    def __init__(self,name,age,number_of_ads):
        User.__init__(self,name,age)
        self.number_of_ads=number_of_ads

    def hi(self):
        User.hi(self)
        print("I'm free_user")

class  Paying_user(User):
    def __init__(self,name,age,plan):
        User.__init__(self,name,age)
        self.plan=plan

    def hi(self):
        print("hi!I'm {},paying_user".format(self.name,))


u=Free_user("li",32,5)
User.print_count()
u.hi()

u1=Paying_user("ma",30,"5$")
User.print_count()
u1.hi()

u.die()
User.print_count()
u1.die()
User.print_count()


"""
程序输出：共有 1 名用户
hi!I'm li
I'm free_user
共有 2 名用户
hi!I'm ma,paying_user
I'm li, dying...
共有 1 名用户
I'm ma, dying...
共有 0 名用户
"""

上面代码中首先创建了 User 基类，然后从 User 类继承下来两个子类：Free_user跟Paying_user。子类要从某个类继承而来，需要在类名后面跟上括号，在括号中填入基类的名称，形如这样：Free_user(User)。

在子类的 __init__ 方法中，通过调用基类的 __init__ 方法把继承自基类的共有字段创建出来，调用的时候将 self 跟传入的属于基类部分的参数原样传入，上面代码中将传入的 name 跟age原样传入了基类的 __init__ 方法中了。因为我们在子类中定义了 __init__ 方法，所以 python 不会自动调用基类的 __init__ 方法，而需要我们显式地调用它。如果子类中没有定义 __init__ 方法，则 python 会在创建子类的实例时自动调用基类的 __init__ 方法。这是为什么呢？我们在子类中对基类的 hi 方法进行了重写，但对 die 方法则没有，但是我们通过子类创建的实例能够调用 die 方法，这说明在调用 die 方法时子类的实例被看做了父类的实例了，同时在调用 hi 方法时却都调用了重写的子类中的方法了，这说明，当实例调用一个方法时，会首先在实例化自己的类中寻找对该方法的定义，如果没有，则在该类的父类中寻找。

最后，从前一小节我们知道，以双下划线为前缀的属性名会被 python 自动替换成另一个名称，这时候当父类中有个以双下划线为前缀的属性，我们在子类中也有一个相同的属性的时候，由于 python 自动替换了这两个属性名称，子类中的方法并没有覆盖掉父类中的属性，而只是，子类中的该属性跟父类中的该属性是两个不同的属性。看例子：

# 其他一些属性用“，”省略了
>>> class a:
...     def __a_method(self):
...         pass
... 
>>> dir(a())
['__class__', ,,, '_a__a_method']
>>> class b(a):
...    def __a_method(self):
...         pass
... 
>>> dir(b())
['__class__', ,,, '_a__a_method', '_b__a_method']
>>>

可以看到，__a_method在 a 类的实例中被替换成了 _a_a_method，在b 类的实例中被替换成了 _b__a_method，这跟_a_a_method 不同，b类的实例中继承了_a_a_method，同时，还有自己类型的_b_a_method。

看个例子：

>>> list.__base__
<class 'object'>
>>> type(list)
<class 'type'>
>>> class User:
...     pass
... 
>>> User.__base__
<class 'object'>
>>> type(list)
<class 'type'>

类的属性 __base__ 可以指明该类是继承自哪个类。从上面的例子可以看到，python 中定义内置数据类型的类（class）（以 list 为例）从 object 类继承而来，但是其类型（type)是 type 类，我们自己创建并且没有明确指定从是哪个类继承而来的类（以 User 为例），跟内置类型一样，从 object 类继承而来，其类型（type)是 type 类。如果我们自己创建的，并且从层次更低的类（比如 User 类）中继承而来，那么该类的__base__（基类）跟 type 函数所显示的类型是怎么样的呢，接上面的例子：

>>> Free_user.__base__
<class '__main__.User'>
>>> type(Free_user)
<class 'type'>
>>>

可以看到，Free_user从 User 继承而来，但其类型依然是 type，所以所有的类（class) 的类型应当都是 type，是不是这样呢，object 会不会例外呢？type自己呢？它的类型呢？下面的例子验证了它们的类型也是type：

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

从例子中我们知道了，所有的类（class）的类型都是 type 类，所以，所有的类（class）都是从 type 类中实例化出来的实例，甚至 type 类实例化了自己，所以所有的类包括 object 和type都是实例，这说明所有的类都是对象 。为了清晰的指代不同种类的对象，我们把本身是类的对象称为 类对象 ，把从类中实例化而来并且本身不是类的对象成为 实例对象，实例对象是层次最低的对象。

我们可以看到 object 类跟 type 类是 python 中抽象层次最高的对象了。那么它们两个的关系如何呢？看例子：

>>> type.__base__
<class 'object'>
>>> print(object.__base__)
None
>>>

可以看到，type从 object 继承而来，并且我们已经知道 object 的类型是 type。从例子中可以看到object 没有基类，所以如果把类的层层继承想象成一条锁链，那么 object 将是继承链上的顶点。前面我们提到的对象的一些特殊属性如 __init__、__class__ 继承自 object, 而__base__ 这个特殊属性则只有类对象才有，是在 type 中定义的。如下：

# 其他一些属性用“，”省略了
>>> dir(object)
['__class__', ,,, '__init__', ,,, '__subclasshook__']
>>> dir(type)
['__abstractmethods__', '__base__', '__bases__', ,,, 'mro']
>>>

[欢迎浏览我的个人博客，https://diwugebingren.github.io
](https://diwugebingren.github….

1.0. 定义方法（method）

1.1. 声明字段（field）

1.2. 实例变量与类变量

1.3. 继承（inherit）

1.4. 类（class），对象（object）与类型（type）之间的关系

Just My Socks（注册教程内含优惠码）