Python进阶（二）:继承与特殊方法

继承

定义

    子类继承父类的属性并可以拥有自己的属性

使用

class Person(object):                       #注意经典类与新式类
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def who(self):
        return 'I am a Person, my name is %s' % self.name    

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    def who(self):
        return 'I am a Student, my name is %s' % self.name
        
class Teacher(Person):                 #括号内写明继承的类
    def __init__(self, name, gender, subject):
        super(Teacher, self).__init__(name, gender)    #初始化父类继承的属性
        self.subject = subject
    def who(self):
        return 'I am a Teacher, my name is %s' % self.name
    
teacher = Teacher('Tom', 'Male', 'English')
print teacher.name
print teacher.gender
print teacher.subject
#使用isinstance判断类型
print isinstance(t, Person)      #True
print isinstance(t, Student)     #False
print isinstance(t, Teacher)     #True
print isinstance(t, object)      #True

class Boss(Person):
    def __init__(self, name, gender,company):
        super(Boss, self).__init__(name, gender)
        self.company = company
'''多态
在实际调用的时候，会首先查找自身的定义，如果自身有定义，则优先使用自己定义的函数；如果没有定义，则顺着继承链向上找。
'''
p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')
b = Boss('Bob', 'Male', 'Alibaba')
print p.who()  # I am a Person, my name is Tim
print s.who()  # I am a Student, my name is Bob
print t.who()  # I am a Teacher, my name is Alice
print b.who()  # I am a Person, my name is Bob

'''多重继承
除了从一个父类继承外，Python允许从多个父类继承，称为多重继承。多重继承和单继承没有特别大的差异，只是在括号内加入多个需要继承的类的名字即可。
'''
class A(object):
    def __init__(self, a):
        print ('init A...')
        self.a = a

class B(A):
    def __init__(self, a):
        super(B, self).__init__(a)
        print ('init B...')

class C(A):
    def __init__(self, a):
        super(C, self).__init__(a)
        print ('init C...')

class D(B, C):
    def __init__(self, a):
        super(D, self).__init__(a)
        print ('init D...')

'''获取对象信息
type():获得对象类型
dir():获取变量的所有属性
getattr():获取对象的属性
setattr(key, value[, default]):设置对象的属性
'''

特殊方法

• 以双下划线开头
• 以双下划线结束
• 每个对象都有特殊方法

'''__str__(),___repr__()
Python 定义了__str()__和__repr__()两种方法，__str()__用于显示给用户，而__repr__()用于显示给开发人员，当使用str()时，实际调用的是__str__()方法，而直接输入变量，调用的是__repr__()方法。
'''
class Student():
    def __init__(self, name, gender, score):
        self.name = name
        self.gender = gender
        self.score = score
    
    def __str__(self):
        return 'Student: {}, {}, {}'.format(self.name, self.gender, self.score)
    
    def __repr__(self):
        return 'Student: {}, {}, {}'.format(self.name, self.gender, self.score)
    
s = Student('Bob', 'Male', 80)
print s         # ==> Student: Bob, Male, 80
print str(s)    # ==> Student: Bob, Male, 80

'''__len__()
通过自定义__len__()方法，可以让len()函数返回相关的结果，如果没有定义__len__()方法的类使用len()函数获取长度时，将会引起异常。
'''
class Fib():
    def __init__(self, n):
        self.count = n
        num = [0,1]
        for i in range(2,n):
            num.append(num[i-1]+num[i-2])
        self.num = num
    
    def __repr__(self):
        return str(self.num)
    
    def __len__(self):
        return self.count
    
print Fib(10)            # ==> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
print len(Fib(10))       # ==> 10

''‘数学运算
Python的除法可以分为地板除和普通除法，地板除的特殊方法是__floordiv__（向下取整），普通除法是__truediv__（在2.x版本中则是__div__函数）
'''
class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __add__(self, r):
        return Rational(self.p * r.q + self.q * r.p, self.q * r.q)
    def __sub__(self, r):
        return Rational(self.p * r.q - self.q * r.p, self.q * r.q)
    def __mul__(self, r):
        return Rational(self.p * r.p, self.q * r.q)
    def __div__(self, r):
        return Rational(self.p * r.q, self.q * r.p)
    def __str__(self):
        return '{}/{}'.format(self.p, self.q)

r1 = Rational(1,2)
r2 = Rational(2,3)

print r1+r2          # ==> 7/6
print r1-r2          # ==> -1/6
print r1*r2          # ==> 2/6
print r1/(r2)        # ==> 3/4

'''__slots__()
__slots__的目的是限制当前类所能拥有的属性，避免因为外部属性的操作导致类属性越来越难以管理
'''
class Person(object):
    __slots__ = ('name', 'gender')
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    
class Student(Person):
    __slots__ = ('score',)
    def __init__(self, name, gender, score):
        self.name = name
        self.gender = gender
        self.score = score

p = Person('John', 'Male')
s = Student('Marry', 'Female', 80)

print p.name        # ==> John
print s.score       # ==> 80

'''__call__()
通过实现__call__方法将一个类实例变成可调用对象
'''
class Fib():
    def __init__(self):
        pass
    def __call__(self, n):
        num = [0,1]
        for i in range(2,n):
            num.append(num[i-1]+num[i-2])
        return num

f = Fib()
print f(10)      # ==> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]