面向对象:封装与继承

"""
继承
多态与多态性
面向对象高级
装饰器
内置方法
反射(******)
元类
单例模式 什么是单例模式?????
异常处理
"""
# 面向对象
"""
 面向过程编程
 面向过程编程，核心是过程二字，过程就是解决问题的步骤 即先干什么再干什么最后干什么
 基于该思想编程就好比在造一条流水线
 优点:复杂的问题流程化从而简单化
 缺点:可扩展性较差
 
 面向对象编程
 面向对象编程 核心是对象二字 对象即一系列相似的特征与技能的集合体
 基于该思想编写程序就好比在创造一个世界，程序员就是这个世界的造物主
 在造物主眼里一切皆对象
 优点:可扩展性高
 缺点:较于面向过程编程难度较高
"""
# 什么是类？:一系列对象相似的特征与技能的结合体
# 类你可以理解为就一个容器， 将产生的一堆名字放到这个容器中
# # python为了提供了获取容器对象内部属性或方法的固定用法 统一采用 句点符 .
# # 句点符的左边肯定是一个容器类型(里面存了一堆名字) # 模块
# print(User.school)
# print(User.func)

# 对象
#调用类实例化生成的叫做对象,对象是一个具体的实在的东西,而类是一个抽象的不存在的概念

# 属性查找顺序
# 先从自身找，找不到然后会去产生它的类里面去找，然后再去类的父类的里面找,一层一层的往上找,
##直到找到我为止 找不到就报错

# 定义一个类你就把它看成是 一个新的数据类型
# l = [1,2,3,4,5,6]
# print(type(l))
##python 统一了类与类型的概念,一切皆对象,包括一个字典 一个字符串 一个列表 一个数 都是它所属的
##一个类调用之后产生的一个对象,只不过省略了调用类的过程

# 绑定方法
# 在类中定义的函数 叫方法 类可以直接来调用 但是需要手动传self参数
# 在没有被任何装饰器装饰的情况下 类中的方法是绑定给对象的
# 绑定:谁来调就将谁当做第一个参数自动传入

# 函数与方法区别
# 在调用函数和方法的区别在于 调用时是否会给你自动传参 如果自动传参那么就叫方法
# 如果不能自动传参 那么就叫函数


# 面向对象之 ==========封装
"""
致命三问:
什么是封装？
 装:将一大堆名字装到一个容器中
 封:隐藏起来 对内公开对外隐藏
为什么要有封装？
 将复杂丑陋的接口隐藏起来，暴露给用户简单易操作的接口，还可以对这个接口的操作增加一系列限制条件
如何使用
"""
class User:
 def __init__(self,name,age,gender):
 self.__name = name
 self.__age = age
 self.__gender = gender

 def tell_info(self):
 print('%s:%s:%s'%(self.__name,self.__age,self.__gender))

 def set_info(self,name,age,gender):
 if not isinstance(name,str):
 print('名字必须是str类型')
 return
 if not isinstance(age,int):
 print('age must be a number')
 return
 if not isinstance(gender,str):
 print('gender必须是str类型')
 return
 self.__age = age
 self.__gender = gender

obj = User('jason',18,'male')
obj.tell_info()
# obj.set_info(123,'male',666)
obj.set_info('egon',19,'male')
# print(obj.__name)
# obj.__sex = 'sexy'
# print(obj.__sex)
# 封装特点:
# 1.仅仅是语法层面上的变形 会将__属性名 变形成_类名__属性名
# 2,这种封装仅仅只在类的定义阶段有效
# 3.对内开放对外隐藏

'''
python类中定义的以__ 双下划线开头的属性或者变量 直接用类名或者对象名 加句点符是访问不到的,也就是被隐藏起来了,
实际情况是该变量的名字被做了一个变形,变成了 _类名__属性名 
需要注意的是这种封装仅仅是在类的定义阶段有效,在其他阶段定义的这样的类名不会被改名 
类内部依然可以访问到这个变量或者属性或者变量名 
'''

# coding:utf-8


###面向对象之======继承
"""
什么是继承
 继承是一种新建类的方式，继承的类称之为子类或派生类
 被继承的类称之为父类或基类或超类
 子类继承父类，也就意味着子类继承了父类所有的属性和方法
 可以直接调用
为什么要有继承
 减少代码冗余
如何使用
"""
class Parent1:
 pass
class Parent2:
 pass
class Son1(Parent1):
 pass
# python中支持多继承
class Son2(Parent1,Parent2):
 pass
# 如何查看类的父类
# print(Son1.__bases__)
# print(Son2.__bases__)
###pthon 中可以用这个__bases__查看一个对象或者一个类的父类
###但是没有方法或者语法可以查看一个类的子类

# 自定义的没有显示继承任何类的父类到底有没有偷偷继承某个类呢？
##这个问题就得探究一下新式类与经典类的区别了
# print(Parent1.__bases__)
# print(Parent2.__bases__)

"""
python2:一个类如果没有显示继承任何类的情况下，不继承任何类
python3:一个类如果没有显示继承任何类的情况下，默认都继承object类

经典类与新式类
 经典类:
 不继承object或者其子类的类 叫经典类 
 新式类: 
 继承object或者其子类的类 叫新式类
 
ps：经典类与新式类只在python2有区分
python3中只有新式类,没有经典类,
"""

# 派生:
# 在继承了父类的属性和方法的基础之上 自己定义了其他的属性和方法
# 如果派生出的方法与父类的同名了 那么相当于覆盖了父类的方法

# 子类方法中调用父类的方法:
# 方式1:指名道姓
# OldboyPeople.__init__(self,name,age,gender) 跟继承一毛钱关系都没有

# 方式2:跟继承有关系

# 单继承情况下的属性查找
'''
单继承的情况下,属性查找的顺序是从下到上,一层一层的往上找,直到找到为止,找不到就报错

'''
# 多继承情况下的属性查找:
'''
1,没有形成菱形结构也就是没有形成一个圈的时候:
 从左到右,一个一个的找,一条分支找完之后,再退回上一个节点,找旁边的一个分支,找完之后再
 退回上一个节点,找到为止,或者直到将所有的分支都找完也找不到,就报错
2,形成了菱形结构:
 和没有形成菱形结构基本类似,也是按照从左到右的顺序一级一级的找,一个分支一个分支的找,
 唯一的区别就是,最后那个汇总的总节点,在前面查找的时候不去查找,在查找到最右边的一个分支的
 时候,再去查找,
 
 按照这个查找顺序形成的一个顺序表,叫做mro列表,形成这个列表所采用的算法,叫做C3算法
 也就是这个查找顺序
'''
class D:
 pass
class E:
 pass
class F:
 pass
class A(D):
 pass
class B(E):
 pass
class C(F):
 pass
class G(A,B,C):
 pass
"""
[G A D B E C F]
[<class '__main__.G'>, <class '__main__.A'>, <class '__main__.D'>, 
<class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, 
<class '__main__.F'>, <class 'object'>]
"""
# print(G.mro())
# # super是严格按照mro列表的顺序调用父类的方法的！！！

###举例应用:
###json 序列化本来是不支持时间数据格式的
###这里我们自己定义一个类 做适当的修改,就可以变得支持时间格式了,
# 也就是采用继承的思想,具体做法如下:

from datetime import datetime,date
import json
d ={'name':'jason','password':'123'}
res = {"t1":datetime.today(),'t2':date.today()}
class MyCustomerJson(json.JSONEncoder):
 def default(self, o):
 if isinstance(o,datetime):
 return o.strftime('%Y-%m-%d %X')
 elif isinstance(o,date):
 return o.strftime('%Y-%m-%d')
 else:
 return super().default(self,o)
print(json.dumps(res,cls=MyCustomerJson))
# TypeError: Object of type 'datetime' is not JSON serializable


# 面向对象之====>多态与多态性
"""
什么是多态
 一种事物的不同形态(动物:人，狗，猫)，代码层面上来说其实就是继承 
为什么要有多态
 多态仅仅是一个概念
 多态性:在不需要考虑对象具体类型的情况下 调用对象的方法 
如何使用
"""

# 多态性能够实现的基础是什么
class Animal:
 def talk(self):
 pass
class People(Animal):
 def jiao(self):
 print('hello')
class Dog(Animal):
 def wang(self):
 print('wangwang')
class Cat(Animal):
 def miao(self):
 print('miaomiao')
p = People()
d = Dog()
c = Cat()

p.talk()
d.talk()
c.talk()
import abc
class Animal(metaclass=abc.ABCMeta):
 @abc.abstractmethod
 def talk(self):
 pass

class People(Animal):
 def talk(self):
 print('hello')
class Dog(Animal):
 def wang(self):
 print('wangwang')
class Cat(Animal):
 def miao(self):
 print('miaomiao')
people = People()

####注意:以后我们写装饰器要这样写,这样才是标准的写法
from functools import wraps
def outer(func):
 @wraps(func)
 def inner(*args,**kwargs):
 return func(*args,**kwargs)
 return inner

@outer # func = outer(func)
def func():
 pass

print(func)
# 
class People:
 def talk(self):
 pass
class Dog:
 def talk(self):
 pass
class Cat:
 def talk(self):
 pass
# 
'''
# python推崇鸭子类型
# 只要你长得像鸭子 走路像鸭子 说话像鸭子 那么你就是鸭子

# 写面条版程序
# 写函数版本的程序
# 面向对象编程
###我们写程序,最开始就是在一个文件下面,从上到下写,面条版程序,后来,我们学习了函
# 数,然后我们就把实现某一个固定功能的一个代码段封装成一个函数,这就有了函数版本
# 的程序,后来学了面向对象,我们将一些功能函数和属性变量封装起来,这就有了面向对象编程
#此外,我们还学习了模块与包的导入,将特定的功能和函数放置在一个包中,这样使得大大降低了代码的
#冗余,使得程序结构更加的清晰
'''