面向对象编程（OOP)
什么是面向对象 ?
面向对象编程 (OOP，Object Oriented Programming）可以理解为将具有相互 关系的数据/操作封装成对象，以对象的⻆度去处理问题，让对象来完成相应处理 。
面向对象 vs 面向过程：
- 按照业务逻辑 从上到下 设计程序 的⽅式，叫做 ⾯向过程编程 (Procedure OrientedProgramming，POP，⾯向过程程序设计）
- 面向过程编程 最易被初学者接受，其往往⽤⼀⻓段代码来实现指定功能，⼀步接⼀步，环环相扣
- 对于⼤型项⽬，如果使⽤⾯向过程编程，则很容易导致 代码结构过于紧密、耦合度⾼，易出现代码冗余，并且 不利于团队开发
⾯向对象编程 的优点 ：
- 将数据和业务抽象为 对象，有利于程序整体结构的分析和设计，使设计思路更加清晰
- 业务以对象为单位，对象各⾃完成⼯作，减少了代码耦合度，有助于业务升级 和 代码重构
- ⽅便⼯作划分，有利于提⾼团队开发的效率
类和对象
对象 是承载数据，执⾏操作的 ⼀个具体 ”事物”，⽐如具体某⼀个⼈，具体某⼀只狗...
对象中包含两个组成部分:
- 属性: 记录与对象相关的数据，⽐如姓名，年龄，身⾼，肤⾊等
- ⽅法: 实现与对象相关的操作，⽐如吃饭，睡觉，飞行，歌唱等
类 物以类聚，⼈以群分
- 很多事物存在相同的操作/⾏为，⽐如⼈都进⾏吃饭、睡觉，狗都会跑会叫等等
- 描述共同⾏为的集合，称为类 (class)
- 类是总结事物特征的抽象概念，⽽对象是 具体存在的某个实物
类和对象的关系 ：
- 在编程中，类就是创建对象的制造⼿册，⽤来定义对象的⾏为**
- 每个对象必须有⼀个对应的类
定义类
定义⼀个类，格式如下：
class 类名:
⽅法列表
类名的命名规则按照"⼤驼峰"
定义方法
类是定义对象的共同⾏为的，也就是说在类中定义对象的⽅法
class 类名:
def ⽅法名(self):
...
⽅法的格式和函数类似，也可以设置参数和返回值，但是 需要设置第⼀个参数为 self
demo：定义⼀个Dog类
# 定义类
class Dog:
# ⽅法
def eat(self):
print("吃⻣头")
def drink(self):
print("喝⽔")
创建对象
python中，可以根据已经定义的类去创建出对象
创建对象的格式为:
- 引⽤对象的变量名 = 类名()
# 定义⼀个类
class Dog:
# ⽅法
def eat(self):
print("吃⻣头")
def drink(self):
print("喝⽔")
# 根据类，创建⼀个对象
dog1 = Dog()
调用方法
创建对象的格式为:
- 引⽤对象的变量名.⽅法名()
注意：虽然定义⽅法时设置第⼀个参数 self ，但是调⽤⽅法时不要传递对应 self 的参数
对象调⽤⽅法demo:
# 定义⼀个类
class Dog:
# ⽅法
def eat(self):
print("吃⻣头")
def drink(self):
print("喝⽔")
# 根据类，创建⼀个对象
dog1 = Dog()
dog1.eat() # 调用eat方法
dog2.drink() # 调用drink方法
定义/使⽤属性
格式：
- 引⽤对象的变量名.属性名 = 数据
属性和变量类似，⾸次赋值时会定义属性：
# 创建对象
jiqimao = Cat()
# ⾸次赋值属性，会定义属性
jiqimao.age = 3
# 定义属性后，再赋值属性，会修改属性保存的数据
jiqimao.age = 1
# 获取属性值并打印
print(jiqimao.age) # 1
创建多个对象
类作为对象的模具，根据类可以创建多个对象
# 定义类
class Cat:
def eat(self):
print("吃东⻄")
# 创建对象
cat1 = Cat()
# 调⽤⽅法
cat1.eat()
# 定义属性
cat1.name = "加菲"
print(cat1.name)
# ⼀个类是可以创建多个对象
cat2 = Cat()
# 调⽤⽅法
cat2.eat() # 同类对象都可以调⽤类中定义的对象⽅法
# 定义属性
# 同类的对象可以有同名的属性, ⽽且属性的值可以不同
cat2.name = "小叮当"
print(cat2.name)
self 关键字
关键字 self 主要⽤于对象⽅法中，表示调⽤该⽅法的对象 。
- 在⽅法中使⽤ self ，可以获取到调⽤当前⽅法的对象，进⽽获取到该对象的属性和⽅法
- 某个对象调⽤其⽅法时，python解释器会把这个对象作为第⼀个参数传递给⽅法，所以开发者只需要在定义⽅法时 “预留” 第⼀个参数为 self 即可，即不需要设置self对应的实参:
class Dog:
def introduce(self): # self对应的实参 就是 调⽤该⽅法的对象
# self 主要⽤于 在⽅法中使⽤⾃⼰的属性和⽅法
print("我是%s, 请多多关照" % self.name)
dog1 = Dog()
dog1.name = "大黄"
dog1.introduce() # python解释器会⾃动将调⽤⽅法的对象作为第⼀个实参进⾏传递
# 创建另⼀个对象
dog2 = Dog()
dog2.name = "小黑"
dog2.introduce() # 我是小黑，请多多关照
__init__()⽅法
__init__() : 对象的初始化⽅法，在 创建⼀个对象后会被⾃动调⽤，不需要⼿动调⽤ 。
开发者可以 实现init⽅法，并在该⽅法中定义属性并设置初始值
class Dog:
# 初始化⽅法
def __init__(self):
# 设置对象的默认属性及初始值
self.type = "野狗"
# 创建了⼀个对象
dahuang = Dog( )
# 获取对象的属性
print(dahuang.type) # 野狗
__init__( ) ⾃定义参数
- 除了默认参数 self ，还可以设置任意个数的⾃定义参数，例如 __init__(self,x,y,z)
- init⽅法的⾃定义参数必须和创建对象时传递的参数保持⼀致，例如 tom = Cat(x,y,z)
- 开发者可以 设置⾃定义参数，为对象的默认属性提供 不同的初始值
class Dog:
def __init__(self, name):
# 如果希望属性有不同的初始值,可以设置init的⾃定义参数
self.name = name
def introduce(self):
print("我是%s, 请多多关照" % self.name)
dog1 = Dog("大黄") # init对应的实参在创建对象时进⾏设置
dog1.introduce()
dog2 = Dog("小黑")
dog2.introduce()
__del__() ⽅法
将要删除⼀个对象时，python解释器会⾃动调⽤⼀个⽅法，这个⽅法为 __del__() ⽅法
del⽅法可以辅助查看对象的删除情况
class Dog:
# 将要删除对象时，会⾃动调⽤
def __del__(self):
print("对象将要被删除")
"""情况1"""
dog1 = Dog()
print("程序最后⼀⾏")
"""情况2"""
def func():
dog1 = Dog()
func()
print("程序最后⼀⾏")
__str__()⽅法
- 如果直接print打印对象，会看到创建出来的对象在内存中的地址
- 当使⽤ print（xx） 输出对象的时候，只要对象定义了 __str__(self) ⽅法，就会打印该⽅法 return的信息描述
- str⽅法的返回值必须是 字符串类型
class Cat:
"""定义⼀个猫类"""
def __init__(self, new_name, new_age):
self.name = new_name
self.age = new_age
def __str__(self):
"""返回⼀个对象的描述信息"""
return "名字是:%s , 年龄是:%d" % (self.name, self.age)
# 创建了⼀个对象
tom = Cat("机器猫", 3)
print(tom)
私有
私有属性 ：如果在属性名前⾯加了2个下划线'__'，则表明该属性是私有属性，否则为公有属性
私有属性只能在类的内部访问
class Dog:
def __init__(self):
# 私有属性： __xx 不能在类的外部使⽤
self.__children_count = 0
def birth(self):
"""⽣育"""
print("⽣了⼀个崽⼉")
# __children_count只有在调⽤birth⽅法时才能修改,不应该在类外部直接使⽤
self.__children_count += 1
def __str__(self):
return "我有%d个崽⼉:%d" % self.__children_count
dog1 = Dog()
dog1.birth()
print(dog1)
dog1.birth()
print(dog1)
私有⽅法 ：私有⽅法和私有属性类似，在⽅法名前⾯加了2个下划线'__'，则表明该⽅法是私有⽅法
私有⽅法只能在类内部使⽤
class Dog:
def __init__(self):
# 私有属性： __xx 不能在类的外部使⽤
self.__children_count = 0
def birth(self):
"""⽣育"""
print("⽣了⼀个崽⼉")
self.__children_count += 1
# 休产假
self.__birth_leave() # 休产假只有在⽣孩⼦⽅法中才能使⽤,不能在类外部直接调⽤
def __birth_leave(self):
"""产假"""
print("休3个⽉产假")
def __str__(self):
return "我有%d个崽⼉:%d" % self.__children_count
dog1 = Dog()
dog1.birth()
print(dog1)
dog1.birth()
print(dog1)
继承
⻰⽣⻰，凤⽣凤，⽼⿏的⼉⼦会打洞
面向对象三⼤特性: 封装 继承 多态
继承：某个类直接具备另⼀个类的能⼒（属性和⽅法）
格式：class ⼦类名:(⽗类名)
class Animal:
def eat(self):
print("-----吃-----")
def drink(self):
print("-----喝-----")
class Dog(Animal):
"""
def eat(self):
print("-----吃-----")
def drink(self):
print("-----喝-----")
"""
pass
xiao_hei = Dog()
xiao_hei.eat()
xiao_hei.drink()
多层继承
继承关系可以在多层间传递
class Animal:
def eat(self):
print("-----吃-----")
def drink(self):
print("-----喝-----")
class Dog(Animal):
def bark(self):
print("-----汪汪叫------")
class DYST(Dog):
"""定义了⼀个地狱三头犬类"""
pass
class Cat(Animal):
def catch(self):
print("----捉⽼⿏----")
dyd = SYST()
dyd.eat()
dyd.bark()
重写⽗类⽅法
当⼦类实现⼀个和⽗类同名的⽅法时，叫做重写⽗类⽅法
⼦类重写了⽗类⽅法，⼦类再调⽤该⽅法将不会执⾏⽗类的处理
class Animal:
def eat(self):
print("-----吃-----")
def drink(self):
print("-----喝-----")
class Dog(Animal):
def bark(self):
print("-----汪汪叫------")
class DYST(Dog):
"""定义了⼀个地狱三头犬类"""
def bark(self):
print("----嘻嘻嘻嘻-----")
dyd = DYST()
dyd.eat() # ----吃----
dyd.bark() # ----嘻嘻嘻嘻----
调⽤被重写的⽗类⽅法
⼦类重写了⽗类⽅法，仍然想执⾏⽗类中的⽅法，则可以在类中使⽤ super（） 来调⽤⽅法
class Dog:
def bark(self):
print("-----汪汪叫------")
class DYST(Dog):
"""定义了⼀个地狱三头犬类"""
def bark(self):
print("----滚-----")
def see_host(self):
"""看⻅主⼈"""
print("冷漠脸")
# 调⽤已经被重写的⽅法 三种⽅式
Dog.bark(self) # ⽅式1
super(DYST, self).bark() # ⽅式2
super().bark() # ⽅式3 ⽅式2的简化形式
dyq = DYST()
dyq.see_host() # 输出: 冷漠脸 汪汪叫
私有和继承
⽗类中的 私有⽅法、属性，不会被⼦类继承
可以通过调⽤继承的⽗类的共有⽅法，间接的访问⽗类的私有⽅法、属性
class Animal(object):
def __init__(self):
self.num1 = 1
self.__num2 = 2
def __run(self):
print("----跑---")
def eat(self):
print("-----吃-----")
def drink(self):
print("-----喝-----")
def test(self):
print(self.__num2)
self.__run()
class Dog(Animal):
def bark(self):
print("-----汪汪叫------")
# self.__run() # ⽗类中的私有⽅法，没有被⼦类继承
print(self.num1)
# print(self.__num2) # ⽗类中的私有属性，没有被⼦类继承
xiao_hei = Dog()
xiao_hei.bark()
xiao_hei.test()
多继承
从图中能够看出，所谓多继承，即⼦类有多个⽗类，并且具有它们的特征
class Basketball:
def bark(self):
print("gun")
class Chicken:
def sing(self):
print("鸡你太美")
class Kun(Basketball, Chicken): # 多继承使⽤逗号隔开
pass
lianxisheng = Kun()
lianxisheng.bark() # gun
lianxisheng.sing() # 鸡你太美
注意点：
如果在上⾯的多继承例⼦中，如果⽗类篮球和⽗类鸡中，有⼀个同名的⽅法，那么通过⼦类去调⽤的时候，调⽤哪个？
- 后者覆盖前者
class Basketball:
def eat(self):
print("东南西北风")
class Chicken:
def eat(self):
print("饲料")
class LXS(Basketball, Chicken):
# 在多继承中,调⽤指定⽗类的⽅法
def eat(self):
Chicken.eat(self) # 调⽤God的eat⽅法
zhangsan = LXS()
print(LXS.__mro__) # 多继承中使⽤ mro变量来查看继承查询顺序
zhangsan.eat() # 饲料
多态
多态的概念是应⽤于Java和C#这⼀类强类型语⾔中，⽽Python崇尚“鸭⼦类型”。
所谓多态：定义时的类型和运⾏时的类型不⼀样，此时就成为多态。
Python伪代码实现Java或C#的多态
#-*- charset ='utf-8' -*-
class F1(object):
def show(self):
print 'F1.show'
class S1(F1):
def show(self):
print 'S1.show'
class S2(F1):
def show(self):
print 'S2.show'
# 由于在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既能执⾏S1对象的show⽅法，⼜能执⾏S2对象的show⽅法，所以定义了⼀个S1和S2类的⽗类
# 实际传⼊的参数是：S1对象和S2对象
def Func(F1 obj):
"""Func函数需要接收⼀个F1类型或者F1⼦类的类型"""
print obj.show()
s1_obj = S1()
Func(s1_obj) # 在Func函数中传⼊S1类的对象 s1_obj，执⾏ S1 的show⽅法，结果：S1.show
s2_obj = S2()
Func(s2_obj) # 在Func函数中传⼊Ss类的对象 ss_obj，执⾏ Ss 的show⽅法，结果：S2.show
Python “鸭⼦类型”
鸭⼦类型语⾔中，函数/⽅法可以接受⼀个任意类型的对象作为参数/返回值，只要该对象实现了代码后续⽤到的属性和⽅法就不会报错 。
class F1(object):
def show(self):
print 'F1.show'
class S1(F1):
def show(self):
print 'S1.show'
class S2(F1):
def show(self):
print 'S2.show'
def Func(obj):
print obj.show()
s1_obj = S1()
Func(s1_obj)
s2_obj = S2()
Func(s2_obj)
实例属性、类属性
实例属性:
通过类创建的对象⼜称为实例对象，对象属性⼜称为实例属性，记录对象各⾃的数据，不同对象的同名实例属性，记录的数据可能各不相同。
类属性:
- 类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有。
- 类属性可以使⽤类对象或实例对象访问 。
class Dog:
type = "狗" # 类属性
dog1 = Dog()
dog1.name = "大黄"
dog2 = Dog()
dog2.name = "小黑"
# 类属性 取值
print(Dog.type) # 结果：狗
print(dog1.type) # 结果：狗
print(dog2.type) # 结果：狗
提示：在python中 “万物皆对象”，类本身也是⼀个对象，执⾏class语句时会被创建，称为类对象。
使⽤场景：
- 类的实例：记录的某项数据始终保持⼀致时，则定义类属性。
- 实例属性：要求每个对象为其单独开辟⼀份内存空间来记录数据，⽽类属性为全类所共有 ，仅 占⽤⼀份内存，更加节省内存空间。
注意点：
类属性只能通过类对象修改，不能通过实例对象修改
class Dog(object):
type = "狗" # 类属性
# 创建对象
dog1 = Dog()
Dog.type = "Dog" # 使⽤ 类对象 修改类属性
dog1.type = "dog" # 不是修改类属性, ⽽是创建了同名的对象属性type
print(Dog.type) # 结果为 "Dog" 类对象访问类属性
print(dog1.type) # 结果为 “dog” 类属性和对象属性同名，实例对象优先访问对象属性
类属性也可以设置为 私有，前边添加两个下划线。 如:
class Dog(object):
count = 0 # 公有的类属性
__type = "狗" # 私有的类属性
print(Dog.count) # 正确
print(Dog.__type) # 错误
类方法、静态方法
类⽅法：类对象所拥有的⽅法
需要⽤装饰器 @classmethod 来标识其为类⽅法，对于类⽅法，第⼀个参数必须是类对象，⼀般以 cls 作为第⼀个参数。
class Dog(object):
__type = "狗"
# 类⽅法，⽤classmethod来进⾏修饰
@classmethod
def get_type(cls):
return cls.__type
print(Dog.get_type())
使⽤场景：
- 当⽅法中需要使⽤类对象 (如访问私有类属性等)时，定义类⽅法
- 类⽅法⼀般和类属性配合使⽤
静态方法
需要通过装饰器 @staticmethod 来进⾏修饰，静态⽅法既不需要传递类对象也不需要传递实例对象（形参没有self/cls）。
静态⽅法也能够通过实例对象和类对象去访问。
class Dog(object):
type = "狗"
def __init__(self):
name = None
# 静态⽅法
@staticmethod
def introduce(): # 静态⽅法不会⾃动传递实例对象和类对象
print("⽝科哺乳动物,属于⻝⾁⽬..")
dog1 = Dog()
Dog.introduce() # 可以⽤ 实例对象 来调⽤ 静态⽅法
dog1.introduce() # 可以⽤ 类对象 来调⽤ 静态⽅法
使⽤场景：
当⽅法中既不需要使⽤实例对象(如实例对象，实例属性)，也不需要使⽤类对象 (如类属性、类方法、创建实例等)时，定义静态⽅法 。
取消不需要的参数传递，有利于减少不必要的内存占⽤和性能消耗 。
注意点：
类中定义了同名的对象⽅法、类⽅法、静态⽅法时，调⽤⽅法会优先执⾏最后定义的⽅法 。
class Dog:
def demo_method(self):
print("对象⽅法")
@classmethod
def demo_method(cls):
print("类⽅法")
@staticmethod
def demo_method(): # 被最后定义,调⽤时优先执⾏
print("静态⽅法")
dog1 = Dog()
Dog.demo_method() # 结果: 静态⽅法
dog1.demo_method() # 结果: 静态⽅法
__new__ ⽅法
创建对象时，系统会⾃动调⽤new⽅法
开发者可以实现new⽅法来⾃定义对象的创建过程
class Cat:
def __new__(cls):
print("创建对象")
return object.__new__(cls)
def __str__(self):
return "%s" % self.name
dog1 = Dog()
dog1.age = 20
print(dog1)
总结
- __new__ ⾄少要有⼀个参数cls，代表要实例化的类，此参数在实例化时由Python解释器⾃动提供
- __new__ 必须要有返回值，返回实例化出来的实例，这点在⾃⼰实现 __new__ 时要特别注意，可
- 以return⽗类 __new__ 出来的实例，或者直接是object的 __new__ 出来的实例
关于python面向对象的基本要点到这里就结束了，了解更多见：https://blog.csdn.net/Scrat_Kong/article/details/90257118