这是我参与更文挑战的第24天，活动详情查看： 更文挑战
不知不觉也来到python的面向对象教程阶段了😄，看到这几个字立刻就想到这个面向对象的三大特征 1. 封装 2. 继承 3. 多态
面向对象编程 Object Oriented Programming，简称OOP
面向对象和面向过程的区别
区别就是有木有对象 哈哈，面向对象都是通过这个对象去传递消息的， 例如 写代码时，面向对象都是先考虑有没有这个对象，没有的话要去创建这个对象（Object），而对象是类（Class）里面的一个实例（Instance）, 在这个类里会有该类对象的特有属性，还有行为（方法）。 而面向过程呢，没有这个类和对象的概念，代码里出现的都是封装好的函数和变量。
例如打印学生的成绩 面向过程：
std1 = { 'name': 'Michael', 'score': 98 } std2 = { 'name': 'Bob', 'score': 81 } def print_score(std): print('%s: %s' % (std['name'], std['score'])) 复制代码
面向对象：
class Student(object): age=18 # 类属性 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) print(bart) # <__main__.Student object at 0x000001F7D6996DF0> bart.print_score() # Bart Simpson: 59 lisa.print_score() # Lisa Simpson: 87 print(Student.age) # 18 print(bart.age) # 18 复制代码
从上面这个面向对象的例子中，
class Student(object):表示一个Student类，继承object类，类名一般首字母大写,和java一样.
print(bart)可以看到该对象是属于Student类，内存地址为后面的0x000001F7D6996DF0
def __init__(self, name, score):方法（注意是双下划线）
注意到
__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身
- 有java构造器的feel,不同的是每个方法的第一个参数都是
self
- 实例属性： 通过实例变量或者self进行绑定
- 类属性： 如上
age=18
访问限制（封装）
private变量：双下划线开头并且不能以双下划线结尾的 （不能直接访问） 特殊变量： 双下划线开头并且以双下划线结尾 （能直接访问）
有些时候，你会看到以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。 双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。不能直接访问
__name是因为Python解释器对外把__name变量改成了_Student__name，所以，仍然可以通过_Student__name来访问__name变量：
网络异常，图片无法展示|
通过将变量私有化，提供get/set方法去获取/设置这个变量，来提高程序的健壮性（毕竟在方法中可以对参数进行处理）。
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_score(self): return self.__score def set_score(self, score): self.__score = score bart = Student('Bart Simpson', 59) print(bart.__name) # 'Student' object has no attribute '__name' print(bart._Student__name) # Bart Simpson bart.set_score(88) print(bart.get_score()) #88 复制代码
继承
被继承的class称为基类、父类或超类（Base class、Super class）。 例子：父类：Animal，子类Dog
class Animal(object): __age=1 def run(self): print('Animal is running...') def set_age(self,age): self.__age=age def get_age(self): return self.__age class Dog(Animal): def run(self): print('Dog is running...') class Cat(Animal): def run(self): print('Cat is running...') d=Dog() d.run() d.set_age(2) print(d.get_age()) print(d.__age) 复制代码
额，这个python的写法确实好简洁呀！直接将括号中的类改掉即可。
继承和java的一样，继承就有了父类的公有属性和方法,毕竟私有的访问不了。
多态
什么是多态呢？ 多态是指事物的多种形态。比如上面的这个动物例子，动物都会跑，但是猫和狗的跑的方法是不一样的。
额。。这个java有重载和重写，分别对应编译时的多态和运行时的多态。但是这个python是解释型的。。这个应该就只有运行时的多态。
运行时的多态，这个可是面向对象最精髓的东西了。
多态的好处就是，当我们需要传入Dog、Cat、Tortoise……时，我们只需要接收Animal类型就可以了，因为Dog、Cat、Tortoise……都是Animal类型，然后，按照Animal类型进行操作即可。由于Animal类型有run()方法，因此，传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的run()方法，这就是多态的意思
来感受下这个例子： 定义一个函数，接受animal类型
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... 复制代码
运行时的多态的两个特点：
- 方法重写
- 父类引用指向子类对象
静态语言VS动态语言
对于静态语言（例如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。 对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了：
🤨
这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。Python的“file-like object“就是一种鸭子类型。对真正的文件对象，它有一个read()方法，返回其内容。但是，许多对象，只要有read()方法，都被视为“file-like object“。许多函数接收的参数就是“file-like object“，你不一定要传入真正的文件对象，完全可以传入任何实现了read()方法的对象。
注意：动态语言的鸭子类型特点决定了继承不像静态语言那样是必须的。
获取对象信息
type()
用于判断对象类型, 返回对应的Class类型 判断一个对象是否是函数,可以使用types模块中定义的常量
import types print(type(123)) #<class 'int'> print(type('hello world')) #<class 'str'> print(type(abs)) #<class 'builtin_function_or_method'> def fn(): pass print(type(fn)) #<class 'function'> print(types.BuiltinFunctionType) #<class 'builtin_function_or_method'> print(types.FunctionType) #<class 'function'> 复制代码
isinstance()
这个之前就用得很多啦，
print(isinstance('hello',str)) # True # 是不是其中的一种类型 print(isinstance('hello',(int,list,str))) # True 复制代码
能用type()判断的基本类型也可以用isinstance()判断 总是优先使用isinstance()判断类型，可以将指定类型及其子类“一网打尽”
dir()
获得一个对象的所有属性和方法，，它返回一个包含字符串的list
print(dir(str)) ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] 复制代码
上面的特殊变量 比如
__len__方法返回长度。在Python中，如果你调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，它自动去调用该对象的__len__()方法，所以，下面的代码是等价的：
len('ABC') # 3 'ABC'.__len__() # 3 # 重写len方法 class MyDog(object): def __len__(self): return 10 len(MyDog()) #10 复制代码
getattr()、setattr()以及hasattr()
直接操作一个对象的状态： 要注意的是，只有在不知道对象信息的时候，我们才会去获取对象信息。
len('ABC') 'ABC'.__len__() class MyDog(object): def __init__(self): self.x=9 def power(self): return self.x**2 def __len__(self): return 10 d=MyDog() print(len(d)) # 10 print(d.x) # 9 print(hasattr(d,'x')) # True if(not hasattr(d,'y')): setattr(d,'y',100) print('y is {}'.format(getattr(d,'y'))) # y is 100 # 试图获取不存在的属性，会抛出AttributeError的错误： print('z is {}'.format(getattr(d,'z'))) # AttributeError: 'MyDog' object has no attribute 'z' print('z is {}'.format(getattr(d,'z',222))) # 可以给个默认值 222 ,不存在时返回。 fn=getattr(d,'power') # 可以获取函数 print(d.power()) #81 print(fn()) # 81 复制代码
正确用法
假设我们希望从文件流fp中读取图像，我们首先要判断该fp对象是否存在read方法，如果存在，则该对象是一个流，如果不存在，则无法读取。hasattr()就派上了用场。 请注意，在Python这类动态语言中，根据鸭子类型，有read()方法，不代表该fp对象就是一个文件流，它也可能是网络流，也可能是内存中的一个字节流，但只要read()方法返回的是有效的图像数据，就不影响读取图像的功能。
def readImage(fp): if hasattr(fp, 'read'): return readData(fp) return None
