- 派生方法实战演练
- 面向对象三大特性之封装
- 面向对象三大特性之多态
- 面向对象之反射
- 反射的实战案例
派生方法实战演练
import json
import datetime
d = {'t1': datetime.date.today(),
't2': datetime.datetime.today(),
't3': 'jason'}
res = json.dumps(d)
print(res)
"""
raise TypeError(f'Object of type {o.__class__.__name__} '
TypeError: Object of type date is not JSON serializable
序列化报错：不是可序列化类型
"""
"""
能够被序列化的数据是有限的>>>:里里外外都必须是下列左边的类型
+-------------------+---------------+
| Python | JSON |
+===================+===============+
| dict | object |
+-------------------+---------------+
| list, tuple | array |
+-------------------+---------------+
| str | string |
+-------------------+---------------+
| int, float | number |
+-------------------+---------------+
| True | true |
+-------------------+---------------+
| False | false |
+-------------------+---------------+
| None | null |
+-------------------+---------------+
"""
转换方式1：手动转（将不可序列化的手动转字符串等可序列化类型）
d = {'t1': str(datetime.date.today()),
't2': str(datetime.datetime.today()),
# }
res = json.dumps(d)
print(res) # {"t1": "2022-11-07", "t2": "2022-11-07 14:54:59.789983"}
转换方式2:派生方法
"""
查看dumps源码，注意cls参数，默认转JsonEncoder
查看该类的源码，发现default方法是报错的发起者
编写类继承JsonEncoder并重写default方法，之后调用dumps手动传cls=我们自己的类
"""
d = {'t1': str(datetime.date.today()),
't2': str(datetime.datetime.today()),
}
class My_JsonEncoder(json.JSONEncoder):
def default(self, o):
"""
:param o: 接收无法被序列化的数据
:return: 返回可以被序列化的数据
"""
if isinstance(o, datetime.datetime): # 如果o的数据类型是datetime.datetime
return o.strftime('%Y-%m-%d %X')
elif isinstance(o, datetime.date): # 如果o的数据类型是datetime.date
return o.strftime('%Y-%m-%d')
return super().default(o) # 如果都不是的话还是调用原来的方法
res = json.dumps(d,cls=My_JsonEncoder)
print(res) # {"t1": "2022-11-07", "t2": "2022-11-07 15:05:24.140046"}
面向对象三大特性之封装
封装:就是将数据和功能封装起来
隐藏:将数据和功能隐藏起来不让用户直接调用，而是开发一些接口间接调用，从而可以在接口内添加额外的操作
伪装:将类里面的方法伪装成类里面的数据
'伪装'：
class C:
def func(self):pass
boj = C() # 产生对象
boj.func() # 对象调用类中的方法
'经过伪装'
boj.func # 实现伪装，其实还是boj.func()
隐藏
class MyClass:
school_name = '老男孩大学'
_ = '嘿嘿嘿'
_name = 'tony'
"""类在定义阶段，名字前面有两个下划线，该名字就会被隐藏起来，无法直接访问"""
__age = 18
"""在python中没有真正的隐藏，仅仅是换了个名字_类名__名字"""
def choice_course(self):
print('学生正在选课')
print(MyClass.school_name) # 老男孩大学
obj = MyClass() # 产生一个对象
print(obj.school_name) # 老男孩大学
print(MyClass._) # 嘿嘿嘿
print(MyClass._name) # tony
print(MyClass.__age) # 报错，显示没有这个名字
MyClass.__hobby = 'JDB' # 无法隐藏，这句话表示在类中添加数据
print(MyClass.__hobby) # JDB
obj.__age # 报错，显示没有这个名字
obj.__addr = '派出所' # 这句话表示在对象中添加数据
隐藏的实际用法
class Person:
def __init__(self, name, age, hobby):
self.__name = name # 对象也可以拥有隐藏的属性
self.__age = age
self.__hobby = hobby
def get_info(self):
# 在类体代码中，是可以直接使用隐藏名字，然后打印
print(f"""
姓名:{self.__name}
年龄:{self.__age}
爱好:{self.__hobby}
""")
# 隐藏的属性开放修改的接口，可以自定义很多功能，也可以增加一些限制
def set_name(self, new_name): # 修改名字的接口
if len(new_name) == 0:
raise ValueError('名字不能没有')
if new_name.isdigit():
raise ValueError('名字不能是数字')
self.__name = new_name # 在类的定义阶段，是可以点出来隐藏的名字
obj = Person('jason', 18, 'read')
obj.get_info() # 姓名:jason 年龄:18 爱好:read
obj.set_name('tony老师') # 调用修改名字的接口
obj.get_info() # 就是名字就是修改后的tony老师
"""
以后我们在编写面向对象代码类的定义时，也会看到很多单下划线开头的名字
表达的意思通常特指不要直接访问，而是查找一下下面可能定义的接口
"""
伪装
BMI指数:衡量一个人的体重与身高对健康影响的一个指标
体质指数（BMI）=体重（kg）÷身高^2（m）
EX：70kg÷（1.75×1.75）=22.86
class Person(object):
def __init__(self, name, height, weight):
self.name = name
self.height = height
self.weight = weight
@property
def BMI(self):
return self.weight / (self.height ** 2)
p1 = Person('jason', 1.83, 78)
p1.BMI() # BMI应该作为人的基本数据而不是方法
print(p1.BMI) # 利用装饰器伪装成数据
class Foo:
def __init__(self, val):
self.__NAME = val # 将属性隐藏起来
@property # 伪装属性，可以被点出来
def name(self):
return self.__NAME
@name.setter
def name(self, value):
if not isinstance(value, str): # 在设定值之前进行类型检查
raise TypeError('%s must be str' % value)
self.__NAME = value # 通过类型检查后，将值value存放到真实的位置
@name.deleter # 删除名字，直接报错，不能删除
def name(self):
raise PermissionError('Can not delete')
f = Foo('jason')
print(f.name) # jason,这是由于伪装的原因
f.name = 'jason123'
print(f.name)
del f.name # 删除直接报错， Can not delete
f.name = 'jason' # 触发name.setter装饰器对应的函数name(f,’jason')
f.name = 123 # 触发name.setter对应的的函数name(f,123),抛出异常TypeError
del f.name # 触发name.deleter对应的函数name(f),抛出异常PermissionError
三大特性之多态
多态：一种事务的多种形态
水：液态，固态，气态
动物：人，猪，猫，狗
class Animal:
def spark(self):
"""叫的方法"""
pass
class Cat(Animal): # 子类继承父类Animal
def miao(self):
print('喵喵喵')
class Dog(Animal):
def wang(self):
print('汪汪汪')
class Pig(Animal):
def heng(self):
print('哼哼哼')
"""以上都属于动物的叫声，属于叫声的多态性，实际的写法应该为下面"""
class Animal:
def spark(self):
"""叫的方法"""
pass
class Cat(Animal): # 子类继承父类Animal
def spark(self):
print('喵喵喵')
class Dog(Animal):
def spark(self):
print('汪汪汪')
class Pig(Animal):
def spark(self):
print('哼哼哼')
"""
面向对象中多态意思是 一种事务可以有多种形态但是针对相同的功能应该定义相同的方法，这样不论我们拿到的是哪个具体的事务，都可以通过相同的方法调用功能
"""
s1 = 'hello word'
L1 = [11,22,33,44]
d = {'name':'jason','pwd':123}
print(s1.__len__())
print(l1.__len__())
print(d.__len__())
'不同的数据类型，调用长度的方法都是len其实也是一种多态的表现'
"""
鸭子类型：只要你看上去像鸭子，走路像鸭子，说话像鸭子，那么你就是鸭子
"""
# linux系统
"""
文件 能够读取数据也能够保存数据
内存 能够读取数据也能够保存数据
硬盘 能够读取数据也能够保存数据
......
一切皆文件
"""
多态的正确写法：
class File:
def read(self): pass
def write(self): pass
class Memory:
def read(self): pass
def write(self): pass
class Disk:
def read(self): pass
def write(self): pass
"""python永远提倡自由简介大方，不约束程序员行为，但是多态提供约束的方法"""
import abc
# 指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
class Animal(metaclass=abc.ABCMeta):
@abc.abstractmethod # 该装饰器限制子类必须定义有一个名为talk的方法
def talk(self): # 抽象方法中无需实现具体的功能
pass
class Cat(Animal): # 但凡继承Animal的子类都必须遵循Animal规定的标准
def talk(self):
pass
cat = Cat() # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化
面向对象之反射
利用字符串操作对象的数据和方法
1.hasattr() 重点
判断对象是否含有某个字符串对应的属性名或方法名
2.getattr() 重点
根据字符串获取对象对应的属性名（值）或方法名（函数体代码）
3.setattr()
根据字符串给对象设置或修改数据
4.delattr()
根据字符串删除对象里面的名字
class C1:
school_name = '小姐姐学院'
def choice_course(self):
print('大宝贝们正在选课')
反射推导：
obj = C1() # 生成一个对象
"""判断某个名字对象是否可以使用（存在）"""
推导思路
try:
obj.xxx
except AttributeError:
print('你木有这个名字')
"""判断用户随意指定的名字对象是否可以使用（存在）"""
traget_name = input('请输入对象可能使用的名字>>>:').strip()
try:
obj.traget_name
except AttributeError:
print('你木有这个名字')
"""输入存在的名字也显示没有是因为用户输入的是字符串，而我们的点的是变量名"""
'反射：利用字符串操作对象的数据和方法'
print(hasattr(obj, 'school_name')) # 返回True，证明有
print(getattr(obj, 'school_name')) # 获取这个字符串对应属性名的值
print(getattr(obj, 'choice_course')) # 获取的是函数体代码
class C1:
school_name = '小姐姐学院'
def choice_course(self):
print('大宝贝们正在选课')
obj = C1() # 生成一个对象
while True:
target_name = input('请输入您想要操作的名字>>>:').strip()
if hasattr(obj, target_name): # 判断用户输入的名字是否有
print('恭喜您 系统中有该名字')
# 获取该名字对应的数据值
date_or_func = getattr(obj,target_name) # 有的话getattr获取这个名字的值
if callable(date_or_func): # callable判断这个名字是否可以加括号
print('您本次使用的是系统中的某个方法')
date_or_func() # 判断是可以加括号的，我们直接调用
else:
print('您本次使用的是系统中某个数据') # 如果不是就可以直接打印
print(date_or_func) # 打印这个值
else:
print('很抱歉，系统中没有该名字')
反射实战案例
1.什么时候应该考虑使用反射，只要需求中出现了关键字
对象...字符串...
2.实战案例
1.模拟cmd终端
class WinCmd:
def tasklist(self): # 方法名
print("""
1.学习编程
2.学习python
3.守护妹妹
""")
def ipconfig(self): # 方法名
print("""
地址:127.0.0.1
地址:上海浦东新区
""")
def get(self, target_file): # 方法名
print('获取指定文件', target_file)
def put(self, target_file): # 方法名
print('上传指定文件', target_file)
def server_run(self): # 方法名
print('欢迎进入简易版本cmd终端')
while True:
traget_cmd = input('请输入您的指令>>>:').strip()
res = traget_cmd.split(' ') # 切割空格 # 按照空格切割成一个列表，来区分用户输入的是单个名字还是有俩
if len(res) == 1: # 如果这个列表的长度是1，证明列表里面只有一个元素
if hasattr(self, res[0]): # 判断列表里面的字符串有没有这个名字
getattr(self, res[0])() # 如果有的话加括号获取这个值，然后加括号调用
else:
print(f'{res[0]}不是内部或者外部命令') # 如果没有这个名字就打印
elif len(res) == 2: # 如果列表的长度是2.证明调用的是上传或者获取文件，第一个元素是方法名，第二个元素是文件名
if hasattr(self, res[0]): # 判断列表里面有没有索引0的名字
getattr(self, res[0])(res[1])# 有的话，直接getattr，索引0获取这个名字的值调用，将列表索引1作为参数传进去 else:
else:
print(f'{res[0]}不是内部或者外部命令')
obj = WinCmd() # 生成一个对象
obj.server_run() # 调用类中的方法
2.一切皆对象
import seetings
print(dir(seetings)) # 获取文件里面所有的名字
useful_dict = {} # 先定义一个字典
for name in dir(seetings): # 循环获取名字
if name.isupper(): # 如果名字是大写
useful_dict[name] = getattr(seetings, name) # 获取对象seetings里面name对应的值，增加键值对
print(useful_dict)
while True:
target_name = input('请输入某个名字>>>:').strip()
if hasattr(seetings, target_name): # 如果在对象settings里面有这个名字
print(getattr(seetings, target_name)) # 就直接打印这个名字
else:
print('该模块文件中没有该名字')
浙公网安备 33010602011771号