派生方法
目录
派生方法简介
# 什么是派生方法？
子类中编写了父类的中相同的方法 并且在该方法调用了父类的方法
super在哪个类里面，哪个类就算是子类。
super点名字以当前所在的哪个类为准，然后去当前类的父类找名字。self点名字从对象本身开始找名字。
派生方法实战
json转换格式问题
# json不能序列化python所有的数据类型 只能是一些基本数据类型
# 字典中的datatime类型不能被json序列化
import json
import datetime
d = {
't1': datetime.date.today(),
't2': datetime.datetime.today(),
't3': 'jason'
}
res = json.dumps(d) # TypeError: Object of type date is not JSON serializable
print(res)
"""
能够被序列化的数据是有限的>>>:里里外外都必须是下列左边的类型
+-------------------+---------------+
| Python | JSON |
+===================+===============+
| dict | object |
+-------------------+---------------+
| list, tuple | array |
+-------------------+---------------+
| str | string |
+-------------------+---------------+
| int, float | number |
+-------------------+---------------+
| True | true |
+-------------------+---------------+
| False | false |
+-------------------+---------------+
| None | null |
+-------------------+---------------+
"""
为了达到能保存为json文件传输的目的，有以下两种方法。
方法一：手动转字符串
# 1.转换方式1:手动转类型(简单粗暴)
import datetime
import json
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 15:22:20.790922"}
方法二：继承并使用派生方法重写json源码
1.查看json.dumps源码 注意cls参数 默认传JsonEncoder
2.再看JSONEncoder源码 发现default方法是报错的发起者
3.思路：编写类继承JSONEncoder并重写default方法，之后调用dumps手动传cls=我们自己写的类
import datetime
import json
d = {
't1': datetime.date.today(),
't2': datetime.datetime.today(),
't3': 'cloud'
}
class MyJsonEncoder(json.JSONEncoder): # 1.继承JSONEncoder
def default(self, o): # 2.重写父类default
"""
:param o: 接收无法被序列化的数据
:return: 返回可以被序列化的数据 我们这里希望datatime类型的数据也能返回
"""
if isinstance(o, datetime.datetime): # 3.判断是否是datetime类型 如果是则将o处理成可以被序列化的类型
return o.strftime('%Y-%m-%d %X')
elif isinstance(o, datetime.date):
return o.strftime('%Y-%m-%d')
else:
super().default(o) # 4.最后还是调用原来的方法 防止有一些额外操作没有做 即输入的对象不可序列化就报错 如果不调用会输出null
# （调用父类的方法，会将对象自己作为第一个参数传进去）
json_obj = json.dumps(d, cls =MyJsonEncoder)
print(json_obj) # {"t1": "2022-11-07", "t2": "2022-11-07 15:47:14", "t3": "cloud"}
面向对象之封装
封装和隐藏
封装:就是将数据和功能'封装'起来
'''封装 ---衍生---> 隐藏'''
隐藏:将数据和功能隐藏起来不让用户直接调用，而是开发一些接口间接调用从而可以在接口内添加额外的操作
双下划线隐藏(_ _name)
- 类在定义阶段，名字前面有两个下划线，那么该名字会被隐藏起来，无法直接访问。
class Person:
name = 'cloud'
_ = '这里什么也没有'
_name = 'alice'
'''类在定义阶段 名字前面有两个下划线 那么该名字会被隐藏起来 无法直接访问'''
__age = 18
"""在python中其实没有真正意义上的隐藏 仅仅是换了个名字而已 _类名__名字"""
def __talk(self):
print('你好！')
# 1.可以访问的名字
print(Person.name)
print(Person._)
print(Person._name)
# ps：对象也都可以访问这些名字
# 2.无法访问 被隐藏的名字
print(Person.__age) # AttributeError: type object 'Person' has no attribute '__age'
print(Person.__talk) # AttributeError: type object 'Person' has no attribute '__age'
# ps:对象也都无法访问
"""
以后我们在编写面向对象代码类的定义时 也会看到很多单下划线开头的名字
表达的意思通常特使不要直接访问 而是查找一下下面可能定义的接口
"""
- 进行修改名字的操作之后 就隐藏不了了
class Person:
__age = 18
# 1.修改名字之后可以访问
Person.__age = 3
print(Person.__age) # 3
obj = Person()
print(obj.__age) # 3
- 只能在类的定义阶段创建隐藏属性
class Person:
name = 18
# 1.新增隐藏属性__age
Person.__age = 3
# 2.无法隐藏 可以访问__age
print(Person.__age) # 3
隐藏的本质
- 隐藏仅仅是换了个名字
'''python崇尚自由
Python中的隐藏不是真正的隐藏 而是自动转换成了特定的语法
规则： __变量名 >>> _类名__变量名 '''
class Person:
def __init__(self, name): # 1.给对象创建隐藏的属性__name
self.__name = name
# 2.查看obj的名字
obj = Person('cloud')
print(obj.__dict__) # {'_Person__name': 'cloud'}
# 3.调用
print(obj._Person__name) # cloud
# ps:隐藏的属性不建议直接调用 而应该用接口来访问
# 4.类的例子
class Person:
__age = 18
print(Person._Person__age) # 18
用接口访问隐藏属性
'''隐藏的属性不能直接拿变形之后的名字进行访问，而是要通过特定的通道（接口）访问。
如何写接口？'''
class Person:
def __init__(self, name, age, hobby):
self.__name = name # 1.对象也可以拥有隐藏的属性
self.__age = age
self.__hobby = hobby
def get_info(self):
# 2.类体代码中 是可以直接使用隐藏的名字
print(f"""
姓名:{self.__name}
年龄:{self.__age}
爱好:{self.__hobby}
""")
# 3.隐藏的属性开放修改的接口 可以自定义很多功能
def set_name(self, new_name):
if len(new_name) == 0:
raise ValueError('名字长度不能为0')
if new_name.isdigit():
raise ValueError('名字不能是数字')
self.__name = new_name
obj = Person('cloud', 18, 'fight')
obj.get_info()
obj.set_name('tifa') # 调用接口修改隐藏属性
obj.get_info()
输出结果：
隐藏函数：
伪装
- 伪装做了一件什么事？
将类里面的方法伪装成类里面的数据 - 是数据，而不是功能。
有时候很多数据需要计算才可以获得
但是感觉这些数据应该是数据 而不是功能 比如BMI指数 应该是一个数据 而不是功能 - 数据的特征
首先数据肯定是不能调用的
其次数据应该可以通过赋值操作进行修改
已经知如上条件，如何用代码实现？
用@proprety装饰函数
加一个装饰器@property 就会变成数据 不需要加括号了
看着像数据 其实还是一个函数！！！！ 是用装饰器做了一个伪装
上代码：
class Person2(object):
def __init__(self, name):
self.__NAME = name
@property # 1.添加装饰器 将函数name变成数据！
def name(self):
return self.__NAME
obj = Person2('小澪')
print(obj.name) # 小澪 # 加了装饰器之后不需要调用了！
print(obj.name()) # 居然报错也能伪装 这也伪装的太好了 实际name是个函数 str是表象 # TypeError: 'str' object is not callable
print(Person2.name) # 用类调用 可以发现name这个名字对应在不是一个数据 而是property object
print(Person2.name()) #这里一调用 原形毕露了吧 # TypeError: 'property' object is not callable
'''语法糖@property下面的方法只能有self这个形参，
且理论上来说你是数据 数据是无法传参的'''
@proprety功能之@name.setter设置属性
# 模拟出数据的赋值修改如：name = 'cloud'
class Person3(object):
def __init__(self, name):
self.__NAME = name
@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
obj = Person3('小潮')
print(obj.name) # 小潮 #
obj.name = '小澪' # 可以修改 就好像name是真的数据！ 实际底层还是用了 第二个name方法
print(obj.name) # 小澪 # 修改成功了！
# ps: 装饰器语法糖@name.setter中，这个name应该是你想要伪装的函数名，它不是一成不变的，只是本例中被伪装的函数用的是name这个名字。
@proprety功能之@name.deleter删除属性触发器
class Person3(object):
def __init__(self, name):
self.__NAME = name
@property
def name(self):
return self.__NAME
@name.deleter
def name(self):
print('你居然想删除')
# 这里也可以主动抛出异常
# raise PermissionError('Can not delete')
obj = Person3('小潮')
print(obj.name) # 小潮
del obj.name # 执行这条代码后 第二个name会执行 print('你居然想删除')会执行
print(obj.name) # 小潮 # 并且实际上obj.name并没有删除掉
del Person3.name # 这样真的删除了
print(obj.name) # AttributeError: 'Person3' object has no attribute 'name'
del关键字删除类中名字
# del关键字删除类中名字 del关键字本质是清除引用
class Mysql():
name = 123
def my(self):
pass
a = Mysql()
a.age = 18
print(dir(a)) # ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get
# attribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__ne
# w__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakre
# f__', 'age', 'my', 'name']
print(a.__dict__) # {'age': 18}
del a.age
del Mysql.name
print(a.__dict__) # {}
print(dir(a)) # ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get
# attribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__ne
# w__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakr
# ef__', 'my']
面向对象之多态
多态: 一种事物的多种形态
# 举例：
水: 液态 固态 气态
动物: 人 猪 猫 狗
# 1.面向对象中的多态
面向对象中多态意思是：
一种事物可以有多种形态但是针对相同的功能应该定义相同的方法（名字）；
这样无论我们拿到的是哪个具体的事物；
都可以通过相同的方法（名字）调用功能。
动物多态
class Animal:
def spark(self):
'''叫的方法'''
pass
class Cat(Animal):
# def miao(self):
# print('喵喵喵')
def spark(self):
print('喵喵喵')
class Dog(Animal):
# def wang(self):
# print('汪汪汪')
def spark(self):
print('汪汪汪')
class Pig(Animal):
# def heng(self):
# print('哼哼哼')
def spark(self):
print('哼哼哼')
对于不同的动物，它们都会叫，根据多态性，我们应该定义它们叫的方法应该统一叫spark，
而不是每个动物'叫'这个功能的名字都不同，导致访问的时候麻烦。
len方法体现多态
# len方法是多态性的体现 不管是什么数据类型 想统计长度 就使用len 这样可以减少操作的复杂度
s1 = 'hello world'
l1 = [1,2,3,4]
d1 = {'name':'cloud','pwd':123}
print(len(s1))
print(len(l1))
print(len(d1))
# 实际是调用了各种属性类型内部的双下len方法
print(s1.__len__()) # 11
强制遵守多态性 abc模块
'''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，无法实例化
鸭子类型
鸭子类型是多态理论的衍生理论。
# 鸭子理论
只要你看着像鸭子 走路像鸭子 说话像鸭子 那么你就是鸭子！
# 无论是猫狗猪 都是动物 只要你是动物你就应该有动物的功能
我们可以完全不依赖继承，'只需要制造出外观和行为相同的对象'，同样可以实现不考虑对象类型而使用对象，这就是python崇尚的'鸭子类型。'
总结
# 1. linux系统一切皆文件
"""
文件 能够读取数据也能够保存数据
内存 能够读取数据也能够保存数据
硬盘 能够读取数据也能够保存数据
......
"""
操作的时候就不需要考虑，你是硬盘对象、还是内存对象，
因为它们都是文件，我们就用文件的方法名即可，它们都包含文件的功能（读、写）。
这符合鸭子类型的理论。
# 2. 总结：
# 多个类的功能相似时 那么给这几个类定义方法的时候 就要定义相同的方法名
# 一种事物虽然有多种形态，但是它们不同形态下应该还是有相似的功能，我们定义这些功能时，就要遵循相同的名字。而反过来看就是鸭子类型，你是鸭子那就应该有这些功能。
面向对象之反射
# 1.什么是反射？
程序可以访问、检测和修改'本身状态'或者行为的一种能力。
大白话：其实就是通过字符串操作对象的数据和方法
# 2.反射的作用
正常使用对象中的方法是要通过变量名去调用的，
使用反射可以让用户，通过输入字符串，调用对象中的数据或者方法。
# 3.四个方法
hasattr() 判断对象是否含有字符串对应的数据或者功能
getattr() 根据字符串获取对应的变量名或者函数名
setattr() 根据字符串给对象设置数据 (名称空间的名字)
delattr() 根据字符串删除对象对应的数据 (名称空间中的名字)
hasattr()
# 返回布尔值
class C1:
name = 'cloud'
def talk(self):
print('hello')
# 1.使用反射判断对象中是否有所需的名字
print(hasattr(C1, 'name')) # True
obj = C1()
print(hasattr(obj,'talk')) # True
getattr()
class C1:
name = 'cloud'
age = 18
def talk(self):
print(self.age)
# 1.获取类中的值
print(getattr(C1, 'name')) # cloud
# 2.获取类中的方法
print(getattr(C1, 'talk')) # <function C1.talk at 0x000001A9A00060D0>
# 3.调用
obj = C1()
getattr(C1, 'talk')(obj) # 18
# 4.获取对象中的方法
print(getattr(obj, 'age')) # 18
setattr()
class C1:
name = 'cloud'
age = 18
def talk(self):
print(self.age)
# 1.通过字符串设置类中的数据
print(C1.name) # cloud
setattr(C1,'name','alice')
print(C1.name) # alice
delattr()
class C1:
name = 'cloud'
age = 18
# 1.通过字符串删除名字
print(C1.name)
delattr(C1, 'name')
print(C1.name) # AttributeError: type object 'C1' has no attribute 'name'
反射实际案例
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:
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()
3.一切皆对象
# 模块名也是对象 支持使用反射
# 写代码让配置文件 小写的变量名不起作用
# 利用反射保留某个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(settings, target_name))
# else:
# print('该模块文件中没有该名字')
练习
用反射实现用户增删改查
不隐藏属性
class User_massage:
def __init__(self, name, age, hobby):
self.name = name
self.age = age
self.hobby = hobby
def get_massage(self):
print('展示信息：')
for i in self.__dict__:
print(f'{i}:{getattr(self, i)}')
def change_massage(self):
user_input = input('请输入你要改的属性>>:')
change_value = input('要把原来的值改成>>:')
if hasattr(self, user_input):
setattr(self, user_input, change_value)
else:
print('没有此属性')
def del_massage(self):
user_input = input('请输入你要删除的属性>>:')
if hasattr(self, user_input):
delattr(self, user_input)
else:
print('没有此属性')
obj = User_massage('jason', 18, 'sleep')
while True:
user_choice = input('''
1.get_massage
2.change_massage
3.del_massage
请输入要执行的功能>>>:''')
if user_choice in dir(obj):
getattr(obj, user_choice)()
else:
print('没有此功能')
使用隐藏属性
class User_massage:
def __init__(self, name, age, hobby):
self.__name = name
self.__age = age
self.__hobby = hobby
def get_massage(self):
print('展示信息：')
for i in self.__dict__:
print(f'{i.rsplit("_",maxsplit=1)[1]}:{getattr(self, i)}')
def change_massage(self):
user_input = input('请输入你要改的属性>>:')
change_value = input('要把原来的值改成>>:')
mix_name = '_User_massage'+ '__' + user_input
if mix_name in dir(obj):
setattr(self, mix_name, change_value)
else:
print('没有此属性')
def del_massage(self):
user_input = input('请输入你要删除的属性>>:')
mix_name = '_User_massage' + '__' + user_input
if hasattr(self, mix_name):
delattr(self, mix_name)
else:
print('没有此属性')
obj = User_massage('jason', 18, 'sleep')
while True:
user_choice = input('''
1.get_massage
2.change_massage
3.del_massage
请输入要执行的功能>>>:''')
if user_choice in dir(obj):
getattr(obj, user_choice)()
else:
print('没有此功能')
