类 经典类 新式类 对象

面向对象介绍

 

世界万物，皆可分类
世界万物，皆为对象
 
只要是对象，就有属性
只要是对象，就有分类

 

特性

类 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)