派生方法的更多应用
import json
import datetime
a = {'t1':datetime.date.today(),
't2':datetime.datetime.today(),
't3':'moon'}
res = json.dumps(a)
print(res)
方式1:手动转类型
import json
import datetime
o = datetime.datetime.today()
o = o.strftime('%Y %m %d')
# 手动在外面直接转
a = {'t1':str(datetime.date.today()),
#在里面直接转
't2':o,
't3':'moon'}
res = json.dumps(a)
print(res)
方式2：派生方法
'''
报错信息：
raise TypeError(f'Object of type {o.__class__.__name__} '
TypeError: Object of type date is not JSON serializable
'''
"""
查看dumps源码 注意cls参数 默认传JsonEncoder
查看该类的源码 发现default方法是报错的发起者，default的报错信息和我们获得的报错信息一直
编写类继承JsonEncoder并重写default方法 之后调用dumps手动传cls=我们自己写的类
"""
class Mydumps(json.JSONEncoder):
def default(self,o):
# 重新编写该方法
if isinstance(o,datetime.datetime):
# 判断是不是datetime.datetime类型，如果是则返回字符串格式时间
return o.strftime('%Y %m %d %X')
if isinstance(o,datetime.date):
# 判断是不是datetime.date类型，如果是则返回字符串格式时间
return o.strftime('%Y-%m-%d')
return super().default(o)
# 如果不是，那还是调用原来的方法不变
#
res = json.dumps(a,cls=Mydumps)
print(res)
面向对象三大特性之封装
封装：就是将数据和功能 封装 起来
隐藏：将数据和功能隐藏起来，用户不可以直接调用，而是开发一些接口间接调用，从而我们可以在接口内添加额外的操作
class MyClass:
school_name = '倚天屠龙记'
_ = '嘿嘿嘿'
__name = '张无忌'
'''
类在定义阶段 名字前面有2个下划线 那么该名字就会被隐藏起来，
无法直接访问
'''
def __choice_course(self):
print('正在选课')
# obj = MyClass()
# print(obj.school_name)
# obj.__hobby = '九阳神功'
# #只有在定义阶段双下划线才会隐藏
# print(obj.__hobby)
# obj.__choice_course
# # 被隐藏的无法直接调用
class Person:
def __init__(self,name,age):
self.__name = name
self.__age = age
def get_info(self):
# 在类体代码中是可以直接使用隐藏的名字
print(f'''
姓名：{self.__name}
年龄：{self.__age}
''')
# 隐藏的属性开发修改的接口，可以自定义很多功能
# 可以在执行命令前后添加更多操作
def set_name(self,new_name):
if len(new_name) == 0:
raise ValueError('名字不能为空')
if new_name.isdigit():
raise ValueError('名字不可以是数字')
self.__name = new_name
ojb = Person('张无忌',18)
ojb.get_info()
# 通过调用方法来查看对象内 隐藏的数据
ojb.set_name('张三丰')
# 通过调用方法来修改名字，
ojb.get_info()
ojb.set_name('')
'''
以后我们在编辑类的定义时，也会看到很多下划线开头的名字，表达的意思通常
都是不能直接访问，而是需要查找一下与之相关的方法接口
'''
面向对象伪装
举例说明：
BMI指数：衡量一个人的体重与身高对健康的影响
计算公式 体重/身高**2
class Person:
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('张无忌', 1.70, 70)
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(f'{value} must be str')
self.__NAME = value
# 将通过类型检查后，将值value存放到真实的位置
@name.deleter
def name(self):
raise PermissionError('can not delete')
f1 = Foo('moon')
print(f1.name)
f1.name = 'jason'
# 其实这里是调用了@name.setter对应的函数，
print(f1.name)
f1.name = 123
# 这里是调用了@name.setter对应的函数.函数内设置非字符串类型数据就会报错
print(f1.name)
三大特性之多态
class Animal:
def spark(self):
pass
class Cat(Animal):
def miao(self):
print('喵喵喵')
class Dog(Animal):
def wang(self):
print('汪汪汪')
# 例如动物的叫声，每个动物都有独特的叫声，但是这也可以称之为动物的
# 统一动作，都可以命名为叫声。
# 正确写法：
class Animal:
def spark(self):
pass
class Cat(Animal):
def spark(self):
print('喵喵喵')
class Dog(Animal):
def spark(self):
print('汪汪汪')
'''
面向对象中多态的意思是，一种事物可以有多种形态但是针对相同的功能应该定义
相同的方法，这也无论我们拿到的对象是什么，都可以通过同样的方法调用到该功能
'''
# 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中我们要遵守这个规定 同样的方法尽力名称相同
'''
面向对象之反射
利用字符串操作对象的数据和方法
1.hasattr()
判断丢下是否含有某个字符串对应的属性名或方法名
2.getattr()
根据字符串获取对象对应的属性名或方法名
3.setattr()
根据字符串给对象设置或修改数据
4.delattr()
根据字符串删除对象里的名字
class C1:
name = '倚天屠龙记'
def choice_course(self):
print('张无忌牛逼')
obj = C1()
print(hasattr(obj,'name'))
# 可以根据字符串类型来查询是否有这个 变量名
print(getattr(obj,'name'))
# 可以根据字符串类型来获取这个变量名
print(getattr(obj,'choice_course'))
class C2:
name = '倚天屠龙家'
def choice(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.什么时候应该考虑使用反射 只要需求中出现了关键字
对象....字符串....
# 模拟cmd终端
class Cmd:
def tasklist(self):
print('''
1.学习python
2.学习英语
3.摆烂
''')
def ipconfig(self):
print('''
ip地址：120.2.1.0
地址：伊拉克
''')
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_file = input('请输入您的指令')
res = target_file.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 = Cmd()
obj.server_run()
2. 一切皆对象
# # 模拟cmd终端
#
# class Cmd:
# def tasklist(self):
# print('''
# 1.学习python
# 2.学习英语
# 3.摆烂
# ''')
#
# def ipconfig(self):
# print('''
# ip地址：120.2.1.0
# 地址：伊拉克
# ''')
#
# 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_file = input('请输入您的指令')
# res = target_file.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 = Cmd()
# obj.server_run()
import settings
可以直接把py文件也当作一个对象来处理
# 利用反射 保留某个py文件中所有的大写变量名和对应的数据值
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:
name = input('请输入某个名字')
if hasattr(settings,name):
print(getattr(settings,name))
else:
print('该模块中没有此名字')