一：封装
1.内置的三种方法：
# 1.三种内置函数
class Cat:
def __init__(self,new_name):# 类中的变量进行初始化
self.name = new_name
print("%s 来了"% self.name)
def __del__(self): # 在类的对象销毁前，调用的方法
print("%s 去了"% self.name)
def __str__(self): # 在print()是要打印的信息，而不再是打印地址
return "我是小猫：%s"% self.name
tom = Cat("Tom") # 自动调用了init方法
print(tom) # 先调用str方法，执行完再执行del方法。
运行结果：
Tom 来了
我是小猫：Tom
Tom 去了
封装案例：小明 小妹爱跑步
# 封装案例：小明爱跑步
class Person:
def __init__(self,name,weight):
self.name = name
self.weight = weight
def __str__(self):
return "我的名字是 %s 体重是 %.2f 公斤" % (self.name,self.weight)
def run(self):
print("%s 爱跑步 " % self.name)
self.weight -= 0.5
def eat(self):
print("%s 是吃货 "% self.name)
self.weight += 1
xiaoming = Person("小明",75.0)
xiaoming.run()
xiaoming.eat()
print(xiaoming)
xiaomei = Person("小妹",45)
xiaomei.eat()
xiaomei.run()
print(xiaomei)
print(xiaoming) # 互相不影响
# ：结论 同一个类创建的多个对象之间是互不干扰的
运行过程
小明 爱跑步
小明 是吃货
我的名字是 小明 体重是 75.50 公斤
小妹 是吃货
小妹 爱跑步
我的名字是 小妹 体重是 45.50 公斤
我的名字是 小明 体重是 75.50 公斤
二： 继承
class Animal:
def eat(self):
print("吃")
def drink(self):
print("喝")
def run(self):
print("跑")
def sleep(self):
print("睡")
wangcai1 = Animal()
wangcai1.run()
wangcai1.eat()
wangcai1.drink()
wangcai1.sleep()
class Dog (Animal): #class 类名(父类名): 子类继承父类的所有的方法。
def bark(self):
print("汪汪叫")
wangcai2 = Dog()
wangcai2.bark()
wangcai2.sleep()
# class Xiaotianquan(Dog):
# def fly(self):
# print("哈哈，我会飞")
# class Cat(Animal):
# def catch(self):
# print("我会抓老鼠")
#
# xtq = Xiaotianquan()
# xtq.fly()
# xtq.bark()
# xtq.eat()
# 子类重写父类的方法：定义同名方法即可。
# 让哮天犬叫的特殊
# class XiaoTianQuan(Dog):
# def bark(self):
# print("嗷呜，嗷呜")
#
# xtq = XiaoTianQuan()
# xtq.bark() # 此时输出嗷呜，嗷呜
# 对父类的方法进行重写
# 子类方法的实现 中包含父类方法的实现
# 过程 1.子类重写父类的方法
# 2.在使用的地方使用 super().父类方法 关键字调用父类的方法执行。
# 3.代码其他位置针对子类的需求，编写子类特有的代码实现
class XiaoTianQuan(Dog):
def fly(self):
print("哈哈，我会飞")
def bark(self):
# 1.针对子类的特性编写自己的代码。
print("嗷呜 嗷呜")
# 2.使用super() 来调用原来父类的方法
super().bark()
# 3.增加其他子类的代码
print("XWXDWDSW")
xtq = XiaoTianQuan()
xtq.bark() # 输出嗷呜 嗷呜 汪汪叫 XWXDWDSW
父类的私有属性和私有方法：
class A ():
def __init__(self):
self.num1 = 100
self.__num2 = 200 # 私有属性前有两个下划线
def __test(self):
print("私有方法 %d %d "% (self.num1,self.__num2))
def test(self):
print("我是共有方法")
class B(A):
def demo(self):
# 1.访问父类的私有属性
# print("访问父类的私有属性 %d" % self.__num2) # 运行报错
print("不能调用")
# 2.调用父类的私有方法
# self.__test()报错
b = B()
print(b)
b.demo()
print(b.test())
多继承：
class A:
def test(self):
print("test 方法")
class B:
def demo(self):
print("demo 方法")
class C(A,B):
pass
c = C()
c.test() # 输出test 方法
c.demo() # 输出demo 方法
多继承的注意事项：
假设A B存在同名的方法？
class B:
def test(self):
print("B----test 方法")
def demo(self):
print("B----demo 方法")
class C(A,B):
pass
c = C()
c.test() # 输出test 方法
c.demo() # 输出demo 方法
输出：
A----test 方法
A----demo 方法
若修改成
class C(B,A):
B----test 方法
B----demo 方法
python 的MRO（方法搜索顺序）：
print(C.mro())
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
先搜索C ，再搜索B 再搜索A 最后搜索Object
三 ：多肽
让不同的子类对象调用相同的方法产生不同的结果：多肽。
class Dog(object):
def __init__(self,name):
self.name = name
def game(self):
print("%s 蹦蹦跳跳的玩耍" % self.name)
class XiaoTianQuan(Dog):
def game(self):
print("%s 飞上天和太阳肩并肩" % self.name)
class Person(object):
def __init__(self,name):
self.name = name
def game_with_dog(self,dog):
print("%s 和 %s 快乐的玩耍" % (self.name ,dog.name))
dog.game()
# 1.创建一个狗对象
#wangcai = Dog("旺财")
wangcai = XiaoTianQuan("飞天旺财")
# 2.创建一个小明对象
xiaoming = Person("小明")
# 3.让小明调用和狗玩的方法
xiaoming.game_with_dog(wangcai)
运行结果：
小明 和 飞天旺财 快乐的玩耍
飞天旺财 飞上天和太阳肩并肩
