派生实操
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 |
+-------------------+---------------+
# 我们只需要将键对应的值转换类型即可
# 转换方式一:
d = {
't1': str(datetime.date.today()),
't2': str(datetime.datetime.today()),
't3': 'jason'
}
# 转换方式二:
"""
1.查看json下的dumps的源码：
def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,
allow_nan=True, cls=None, indent=None, separators=None,
default=None, sort_keys=False, **kw):
2.注意cls参数：默认传JsonEncoder
if cls is None:
cls = JSONEncoder
3.查看JsonEncoder的源码，发现default方法是报错的发起者
def default(self, o):
raise TypeError(f'Object of type {o.__class__.__name__} '
f'is not JSON serializable')
4.我们只需编写类继承JsonEncoder并且重写default方法，之后调用dumps手动传入cls=我们自己写的类
"""
# 重写后的类：
class MyJsonEncoder(json.JSONEncoder):
def default(self, o):
"""
:param o: # 接收无法被序列化的数据
:return: # 返回可以被序列化的数据
"""
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)
# 最后还是调用原来的方法，防止有一些额外操作没有做
res = json.dumps(d, cls = MyJsonEncoder)
print(res)
伪装
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.68,52)
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 = 'jason123'
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
三大特性之多态
1. 多态： 一种事物的多种形态
# 面向对象中的多态意思是一种事物可以有多种形态，但是针对相同功能应该定义相同的方法。这样
不管我们拿到的是哪种具体事物，都可以通过相同的方法调用该功能
2.鸭子类型
深层理解： 指的是面向对中，子类不需要显示的继承某个类，只要有某个的方法和属性，那我就属于这个类
"""
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.什么时候考虑使用反射：
需求中出现关键字 ： 对象....字符串...
2.反射的方法：
# 1.hasattr() 重点
判断对象是否含有某个字符串对应的属性名或方法名
# 2.getattr() 重点
根据字符串获取对象对应的属性名(值)或方法名(函数体代码)
# 3.setattr()
根据字符串给对象设置或修改数据
# 4.delattr()
根据字符串删除对象里面的名字
使用：
class C1:
school_name = '小姐姐学院'
def choice_course(self):
print('大宝贝们正在选课')
obj = C1()
while True:
target_name = input('请输入您想要操作的名字>>>:')
if hasattr(obj, target_name):
print('恭喜您 系统中有该名字')
# 获取该名字对应的数据(值 函数)
data_or_func = getattr(obj, target_name)
if callable(data_or_func):
print('您本次使用的是系统中的某个方法')
data_or_func()
else:
print('您本次使用的是系统中的某个数据')
print(data_or_func)
else:
print('很抱歉 系统中没有该名字')
面向对象三大特性之封装
1. 封装： 封装就是将数据和功能封装起来
2. 隐藏： 将数据和功能隐藏起来不让用户直接调用，而是开发一些接口间接调用从而在接口内添加额外的操作
3. 伪装： 将类里面的方法伪装成类里面的数据
class C：
def func(self):pass
obj = C()
obj.func()
"""经过伪装"""
obj.func
# 在类的定义阶段，名字前面有连个下划线，则会将名字隐藏起来无法直接点出来访问。但是python中的隐藏是墨守成规的，所谓的隐藏就是换了一个名字而已，_类名__名字。
# 隐藏属性
class Person:标签：.__,obj,name,self,多态,面向对象,三大,print,def From： https://www.cnblogs.com/juzijunjun/p/16867182.html
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()
obj.set_name('tony')
obj.get_info()
obj.set_name('')
# 我们在编程中如果遇到单下划线开头的名字，其所表达的意思通常是:不要直接访问,而是查找一下下面可能定义的接口