python类需要关注的几个问题

新式类和经典类的区别：

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,object):
   pass

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

D 继承了 object 和不继承程序输出不一样，继承 object 会调用 C 类的 foo，否则会调用 Ａ 的。

使用 super 进行父类构造调用那么必须使用 object 继承的新式类，否则报错。

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 类。

 

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

#!/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']

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

 

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'。

 

定义 __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__方法需要返回一个字符串，当做这个对象的描写