面向对象介绍
世界万物，皆可分类 世界万物，皆为对象 只要是对象，就有属性 只要是对象，就有分类
特性
类 class
一个类即是对一类拥有相同属性的对象的抽象蓝图、原型。 在类中定义了这些对象都具备的属性
对象 object
一个对象即是一个类的实例化后的实例，是个抽象的东西，一个类必须经过实例化后方可在程序中使用 一个类可以实例化多个对象，每个对象可以有自己不同的属性
封装 encapsulation
在类中对数据的赋值、内部调用对外部用户都是透明的，这类变成了一个胶囊或容器，里面包含着类的属性和方法 内部的功能都封装了，外部无法访问 就是私有函数 __ 来实现的一种方法
举例
上下两种方法的区别在哪里，有什么弊端，有什么优势？
class dog:
def __init__(self,name):
self.name = name
def bulk(self):
print ("%s wang wang"% self.name)
d1 = dog("d1")
d1.bulk()
class dog:
def __init__(self):
pass
def bulk(self,name):
print ("%s wang wang "%name)
d3 = dog()
d3.bulk("dog_3")
d4 = dog()
d4.bulk("dog_4")
构造函数__init__
__init__方法的第一个参数永远是slef,表示创建实例本身，因此，在__init__方法内部，可以把各种
属性绑定到self,因为self指向创建实例的本身
#用于在实例化的时候做一些初始化的工作
#类名
class cs:
n = 123 #类变量 #先找实例变量，没有实例变量找类变量
def __init__(self,name,role,wapon,life=100,money=15000):
#构造函数，用来对类的做初始化的工作
self.name = name #实例变量（静态属性），作用域就是本身
self.role = role
self.wapon = wapon
self.life = life
self.money = money
def person(self): #类的方法，功能（动态属性）
print ("%s"%self.role,self.name)
role_1 = cs("king","police","ak") #生成一个实例
role_1.add_attrbute = "100" #增加属性
role_1.name = "renmae lisi" #修改属性
del r1.weapon #删除属性
print (role_1.add_attrbute，role_1.name,role_1.wapon(会提示没有这个属性))
class Role:
name = "out_ini_"
name_list = []
def __init__(self,name,age=None):
self.name = name
self.age = age
def test(self):
print (self.name)
print (self.age)
r1 = Role("zhangsan","20")
r1.name_list.append("from r1")
r2 = Role("lisi","50")
r2.name_list.append("from r2")
print (r2.name_list,r1.name_list)
#打印 因为str和tuple是不可变变量，list和dict是可变变量
['from r1', 'from r2'] ['from r1', 'from r2']
语法
属性
增
删
改
tuple,list与str的区别
方法
问 ： 类变量的用途？ 答 ： 大家公用的属性
举例
class person(name,age,addr)
ch = "中国"
def __init__(self,name,age,addr):
self.name = name
p1 = person(name,age,addr)
析构函数
在实例释放、销毁的时候执行的，通常用于做一些结尾和收尾工作，不用调用最后执行
如关闭一些数据库连接，打开的临时文件
#在对象释放或销毁的时候自动执行，删除实例化
def __del__(self):
print ("%s 彻底销毁..")%"ssss"
私有方法、私有属性
私有属性:
def __init__(self,name):
self.__name__ = name #私有属性
def show_Status(self):
print (%nself.__ame)
r1.showstatus() #只有在def里才能改，要使用的话需要先定一个调用私有方法的函数，需要才能调用
私有方法：
只能在内部调用，不能在类外部调用
class Person:
def __init__(self,name):
self.name = name
print (self.name)
def __work(self,salary): #定义私有方法
print ("%s salary is: %d"%(self.name,salary))
def worker(self):
self.__work(500) #在内部调用，外部的话会找不到私有方法
if __name__=="__main__":
officer = Person("Tom")
officer.worker()
继承 Inheritance
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承
子类可以继承父类
子类之间不能直接调用
class people:
def __init__(self,name,age=10):
self.name = name
self.age = age
def eat(self):
print ("%s is eating..."%self.name)
def sleep(self):
print ("%s is sleeping.."%self.name)
def talk(self):
print ("%s is talking.."%self.name)
class man(people): #继承people的类
pass
m_1 = man("TOM") #直接调用
m_1.eat()
修改父类方法
class people:
def __init__(self,name,age=10):
self.name = name
self.age = age
def eat(self):
print ("%s is eating..."%self.name)
def sleep(self):
print ("%s is sleeping.."%self.name)
def talk(self):
print ("%s is talking.."%self.name)
class man(people):
def piao(self):
print ("%s is piao ..."%self.name)
def modify_function(self):
people.sleep(self) #修改父类
print ("modify...father function..%s"%self.name)
m1 = man("tom") #继承父类，没有初始化，都继承过来
m1.piao()
m1.modify_function() #修改父类的方法
子类增加初始化构造函数
class people:
def __init__(self,name,age=10):
self.name = name
self.age = age
def eat(self):
print ("%s is eating..."%self.name)
def sleep(self):
print ("%s is sleeping.."%self.name)
def talk(self):
print ("%s is talking.."%self.name)
class man(people):
def __init__(self,name,age,money) #沿用父类的属性，并加上自己的新属性
people.__init__(self,name,age) #调用父类的构造函数，自己再增加一个moeny的属性
#super(man,woman,self).__init__(name,age) #另一种重构造父类方法，只是不用再修改父类调用的people这个名字,还支持多继承
self.money = moeny
print "money"
def piao(self):
print ("%s is piao ..."%self.name)
def modify_function(self):
people.sleep(self)
print ("modify...father function..%s"%self.name)
m1 = man("tom")
m1.piao()
m1.modify_function()
区别主要提现在多继承顺心上(多继承)
python3 经典类和新势类 广度优先
python2 经典类 是深度优先
python2 新势类 是广度优先
经典类
class people:
def __init__(self):
pass
新势类
class people(object):
def__init__(self):
pass
多继承
class people(object):
def __init__(self,name):
self.name = name
class relation(object):
def make_friends(self,obj):
print ("%s make friends %s"%(self.name,obj.name))
class man(people,relation):
def run(self):
print (self.name)
m1 = man("tom")
m2 = man("jack")
m1.make_friends(m2)
tom make friends jack..
多态 Polymorphism
简单说 ： 一个统一接口多个实现 主要作用就是实现接口的重用 举例 销售是一个类 技术是一个类 行政是一个类 例如老板说9点开始工作，员工都开始工作，那么不需要分别对销售部说工作、对技术部、行政部也去说工作 这样的话，只要调用员工类中的工作属性就可以实现全员工作
class animal:
def __init__(self,name):
self.name = name
@staticmethod
def animal(obj)
obj.talk()
class cat(animal):
def talk(self)
print (" meow ")
class dog(animal):
def talk(self)
print (" wow wow ")
c = cat("jack")
d = dog("tom")
Animal.animal.talk(c)
Animal.animal.talk(d)