秃顶之路-Day23

Day 23

1.__del__魔术方法（析构方法）lf
触发时机：当对象被内存回收的时候自动触发
第一种，页面执行完毕回收所有变量。第二种，所有的对象被del的时候
功能:对象使用完毕后资源回收
参数：一个self接受对象
返回值：无

class LangDog():
	food='改吃蔬菜'
	def __init__(self,name):
		self.name=name
	def __del__(self):
		print('析构方法被触发')
obj=LangDog('肉丝')
# 1.页面执行完毕回收所用变量
print(obj.name) 
# 2.所有对象被del的时候
other_obj=obj
del obj
del other_obj
# 3.模拟文件操作
import os
class ReadFile():
	def __new__(cls,filename):
		if os.path.exists(filename):
			return object.__new__(cls)
		else:
			return print('该文件是不存在的')
	def __init__(self,filename):
		self.fp=open(filename,mode='r+',encoding='utf-8')
	def readcontent(self):
		# 读取文件
		return self.fp.read()
	def __del__(self):
		# 关闭文件
		self.fp.close()
obj=ReadFile('cehai.txt')
if obj is not None:
	res=obj.readcontent()
	print(res)
else:
	print('没有该类文件')
# 三元运算符
'''真值 if 条件表达式 else 假值'''
print(obj.readcontent()) if obj is not None else print('没有该类文件')

2.str 魔术方法
触发时机：使用print(对象)或者str(对象)的时候触发
功能：查看对象
参数：一个self接受当前对象
返回值：必须返回字符串类型

class Cat():
	gift='小猫咪会卖萌'
	def __init__(self,name):
		self.name=name
	def __str__(self):
		return self.cat_info()
	def cat_info(self):
		return '小猫咪的名字是{}'.format(self.name)
	__repr__ = __str__
	tom=Cat('汤姆')
	res=str(tom)
	print(res)
	# 小扩展 让repr强转对象时，触发打印内容
	res=repr(tom)
	print(res)

3.repr 魔术方法
触发时机：使用repr（对象）的时候触发
功能：查看对象，与魔术方法__str__相似
参数：一个self接受当前对象
返回值：必须返回字符串类型

class Mouse():
	gift='偷粮食'
	def __init__(self,name):
		self.name=name
	def __repr__(self):
		return self.mouse_info()
	def mouse_info(self):
		return '名字是{}，龙生龙，凤生凤，老鼠的儿子会打洞还会{}'.format(self.name,self.gift)
	# 系统在最底层，自动加了一句赋值操作
	__str__ = __repr__
jerry=Mouse(''杰瑞)
res=str(jerry)
print(res)

4.call 魔术方法
触发时机：把对象当作函数调用的时候自动触发
功能：模拟函数化操作
参数：参数不固定，至少一个self参数
返回值：看需求

# （1）基本语法
class MyClass():
	a=1
	def __call__(self):
		print('call魔术方法被触发了')
obj=MyClass()
obj()
# （2）模拟洗衣服的过程
class Wash():
	def __call__(self,something):
		print('我现在要洗{}'.format(something))
		self.step1()
		self.step2()
		self.step3()
		return '洗完了'
	def step1(self):
		print('加热水，加洗衣粉，加洗衣液') 
	def step2(self):
		print('衣服泡进去搅乱，搓一搓')
	def step3(self):
		print('脱水')
obj=Wash()
# 方法一
# obj.step1
# obj.step2
# obj.step3
# 方法二
res=obj('衣服')
print(res)
# （3）模拟内置函数int 实现相应的操作
import math
class MyTnt():
	def calc(self,num,sign=1)
		strvar=num.lstrip('0')
		if strvar == '0'
			return 0
		return eval(strvar)*sign
	def __call__(self,num):
		if isinstance(num,bool):
			if num == True:
				return 1
			else:
				return 0
		elif isinstance(num,int)
			return num
		elif isinstance(num,float)
			# 方法一
			'''
			strvar=str(num)
			lst=strvar.split('.')
			return eval(lst[0])
			'''
			# 方法二
			if num >= 0:
				return math.floor(num)
			else:
				return math.ceil(num)
			# return math.floor(num) if num >= 0 else math.ceil(num)
		elif isinstance(num,str):
			if (num[0]=='+' or num[0]=='-') and num[1:].isdecimal():
				if num[0] == '+':
					sign=1
				else:
					sign=-1
				return self.calc(num[1:],sign)
		elif num.isdecimal():
			return self.calc(num)
		else:
			return '臣妾做不到啊'
myint=MyInt()
myint('000000000000000000000000000002132132')

5.bool 魔术方法
触发时机：使用bool（对象）的时候自动触发
功能：强转对象
参数：一个self接受当前对象
返回值：必须是布尔类型
类似的方法还有如下（了解）：
complex
int
float

class MyClass():
	def __bool__(self):
		return False
obj=MyClass()
res=bool(obj)
print(res)

6.add 魔术方法 （与之相关的__radd__反向加法）
触发时机：使用对象进行运算相加的时候自动触发
功能：对象运算
参数：二个对象参数
返回值：运算后的值
类似的方法还有如下：
sub(self,other)
mul(self,other)

class Myclass1():
	def __init__(self,num):
		self.num=num
	def __add__(self,other)
		return self.num + other
	def __radd__(self,other)
		return self.num*2 + other
# 第一种
a=MyClass(10)
res=a+7
print(res)
# 第二种
b=MyClass(5)
res=20+b
print(res)
# 第三种
res=a + b
print(res)
"""
23
次触发魔术方法, a+ =>触发__add__方法
self => a other => b
self.num + other => a.num+ b => 10 + b

res = 10 + b
第二次触发魔术方法 __radd__
self => b other=> 10
self.num * 2 + other => b.num*2 + other => 5 * 2 + 10 => 20
res = 20 
"""

7.len 魔术方法
触发时机：使用len（对象）的时候自定触发
功能：用于检测对象中或者类成员的个数
参数：一盒self接受当前对象
返回值：必须返回整形4
类似的还有如下：
iter
reversed
contains(self,item)

class MyClass():
	pty1=1
	pty2=2
	__pty3=3
	pty4=10
	pty=100
	def func1():
		pass
	def func2():
		pass
	def __func3():
		pass
	def __len__(self):
		lst=[]
		dic=MyClass.__dic__
		lst=[i for i in dic if not (i.starswish('__' and i.endswish('__'))]
		return len(lst)
obj=MyClass()
print(len(obj))
"""
{
'__module__': '__main__', 
'pty1': 1, 
'pty2': 2, 
'_MyClass__pty3': 3, 
'func1': <function MyClass.func1 at 0x7fc198171378>, 
'func2': <function MyClass.func2 at 0x7fc198171400>, 
'_MyClass__func3': <function MyClass.__func3 at 0x7fc198171488>, 
'__len__': <function MyClass.__len__ at 0x7fc198171510>, 
'__dict__': <attribute '__dict__' of 'MyClass' objects>, 
'__weakref__': <attribute '__weakref__' of 'MyClass' objects>,
'__doc__': None
}
"""

8.与类相关的魔术属性

class Man():
	pass
class Women():
	pass
class Children(Man,Woman):
	'''
	功能：描述小孩的天生属性
	成员属性：eye  skin
	成员方法：skylight moonread  __makebaby
	'''
	eye='血轮眼'
	skin='白色'
	def skylight(self):
		print('宇智波家族的小孩，天生能够发动天照技能')
	def moonread(self):
		print('宇智波家族的小孩，能够发动月亮的关照消灭你')
		res=func.__name__
		print(res,type(res))
	def __makebaby(self):
		print('这一招，只能我自己能用')
# __dict__获取对象或类的内部成员结构
obj=Children()
print(obj.__dict_)
print(Children.__dict__)
# __doc__获取对象或类的内部文档
print(obj.__doc__)
print(Children.__doc__)
# __name__获取类名函数名
def func111():
	print('我是func111方法')
# 获取函数名
obj.moodread(func111)
# 获取类名
obj.moodread(Man)
# __class__获取当前对象所属的类
print(obj.__class__)
# __bases__获取一个类直接继承的所有父类，返回元组
print(Children.__base__)