昨日回顾：
面向对象编程：
核心是‘对象’，对象指的是特征与技能的结合体。
基于该编程思想编写程序，就好比在创造世界，一种上帝的思维模式
类
类是一系列对象相同的特征与技能的结合体。
定义类时发生的事情：
会产生一个空的名称空间
- 会把类内部所有名字扔进名称空间中。
会执行类内部的代码。
调用类时发生的事情：
会产生一个空的对象
- 会自动触发
__init__ - 会将对象与括号内的参数一同传给
__init__.
- 会自动触发
注意：调用类的过程称之为类的实例化，产生的对象称之为类的一个实例
对象：
对象的属性查找顺序：
对象查找类的属性：1.会先去对象的名称空间查找
2. 若对象没有则会去类的名称空间查找对象的绑定方法特殊之处
- 由类来调用类内部的函数，该函数只是一个普通的函数，函数需要接收几个参数就得传几个参数。
- 由对象来调用类内部的函数，该函数称之为对象的绑定方法，会将不同的对象绑定给不同的方法，特殊之处是会将对象当作第一个参数传给该方法。
一切皆对象
在python中，一切皆对象。
指的是通过type()查看，若返回的是
的都是对象。 例如:python的8大数据类型。
继承初体验
# 父类
class ParentClass1:
pass
class ParenClass2:
pass
#子类
class SubClass1(ParentClass1):
pass
#继承多个父类
class SubClass2(ParenClass1,ParentClass2):
pass
#查看继承的父类:__bases__,是类的属性，用来查找当前类的父亲。
print(SubClass1.__bases__) #(<class'__main__.ParentClass1'>,)
print(SubClass2.__bases__) #(<class'__main__.ParentClass1'>,<class'__main.ParentClass2'>)# 寻找继承关系
如何寻找继承关系：
先抽象，再继承
什么是抽象？
抽象指的是抽取相似的部分，称之为抽象。
—先抽象（抽象思想）
奥巴马——人类——动物类
麦兜——猪类——动物类
小丁丁——狗类——动物类
抽象定义动物类，称之为父类。
特征：
眼睛，鼻子。。
技能：
吃，喝，拉，撒。。
—再继承（在程序中）：
奥巴马对象——调用人类——继承动物类
麦兜对象——调用猪类——继承动物类
小丁丁对象——调用狗类——继承动物类
继承的关系：
对象是特征与技能的结合体。
类是一系列对象相同的特征与技能的结合体
继承是一系列类相同的特征与技能的结合体
老男孩选课系统：
# 父类：
'''
抽象：
school
__init__(self,name,age,sex)
'''
class OldboyPeople:
school = 'oldboy'
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
# 老师类：名字，年龄，性别
class OldboyTeacher(OldboyPeople):
# 老师改分数技能
def change_score(self):
print(f'老师[{self.name}修改分数...]')
#学生类：名字，年龄，性别
class OldboyStudent(OldboyPeople):
#学生可以选择课程
def choose_course(self,course):
print(f'学生[{self.name}]选择可存[{course}]')
stu1 = OldboyStudent('小丁丁'，95，'female')
tea1 = OldboyStudent('tank',17,'male')
print(stu1.name,stu1.age,stu1.sex)
print(tea1.name,tea1.age,tea1.sex)
# 继承背景下对属性查找顺序
在继承背景下，对象属性的查找顺序：
1. 对象查找属性会先从对象的名称空间中查找
2. 若对象没有，则会去类里面找
3. 若当前类是子类，并且没有对象找的属性，会去父类中查找注意：对象查找属性，若子类有，不管父类有没有，以子类的为准
# 父类
class OldboyPeople:
school = 'oldboy'
def __init__(self,name,age,sex)
self.name = name
self.name = age
self.sex = sex
#子类
class OldboyTeacher(OldboyPeople):
def change_score(self):
print(f'老师[{self.name} 修改分数])
tea1 = OldboyTeacher('tank',17,'male')
print(tea1.school)
# 查看对象名称空间
print(tea1.__dict__)
__class__:对象的属性，查看当前对象的类.
#查看子类名称空间
print(tea1.__class__.__dict__)
#查看父类名称空间
print(tea1.__class__.__bases__[0].__dict__)
#验证
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.f1()# 子类有以子类为准
class Soo(Foo):
def f1(self):
print('Soo.f1')
soo_boj = Soo()
soo_boj.f2()# Foo.f2 Soo.f1# 派生
什么是派生？
派生指的是子类继承父类的属性，并且派生出新的属性
子类派生出新的属性，若与父类的属性相同，则以子类得到为准。
继承是谁与谁的关系，指的是类与类的关系，子类与父类是从属关系。
# 子类派生出新的属性，并重用父类的属性
class OldboyPeople:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
class OldboyTeacher(OldboyPeople):
# 等级, 薪资
def __init__(self, name, age, sex, level, sal):
self.name = name
self.age = age
self.sex = sex
self.level = level
self.sal = sal
class OldboyStudent(OldboyPeople):
# 课程
def __init__(self,name, age, sex, course):
self.name = name
self.age = age
self.sex = sex
self.course = course
问题: 子类继承父类的__init__毫无意义.解决方式有两种：
方式一：
直接通过 父类.(调用)__init__,把__init__当做普通函数使用，传入对象与继承的属性。
方式二：
super是一个特殊的类，在子类中调用super()会得到一个特殊的对象，通过 . 指向的是父类的名称空间。
class OldboyPeople:
def __init__(self,name,age,sex)
self.name = name
self.age = age
self.sex = sex
class OldboyTeacher(OldboyPeople):
def __init__(self,name,age,sex,level,sal)
OldboyPeople.__init__(self,name,age,sex)
self.level = level
self.sal = sal
class OldboyStudent(OldboyPeople):
def __init__(self,name,age,sex,course):
OldboyPeople.__init__(self,name,age,sex)
self.course = course
def choose_course(self):
print(f'学生{self.name}选择课程{self.course}')class OldboyPeople:
def __init__(self,name,age,sex)
self.name = name
self.age = age
self.sex = sex
class OldboyTeacher(OldboyPeople):
def __init__(self,name,age,sex,level,sal):
super().__init_-(name,age,sex)
self.level = level
self.sal = sal
class OldboyStudent(OldboyPeople):
def __init__(self,name,age,sex,course):
super().__init__(self,name,age,sex)
self.course = course
def choose_course(self):
print(f'学生{self.name}选择课程{self.course}')
tea1 = OldboyTeacher('tank',17,'male',9,'3.0')
stu1 = OldboyStudent('zzx',23,'male','python')
print(tea1.name,tea1.level)
print(stu1.name,stu1.course)
stu1.choose_course()# 新式类与经典类
在python2中，才会有新式类和经典类之分。
在python3中，所有的类都是新式类。
新式类：
继承object的类都称之为新式类.
python3中，子类不继承自定义的类，默认继承object
经典类：
在python2中，凡是没有继承object的类都是经典类。
mor（）：属于object——》type的函数，用来查看当前类的继承顺序，在多继承的情况下。
# 钻石继承
钻石继承也可以称之为菱形继承
（了解 面试）
在多继承的情况下形成的钻石继承（继承顺序）
经典类： 深度优先
新式类：
广度优先
# 通过继承实现修改json模块数据类型
import json
from datetime import date, datetime
print(json.JSONEncoder)
print(datetime.today()) # 当前时间
print(date.today()) # 当前日期
# 开发者的角度: 直接转成str
# dict1 = {
# 'name': 'tank',
# 'today': str(datetime.today()),
# 'today2': str(date.today())
# }
#
# res = json.dumps(dict1)
# print(res)
# isinstance:
# python内置的函数,可以传两个参数,判断参数一是否式参数二的一个实例.
# 开源者的角度: 修改json源码
class MyJson(json.JSONEncoder):
def default(self, o):
# 子类派生的功能
# 判断o是否式datetime的一个实例
if isinstance(o, datetime):
return o.strftime('%Y-%m-%d %X')
elif isinstance(o, date):
return o.strftime('%Y-%m-%d')
else:
# 继承父类的default方法的功能
return super().default(self, o)
dict1 = {
'name': 'tank',
'today': datetime.today(),
'today2': date.today()
}
res = json.dumps(dict1, cls=MyJson) # cls=None,默认指向的是原json的JSONEncoder
print(res)