进入python的世界_day28_python基础—— 面向对象三大特性之封装、多态、反射

一、要学会看源码了（略微）

1.举例

​ 比如说以前学的json，虽然知道是可以把字典转为json格式的数据，但是当时的字典K、V都是可以被转的类型，如果V 不是json支持转的格式，转换时候就会报错，怎么查看json支持哪些数据转换呢？

d = {
    'a': datetime.date.today(),
    'b': datetime.datetime.today(),
    'c': '你好'
}
# 发现没法json.dumps（d）转换

json.JSONEncoder
按住Ctrl 鼠标左键点JSONEncoder进去

可以看到

 Supports the following objects and types by default:

    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

​ 这个表就是强调，所有要被转换的数据类型，从头到尾都得是表内的数据类型

​ 如果发现刚好手里的数据类型不在列表中，但又想转换为json格式的数据，怎么做？

• 第一种——直接暴力字符串转换，万物皆可转字符串

  str()包一下

• 第二种——派生方法

  # 我们继续看JSONEncoder 里面的源码，长的不看，缩起来先，看到眼熟的停下（前面报错就是报错这个内容）
  def default(self, o):
      """
      ...
      """
      raise TypeError(f'Object of type {o.__class__.__name__} '
                      f'is not JSON serializable')
      # 主动报错语法 所以说如果我们在.dump/s()转换时，如果转不了。由default 该方法执行报错
  

那么解决办法就出来了，写一个类，继承JSONEncoder，并重写default方法

class MyJsonEncoder(json.JSONEncoder):
    def default(self, o):
        print(o)

res = json.dumps(d, cls=MyJsonEncoder)
>>>
# 2022-11-07
# 2022-11-07 15:35:38.896436
# 发现c不会被打印
# o就是没法转的数据
————————————————————————————————————————————
class MyJsonEncoder(json.JSONEncoder):
    def default(self, o):
        print(o)
# 在def default(self, o):这句代码底下打""""""会自动出现几行代码，意思让你解释一下o 还有返回值的含义
        """
        
        :param o:
        :return:
        """
____________________________________________
# 接下来可以对o做处理
class MyJsonEncoder(json.JSONEncoder):
    def default(self, o):
        """
        :param o:
        :return:
        """
        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) # 最后又调原来的方法发，


res = json.dumps(d, cls=MyJsonEncoder)
print(res)

>>>
{"a": "2022-11-07", "b": "2022-11-07 15:50:36", "c": "\u4f60\u597d"}

二、面向对象三大特征核心——封装

1.介绍

​ 封装即整合，将数据和功能整合起来

2.隐藏

​ 将封装的属性进行隐藏操作

​ 类在定义阶段，在属性名前加__前缀,就会实现一个对外隐藏属性效果

​ 如果要找这个被藏起来的，用_类名+隐藏的方法名，就可以找到

可以自己试试__dict__，查看所有名称空间，可以看到_类名+隐藏名

​ 对象也是可以有一些隐藏的属性的

​ 如果不是在定义阶段，是后面类新增或者产生的对象新增__啥啥啥，不行，藏不了

class A:
    age = 18
    _ = '猜猜能不能访问到？'
    _hobby = '起飞'
    __city = '你找不到我'

print(A.age)
print(A._)
print(A.__city)

>>>
# 18
# 猜猜能不能访问到？
# AttributeError: type object 'A' has no attribute '__city'
——————————————————————————————————————————————————
print(A._A__city)		>>> # 你找不到我

A.__name = 'jack'   
print(A.__name)         >>> # 可以找到
obj = A()
obj.__id = 999
print(obj.__id)          >>> # 也可以拿到

3.为何要隐藏

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

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

    def get_info(self):
        # 通过该接口就可以间接地访问到名字属性
        print(f"""
            姓名：{self.__name}
            年龄：{self.__age}
        """)


obj = People('jack', 18)
obj.get_info()
>>>
      #      姓名：jack
      #      年龄：18
————————————————————————————————————————————————
# 但是发现欸类生成的对象改不了数据，这时候我们在类里再开一个接口
     def set_name(self, new_name):
         self.__name = new_name
obj.set_name('john')
obj.get_info()

>>>
      #      姓名：john
      #      年龄：18	
——————————————————————————————————————————————————
# 如果要限制改名字的一些情况，可以在set_name里面加点东西(意思做拓展)
     def set_name(self, new_name):
         if type(new_name) is not str:
             print('兄dei~，必须传字符串类型~')
             return
         self.__name = new_name
obj.set_name(666) 
>>>
      # 兄dei~，必须传字符串类型~

• 总结：隐藏只是一种变形，可以把一些难看的、复杂的功能藏起来，统一暴露一个或多个好看的接口展示给用户

4.伪装

​ property装饰器——是用来绑定给对象的方法伪造成一个数据属性

​ 当贴着的方法只有一个形参时（多个形参搞不了），以后调用该方法， 不用加括号

​ 伪装成了一个数据而不是方法

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

    @property
    def info(self):
        # 已经装饰了，直接调info就可以访问到
        print(f"""
            姓名：{self.__name}
            年龄：{self.__age}
        """)

obj = People('jack', 18)

obj.info

三、面向对象三大特征核心——多态

1.介绍

​ 同一种事物有多种形态

2.多态性

​ 方便使用者，因为父类统一子类的方法，只需要了解父类的方法，子类一定有

# 比如学车（c1），学成了后可以开吉利牌子的车，长城牌子的车，比亚迪牌子的车

​ 多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

3.鸭子类型

​ 只要长得像，看上去也一样功能，那你们都是鸭子

4.abc模块（了解） 统一所有子类的方法

class Animal(metaclass=abc.ABCMeta):  # 统一所有子类的方法
    @abc.abstractmethod # 装饰以后，只要有一个类继承了Animal,必须写一个say方法，不然就报错
    def say(self):
        print('动物基本的发声...', end='')


class People(Animal):
    def say(self):
        super().say()
        print('啊对对对')


class Dog(Animal):
    def say(self):
        super().say()
        print('汪汪汪')


class Pig(Animal):
    def say(self):
        super().say()
        print('哼哼哼')


obj1 = People()
obj2 = Dog()
obj3 = Pig()

obj1.say()  # 动物基本的发声...啊对对对
obj2.say()  # 动物基本的发声...汪汪汪
obj3.say()  # 动物基本的发声...哼哼哼

面向对象之反射——挺高端

​ 有了反射，面向对象才能与用户交互起来，注意，一旦和用户交互，用户传过来的都是字符串

​ 反射就是利用字符串操作对象的数据和方法，有四个反射的方法

1.hasattr()

​ 判断对象是否有某一个字符串所对应的属性名或方法名

class A:
    name = 'jack'

obj = A()


print(hasattr(obj, 'name'))     # True
print(hasattr(obj, 'x'))        # False

2.getattr()

​ 根据字符串获取对象对应的属性名（值）或方法名（函数体代码） 如果没有会报错的，所以建议先用hasattr判断后再用getattr

class A:
    name = 'jack'

obj = A()


print(getattr(obj, 'name'))     # jack

上面两和起来用实际使用价值：

​ 能交互了！能交互了！

class A:
    name = 'jack'

    def func(self):
        print('一个方法')


obj = A()

while True:
    user_name = input('请输入您要操作的名字>>>：').strip()
    if hasattr(obj, user_name):  # 利用反射做判断
        print('恭喜您找到')
        f = getattr(obj, user_name)
        if callable(f):
            print('您本次使用的是系统中的某个方法')
            f()
        else:
            print('您本次使用的是系统中的某个数据')
            print(f)
    else:
        print('找不到啦')

3.setattr()

​ 就是给对象添加一些东西

​ 这个添加的东西，可以根据用户自己决定，活灵活现起来了

class A:
    name = 'jack'

    def func(self):
        print('一个方法')


obj = A()
print(obj.__dict__)
setattr(obj, 'age', 20)
print(obj.__dict__)
>>>
# {}
# {'age': 20}

4.delattr()

​ 删除数据，用的很少，对象不能去删除不是自己的哈

class A:
    name = 'jack'

    def func(self):
        print('一个方法')

print(A.__dict__)
obj = A()
delattr(A, 'name')
print(A.__dict__)
>>>
# {'__module__': '__main__', 'name': 'jack', 'func': <function A.func at 0x00000234128C75E0>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}


# {'__module__': '__main__', 'func': <function A.func at 0x00000234128C75E0>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}

面试题

class A:
    def __func1(self):
        print('B.foo')

    def wa(self):
        self.__func1()


class C(A):
    def __func1(self):
        print('C.func1')

c = C()
c.wa()

#解题思路：
首先我们看class A,类定义阶段，隐藏函数就已经定下
self. __func1()  = self._A__func1()

而class C中的 __func1() = _C__func1()


当我们在找wa时在class A中 找到了self.__func1()，此时我们在父类是找不到子类的隐藏方法的，于是就在自身找，就找到了self._A__func1()
>>>
# B.foo

原文地址：http://www.cnblogs.com/wznn125ml/p/16867264.html