今日内容总结
派生方法的实战总结
import json
import detetime
d = {'t1':datetime.date.today(),'2':datetime.datetime.today(),'3':111}
# 如果想要序列化这个字典
eg：res = json.dumps(d)
'''
序列化报错：
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 |
+-------------------+---------------+
'''
#解决方案：
方案一：
我们可以手动加上 str()来将数据类型做一个转换
方案二：
追溯源头 使用派生的方法
'''
先使用 Ctrl和鼠标 查看源码再dumps源码中有一个cls参数 默认是传入JsonEncoder
查看该类的源码发现default方法是报错的源头
编写类并继承JsonEncoder并重写default方法 之后调用dumps手动传入cls = 我们的类
'''
#代码实现：
class MyJsonEncoder(json.JsonEncoder):
def default(self,o):
'''
:param o: 接收无法被序列化的数据
:return: 返回可以被序列化的数据
'''
if isinstance(o,datetime.datetime): # 判断是否是datetime类型 如果是久处理成可被序列的类型
return o.strftime(%Y-%m-%d %X)
elif isinstance(o,datetime.date):
return o.strftime(%Y-%m-%d)
return super().default(o) # 最后调用原来的方法 这样就防止了一些额外操作没有做
res = json.dumps(d,cls = MyJsonEncoder)
print
面向对象的三大特征之封装
封装：就是将数据和功能'隐藏'起来
隐藏：将数据和功能隐藏起来不让用户直接使用 而是开发一些可调用的接口从而可以再接口内添加一些额外的操作
伪装：将类里面的方法伪装成数据
class C():
def func(self):pass
obj = C()
obj.func() # 这样看上去就是一个方法
'''经过伪装'''
obj.func
class MyCalss:
school_name = '清华大学'
_ = 'hhh'
__age = 99
# 类在定义阶段 变量名如果是两个下划线 那么就会被隐藏 在类外无法直接被调用
# 这种隐藏并不是正在意义上的隐藏 仅仅是换了一个名字
obj = MyClass()
obj.__name = 'aaa' # 无法被隐藏 只有在类定义阶段才行
'''
如果我们使用MyClass.__dict__的方式可以查看到隐藏了的
再使用print(MyClass._MyClass__age)
所以并不是真正的被隐藏了
'''
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(naw_name) == 0:
raise ValueError('你什么都没写哦')
if naw_name.isdigit():
raise ValueError('名字不能使数字')
self.__name = new_name
obj = Person('aaa',19,'read')
obj.get_info()
#想要修改就直接：
obj.set_name('wwww')
obj.get_info()
'''
因为使用两个下划线并不能真正的隐藏 所以在编写代码时如果出现单个下划线在前面
就别直接调用 而是去查找一下下面的可能定义的接口
'''
伪装
用BMI举例
BMI：是衡量一个人的体重与身高对健康影响的一个指标
计算公式：体重 ÷ (身高的平方)
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('aaa',1.80,80)
p1.BMI() # 一眼就知道是方法 所以不行
利用@property 来伪装成数据
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存放到真实的位置self.__NAME
@name.deleter
def name(self):
raise PermissionError('Can not delete')
f = Foo('jason')
print(f.name)
f.name = 'jason666'
print(f.name)
del f.name
# 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 Anmimal:
pass
class Cat(Anmimal):
def miao():
print('喵喵喵')
class Dog(Anmimal):
def wang():
print('汪汪汪')
# 但在作为动物 他们都会叫
'''
面向对象多条的意思是 一种事物可以有多种形态但是针对相同的功能应该有定义相同方法
这样无论我们拿到的具体是哪个具体的事物 都可以通过相同的方法调用功能
'''
class Anmimal:
def spark(self):
#叫的方式
pass
class Cat(Anmimal):
def spark(self):
print('喵喵喵')
意义：
假设我们使用相同的功能去操作不同类型的数据 就可以节省代码
eg：
l1 = [1,2,3]
s1 = '123'
d1 = {'1':0,'2':2}
print(l1.__len__)
print(s1.__len__)
print(d1.__len__)
面对不同数据类型的数据 我们就可以使用相同的方法来计算
'''
鸭子类型🦆：只要看上去像鸭子走路像鸭子 那么就是鸭子
'''
# linux 系统
'''
文件 能够读取数据和存储数据
内存 能够读取数据和存储数据
硬盘 能够读取数据和存储数据
所以在linux系统中 一切皆文件
'''
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 choise_course(self):
print('正在选课')
obj = C1()
# 推导思路
'''判断某个名字对象是否可以使用(存在)'''
try:
obj.xxx
except AttributeError:
print('没有该名字')
'''判断用户随意指定的随意的名字是否可以使用(存在)'''
target_name = input('输入你的名字>>>:').strip()
try:
obj.target_name
except AttributeError:
print('没有该名字')
# 反射:利用字符串操作对象的数据和方法
# print(hasattr(obj, 'school_name')) # True
# print(getattr(obj, 'school_name')) # 清华大学
# print(getattr(obj, 'choice_course')) # <bound method C1.choice_course of <__main__.C1 object at 0x00000248C0B65A30>>
class C1:
school_name = '家里蹲大学'
def choice_course(self):
print('正在选课')
obj = C1()
while Ture:
target_name = input('请输入你的名字>>>:').strip()
if hasattr(obj,target_name):
print('还真有这名字')
deta_or_func = getattr(obj,target_name)
if callable(deta_or_func):
print('正在使用这个功能')
deta_or_func()
else:
print('正在使用这种数据')
print(deta_or_func)
else:
print('没有这名字')
反射实战案列
1.什么时候该考虑使用反射 只要需求出现了关键字
对象...字符串...
2.实战案例
1.模拟cmd终端
class Wincmd:
def tasklist(self):
print('''
1.学习
2.学习
3.学习
''')
def ipconfig(self):
print('''
地址：12.122.145
地址：上海浦东新区
''')
def get(self,target_file):
print('获取指定内容',target_file)
def put(self,target_file):
print('上传指定文件',target_file)
def server_run(self):
print('欢迎进入简易版本的cmd终端')
while True:
target_cmd = input('请输入你的指令>>>:')
res = target_cmd.split(' ')
if len(res)==1:
if hasattr(self,res[0]):
getattr(self,res[0])()
else:
print(f'{res[0]}不是内部或外部指令')
elif len(res)==2:
if hasattr(self,res[0]):
getattr(self,res[0])(res[1])
else:
print(f'{res[0]}不是内部或外部指令')
obj = Wincmd()
obj.server_run()
2.一切且对象
# 利用反射保留某个py文件中所有大写对应的变量名及对应的数据值
import settings
print(dir(settings)) # dir列举对象可使用的名字
useful_dict = {}
for name in dir(settings):
if name.isupper():
useful_dict[name] = getattr(settings,name)
print(useful_dict)
while True:
target_name = input('请输入名字>>>:')
if hasattr(settings,target_name):
print(getattr(setings,target_name))
else:
print('模块中没有该名字')
浙公网安备 33010602011771号