继承下的派生实际应用 面向对象三大特性之封装 property 面向对象三大特性之多态 面向对象之反射
import datetime
import json
class MyJsonEncoder(json.JSONEncoder):
def default( self , o):
# 形参o就是即将要被序列化的数据对象
# print('重写了', o)
'''将o处理成json能够序列化的类型即可'''
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) # 调用父类的default(让父类的default方法继续执行 防止有其他额外操作)
d1 = { 't1' : datetime.datetime.today(), 't2' : datetime.date.today()}
res = json.dumps(d1, cls = MyJsonEncoder)
print (res)
"""
TypeError: Object of type 'datetime' is not JSON serializable
json不能序列化python所有的数据类型 只能是一些基本数据类型
json.JSONEncoder
1.手动将不能序列化的类型先转字符串
{'t1': str(datetime.datetime.today()), 't2': str(datetime.date.today())}
2.研究json源码并重写序列化方法
研究源码发现报错的方法叫default
raise TypeError("Object of type '%s' is not JSON serializable" % o.__class__.__name__)
我们可以写一个类继承JSONEncoder然后重写default方法
"""
将类中的某些名字'隐藏'起来 不让外界直接调用
隐藏的目的是为了提供专门的通道去访问 在通道内可以添加额外的功能
如何封装
1. 在变量名的前面加上两个下划线__
何时生效
2. 封装的功能只在类定义阶段才能生效!!!
语法
3. 在类中封装仅仅是做了变形
4. __变量名 >>> _类名__变量名
特殊方法（接口）
5. 虽然指定了封装的内部变形语法 但是也不能直接去访问
看到了就表示这个属性需要通过特定的通道(接口)去访问
class Student( object ):
school = '清华大学'
__label = '逆来顺受'
代码实操
class Student( object ):
school = '清华大学'
__label = '逆来顺受' # 由于python崇尚自由 所以并没有真正的隐藏 而是自动转换成了特定的语法
def __init__( self , name, age):
self .name = name
self .age = age
def choose_course( self ):
print ( '%s正在选课' % self .name)
stu1 = Student( 'jason' , 18 )
print (stu1.school) # 清华大学
print (stu1.name) # jason
print (stu1.age) # 18
print (stu1.__label) # 报错 AttributeError: 'Student' object has no attribute '__label'
print (Student.__dict__) # '_Student__label': '逆来顺受'
print (Student._Student__label)
print (stu1._Student__label)
为什么要封装'隐藏'
目的的是为了隔离复杂度，例如ATM程序的取款功能,该功能有很多其他功能组成
比如插卡、身份认证、输入金额、打印小票、取钱等，而对使用者来说,只需要开发取款这个功能接口即可,其余功能我们都可以隐藏起来
代码实操
提供专门的通道去访问 在通道内可以添加额外的功能
class Student( object ):
__school = '清华大学'
def __init__( self , name, age):
self .__name = name
self .__age = age
# 专门开设一个访问学生数据的通道(接口)
def check_info( self ):
print ( """
学生姓名:%s
学生年龄:%s
""" % ( self .__name, self .__age))
# 专门开设一个修改学生数据的通道(接口)
def set_info( self ,name,age):
if len (name) = = 0 :
print ( '用户名不能为空' )
return
if not isinstance (age, int ):
print ( '年龄必须是数字' )
return
self .__name = name
self .__age = age
stu1 = Student( 'jason' , 18 )
stu1.check_info()
stu1.set_info( 'jasonNB' , 28 )
stu1.check_info()
stu1.set_info(' ',' haha')
有时候很多数据需要经过计算才可以获得
但是这些数据给我们的感觉应该属于数据而不是功能
扩展知识
体质指数（BMI）=体重（kg）÷身高^2（m）
class Person( object ):
def __init__( self , name, height, weight):
self .__name = name
self .height = height
self .weight = weight
@property
def BMI( self ):
# print('%s的BMI指数是:%s' % (self.name, self.weight / (self.height ** 2)))
return '%s的BMI指数是:%s' % ( self .__name, self .weight / ( self .height * * 2 ))
p1 = Person( 'anna' , 1.6 , 60 )
# p1.BMI() # 报错 'str' object is not callable
'''str对象是不可调用的'''
print (p1.BMI) # anna的BMI指数是:23.437499999999996
一种事物的多种状态
eg：
水：固态，液态，气态
动物：猫，狗，猪
class Animal( object ):
def speak( self ):
pass
class Cat(Animal):
def speak( self ):
print ( '喵喵喵' )
class Dog(Animal):
def speak( self ):
print ( '汪汪汪' )
class Pig(Animal):
def speak( self ):
print ( '哼哼哼' )
"""
上述场景下 虽然体现了事物的多态性 但是并没有完整的体现出来
因为现在不同的形态去叫 需要调用不同的方法 不够一致
只要你是动物 那么你想要说话 就应该调用一个相同的方法 这样便于管理
"""
c1 = Cat() # 生成对象
d1 = Dog()
p1 = Pig()
c1.speak() # 调用speak方法
d1.speak()
p1.speak()
多态性的好处在于增强了程序的灵活性和可扩展性，比如通过继承Animal类创建了一个新的类，实例化得到的对象obj，可以使用相同的方式使用obj.speak()
面向对象的多态性也需要python程序员自己去遵守
虽然python推崇的是自由 但是也提供了强制性的措施来实现多态性
不推荐使用
import abc
'''指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化'''
class Animal(metaclass = abc.ABCMeta):
@abc .abstractmethod # 该装饰器限制子类必须定义有一个名为talk的方法
def talk( self ): # 抽象方法中无需实现具体的功能
pass
class Person(Animal): # 但凡继承Animal的子类都必须遵循Animal规定的标准
def talk( self ):
pass
p1 = Person() # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化
鸭子理论
由多态性衍生出一个鸭子类型理论
只要你看着像鸭子 走路像鸭子 说话像鸭子 那么你就是鸭子!!!
鸭子类型的实战案例
"""
在linux系统中有一句话>>>:一切皆文件!!!
内存可以存取数据
硬盘可以存取数据
...
那么多有人都是文件
"""
class Memory( object ):
def read( self ):
pass
def write( self ):
pass
class Disk( object ):
def read( self ):
pass
def write( self ):
pass
# 得到内存或者硬盘对象之后 只要想读取数据就调用read 想写入数据就调用write 不需要考虑具体的对象是谁
什么是反射
专业解释:指程序可以访问、检测和修改本身状态或者行为的一种能力
大白话:其实就是通过字符串来操作对象的数据和功能
反射需要掌握的四个方法
hasattr():判断对象是否含有字符串对应的数据或者功能
getattr():根据字符串获取对应的变量名或者函数名
setattr():根据字符串给对象设置键值对(名称空间中的名字
delattr():根据字符串删除对象对应的键值对(名称空间中的名字)
反射的实际运用
需求：编写一个小程序 判断Student名称空间中是否含有用户指定的名字 如果有则取出展示
class Student( object ):
school = '清华大学'
def get( self ):
pass
print (Student.__dict__)
'''字符串的school 跟 变量名school差距大不大? 本质区别'''
guess_name = input ( '请输入你想要查找的名字>>>:' ).strip()
# 不使用反射不太容易实现
print ( hasattr (Student, 'school' )) # True
print ( hasattr (Student, 'get' )) # True
print ( hasattr (Student, 'post' )) # False
print ( getattr (Student, 'school' )) # 清华大学
print ( getattr (Student, 'get' )) #
guess_name = input('请输入你想要查找的名字>>>:').strip()
if hasattr(Student, guess_name):
