1.封装方法
如何封装:给方法名称前面加上双下划线
# ATM 的取款功能
# 1.插入银行卡 2.输入密码 3.选择取款金额 4.取款
class ATM:
def __insert_card(self):
print("插入银行卡...")
def __input_pwd(self):
print("输入密码...")
def __select_money(self):
print("选择取款金额...")
def withdraw(self):
self.__insert_card()
self.__input_pwd()
self.__select_money()
print("取款成功!....")
atm = ATM()
atm.withdraw() # 外部调用这个简单的接口 就能完成一系列复杂的操作
# atm.select_money() #直接调用内部的方法 是没有意义的无法完成整个功能
# 当然用户按照流程一一调用也可以完成功能 但是太麻烦
# atm.insert_card()
# atm.input_pwd()
# atm.select_money()
封装方法的好处:
1.提高安全性
2.隔离复杂度(将复杂的内容隔离到内部,外部只留下简单的接口,对于使用者,难度降低)
什么时候用封装
当一个类中某些属性或方法,不应该让外界直接访问,那就应该将其进行封装
封装的实现原理
本质上python并没有强行限制你的访问,而是通过语法转换来实现的封装
class Person:
def __init__(self,name,sex,age,idCard):
self.name = name
self.sex = sex
self.__age = age
self.__idCard = idCard
def get_idCard(self):
return self.__idCard
def __test(self):
pass
print("aaaaaaaaaa")
p = Person("比尔盖茨","男",20,"322323232332332")
# print(p.__idCard)
p.__idCard = "XXXXXX"
print(p.__idCard)
print(p.get_idCard())
print(p.__dict__)
print(Person.__dict__)
p.__xxxxxxxxxxxx = 1
print(p.__dict__)
1.通过__dict__可以发现,私有的属性名称前自动加上了_类名,python就是通过这样的转换方式来实现封装
2.只有在类的内部的双下划线才会被自动转换,并且这个转换过程只执行一次,在类丁已完成后,在添加的双下划线开头的
3.父类中私有的方法,子类中无法使用
子类无法覆盖父类的私有方法
class A:
def f(self):
self.__f1() #_A__f1
def __f1(self):
print("A __f1")
class B(A):
def __f1(self): # _B__f1
print("B __f1")
def f2(self):
self.f()
b = B()
b.f2()
# 之所以无法覆盖 是因为 子类和父类中的私有方法 名称必然不相同 所以无法覆盖 子类的方法一定子类独有的 因为名称不同
class A:
__age = 10
# 绕过封装的限制直接访问 这是毫无意义的
print(A._A__age)
使用property可以将一个方法伪装成一个属性
当一些属性的值不是固定的,而是通过计算得来的时候,我们必须为这个属性增加方法,才能完成计算,但是一旦使用方法后,该属性的访问,就变成了方法调用,很明显与其他的属性访问方式不同,这样会给使用者造成迷惑
所有需要将这个方法伪装成普通属性,这就用到了Property
property可以将方法伪装成属性,利用这个特点,我们也可以将其使用到封装中
之前没有这个装饰器我们需要为私有的属性,提供两个方法,但是这样一来访问私有属性时的方式就发生了变化
这时候可以使用property来进行伪装,使得访问私有属性与访问普通属性的方式一致
另外 property还提供了 setter(用于修改属性的值) 和 deleter(删除属性的值)
# BIM案例:
class Person:
def __init__(self,name,weight,height):
self.name = name
self.weight = weight
self.height = height
# self.bmi = weight/(height*height)
# def bmi(self):
# return self.weight / (self.height * self.height)
@property
def bmi(self):
return self.weight / (self.height * self.height)
p = Person("尔晴",50,1.5)
# print(p.bmi)
# p.weight = 90
# print(p.bmi)
# 现在 虽然可以实现需求 但是我们把一个属性变成了一个行为 这是不合理的
# print(p.bmi())
# p.weight = 90
# print(p.bmi())
# 使用property装饰器 可以将一个方法伪装成一个属性
print(p.bmi)
p.height += 0.2
print(p.bmi)
class Student:
def __init__(self,name,sex,idCard):
self.name = name
self.sex = sex
self.__idCard = idCard
def get_idCard(self):
return self.__idCard
def set_idCard(self,new_id):
self.__idCard = new_id
@property # 需要掌握
def idCard(self):
return self.__idCard
@idCard.setter #了解的
def idCard(self,new_id):
self.__idCard = new_id
@idCard.deleter # 了解的
def idCard(self):
print("身份证属性被删除了.....")
del self.__idCard
stu = Student("尔康","男","323254554554")
# print(stu.get_idCard())
# stu.set_idCard("xxxx")
print(stu.get_idCard()) # 使用装饰器前
print(stu.name) # 普通属性的访问
print(stu.idCard) # 使用装饰器后
stu.idCard = "aaaaaaa" # 使用装饰器后的修改操作
print(stu.idCard)
del stu.idCard
print(stu.__dict__)
print(Student.__dict__)
封装的特点
被隐藏的内容 在内部是可以直接访问,外部无法访问
2. 多态
什么是多态
多种状态,形态
生活中具备多种形态的事物,水(水蒸气,冰,液态水),奥特曼,数码宝贝
一种事物,具备多种形态或状态,就称之为多态
官方解释:不同对象,可以响应同一方法,并作出不同的行为,产生不同结果
如何实现多态?
让几个不同类拥有相同的父类,这样一来他们就具备了相同的方法,每个子类覆盖父类的方法
class Animal:
def eat(self):
print("动物在吃东西...")
def sleep(self):
print("动物在睡觉...")
def drink(self):
print("动物需要水.....")
class Person(Animal):
def eat(self):
print("人吃粮食...")
class Pig(Animal):
def eat(self):
print("猪吃饲料...")
class Dog(Animal):
def eat(self):
print("狗吃骨头...")
person = Person()
pig = Pig()
dog = Dog()
person.eat()
pig.eat()
dog.eat()
#假设你学习了C1驾照 意味着 所有C1类的汽车都能开 因为每种C1汽车的驾驶方式相同
# 当使用了多态之后 对象的使用者不需要关系这个对象具体的实现,只需要知道该对象属于哪个基类,就能直接使用它
# 如此扩展性变高了
class Phone:
def call(self):
print("手机就能打电话..")
def send_msg(self):
print("手机能发短信..")
class WindowsPhone(Phone):
def call(self):
print("拨号打电话..")
def send_msg(self):
print("输入号码发短信..")
class IPhone(Phone):
def call(self):
print("拨号打电话..")
def send_msg(self):
print("输入号码发短信..")
# 可以定义一个方法接受一个手机为参数 无论是是类型的手机 都可以被使用
def CALL(phone):
phone.call()
wp = WindowsPhone()
ipx = IPhone()
CALL(wp)
CALL(ipx)
# 系统内置的方法有很多都体现了多态
print(len("abc"))
print(len([1,2,3,4,]))
print(len({"name":"123","sex":"man"}))
print("abc".__len__())
print([1,2,3,4,].__len__())
print({"name":"123","sex":"man"}.__len__())
print(len({1,23,4,5}))
多态值abc模块
多态是多个类的对象拥有相同的方法,但是我们没有从语法严格要求说必须提供这些方法,子类完全可以不提供这些方法
#现在要做的就是 严格要求 子类必须实现父类声明的方法
import abc
#abc是abstract class ,是抽象类的缩写,抽象的意思是 不清晰 不具体 看不懂
不清晰不具体的类,就是抽象类
使用abc模块来限制子类的步骤
1.为类中指定元类为abc.ABCMeta
2.在相应的方法上加上abc.abstractmethod
class Animal(metaclass=abc.ABCMeta):
@abc.abstractmethod
def eat(self):
pass
@abc.abstractmethod
def drink(self):
pass
class Cat(Animal):
def eat(self):
print("猫爱吃鱼肉...")
def drink(self):
print("用舌头舔..")
class Dog(Animal):
def eat(self):
print("狗爱吃骨头...")
def drink(self):
print("用舌头舔..")
class Pig(Animal):
def eat(self):
print("猪 爱吃草...")
def drink(self):
print("用嘴吸的..")
p = Pig()
# p.eat()
c = Cat()
# c.eat()
# 多态的好处 完全不需要考虑得到的对象时声明类型 只要知道了其基类中的内容就能使用
def feeding(animal):
animal.eat()
animal.drink()
feeding(c)
feeding(p)
# 多态中的基类 相当于(协议 标准 规范) 要求子类必须满足这些标准
多态练习
import abc
# 电脑基类
class Computer(metaclass=abc.ABCMeta):
@abc.abstractmethod
def open(self):
pass
@abc.abstractmethod
def shutdown(self):
pass
class DesktopComputer(Computer):
def open(self):
print("台式机正在启动....")
def shutdown(self):
print("台式机正在关机....")
class Worker:
def working(self,pc):
# 先开机
pc.open()
print("工作中.....")
pc.shutdown()
w1 = Worker()
dp = DesktopComputer()
w1.working(dp)
# 增加了笔记本电脑
class BookComputer(Computer):
def open(self):
print("笔记本正在启动....")
def shutdown(self):
print("笔记本正在关机....")
bc = BookComputer()
w1.working(bc)
class PadComputer(Computer):
def open(self):
print("平板正在启动....")
def shutdown(self):
print("平板正在关机....")
bc = PadComputer()
w1.working(bc)
3. 鸭子类型
python推崇简单的编程方式
鸭子类型,如果一个对象叫声像鸭子,走路也像鸭子,那就把它当成鸭子
对应到代码中,就是只要你的行为一样,那就把你当成一个类型来看
class Duck:
def bark(self):
print("鸭子嘎嘎叫...")
def run(self):
print("摇摇晃晃走....")
class Chicken:
def bark(self):
print("鸡咯咯叫...")
def run(self):
print("摇摇晃晃走....")
def test(obj):
obj.bark()
obj.run()
duck = Duck()
c = Chicken()
test(duck)
test(c)
如果你足够自觉,你可以不适用abc模块,也不需要公共的基类,自觉地将方法名都写成一样,同样可以实现多态
这种方式称之为鸭子类型