一、私有属性
- 如果有一个对象，当需要对其进行修改属性时，有2种方法
对象名.属性名 = 数据 ---->直接修改
对象名.方法名() ---->间接修改
- 为了更好的保存属性安全，即不能随意修改，一般的处理方式为
将属性定义为私有属性
添加一个可以调用的方法，供调用
- demo:
class People(object): def __init__(self, name): self.__name = name def getName(self): return self.__name def setName(self, newName): if len(newName) >= 5: self.__name = newName else: print("error:名字长度需要大于或者等于5") people = People("Neuedu") print(people.__name)
结果：
结果.png
- demo:
class People(object): def __init__(self, name): self.__name = name def getName(self): return self.__name def setName(self, newName): if len(newName) >= 5: self.__name = newName else: print("error:名字长度需要大于或者等于5") people = People("Neuedu") print(people.getName()) print('-'*15) people.setName('Neu') print(people.getName()) print('-'*15)
结果：
结果.png
- 总结
- Python中没有像C++中public和private这些关键字来区别公有属性和私有属性
- 它是以属性命名方式来区分，如果在属性名前面加了2个下划线'__'，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）。
二、私有方法
- demo:
class Dog: def __init__(self, new_age): # 定义了一个私有属性 self.__age = new_age def set_age(self, new_age): if new_age > 0 and new_age < 20: self.__age = new_age def get_age(self): return self.__age # 定义了一个私有方法 def __sit_down(self): print("坐下了.......") print("年龄是:%d" % self.__age) def sit_down(self, host_name): if host_name == "主人": self.__sit_down() # 调用另外一个方法的时候,需要写上self wang_cai = Dog(1) wang_cai.set_age(-2) result = wang_cai.get_age() print(result) wang_cai.sit_down("主人") wang_cai.sit_down("赵四")
结果：
结果.png
三、__del__()方法
- 创建对象后，python解释器默认调用__init__()方法；
- 当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法
- demo:
import time class Animal(object): # 初始化方法 # 创建完对象后会自动被调用 def __init__(self, name): print('__init__方法被调用') self.__name = name # 析构方法 # 当对象被删除时，会自动被调用 def __del__(self): print("__del__方法被调用") print("%s对象马上被干掉了..."%self.__name) # 创建对象 dog = Animal("哈皮狗") # 删除对象 del dog cat = Animal("波斯猫") cat2 = cat cat3 = cat print("---马上 删除cat对象") del cat print("---马上 删除cat2对象") del cat2 print("---马上 删除cat3对象") del cat3 print("程序2秒钟后结束") time.sleep(2)
结果：
结果.png
- 总结
- 当有1个变量保存了对象的引用时，此对象的引用计数就会加1
- 当使用del删除变量指向的对象时，如果对象的引用计数不会1，比如3，那么此时只会让这个引用计数减1，即变为2，当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除
四、继承介绍以及单继承
- 继承的概念
在现实生活中，继承一般指的是子女继承父辈的财产，如下图
图.png
搞不好,结果如下..
图.png
在程序中，继承描述的是事物之间的所属关系，例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物；同理，波斯猫和巴厘猫都继承自猫，而沙皮狗和斑点狗都继承足够，如下如所示：
图.png
- demo:继承示例
# 定义一个父类，如下: 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) print('bs的颜色为:%s'%bs.color) bs.eat() bs.setNewName('波斯') bs.run()
结果：
结果.png
- 说明：
虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法
- 总结
- 子类在继承的时候，在定义类时，小括号()中为父类的名字
- 父类的属性、方法，会被继承给子类
- demo:注意点
class Animal(object): def __init__(self, name='动物', color='白色'): self.__name = name self.color = color def __test(self): print(self.__name) print(self.color) def test(self): print(self.__name) print(self.color) class Dog(Animal): def dogTest1(self): #print(self.__name) #不能访问到父类的私有属性 print(self.color) def dogTest2(self): #self.__test() #不能访问父类中的私有方法 self.test() A = Animal() #print(A.__name) #程序出现异常，不能访问私有属性 print(A.color) #A.__test() #程序出现异常，不能访问私有方法 A.test() print("------分割线-----") D = Dog(name = "小花狗", color = "黄色") D.dogTest1() D.dogTest2()
结果：
结果.png
- 私有的属性，不能通过对象直接访问，但是可以通过方法访问
- 私有的方法，不能通过对象直接访问
- 私有的属性、方法，不会被子类继承，也不能被访问
- 一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用
五、单继承
- demo:
class Animal: def eat(self): print("-----吃-----") def drink(self): print("-----喝-----") class Dog(Animal): """ def eat(self): print("-----吃-----") def drink(self): print("-----喝-----") """ pass class Cat: pass wang_cai = Dog() wang_cai.eat() wang_cai.drink()
结果：
结果.png
六、在子类中添加新功能
- demo:
class Animal: def eat(self): print("-----吃-----") def drink(self): print("-----喝-----") class Dog(Animal): def bark(self): print("-----汪汪叫------") class Cat(Animal): def catch(self): print("----捉老鼠----") wang_cai = Dog() wang_cai.eat() wang_cai.drink() wang_cai.bark() jia_fei = Cat() jia_fei.eat() jia_fei.drink() jia_fei.catch()
结果：
结果.png
七、多层继承
- demo:
class Animal: def eat(self): print("-----吃-----") def drink(self): print("-----喝-----") class Dog(Animal): def bark(self): print("-----汪汪叫------") class XTQ(Dog): """定义了一个哮天犬 类""" pass class Cat(Animal): def catch(self): print("----捉老鼠----") xtq = XTQ() xtq.eat() xtq.bark()
结果：
结果.png
八、重写父类方法
- demo:
class Animal: def eat(self): print("-----吃-----") def drink(self): print("-----喝-----") class Dog(Animal): def bark(self): print("-----汪汪叫------") class XTQ(Dog): """定义了一个哮天犬 类""" def bark(self): print("----嗷嗷叫-----") class Cat(Animal): def catch(self): print("----捉老鼠----") xtq = XTQ() xtq.eat() xtq.bark()
结果：
结果.png
九、重写父类方法与调用父类方法
- demo:
class Animal(object): def eat(self): print("-----吃-----") def drink(self): print("-----喝-----") class Dog(Animal): def bark(self): print("-----汪汪叫------") print("-----汪汪叫------") print("-----汪汪叫------") print("-----汪汪叫------") print("-----汪汪叫------") class XTQ(Dog): """定义了一个哮天犬 类""" def bark(self): # print("-----汪汪叫------") # print("-----汪汪叫------") # print("-----汪汪叫------") # print("-----汪汪叫------") # print("-----汪汪叫------") # Dog.bark(self) # 调用已经被重写的方法1 super(XTQ, self).bark() # 调用已经被重写的方法2 super().bark() # 调用已经被重写的方法3 print("----嗷嗷叫-----") class Cat(Animal): def catch(self): print("----捉老鼠----") xtq = XTQ() xtq.eat() xtq.bark()
结果：
结果.png
十、私有方法、属性，继承问题
- demo:
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) # 父类中的私有属性，没有被子类继承 wang_cai = Dog() wang_cai.bark() wang_cai.test()
结果：
结果.png
- 父类中的 私有方法、属性，不会被子类继承
- 可以通过调用继承的父类的共有方法，间接的访问父类的私有方法、属性
十一、多继承
- 多继承
图.png
从图中能够看出，所谓多继承，即子类有多个父类，并且具有它们的特征
Python中多继承的格式如下:
- demo:
# 定义一个父类 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()
结果：
结果.png
- 说明
python中是可以多继承的
父类中的方法、属性，子类会继承
- 注意点
- 想一想:
如果在上面的多继承例子中，如果父类A和父类B中，有一个同名的方法，那么通过子类去调用的时候，调用哪个？
- demo:
#coding=utf-8 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): pass obj_C = C() obj_C.test() print(C.__mro__) #可以查看C类的对象搜索方法时的先后顺序
结果：
结果.png
十二、多态
多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态
- Python伪代码实现Java或C#的多态
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 “鸭子类型”
- demo:
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)
结果：
结果.png
十三、类属性、实例属性
- 在了解了类基本的东西之后，下面看一下python中这几个概念的区别
- 先来谈一下类属性和实例属性
在前面的例子中我们接触到的就是实例属性（对象属性），顾名思义，类属性就是类对象所拥有的属性，它被所有类对象的实例对象所共有，在内存中只存在一个副本，这个和C++中类的静态成员变量有点类似。对于公有的类属性，在类外可以通过类对象和实例对象访问
- 类属性
- demo:
class People(object): name = 'Tom' #公有的类属性 __age = 12 #私有的类属性 p = People() print(p.name) #正确 print(People.name) #正确 print(p.__age) #错误，不能在类外通过实例对象访问私有的类属性 print(People.__age) #错误，不能在类外通过类对象访问私有的类属性
结果：
结果.png
- 实例属性(对象属性)
- demo:
class People(object): address = '山东' #类属性 def __init__(self): self.name = 'xiaowang' #实例属性 self.age = 20 #实例属性 p = People() p.age =12 #实例属性 print(p.address) #正确 print(p.name) #正确 print(p.age) #正确 print(People.address) #正确 # print(People.name) #错误 # print(People.age) #错误
结果：
结果.png
- 通过实例(对象)去修改类属性
- demo:
class People(object): country = 'china' #类属性 print(People.country) p = People() print(p.country) p.country = 'japan' print(p.country) #实例属性会屏蔽掉同名的类属性 print(People.country) del p.country #删除实例属性 print(p.country)
结果：
结果.png
- 总结
- 如果需要在类外修改类属性，必须通过类对象去引用然后进行修改。如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。
十四、静态方法和类方法
- 类方法
- 是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以'cls'作为第一个参数的名字，就最好用'cls'了），能够通过实例对象和类对象去访问。
- demo:
class People(object): country = 'china' #类方法，用classmethod来进行修饰 @classmethod def getCountry(cls): return cls.country p = People() print(p.getCountry() ) #可以用过实例对象引用 print(People.getCountry()) #可以通过类对象引用
结果：
结果.png
- 类方法还有一个用途就是可以对类属性进行修改：
- demo:
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()) #可以用过实例对象引用 print(People.getCountry()) #可以通过类对象引用 p.setCountry('japan') print(p.getCountry()) print(People.getCountry())
结果：
结果.png
结果显示在用类方法对类属性修改之后，通过类对象和实例对象访问都发生了改变
- 静态方法
- 需要通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数
- demo:
class People(object): country = 'china' @staticmethod #静态方法 def getCountry(): return People.country print(People.getCountry())
结果：
结果.png
- 总结
从类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法；而实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用
网友评论