面向对象

派生方法实战演练

import json
import datetime

d = {
    't1' : datetime .date.today
    't2' : datetime. datetime.today(),
    't3' : 'jason'
}
# res = json.dumps(d)
# print(res)
"""
序列化报错
reaise TypeError (f'object of type {o_class_._name_}')
TypeError: Object of type date is not JSON serializable
"""
"""
能够被序列化的数据是有限的>>>:里里外外都必须是下列左边的类型
    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+
"""
# 1.转换方式1:手动转类型(简单粗暴)
# d = {
#     't1': str(datetime.date.today()),
#     't2': str(datetime.datetime.today())
# }
# res = json.dumps(d)
# print(res)
# 2.转换方式2:派生方法(儒雅高端)
"""
查看dumps源码 要注意cls 参数 默认传JsonEncoder
查看该类的源码 发现defult方法是报错的发起者
编写类继承JsonEncoder并重写default方法，之后调用dumps手动传cls= 我们自己写的类
"""
class MyJonEncode (json.JSONENCoder):
    def default(self,o)
    """
    :param o :接收无法被序列化的数据
    ：return: 返回可以被序列化的数据
    """
    if isinstance(o,datetime.datetime):# 判断是否是datetime.datetime类型，如果是则处理成可以被序列化的类型
        return o.strftime('%Y-%m-%d %X')# 把o转成可被序列化的类型，返回出去(年月日时分秒)
    elif isinstance(o,datetime.date):
        return o.strftime('%Y-%m-%d')# (年月日)
    return super().default(o)# 最后还是调用原来的方法，防止有一些额外操作没有做
        
res= json.dumps(d,cls=MyJsonEncode)
print(res)

面向对象三大特性之封装

封装： 就是将数据和功能‘'封装'起来
隐藏：将数据和功能都隐藏起来不让用户直接调用，而是开发一些接口间接调用从而可以在接口内添加额外的操作
伪装：将类里面的方法伪装成类里面的数据
class c :
    def func(self):pass
obj = c()
obj.func()
"""经过伪装"""
obj.func


#class MyClass:
#     school_name = '老女孩大学'
#     _ = '嘿嘿嘿'
#     _name = 'tony'
#     '''类在定义阶段 名字前面有两个下划线 那么该名字会被隐藏起来 无法直接访问'''
#     __age = 18
#     """在python中其实没有真正意义上的隐藏 仅仅是换了个名字而已 _类名__名字"""
#     def __choice_course(self):
#         print('老北鼻正在选课')


# print(MyClass.school_name)
# obj = MyClass()
# print(obj.school_name)
# print(MyClass._)
# print(MyClass._name)
# MyClass.__hobby = 'JDB'  # 无法隐藏
# print(MyClass.__hobby)
# obj = MyClass()
# obj.__addr = '派出所'
# print(obj.__addr)
# print(MyClass.__dict__)
# print(MyClass._MyClass__age)


class Person:
    def __init__(self, name, age, hobby):
        self.__name = name  # 对象也可以拥有隐藏的属性
        self.__age = age
        self.__hobby = hobby

    def get_info(self):
        # 类体代码中 是可以直接使用隐藏的名字
        print(f"""
        姓名:{self.__name}
        年龄:{self.__age}
        爱好:{self.__hobby}
        """)

  # 隐藏的属性开放修改的接口 可以自定义很多功能
    def set_name(self, new_name):
        if len(new_name) == 0:
            raise ValueError('你好歹写点东西')
        if new_name.isdigit():
            raise ValueError('名字不能是数字')
        self.__name = new_name


obj = Person('jason', 18, 'read')
obj.get_info()
# obj.set_name('tony老师')
# obj.get_info()
obj.set_name('')

伪装

@name.setter

这个是修改值

@name.deleter

这个是删除值

BMI指数:衡量一个人的体重与身高对健康影响的一个指标
    体质指数（BMI）=体重（kg）÷身高^2（m）
	 EX：70kg÷（1.75×1.75）=22.86
      class Person(object):
    def __init__(self,name,height,weight):
        self.name =name
        self.height = height
        self.weight = weight
    @property
    def BMI(self):
        return self.weight/(self.height **2)

p1 = Person('jason',1.60,48)

#p1.BMI()# BMI应该作为人的基本数据而不是方法
#print(p1.BMI)  #利用装饰器伪装成数据

class  Foo:
    def __init__(self,val):
        self .__NAME=val# 将属性隐藏起来

    @property
    def name(self):
        return self.__NAME
    

    @name .setter
    def name(self,value):
        if not isinstance(value,str): # 在设定值之前进行类型检查
            raise TypeError('%s must be str'% value)
        self.__NAME=value# 通过类型检查后，将值value存放到真实的位置self._NAME

    @name.deleter
    def name(self):
        raise PermissionError('can not delete')



f = Foo('jason')
print(f.name)
f.name = 'jason123'
print(f.name)
del f.name
# f.name = 'jason'  # 触发name.setter装饰器对应的函数name(f,’jason')
# f.name = 123  # 触发name.setter对应的的函数name(f,123),抛出异常TypeError
# del f.name  # 触发name.deleter对应的函数name(f),抛出异常PermissionError

三大特性之多态

"""
面向对象中多态意思是 一种事物可以有多种形态但是针对相同的功能应该定义相同的方法
这样无论我们拿到的是哪个具体的事物 都可以通过相同的方法调用功能
"""

多态:一种事物的多种形态
	水:液态 固态 气态
	动物:人 猪 猫 狗

class Animal:
    def spark(self):
        pass


class Cat(Animal):
    def miao(self):
        print('喵喵喵')

    def spark(self):
        print('喵喵喵')


class Dog(Animal):
    def wang(self):
        print('汪汪汪')

        def spark(self):
            print('汪汪汪')


class Pig(Animal):
    # def heng(self):
    #     print('哼哼哼')
    def spark(self):
        print('哼哼哼')      

import abc


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


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


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

面向对象之反射

推导思路

1、当我们用对象进行操作的时候，修改查看数据值都是用点的方式+名称

2、为了让这个代码简洁一点，我们想到使用input获取用户输入，然后用参数的形式来调用

3、但是这时候我们还是发现不行，因为input获取的是字符串，不是变量名那样的形式，导致报错。

4、虽然这里走到死胡同了，但是python做了反射这个东西来实现对象和用户的交互。

利用字符串操作对象的数据和方法

1.hasattr()		重点
	判断对象是否含有某个字符串对应的属性名或方法名
2.getattr()		重点
	根据字符串获取对象对应的属性名(值)或方法名(函数体代码)
3.setattr()
	根据字符串给对象设置或者修改数据
4.delattr()
	根据字符串删除对象里面的名字

代码部分

"""
字符串的名字跟变量名区别很大，完全不一样
'school_name'
school_name
"""

class c1:
    school_name = '小姐姐学院'
    
    def choice_course(self):
        print('正在选课')
        
obj = c1()
try:
    obj.xxx
except AttributeError:
    print('你没有这个名字')
target_name = input('请输入对象可能使用的名字：').strip()
try:
    obj.target_name
except AttributeError:
    print('你没有这个名字')

反射实战案例

cmd终端（简易版）
这里我们用代码创建一个建议的cmd终端（当然了，内部数据弄简陋一点也没事）：

# 模拟cmd终端


class WinCmd:
    def tasklist(self):
        print("""
            1.学习编程
            2.学习python
            3.学习英语
            """)


    def ipconfig(self):
        print("""
                地址:127.0.0.1
                地址:上海浦东新区
                """)


    def get(self, target_file):
        print('获取指定文件', target_file)


    def put(self, target_file):
        print('上传指定文件', target_file)


    def server_run(self):
        print('欢迎进入简易版本cmd终端')
        while True:
            target_cmd = input('请输入您的指令>>>:')
            res = target_cmd.split(' ')
            if len(res) == 1:
                if hasattr(self, res[0]):
                    getattr(self, res[0])()
                else:
                    print(f'{res[0]}不是内部或者外部命令')
            elif len(res) == 2:
                if hasattr(self, res[0]):
                    getattr(self, res[0])(res[1])
                else:
                    print(f'{res[0]}不是内部或者外部命令')


obj = WinCmd()
obj.server_run()

从文件中拿名字

import settings

print(dir(settings))  # dir列举对象可以使用的名字

useful_dict = {}
for name in dir(settings):
    if name.isupper():
        useful_dict[name] = getattr(settings, name)
print(useful_dict)

while True:
    target_name = input('请输入某个名字')
    if hasattr(settings, target_name):
        print(getattr(settings, target_name))
    else:
        print('该模块文件中没有该名字')