【Python】5.面向对象的Python

Python是一种面向对象编程的语言，Python中几乎都是对象，简单数值类型，代码模块，可以说是万物皆对象。例如对于一个数值对象：

>>> type(1)
<class 'int'>
>>> dir(1)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

一、面向对象编程

面向对象编程的思想将对象作为程序的基本单元，对象=数据（属性）+一套访问和操作这些数据的方法。就像在引言中说的，Python中所有的数据类型都可以被视为对象我们也可以自定义对象，即面向对象中类的概念。
从面向过程的编程到面向对象的编程，从语句到函数到类，抽象程度不断变高，但是更符合我们日常中的概念。
以学生成绩表为例，语句表达：

std1 = { 'name': 'Michael', 'score': 98 }
std2 = { 'name': 'Bob', 'score': 81 }

通过函数打印：

def print_score(std):
    print('%s: %s' % (std['name'], std['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)
lisa = Student('Lisa Simpson', 87)
bart.print_score()
lisa.print_score()

面向对象编程的好处主要有三个方面：
1）多态：可对不同类型的对象执行相同的操作。
2）封装：对外部隐藏有关对象工作原理的细节。
3）继承：可基于通用类创建出专用类。

二、类和对象

1.什么是类和对象

类是一种对象的统称，每个对象都属于特定的类，对象是类的实例，是Python中程序的基本单元，要创建对象，就首先要创建一个类。
通过赋值语句可以给对象赋予名称，名称可以有很多个但是id只有一个。

a = complex(1,1)

2.自定义类：创建与调用

1）class语句和类的初始化

class <类名>:
  def _init_(self,<参数表>):
  def <方法名>(self,<参数表>)：

_init_()是一个特殊的函数名，用于根据类的定义创建实例对象，第一个参数必须是self。
2）调用类和方法

obj = <类名>(<参数表>)
obj.<方法>（）

类方法中的self就是obj对象实例本身

#在Python中约定，类名大写字母开头，函数小写字母开头
class Person: 
 def set_name(self, name): 
 self.name = name 
 def get_name(self): 
 return self.name 
 def greet(self): 
 print("Hello, world! I'm {}.".format(self.name))

>>> foo = Person() #先创建Person()，再将foo名称与之关联
>>> bar = Person() 
>>> foo.set_name('Luke Skywalker') 
>>> bar.set_name('Anakin Skywalker') 
>>> foo.greet() 
Hello, world! I'm Luke Skywalker. 
>>> bar.greet() 
Hello, world! I'm Anakin Skywalker.

3.属性、函数和方法

方法和函数的区别表现在参数self上，方法中的第一个参数关联到它所属的实例，调用的时候无需这个参数，可以在类的外部将方法关联到一个普通的函数，通过这种方法，也可以实现普通函数对类中self实例的访问。

>>> class Class: 
... def method(self): 
... print('I have a self!') 
... 
>>> def function(): 
... print("I don't...") 
... 
>>> instance = Class() 
>>> instance.method() I have a self! 
>>> instance.method = function 
>>> instance.method() I don't...

>>> class Bird: 
... song = 'Squaawk!' 
... def sing(self): 
... print(self.song) 
... 
>>> bird = Bird() 
>>> bird.sing() 
Squaawk! 
>>> birdsong = bird.sing 
>>> birdsong() 
Squaawk!

4.类命名空间

在class语句中定义的代码都是在一个特殊的命名空间（类的命名空间）内执行的，而类的所有成员都可访问这个命名空间，例如：

class MemberCounter: 
 members = 0 
 def init(self): 
 MemberCounter.members += 1 
>>> m1 = MemberCounter() 
>>> m1.init() 
>>> MemberCounter.members 
1 
>>> m2 = MemberCounter() 
>>> m2.init() 
>>> MemberCounter.members 
2

如果给实例中的属性members赋值，那么该值将被写入m1的一个属性中，这个属性遮住了类级变量。m1中的属性将被覆盖为定值（类似于外部传递进来的实参值覆盖类命名空间内的全局变量），类中的操作不在影响该变量，但m1中的方法仍会影响其他实例中的该属性（类级变量）。

>>> class MemberCounter:
	members = 0
	def init(self):
		MemberCounter.members += 1
>>> m1 = MemberCounter()
>>> m1.init()
>>> m1.members
1
>>> m1.members=3
>>> m1.members
3
>>> m2= MemberCounter()
>>> m2.init()
>>> m2.members
2
>>> m1.init()
>>> m1.members
3
>>> m2.members
3
>>> m2.init()
>>> m2.members
4

三、继承

1.继承

1）定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。
例如：Dog类和Cat类都继承自Animal类。

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

class Dog(Animal):
    pass

class Cat(Animal):
    pass

2）通过这种方法，子类可以获得父类全部的属性和方法，并可以新增，或者重写已有的方法。

class Filter: 
  def init(self): 
  self.blocked = [] 
  def filter(self, sequence): 
  return [x for x in sequence if x not in self.blocked] 
class SPAMFilter(Filter): # SPAMFilter是Filter的子类
  def init(self): # 重写超类Filter的方法init 
  self.blocked = ['SPAM']

>>> f = Filter() 
>>> f.init() 
>>> f.filter([1, 2, 3]) 
[1, 2, 3]
>>> s = SPAMFilter() 
>>> s.init() 
>>> s.filter(['SPAM', 'SPAM', 'SPAM', 'SPAM', 'eggs', 'bacon', 'SPAM']) 
['eggs', 'bacon']

2.继承查询

1）要确定一个类是否是另一个类的子类，可使用内置方法issubclass：

>>> issubclass(SPAMFilter, Filter) 
True 
>>> issubclass(Filter, SPAMFilter) 
False

2）查询基类，可访问其特殊属性 __bases__;查询对象属于哪个类，可使用属性__class__:

>>> SPAMFilter.__bases__ 
(<class __main__.Filter at 0x171e40>,) 
>>> Filter.__bases__ 
(<class 'object'>,)

3）确定对象是否是特定类的实例，可使用isinstance:

>>> s = SPAMFilter() 
>>> isinstance(s, SPAMFilter) 
True 
>>> isinstance(s, Filter)
True

3.多个超类

1）多重继承，继承多个父类的属性和方法：

class Calculator: 
 def calculate(self, expression): 
 self.value = eval(expression) 
class Talker: 
 def talk(self): 
 print('Hi, my value is', self.value) 
class TalkingCalculator(Calculator, Talker): 
 pass

>>> tc = TalkingCalculator() 
>>> tc.calculate('1 + 2 * 3') 
>>> tc.talk() 
Hi, my value is 7

2）注意：如果多个超类以不同的方式实现了同一个方法（同名方法），必须在class语句中小心排列这些超类，因为位于前面的类的方法将覆盖位于后面的类的方法。因此，在前面的示例中，如果Calculator类包含方法talk，那么这个方法将覆盖Talker
类的方法talk（导致它不可访问）。

四、多态

1.什么是多态

我们首先要对数据类型再作一点说明。当我们定义一个class的时候，我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型，比如str、list、dict没什么两样，子类对象的数据类型是子类本身，同时也是父类的数据类型。
多态的用法例如，定义一个函数：

def run_twice(animal):
    animal.run()
    animal.run()

>>> run_twice(Animal())
Animal is running...
Animal is running...

>>> run_twice(Dog())
Dog is running...
Dog is running...

>>> run_twice(Cat())
Cat is running...
Cat is running..

2.开闭原则

多态的好处就是，由于Animal类型有run()方法，因此，传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的run()方法，这就是多态的意思。调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：
1）对扩展开放：允许新增Animal子类；
2）对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

3.鸭子类型

一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。
对于静态语言（例如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了，实际上对于Python，就是针对函数中调用的方法，只要有，不管定义的类型是什么，传递进去的类型是什么，都可以：

>>> def runtwice(anywithrun):
	anywithrun.run()
	anywithrun.run()

五、封装

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

1.私有变量

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

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'

注意：①如果变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以尽量避免使用这种变量。
②如果变量名以一个下划线开头，这样的实例变量外部是可以访问的，但是，意思就是，请当作私有变量不要随意访问。
③即使是private变量，Python也提供了访问的方法，因为Python解释器对外把__xxx变量改成了_类名__xxx，所有通过下面这种方式也可以访问，但是尽量不要这样做。

>>> bart._Student__name
'Bart Simpson'

2.读写方法

例如上面的例子，如果外部代码要获取name和score，可以给Student类增加get_name和get_score这样的方法，如果要允许外部代码修改score，可以再给Student类增加set_score方法：

class Student(object):
    ...

    def get_name(self):
        return self.__name

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