【面向对象三】

目录

• • 面向对象三大特性之封装
  • @property装饰器
  • 面向对象三大特性之多态
  • • • • 鸭子类型鸭子类型：“如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子”。比起继承的方式，鸭子类型在某种程度上实现了程序的松耦合度
  • 面向对象之反射

面向对象三大特性之封装

我们可以将类中的某些属性隐藏起来，不来人直接调用，可以通过专门的接口来访问

在变量名的前面加两个下划线__就可以隐藏名字，但是可以通过_类名__属性名直接访问

# 定义一个Student类，school这个属性是被隐藏的，可以在类中设置接口来调用school
class Student(object):
    __school = '清华大学'
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
    # 专门开设一个访问学生数据的通道(接口)
    def check_info(self):
        print("""
        学生姓名:%s
        学生年龄:%s
        """ % (self.__name, self.__age))
    # 专门开设一个修改学生数据的通道(接口)
    def set_info(self,name,age):
        if len(name) == 0:
            print('用户名不能为空')
            return
        if not isinstance(age,int):
            print('年龄必须是数字')
            return
        self.__name = name
        self.__age = age

stu1 = Student('jason', 18)
# 对象直接调用被隐藏的名字是找不到的，会报错没有该属性
# print(stu1.__school)  # 'Student' object has no attribute '__school'
# 但是通过_类名__属性名可以找到
# print(stu1._Student__school)  # 清华大学

stu1.check_info()  # 学生姓名:jason 学生年龄:18
stu1.set_info('jasonNB',28)
stu1.check_info()  # 学生姓名:jasonNB 学生年龄:28
print(stu1.__dict__)  # {'_Student__name': 'jasonNB', '_Student__age': 28}
stu1.set_info('','haha')  # 用户名不能为空

将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，
接口之上可以附加额外的逻辑来对数据的操作进行严格地控制

目的的是为了隔离复杂度，例如ATM程序的取款功能,该功能有很多其他功能组成
比如插卡、身份认证、输入金额、打印小票、取钱等，而对使用者来说,只需要开发取款这个功能接口即可,其余功能我们都可以隐藏起来

@property装饰器

property方法可以将方法伪装成数据，我们在调用时，得到的就是一个数据结果

BMI指数：体质指数（BMI）=体重（kg）÷身高^2（m）

class Person(object):
    def __init__(self, name, height, weight):
        self.__name = name
        self.height = height
        self.weight = weight
    @property
    def BMI(self):
        # print('%s的BMI指数是:%s' % (self.name, self.weight / (self.height ** 2)))
        return '%s的BMI指数是:%s' % (self.__name, self.weight / (self.height ** 2))

# p1 = Person('jason', 1.83, 77)
# # p1.BMI()  # 22.9
# # print(p1.BMI)
# p2 = Person('eason',1.90,85)
# # p2.BMI()  # 23.5
# # print(p2.BMI)
# p3 = Person('xd',1.85,100)
# # p3.BMI()  # 29.2
# print(p3.BMI)
# p4 = Person('xd',1.5,34)
# # p4.BMI()  # 15.1
# print(p4.BMI)

面向对象三大特性之多态

多态指的是一类事物有多种形态，比如动物有多种形态：猫、狗、猪

class Animal: #动物
    def talk(self):
        pass
class Cat(Animal): #动物:猫
    def talk(self):
        print('喵喵喵')
class Dog(Animal): #动物:狗
    def talk(self):
        print('汪汪汪')
cat1 = Cat()
cat1.talk()  # 喵喵喵
dog1 = Dog()
dog1.talk()  # 汪汪汪
# 因为动物都会叫，所以我们可以将说话，都用一种相同的方法来定义

class Animal: #动物
    def talk(self):
        pass
class Cat(Animal): #动物:猫
    def talk(self):
        print('喵喵喵')
class Dog(Animal): #动物:狗
    def talk(self):
        print('汪汪汪')
def Talk(animal):
    animal.talk()
cat = Cat()
Talk(cat) # 喵喵喵

多态性的好处在于增强了程序的灵活性和可扩展性，比如通过继承Animal类创建了一个新的类，实例化得到的对象obj，可以使用相同的方式使用obj.speak()

面向对象的多态性也需要python程序员自己去遵守

虽然python推崇的是自由 但是也提供了强制性的措施来实现多态性
不推荐使用

import abc
# 指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
class Animal(metaclass=abc.ABCMeta):
   @abc.abstractmethod # 该装饰器限制子类必须定义有一个名为talk的方法
   def talk(self): # 抽象方法中无需实现具体的功能
       pass
class Person(Animal): # 但凡继承Animal的子类都必须遵循Animal规定的标准
   def talk(self):
      pass
p1=Person() # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化

鸭子类型鸭子类型：“如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子”。比起继承的方式，鸭子类型在某种程度上实现了程序的松耦合度

# 鸭子类型的实战案例
"""
在linux系统中有一句话>>>:一切皆文件!!!
    内存可以存取数据
    硬盘可以存取数据
    ...
    那么多有人都是文件
"""
class Memory(object):
    def read(self):
        pass
    def write(self):
        pass
class Disk(object):
    def read(self):
        pass
    def write(self):
        pass
# 得到内存或者硬盘对象之后 只要想读取数据就调用read 想写入数据就调用write 不需要考虑具体的对象是谁

面向对象之反射

什么是反射
专业解释:指程序可以访问、检测和修改本身状态或者行为的一种能力
大白话:其实就是通过字符串来操作对象的数据和功能
反射需要掌握的四个方法
hasattr():判断对象是否含有字符串对应的数据或者功能
getattr():根据字符串获取对应的变量名或者函数名
setattr():根据字符串给对象设置键值对(名称空间中的名字)
delattr():根据字符串删除对象对应的键值对(名称空间中的名字)

class Student(object):
    school = '清华大学'
    def get(self):
        pass
print(Student.__dict__)  # 打印Student内的数据
print(hasattr(Student, 'school'))  # True
print(hasattr(Student, 'get'))  # True
print(hasattr(Student, 'post'))  # False

print(getattr(Student, 'school'))  # 清华大学
print(getattr(Student, 'get'))  # <function Student.get at 0x00000232BA5EDC80>

#判断类中是否有想要的名字，并将属性值打印出来
guess_name = input('请输入你想要查找的名字>>>:').strip()
if hasattr(Student, guess_name):
    target_name = getattr(Student, guess_name)
    if callable(target_name):  #判断函数是否可用
        print('类中有一个功能名字是%s'%guess_name,target_name)
    else:
        print('类中有一个数据名字是%s'%guess_name,target_name)
else:
    print('类中没有该名字')

setattr(Student,'level','贵族学校')
print(Student.__dict__)

def index():
  pass
obj = Student()
setattr(obj, '血量', 10000)
setattr(obj, '功能', index)
print(obj.__dict__)  # {'血量': 10000, '功能': <function index at 0x0000021E98461EA0>}
delattr(obj, '功能')
print(obj.__dict__)  # {'血量': 10000}

反射实际案例

# 利用反射获取配置文件中的配置信息
"""一切皆对象 文件也是对象"""
import settings
dir(settings)  # 获取对象中所有可以使用的名字
getattr(settings, 'NAME')
class FtpServer:
     def serve_forever(self):
         while True:
             inp=input('input your cmd>>: ').strip()
             cmd,file=inp.split()
             if hasattr(self,cmd): # 根据用户输入的cmd，判断对象self有无对应的方法属性
                 func=getattr(self,cmd) # 根据字符串cmd，获取对象self对应的方法属性
                 func(file)
     def get(self,file):
         print('Downloading %s...' %file)
     def put(self,file):
         print('Uploading %s...' %file)

obj = FtpServer()
obj.serve_forever()