继承json模块，并派生出新的功能
# 继承json模块中JSONEncoder，并且派生出新的功能
import json
from datetime import date, datetime
# print(datetime.now())
# print(type(datetime.now()))
list1 = [str(datetime.now())]
res = json.dumps(list1)
print(res)
class Myjson(json.JSONEncoder):
def default(self, o):
# 判断一个对象是否是一个类的实例化
if isinstance(o, datetime):
return datetime.strftime(o, '%Y-%m-%d %X')
else:
return super().default(self, o)
a = 12
res = json.dumps(a, cls=Myjson)
print(res)
结果：
["2019-11-27 14:21:56.464236"]
12
组合
什么是组合：
组合指的是一个对象中，包含另一个或多个对象
为什么要用组合：
减少代码的冗余
如何使用组合：
耦合度：
耦合度越高：程序的可扩展性越低
耦合度越低：程序的可扩展性越高
继承：
继承是类与类之间的关系，子类继承父类的属性和方法，子类与父类是一种“从属”关系
组合：
组合式是对象与对象之间的关系，一个对象拥有另一个对象中的属性与方法，是一种什么有什么的关系
# 用继承来写
# 父类
class People:
def __init__(self, name, age, sex, year, month, day):
self.name = name
self.age = age
self.sex = sex
self.year = year
self.month = month
self.day = day
def tell_birth(self):
print(f'''
=======出生年月日========
年: {self.year}
月: {self.month}
日: {self.day}
''')
# 教师类
class Teacher(People):
def __init__(self, name, age, sex, year, month, day):
super().__init__(name, age, sex, year, month, day)
# 学生类
class Student(People):
def __init__(self, name, age, sex, year, month, day):
super().__init__(name, age, sex, year, month, day)
tea1 = Teacher('lixiaoran', 24, 'female', 2019, 12, 12)
print(tea1.day, tea1.month, tea1.year)
tea1.tell_birth()
结果：
12 12 2019
=======出生年月日========
年: 2019
月: 12
日: 12
# 用组合来写
# 父类
class People:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
# 教师类
class Teacher(People):
def __init__(self, name, age, sex):
super().__init__(name, age, sex)
# 学生类
class Student(People):
def __init__(self, name, age, sex):
super().__init__(name, age, sex)
# 日期类
class Date:
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def tell_birth(self):
print(f'''
=======出生年月日========
年: {self.year}
月: {self.month}
日: {self.day}
''')
stu1 = Student('libai', 24, 'female')
date_obj = Date(1992, 12, 12)
stu1.date_obj = date_obj
stu1.date_obj.tell_birth()
print(stu1.date_obj.year, stu1.date_obj.month)
结果：
=======出生年月日========
年: 1992
月: 12
日: 12
1992 12
'''
练习需求:
选课系统:
1.有学生、老师类，学生与老师有属性 “名字、年龄、性别、课程”，
2.有方法 老师与学生可以添加课程， 打印学习/教授课程。
# 组合实现
'''
# 父类
class People:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
# 打印出生日期方法
def tell_birth(self):
print(f'''
=======出生年月日========
年: {self.date_obj.year}
月: {self.date_obj.month}
日: {self.day_obj.day}
''')
# 添加课程
def add_course(self, course_obj):
self.course_list.append(course_obj)
# 打印当前对象中课程列表中的所有课程的信息你
def tell_all_course_info(self):
for course_obj in self.course_list:
course_obj.tell_course_info()
# 学生类
class Student(People):
def __init__(self, name, age, sex):
super().__init__(name, age, sex)
self.course_list = []
# 教师类
class Teacher(People):
def __init__(self, name, age, sex):
super().__init__(name, age, sex)
self.course_list = []
# 日期
class Date:
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
# 定义一个课程类：课程有：课程名称，课程价格，课程周期
class Course:
def __init__(self, course_name, course_price, course_time):
self.course_name = course_name
self.course_price = course_price
self.course_time = course_time
# 定义打印课程方法： 只打印一个课程信息
def tell_course_info(self):
print(f'''
=========课程信息如下========
课程名称： {self.course_name}
课程价格： {self.course_price}
课程周期： {self.course_time}
''')
# 创建学生对象
stu1 = Student('yyx', 24, 'male')
date_obj = Date(1996, 7, 14)
stu1.date_obj = date_obj
# 创建课程对象
python_obj = Course('python', 7777, 6)
go_obj = Course('go', 8888, 8)
java_obj = Course('java', 8888, 14)
# 添加课程
stu1.add_course(python_obj)
stu1.add_course(go_obj)
stu1.add_course(java_obj)
stu1.tell_all_course_info()
结果：
=========课程信息如下========
课程名称： python
课程价格： 7777
课程周期： 6
=========课程信息如下========
课程名称： go
课程价格： 8888
课程周期： 8
=========课程信息如下========
课程名称： java
课程价格： 8888
课程周期： 14
封装
什么是封装：
封装指的是将一堆属性和方法，封装到对象中
ps：
对象就好比是一个“袋子/容器”， 可以存放一对属性和方法
存不是目的，目的是为了取，可以通过"对象"的方式获取属性或方法
为什么封装？
可以通过”对象.“的方式”存放/获取“属性或者方法。
对象拥有‘.’的机制，方便数据的存取
如何进行封装：
class User:
x = 10
def func():
pass
obj = User()
obj.y = 20
obj ---->x,func,y
访问限制机制
什么是访问限制机制：
凡是再类内部定义的属性和方法
以_开头的属性或方法名，都会被限制，外部不能直接访问该属性的原型
ps：看起来像是将该属性或者方法隐藏起来
这是pytho特有的;
注意：
凡是在类内部定义—开头的属性或者方法，都会变形为_ 类名 __属性/方法
为什么要有访问限制：
将一些隐私的数据，隐藏起来，不让外部轻易获取
接口：
可以将一对数据封装成一个接口，可以让用户调用接口
并且通过相应的逻辑，最后再将数据返回给用户
如何实现：
一：
class User:
__name = 'tank'
def __run(self):
print('你是我的！')
print(User._User__name)
obj = User()
obj._User__run()
tank
你是我的！
二：
class User:
__ID = '5472663'
__bal = 1000000
def __init__(self, name, age, sex):
self.__name = name
self.__age = age
self.__sex = sex
# 校验接口获取用户信息
def parse_user(self, username, password):
if username == 'tank' and password == '123':
print(f'''
通过验证，开始获取用户信息
用户名：{self.__name}
用户年龄：{self.__age}
用户性别：{self.__sex}
身份ID：{self.__ID}
用户的资产：{self.__bal}
''')
# 方法
def __run(self):
print('tank is running!')
obj = User('tank', 85, 'female')
obj.parse_user('tank', '123')
obj._User__run()
通过验证，开始获取用户信息
用户名：tank
用户年龄：85
用户性别：female
身份ID：5472663
用户的资产：1000000
tank is running!
什么是property:
是一个python内置的装饰器，可以装饰在”类内部的方法“上
可以将该方法调用方式由----》对象.方法（）--------》对象.方法
为什么用property：
在某些应用场景下，调用的方法只是来获取计算后的某个值
必须通过 对象.方法（) 方式调用，让该方法看起来像动词
让名词的方法，调用时更为合理
目的是为了，迷惑调用者，调用的方法误以为是属性
如何使用：
在方法前加上@property
class User:
def __init__(self, name, age, sex):
self.__name = name
self.age = age
self.sex = sex
@property
def name(self):
return self.__name
@name.setter
def name(self, value):
self.__name = value
@name.deleter
def name(self):
del self.__name
# 了解: 设置被property装饰后的方法
# 注意: 需要修改的方法名字要与被property装饰器后的方法一样
user_obj = User('cwj', 24, 'female')
user_obj.name = 'lishiming'
print(user_obj.name)
# del user_obj.name
# print(user_obj.name)
lishiming
del user_obj.name
# print(user_obj.name)
user_obj.name
AttributeError: 'User' object has no attribute '_User__name'