【Python】从入门到上头—Python类和对象（4）

面向对象特性(了解即可)

• 类(Class): 具有相同的属性和方法的对象的集合。对象是类的实例。

• 方法：类中定义的函数。

• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

• 局部变量：定义在方法中的变量，只作用于当前实例的类。

• 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例 如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

• 实例化：创建一个类的实例，类的具体对象。

• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

  扫描二维码关注公众号，回复： 16499668 查看本文章

一.类和实例

1.创建类语法

class ClassName:
    <statement-1>
    <statement-N>

在Python中，定义类是通过class关键字：

• 以Student类为例

  class Student(object):
      pass
  

• class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。

如何实例对象

• 定义好了Student类，就可以根据Student类创建出Student的实例，创建实例是通过类名+()实现的：

   stu = Student()
  

2.类的属性 和 __init__方法

• 由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去：

  class Student(object):
  
  def __init__(self, name, score):
      self.name = name
      self.score = score
  

  • 注意：特殊方法“__init__”前后分别有两个下划线！！！

  • __init__方法的第1个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。

    • 有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：

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

3.类函数和普通函数的区别

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

4.属性封装

上面的Student类中，每个实例就拥有各自的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 = Student('Bart Simpson', 59)
 bart.print_score()
 #Bart Simpson: 59

二.访问限制

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问，所以，我们把Student类改一改：

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))

改完后，对于外部代码来说，没什么变动，但是已经无法从外部访问实例变量.__name和实例变量.__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'

是如果外部代码要获取name和score怎么办？可以给Student类增加get_name和get_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))

    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

• 需要注意的是，在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__的变量名。

  • 双下划线开头的实例变量是不是一定不能从外部访问呢？’
    • 其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name，所以，仍然可以通过_Student__name来访问__name变量：

   bart._Student__name
   打印结果： 'Bart Simpson'
  

• 但强烈建议不要这么干，因为不同版本的Python解释器可能会把__name改成不同的变量名。

三.继承和多态

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

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

1.继承

语法规则

• 子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。

  class DerivedClassName(BaseClassName):
  <statement-1>
  .
  .
  .
  <statement-N>
  

• 比如，我们已经编写了一个名为Animal的class，有一个run()方法可以直接打印：

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

• 当我们需要编写Dog和Cat类时，就可以直接从Animal类继承：

  class Dog(Animal):
      pass
  
  class Cat(Animal):
      pass
  

• 对于Dog来说，Animal就是它的父类，对于Animal来说，Dog就是它的子类。Cat和Dog类似。

继承有什么好处？

• 最大的好处是子类获得了父类的全部功能。由于Animial实现了run()方法，因此，Dog和Cat作为它的子类，什么事也没干，就自动拥有了run()方法：

  dog = Dog()
  dog.run()
  
  cat = Cat()
  cat.run()
  

  • 运行结果

  Animal is running...
  Animal is running...
  

子类也可以有自己的一些方法，比如Dog类：

class Dog(Animal):

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

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

继承的第二个好处需要我们对代码做一点改进。你看到了，无论是Dog还是Cat，它们run()的时候，显示的都是Animal is running…，符合逻辑的做法是分别显示Dog is running…和Cat is running…，因此，对Dog和Cat类改进如下：

class Dog(Animal):

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

class Cat(Animal):

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

运行结果

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

2.多态

当子类和父类都存在相同的run()方法时，我们说，子类的run()覆盖了父类的run()，在代码运行的时候，总是会调用子类的run()。这样，我们就获得了继承的另一个好处：多态。
- 当我们定义一个class的时候，我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型，比如str、list、dict没什么两样：

a = list() # a是list类型
b = Animal() # b是Animal类型
c = Dog() # c是Dog类型

• 判断一个变量是否是某个类型可以用isinstance()判断：

isinstance(a, list)
#True
 isinstance(b, Animal)
#True
 isinstance(c, Dog)
#True

3.多继承

Python同样有限的支持多继承形式。多继承的类定义形如下例:

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    <statement-N>

• 需要注意圆括号中父类的顺序，·若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时·，

4.类的专有方法(初学者了解即可)

• 通过内置的一系列函数，我们可以对任意一个Python对象进行剖析，拿到其内部的数据。

__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方