派生类,封装,多态,反射

1.  继承下的派生实际应用

import datetime
import json


class MyJsonEncoder(json.JSONEncoder):
    def default(self, o):
        # 形参o就是即将要被序列化的数据对象
        # print('重写了', o)
        """
        将o处理成json能够序列化的类型即可
        :param o: 
        :return: super().default(o) 
        """
        if isinstance(o, datetime.datetime):
            return o.strftime('%Y-%m-%d %X')
        elif isinstance(o, datetime.date):
            return o.strftime('%Y-%m-%d')
        return super().default(o)  # 调用父类的default(让父类的default方法继续执行 防止有其他额外操作)


d1 = {'date_time': datetime.datetime.today(), 'datetime_time': datetime.date.today()}
res = json.dumps(d1, cls=MyJsonEncoder)
print(res)
"""
TypeError: Object of type 'datetime' is not JSON serializable
json不能序列化python所有的数据类型 只能是一些基本数据类型
    json.JSONEncoder

1.手动将不能序列化的类型先转字符串
    {'date_time': str(datetime.datetime.today()), 'datetime_time': str(datetime.date.today())}
2.研究json源码并重写序列化方法
    研究源码发现报错的方法叫default
        raise TypeError("Object of type '%s' is not JSON serializable" % o.__class__.__name__)
    我们可以写一个类继承JSONEncoder然后重写default方法
"""

 

 

2. 封装

# 封装的含义
# 将类中的某些名字'隐藏'起来
# 不让外界直接调用
# 隐藏的目的是为了提供专门的通道去访问
# 在通道内可以添加额外的功能
# 代码实操
class Student(object):
    school = 'python_cat'
    __label = '牛逼'
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def choose_course(self):
        print('%s正在选课'%self.name)
student_obj1 = Student('jason', 18)
print(student_obj1.school)
print(student_obj1.name)
print(student_obj1.age)
print(Student.__dict__)
print(Student._Student__label)
print(student_obj1._Student__label)
"""
如何封装名字
    在变量名的前面加上两个下划线__
封装的功能只在类定义阶段才能生效!!!
    在类中封装其实也不是绝对的 仅仅是做了语法上的变形而已
        __变量名       >>>     _类名__变量名
我们虽然指定了封装的内部变形语法 但是也不能直接去访问
    看到了就表示这个属性需要通过特定的通道(接口)去访问
"""

 

 

3. 封装案例

class Student():
    __school = 'python_cat'

    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    # 专门开设一个访问学生数据的通道(接口)
    def print_info(self):
        print("""
        学生姓名:%s
        学生年龄:%s
        """ % (self.__name, self.__age))

    # 专门开设一个修改学生数据的通道(接口)
    def update_info(self, name, age):
        if not isinstance(age, int):
            print('年龄必须是数字')
            return
        self.__name = name
        self.__age = age


student_obj1 = Student('python_cat', 38)
student_obj1.print_info()
student_obj1.update_info('python cat', 58)
student_obj1.print_info()
student_obj1.update_info('', 'haha')
"""
将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，
    接口之上可以附加额外的逻辑来对数据的操作进行严格地控制

目的的是为了隔离复杂度，例如ATM程序的取款功能,该功能有很多其他功能组成
"""

 

 

4. property装饰器

# property就是将方法伪装成数据

"""
可扩扩展:
    　体表面积(m2)=(4×体重+7)/(体重+90)
"""


# 有时候很多数据需要经过计算才可以获得
#     但是这些数据给我们的感觉应该属于数据而不是功能
#       体表面积>>>:应该属于人的数据而不是人的功能

class Person(object):
    def __init__(self, name, weight):
        self.__name = name
        self.weight = weight

    @property
    def body_surface_area(self):
        return '%s的体表面积指数是:%s' % (self.__name, (self.weight * 4 + 7) / (self.weight + 90))


p1 = Person('dragon', 60)
print(p1.body_surface_area)
p2 = Person('python_cat', 75)
print(p2.body_surface_area)
p3 = Person('李四', 100)
print(p3.body_surface_area)
p4 = Person('王五', 50)
print(p4.body_surface_area)

 

 

5. 多态

# 什么是多态
# 一种事物的多种形态
# 如:水,有固态, 有液态, 有气态


# 多态性
class Human():
    def speak(self):
        pass


class lisi(Human):
    def speak(self):
        print('你丫瞅啥')


class python_cat(Human):
    def speak(self):
        print('喵喵喵')


class dragon(Human):
    def speak(self):
        print('牛逼666')


"""
上述场景下 虽然体现了事物的多态性 但是并没有完整的体现出来
因为现在不同的形态去叫 需要调用不同的方法 不够一致

    只要你是动物 那么你想要说话 就应该调用一个相同的方法 这样便于管理
"""
l1 = lisi()
d1 = dragon()
p1 = python_cat()
l1.speak()
d1.speak()
p1.speak()
"""
面向对象的多态性其实在很早之前就已经接触过了
"""

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

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

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


# 指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
class Human(metaclass=abc.ABCMeta):
    @abc.abstractmethod  # 该装饰器限制子类必须定义有一个名为talk的方法
    def talk(self):  # 抽象方法中无需实现具体的功能
        pass


class Person(Human):  # 但凡继承Human的子类都必须遵循Human规定的标准
    def talk(self):
        pass


p1 = Person()  # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化

"""
由多态性衍生出一个鸭子类型理论
    只要你看着像鸭子 走路像鸭子 说话像鸭子 那么你就是鸭子!!!
"""

# 鸭子类型的实战案例
"""
在linux系统中有一句话>>>:一切皆文件!!!
    内存可以存取数据
    硬盘可以存取数据
    ...
    那么多有人都是文件
"""

 

 

6. 反射

# 什么是反射
# 专业解释: 指程序可以访问、检测和修改本身状态或者行为的一种能力

# 反射需要掌握的四个方法
# hasattr(): 判断对象是否含有字符串对应的数据或者功能
# getattr(): 根据字符串获取对应的变量名或者函数名
# setattr(): 根据字符串给对象设置键值对(名称空间中的名字)
# delattr(): 根据字符串删除对象对应的键值对(名称空间中的名字)


# 反射实际应用
class Student(object):
    school = '家里蹲大学'

    def get(self):
        pass


# 编写一个小程序 判断Student名称空间中是否含有用户指定的名字 如果有则取出展示
print(Student.__dict__)
'''字符串的school 跟 变量名school差距大不大?  本质区别'''
guess_name = input('请输入你想要查找的名字>>>:').strip()
# 不使用反射不太容易实现
print(hasattr(Student, 'school'))
print(hasattr(Student, 'get'))
print(hasattr(Student, 'post'))

print(getattr(Student, 'school'))
print(getattr(Student, 'get'))


def index():
    pass


obj = Student()
setattr(obj, '血量', 10000)
setattr(obj, '功能', index)
print(obj.__dict__)
delattr(obj, '功能')
print(obj.__dict__)
"""
什么时候使用反射 可以记固定的口诀
    以后只要在业务中看到关键字 
        对象 和 字符串(用户输入、自定义、指定) 那么肯定用反射
"""

 

 

7. 反射案例

# 利用反射获取配置文件中的配置信息
"""一切皆对象 文件也是对象"""


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()