Python基础知识之面向对象编程介绍(二）

面向对象2

1.del()方法

创建对象后，Python解释器默认调用__init__()方法：
当删除一个对象时，Python解释器也会默认调用一个方法，这个方法为__del__()方法

import time
import sys
class Animal(object):
#初始化方法
#创建完对象后会自动被调用
    def __init__(self, name):
        print('__init__方法被调用')
        self.__name = name
#当对象被删除时，会自动被调用
    def __del__(self):
        print("__del__方法被调用")
        print("%s对象马上被干掉了..."%self.__name)
#创建对象
dog = Animal("哈皮狗") #__init__方法被调用
#删除对象
del dog #__del__方法被调用
        #哈皮狗对象马上被干掉了...
cat = Animal("波斯猫") #__init__方法被调用
cat2 = cat
cat3 = cat
sys.getrefcount(cat)#Out[25]: 4 ,测量一个对象的引用计数的方法，会比调用数多1
print("---马上 删除cat对象")
del cat
print("---马上 删除cat2对象")
del cat2
print("---马上 删除cat3对象")
del cat3 #__del__方法被调用
         #波斯猫对象马上被干掉了...
print("程序2秒钟后结束")
time.sleep(2)

结果：
__init__方法被调用
__del__方法被调用 哈皮狗对象马上被干掉了…
__init__方法被调用
__del__方法被调用 波斯猫对象马上被干掉了…
—马上 删除cat对象
—马上 删除cat2对象
—马上 删除cat3对象
__del__方法被调用 波斯猫对象马上被干掉了… 程序2秒钟后结束

总结：
当有1个变量保存了对象的引用时，此对象的引用计数就会加1
当使用del删除变量指向的对象时，如果对象的引用计数不会1，比如3，那么此时只会让这个引用计数减1，即变为2，当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除。

2、继承介绍以及单继承

（1）.继承的概念：继承描述的是事物之间的所属关系
（2）继承示例：
#定义一个父类，如下:

class Cat(object):
    def __init__(self, name, color="白色"):
        self.name = name
        self.color = color
    def run(self):
        print("%s--在跑"%self.name)
#定义一个子类，继承Cat类如下:
class Bosi(Cat):
    def setNewName(self, newName):
        self.name = newName
    def eat(self):
        print("%s--在吃"%self.name)
bs = Bosi("印度猫")
print('bs的名字为:%s'%bs.name)#bs的名字为:印度猫
print('bs的颜色为:%s'%bs.color)#bs的颜色为:白色
bs.eat()#印度猫--在吃
bs.setNewName('波斯')
bs.run()#波斯--在跑

结果： bs的名字为:印度猫 bs的颜色为:白色 印度猫–在吃 波斯–在跑

说明：
虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法。
总结：
子类在继承的时候，在定义类时，小括号（）中为父类的名字
父类的属性、方法，会被继承给子类

（3）调用被重写的方法

#调用被重写的方法

class Cat(object):
    def __init__(self, name, color="白色"):
        self.name = name
        self.color = color
    def run(self):
        print("%s--在跑"%self.name)

#定义一个子类，继承Cat类如下

class Bosi(Cat):
    def setNewName(self, newName):
        self.name = newName
    def bark(self):
        print("喵喵的叫")
    def eat(self):
        print("%s--在吃"%self.name)
class jiafeimao(Bosi):
     def name(self,newNAME):
         self.name =newNAME
         print("--飞--")
     def bark(self):
         print("---狂叫")
         #第一种调用被重写的父类的方法
         #Cat.bark(self)
         #第二种方法
         super().bark()
cat1=jiafeimao('波斯')
cat1. bark()

结果：

—狂叫 喵喵的叫

（4）注意点

class Animal(object):
    def __init__(self, name='动物', color='白色'):
        self.__name = name
        self.color = color
    def test1(self):
        print(self.color)
    def __test2(self):
        print(self.__name)
        print(self.color)
    def test3(self):
        self.__test2()
        print(self.__name)
        print(self.color)
class Dog(Animal):
    def dogTest1(self):
        #print(self.__name) #不能访问到父类的私有属性
        print(self.color)
    def dogTest2(self):
        #self.__test2() #不能访问到父类的私有方法
        self.test3()
A = Animal()
#print(A.__name) #程序出现异常，不能访问私有属性
print(A.color)
A.test1()#白色
#A.__test2() #程序出现异常，不能访问私有方法
A.test3()

结果：动物 白色 动物 白色

print("------分割线-----")
D = Dog(name = “小花狗”, color = “黄色”)
D.dogTest1()
D.dogTest2()#

结果： 小花狗 黄色 小花狗 黄色

私有的属性，不能通过对象直接访问，但是可以通过方法访问
私有的方法，不能通过对象直接访问
私有的属性、方法，不会被子类继承，也不能被访问
一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起安全的作用。

3.多继承

所谓多继承，即子类有多个父类，并且具有他们的特征
#定义一个父类

class A:
    def printA(self):
        print('----A----')
#定义一个父类
class B:
    def printB(self):
        print('----B----')
#定义一个子类，继承自A，B
class C(A,B):
    def printC(self):
        print('----C----')
obj_C = C()
obj_C.printA()
obj_C.printB()
obj_C.printC()

结果：
----A----
----B----
----C----

说明：
Python中是可以多继承的
父类中的方法、属性，子类会继承
注意点：

class base(object):
    def test(self):
        print('----base test----')
class A(base):
    def test(self):
        print('----A test----')
#定义一个父类
class B(base):
    def test(self):
        print('----B test----')
#定义一个子类，继承自A、B
class C(A,B):
     def test(self):
        print('----c test----')
obj_C = C()
obj_C.test()
print(C.__mro__) #可以查看C类的对象搜素方法时的先后顺序
#(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.base'>, <class 'object'>)

4.重写父类方法与调用父类方法

（1）重写父类方法

class Cat(object):
    def sayHello(self):
        print("halou-----1")
class Bosi(Cat):
    def sayHello(self):
        print("halou-----2")
bosi = Bosi()
bosi.sayHello()#halou-----2

(2)调用父类的方法

class Cat(object):
    def __init__(self,name):
        self.name = name
        self.color = 'yellow'
class Bosi(Cat):
    def __init__(self,name):
        # 调用父类的__init__方法1(python2)
        #Cat.__init__(self,name)
        # 调用父类的__init__方法2
        #super(Bosi,self).__init__(name)
        # 调用父类的__init__方法3
        super().__init__(name)
    def getName(self):
        return self.name
bosi = Bosi('xiaohua')
print(bosi.name)#xiaohua
print(bosi.color)#yellow

5.多态

多态：定义时的类型和运行时的类型不一样，此时就成为多态。
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)#S1.show
s2_obj = S2()
Func(s2_obj)#S2.show

6、类属性、实例属性

在前面的例子中我们接触到的就是实例属性（对象属性），类属性就是类对象所拥有的属性，它被所有类对象的实例对象所共有，在内存中只存在一个副本，这个和C++中类的静态成员变量有点类似，对于公有的属性，在类外可以通过类对象和实例对象访问。
实例属性：和具体的某个实例对象有关系，并且一个实例对象和另外一个实例对象是不共享属性的。
类属性：类属性所属于类对象，并且多个实例对象之间共享同一个类属性。

class People(object):
    name = 'Tom' #公有的类属性
    __age = 12 #私有的类属性
p = People()
print(p.name) #正确： Tom
print(People.name) #正确：Tom
print(p.__age) #错误，不能在类外通过实例对象访问私有的类属性
print(People.__age) #错误，不能在类外通过类对象访问私有的类属性

实例属性（对象属性）

class People(object):
    address = '山东' #类属性
    def __init__(self):
        self.name = 'xiaowang' #实例属性
        self.age = 20 #实例属性
p = People()
p.age =12 #实例属性
print(p.address) #正确：山东
print(p.name) #正确：xiaowang
print(p.age) #正确：12
print(People.address) #正确：山东
print(People.name) #错误
print(People.age) #错误

通过实例（对象）去修改类属性

class People(object):
    country = 'china' #类属性
print(People.country)#china
p = People()
print(p.country)#china
p.country = 'japan'
print(p.country) #实例属性会屏蔽掉同名的类属性：japan
print(People.country)#china
del p.country #删除实例属性
print(p.country)#china

总结：
如果需要在类外修改类属性，必须通过类对象去引用然后进行修改。如果通过实例对象去引用，会产生一个同名的实例属性，这种方法修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除该实例属性。

7、静态方法和类方法

（1）类方法

类方法是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以’cls’作为第一个参数的名字，就最好用‘cls’了），能够通过实例对象和类对象去访问。

class People(object):
    country = 'china'
#类方法，用classmethod来进行修饰
    @classmethod
    def getCountry(cls):
        return cls.country
p = People()
print (p.getCountry()) #可以用过实例对象引用:china
print (People.getCountry()) #可以通过类对象引用:china

类方法还有一个用途就是可以对类属性进行修改

class People(object):
    country = 'china'
#类方法，用classmethod来进行修饰
    @classmethod
    def getCountry(cls):
        return cls.country
    @classmethod
    def setCountry(cls,country):
        cls.country = country
p = People()
print (p.getCountry()) #可以用过实例对象引用:china
print (People.getCountry()) #可以通过类对象引用:china
p.setCountry('japan')
print (p.getCountry())#japan
print (People.getCountry())#japan

结果显示在用类方法对类属性修改之后，通过类对象和实例对象访问都发生了改变。

（2）静态方法

静态方法需要通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数

class People(object):
    country = 'china'
    @staticmethod
#静态方法
    def getCountry():
        return People.country
print (People.getCountry())#china

总结：
从类方法和实例方法以及静态方法的定义形式就可以看出，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法；而实例方法的第一个参数是实例对象self,那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必要通过类对象来引用。