python 在线

991Python 高级教程 Python 面向对象

定义 __str__() 方法:

class Cat:
    """定义一个猫类"""
 
    def __init__(self, new_name, new_age):
        """在创建完对象之后 会自动调用, 它完成对象的初始化的功能"""
        # self.name = "汤姆"
        # self.age = 20
        self.name = new_name
        self.age = new_age  # 它是一个对象中的属性,在对象中存储,即只要这个对象还存在,那么这个变量就可以使用
        # num = 100  # 它是一个局部变量,当这个函数执行完之后,这个变量的空间就没有了,因此其他方法不能使用这个变量
 
    def __str__(self):
        """返回一个对象的描述信息"""
        # print(num)
        return "名字是:%s , 年龄是:%d" % (self.name, self.age)
 
    def eat(self):
        print("%s在吃鱼...." % self.name)
 
    def drink(self):
        print("%s在喝可乐..." % self.name)
 
    def introduce(self):
        # print("名字是:%s, 年龄是:%d" % (汤姆的名字, 汤姆的年龄))
        # print("名字是:%s, 年龄是:%d" % (tom.name, tom.age))
        print("名字是:%s, 年龄是:%d" % (self.name, self.age))
 
# 创建了一个对象
tom = Cat("汤姆", 30)
print(tom)

总结:

  • 在python中方法名如果是__xxxx__()的,那么就有特殊的功能,因此叫做“魔法”方法
  • 当使用print输出对象的时候,只要自己定义了__str__(self)方法,那么就会打印从在这个方法中return的数据
  • __str__方法需要返回一个字符串,当做这个对象的描写

990Python 高级教程 Python 面向对象

989Python 高级教程 Python 面向对象

Python 的类和类实例都是可变对象,可以随时给属性赋值,并且在原处修改。

在对类属性进行修改时需要特别小心,因为所有的类实例都继承共享类属性,除非实例本身存在和类属性同名的属性。对类属性进行修改,会影响到所有由这个类生成的实例。

class CA(object):

    cls_pre = 'aaaaa'

    def __init__(self):
        self.obj_pre = 'bbbbb'

a = CA()
b = CA()

print(a.cls_pre, a.obj_pre)
print(b.cls_pre, b.obj_pre)

CA.cls_pre = 'ccccc'
c = CA()

d = CA()
d.cls_pre = 'ddddd'

print(a.cls_pre, a.obj_pre)
print(b.cls_pre, b.obj_pre)
print(c.cls_pre, c.obj_pre)
print(d.cls_pre, d.obj_pre)

运行结果:

aaaaa bbbbb
aaaaa bbbbb
ccccc bbbbb
ccccc bbbbb
ccccc bbbbb
ddddd bbbbb

代码中,将类属性 CA.cls_pre 重新赋值为 'ccccc'。在修改类属性之后,不仅是后续创建的类实例 c 的 cls_pre 发生变化,在修改类属性之前的创建的类实例 a、b 的类属性 cls_pre 都发生了变化。

所以,当在class语句外修改类属性时,会导致所有由这个类创建的实例的类属性都随之变化,因为所有的实例都共享类属性 CA.cls_pre。除非实例本身有同名的实例属性对类属性进行了覆盖,比如代码中的 d.cls_pre = 'ddddd'。

988Python 高级教程 Python 面向对象

当你创建一个对象并给它赋一个变量的时候,这个变量仅仅引用那个对象,而不是表示那个对象本身!也就是说,变量名只是指向计算机中存储那个对象的内存。这被称作名称到对象的绑定。

#!/usr/bin/python
#-*- coding=utf-8 -*-

print '-----------简单的赋值-----------'
shoplist = ['apple','mango','carrot','banana']
mylist = shoplist # 简单的赋值 只是引用变量名

del shoplist[0]
del mylist[0]

print 'shoplist 列表:',shoplist
print 'mylist 列表:',mylist

print '完整切片是真正的复制:'

mylist = shoplist[:]

del mylist[0]

print 'shoplist 列表:',shoplist
print 'mylist 列表:',mylist

输出结果为:

-----------简单的赋值-----------
shoplist 列表: ['carrot', 'banana']
mylist 列表: ['carrot', 'banana']
完整切片是真正的复制:
shoplist 列表: ['carrot', 'banana']
mylist 列表: ['banana']

很明显,普通引用只是名称的绑定,而只有完整切片才是真正意义上的复制。所以我们在简单引用后一定要考虑是否可以更改,因为操作可能影响到源对象。

987Python 高级教程 Python 面向对象

Python 为什么要继承 object 类?

继承 object 类的是新式类,不继承 object 类的是经典类,在 Python 2.7 里面新式类和经典类在多继承方面会有差异:

class A:
    def foo(self):
        print('called A.foo()')

class B(A):
    pass

class C(A):
    def foo(self):
        print('called C.foo()')

class D(B, C): 
    pass

if __name__ == '__main__':
    d = D() 
    d.foo()

B、C 是 A 的子类,D 多继承了 B、C 两个类,其中 C 重写了 A 中的 foo() 方法。

如果 A 是经典类(如上代码),当调用 D 的实例的 foo() 方法时,Python 会按照深度优先的方法去搜索 foo() ,路径是 B-A-C ,执行的是 A 中的 foo() ;

如果 A 是新式类,当调用 D 的实例的 foo() 方法时,Python 会按照广度优先的方法去搜索 foo() ,路径是 B-C-A ,执行的是 C 中的 foo() 。

因为 D 是直接继承 C 的,从逻辑上说,执行 C 中的 foo() 更加合理,因此新式类对多继承的处理更为合乎逻辑。

在 Python 3.x 中的新式类貌似已经兼容了经典类,无论 A 是否继承 object 类, D 实例中的 foo() 都会执行 C 中的 foo() 。但是在 Python 2.7 中这种差异仍然存在,因此还是推荐使用新式类,要继承 object 类。