面向对象编程：
思想：角色的抽象，创建类，创建角色（实例化），操作这些实例
面向对象的关键字
#示例：
class Object: #类名首字母大写
name = ‘lyn‘
def __init__(self):pass
Object.name #存储在类的命名空间里
obj = Object() #实例化：创造一个self对象，执行init方法，返回self对象给obj
#对象.属性
#对象.方法 相等于 类名.方法(对象)
#对象可以使用静态变量吗？ True
#类可以使用对象的属性吗？ False
组合（最起码是两个类）
一个类的对象是另外一个类对象的属性
class A:
def __init__(self):
self.name = ‘alec‘
class B:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
b = B(19, 1, 17)
print(b.year,b.month,b.day)
a = A()
a.birth = b
print(a.birth.year)
类和类之间才能被称为继承，类和对象之间只能是实例化
一个类可以被多个类继承 ----只在python里适用
class A:pass #父类，基类，超类
class B:pass #父类，基类，超类
class A_son(A):pass #子类，派生类
class AB_son(A,B):pass #可以继承多个父类
#查看继承的父类
print(A_son.__bases__) #(<class ‘__main__.A‘>,)
print(AB_son.__bases__) #(<class ‘__main__.A‘>, <class ‘__main__.B‘>)
新式类：python3里所有的类都有父类，如果没有标识继承的父类，那它就是 object 的子类
继承示例：
# 把Dog和Person类中的同样的变量提取至Animal类中
class Animal:
def __init__(self,name,aggr,hp):
self.name = name
self.aggr = aggr
self.hp = hp
# 继承Animal类，可以使用父类中的变量
class Dog(Animal):
def bite(self,person):
person.hp -= self.aggr
class Person(Animal):
pass
#正常传值和调用
jin = Dog(‘史努比‘,200,500)
print(jin.name)
面试题：
class Animal:
def __init__(self):
print(‘执行Animal.__init__‘)
self.func()
def eat(self):
print(‘%s eating‘%(self.name,))
def drink(self):
print(‘%s drink‘ % (self.name,))
def func(self):
print(‘Animal.func‘)
class Dog(Animal):
def guard(self):
print(‘guard‘)
def func(self):
print(‘Dog.func‘)
dog = Dog()
#结果为：
# 执行Animal.__init__
# Dog.func
派生属性：继承父类中的变量，然后自己也创建了一些特有属性
class Animal:
def __init__(self,name,blood,aggr):
self.name = name
self.blood = blood
self.aggr = aggr
class Dog(Animal):
def __init__(self,name,blood,aggr,kind):
Animal.__init__(self,name,blood,aggr) #调用了父类的属性
self.kind = kind #自己创建的，属派生属性
派生方法：父类中没有的方法，在子类中出现，叫做派生方法
class Animal:
def __init__(self,name,blood,aggr):
self.name = name
self.blood = blood
self.aggr = aggr
def eat(self):
print(‘生命值增加100点‘)
self.blood += 100
class Dog(Animal):
def __init__(self,name,blood,aggr,kind):
Animal.__init__(self,name,blood,aggr)
self.kind = kind
def eat(self):
Animal.eat(self) #自己有并还想用父类的，则调用父类方法
self.aggr += 10
def bite(self,person):
person.blood -= self.aggr
print(‘狗咬人，人剩了%s血‘%(person.blood))
jin = Dog(‘金老板‘,100,20,‘teddy‘)
jin.eat()
print(jin.blood,jin.aggr)
总结：
super的内部用法，相等于调用父类的init方法
super的外部用法，只调用父类的方法： super(子类名,实例化对象).父类中的方法
class Animal:
def __init__(self,name,blood,aggr):
self.name = name
self.blood = blood
self.aggr = aggr
def eat(self):
print(‘生命值增加100点‘)
self.blood += 100
class Dog(Animal):
def __init__(self,name,blood,aggr,kind):
super().__init__(name,blood,aggr) #内部使用super方法，相等于Animal.__init__(self,name,blood,aggr)
self.kind = kind
def eat(self):
self.aggr += 10
def bite(self,person):
person.blood -= self.aggr
print(‘狗咬人，人剩了%s血‘%(person.blood))
jin = Dog(‘金老板‘,100,20,‘teddy‘)
jin.eat() #只调用自己的方法
super(Dog,jin).eat() #super用法：只调用父类的方法
print(jin.blood,jin.aggr)
多继承中，我们子类的对象调用一个方法，默认是就近原则
class A:
def func(self):print(‘A‘)
class B:
def func(self):print(‘B‘)
class C(A,B): #继承父类时，先找A，再找B，顺序查找
# def func(self):print(‘C‘)
pass
c = C()
c.func() #结果为A
查看继承关系： 对象.mor()
#接上面列子
print(C.mro())
#[<class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘object‘>]
钻石继承
多继承
接口类和抽象类 在python当中的应用点并不是非常必要的
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
@abc.abstractmethod
def talk(self):
pass
class People(Animal): #动物的形态之一:人
def talk(self):
print(‘say hello‘)
class Dog(Animal): #动物的形态之二:狗
def talk(self):
print(‘say wangwang‘)
class Pig(Animal): #动物的形态之三:猪
def talk(self):
print(‘say aoao‘)
因为python中不崇尚用父类约束子类的方法，因为python当中有鸭子类型
3.1 类中私有
所有的私有，都是在变量的左边加上双下划线
所有的私有的，都不能在类的外部使用
class Person:
__key = 123 # 私有静态属性
def __init__(self,name,passwd):
self.name = name
self.__passwd = passwd # 私有属性
def __get_pwd(self): # 私有方法
# print(self.__dict__)
return self.__passwd
def login(self):
return self.__get_pwd()
alec = Person(‘alec‘,‘123456‘)
print(alec.__dict__) # 查看类内部的所有属性，然后可以强制调用私有属性
pwd =alec.login()
print(pwd)
应用场景：
原文：https://www.cnblogs.com/lynlearnde/p/12912283.html