python 的类

目录

1.类和实例

  1.1类和实例的概念

  1.2类的属性

  1.3类的方法

  1.4类的访问限制

2.继承和多态

  2.1继承的概念

  2.2多态

一、类和实例

1.类（Class）和实例（Instance）的概念

类就是一个抽象的模板，而实例就是类的一个个具体的对象，如动物就是一个类，而猪、狗、鸡等等就是一个个动物的实例

#创建一个类
class Student(object):
    pass


#创建实例是通过类名+()实现的：
bart = Student()

#可以看到，变量bart指向的就是一个Student的实例，后面的0x10a67a590是内存地址，每个object的地址都不一样，而Student本身则是一个类
bart  #<__main__.Student object at 0x10a67a590>
Student  #<class '__main__.Student'>

#可以自由地给一个实例变量绑定属性，比如，给实例bart绑定一个name属性：
bart.name = 'Bart Simpson'
bart.name   #'Bart Simpson'

2.类的属性

#__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身
class Student(object):

    def __init__(self, name, score):
        self.name = name
        self.score = score


#有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去
bart = Student('Bart Simpson', 59)
bart.name  #'Bart Simpson'
bart.score  #59

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。

3.类的方法

类定义了一些属性，类的实例就拥有了这些属性，如果要访问这些数据，我们可以在类内部定义访问数据的函数，这样就把数据封装起来，也称为类的方法

类的方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据

#print_score就是类的方法，可以直接访问类的属性name和score
class Student(object):

    def __init__(self, name, score):
        self.name = name
        self.score = score

    def print_score(self):
        print('%s: %s' % (self.name, self.score))

bart.print_score()  #Bart Simpson: 59

#这样一来，我们从外部看Student类，就只需要知道，创建实例需要给出name和score，而如何打印，都是在Student类的内部定义的，这些数据和逻辑被“封装”起来了，调用很容易，但却不用知道内部实现的细节。


#封装的另一个好处是可以给Student类增加新的方法，比如get_grade：
class Student(object):
    ...

    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'

4.类的访问限制

在Class内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据，这样，就隐藏了内部的复杂逻辑。

但是，从前面Student类的定义来看，外部代码还是可以自由地修改一个实例的name、score属性：

bart = Student('Bart Simpson', 59)
bart.score  #59
bart.score = 99  
bart.score  #99

为了不让内部属性被外部访问，可以把属性的名称前加上两个下划线__，就变成了一个私有变量，只有内部可以访问，外部不能访问

这样就确保了外部代码不能随意修改对象内部的状态，这样通过访问限制的保护，代码更加健壮

class Student(object):

    def __init__(self, name, score):
        self.__name = name  #__,私有变量
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))



bart = Student('Bart Simpson', 59)
bart.__name
#输出
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'

但是外部一定要访问的话，上面的例子可以给Student类增加get_name和get_score这样的方法

class Student(object):
    ...

    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

如果又要允许外部代码修改score怎么办？可以再给Student类增加set_score方法：

class Student(object):
    ...

    def set_score(self, score):
        self.__score = score

二、继承和多态

1.继承的概念

继承：

当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）

子类获得了父类的全部功能

#父类
class Animal(object):
    def run(self):
        print('Animal is running...')


#子类
class Dog(Animal):
    pass

class Cat(Animal):
    pass


dog = Dog()
dog.run()

cat = Cat()
cat.run()

2.多态

多态：继承可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写

当子类和父类存在着相同的方法时，子类会覆盖了父类的方法，调用时也会调用子类的方法，

#给Dog添加一些方法：
class Dog(Animal):

    def run(self):
        print('Dog is running...')

    def eat(self):
        print('Eating meat...')


#子类覆盖父类的方法
class Dog(Animal):

    def run(self):
        print('Dog is running...')

class Cat(Animal):

    def run(self):
        print('Cat is running...')

多态的好处：

编写一个函数，函数接受一个类的变量，就可以不加修改地正常运行

#函数run_twice需要接受一个类
def run_twice(animal):
    animal.run()
    animal.run()


run_twice(Animal())
run_twice(Dog())
run_twice(Cat())


#分别输出
Animal is running...
Animal is running...

Dog is running...
Dog is running...

Cat is running...
Cat is running...

#当新加一个子类时，不必对run_twice做任何修改
class Tortoise(Animal):
    def run(self):
        print('Tortoise is running slowly...')
run_twice(Tortoise())
#输出
Tortoise is running slowly...
Tortoise is running slowly...

对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法，而具体调用的run()方法是作用在Animal、Dog、Cat还是Tortoise对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：

对扩展开放：允许新增Animal子类；

对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

继承还可以一级一级地继承下来，就好比从爷爷到爸爸、再到儿子这样的关系。而任何类，最终都可以追溯到根类object