python学习第23天

1.1del 魔术方法

触发时机:当对象被内存回收的时候自动触发[1.页面执行完毕回收所有变量 2.所有对象被del的时候]
功能：对象使用完毕后资源回收
参数：一个self接受对象
返回值：无

(1)页面执行完毕回收所有变量

class LangDog():
   food = "吃肉"
   def __init__(self,name):
      self.name = name
      
   def __del__(self):
      print("析构方法被触发..")
obj = LangDog("刀疤")
print(obj.name)

(2)所有对象都被del的时候

当一个值,没有任何变量指向或者引用,这个值才会被真正的释放

other_obj = obj
print(other_obj is obj)
print("<==start==>")
#del obj
#del other_obj   # 在中间打印析构方法被触发
#print("<==end==>")

(3)模拟文件操作

# fp = open(文件,模式,编码)
# fp.read()
# fp.close()
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):    
      # 读取文件操作
      content = self.fp.read()
      return content
      
   def __del__(self):
      self.fp.close()
      

      
obj = ReadFile("ceshi.txt")
#res = obj.readcontent()
#print(res)

1.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,self.gift)

tom = Cat("汤姆")
# 触发方式一, print 打印该对象
# print(tom)
# 触发方式二, str
res = str(tom)
print(res)

1.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)
      
   # 在系统底层,如果定义了repr , 将会默认赋值给str方法.
   # __str__ = __repr__
      

# repr强转obj对象时触发      
obj = Mouse("杰瑞")
res = repr(obj)
print(res)

# 注意点 底层存在赋值调用给str的语法,所以能实现打印或者str强转对象的触发机制.
print(obj)
res = str(obj)
print(res)

1.4 call 魔术方法

触发时机：把对象当作函数调用的时候自动触发
功能: 模拟函数化操作
参数: 参数不固定,至少一个self参数
返回值: 看需求

(1)基本语法

class MyClass():
   a = 1
   """"""
   def __call__(self):
      print("call魔术方法被触发..") 

obj = MyClass()
obj()

(2)模拟洗衣服的过程

class Wash():

   # 用call魔术方法统一调用
   def __call__(self,something):
      self.step1(something)
      self.step2()
      self.step3()

   def step1(self,something):
      print("脱衣服,洗{}".format(something))
      
   def step2(self):
      print("放水里,扔点洗衣液,洗衣粉,蓝月亮")
      
   def step3(self):
      print("扭干净,穿上")

obj = Wash()
obj("裤衩")

(3)模拟内置方法 int 实现myint

import math
class MyInt():

   def mycalc(self,num,sign=1):
      # 去掉左边多余的0
      strvar = num.lstrip("0")
      if strvar == "":
         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)        
         return strvar.split(".")[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.mycalc(num[1:],sign)
            
         elif num.isdecimal():
            return self.mycalc(num)
            
         else:
            return "老铁,这个真不能转~"
               
      

myint = MyInt()
print(  myint(0)  ) #=> 3
print(  myint(3.13)  ) #=> 3
print(  myint("+00000000000000000001003")  ,"<==1=>")
print(  myint("+abcd")  ,"<===>")
print(  myint("-0000000000000000000.1003")  ,"<==2=>")
print(  int("0000000000000000000003")  )
print(  int("+0000000000000000000003")  )
# print(  int("+-+-+-+-+-+-1233444")  )
print(  myint("+-+-+-+-+-+-1233444")  )

1.5 bool 魔术方法

触发时机：使用bool(对象)的时候自动触发
功能：强转对象
参数：一个self接受当前对象
返回值：必须是布尔类型

类似的还有如下等等(了解):
   __complex__(self)      被complex强转对象时调用
   __int__(self)          被int强转对象时调用
   __float__(self)        被float强转对象时调用
   ...
   ...

(1)基本语法

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

1.6 add 魔术方法(一直相关的 radd 反向加法)

触发时机：使用对象进行运算相加的时候自动触发
功能：对象运算
参数：二个对象参数
返回值：运算后的值

类似的还有如下等等(了解):
   __sub__(self, other)           定义减法的行为：-
   __mul__(self, other)           定义乘法的行为：
   __truediv__(self, other)       定义真除法的行为：/
   ...
   ...

(1)基本语法

class MyAdd():
   def __init__(self,num):
      self.num = num

   # 对象在加号+左侧的时,自动触发
   def __add__(self,other):
      return self.num + other
      
   def __radd__(self,other):
      return self.num + other*2
      
# 情况一
a = MyAdd(7)
# self 接受a   other接受7 , 触发的是__add__方法
# 情况二
# res = a + 7
# self 接受a   other接受7 , 触发的是__radd__方法
# res = 7 + a
# print(res)
# 情况三
"""
a+b 先触发 __add__  ,self 接受的7 , other 接受的是b
res = 7+b

7+b 再触发 __radd__ ,self 接受的b , other 接受的是7
return  8+7*2 = 22
res = 22

"""
b = MyAdd(8)
res = a+b
print(res,"<111222>")

1.7 len 魔术方法

触发时机：使用len(对象)的时候自动触发 
功能：用于检测对象中或者类中成员的个数
参数：一个self接受当前对象
返回值：必须返回整型

类似的还有如下等等(了解):
   __iter__(self)                 定义迭代容器中的元素的行为
   __reversed__(self)             定义当被 reversed() 调用时的行为
   __contains__(self, item)       定义当使用成员测试运算符（in 或 not in）时的行为
   ...
   ...

(1)计算一下类中所有自定义成员的个数

class MyClass():
   pty1 = 1
   pty2 = 2
   __pty3 = 3
   
   def func1():
      pass
      
   def func2():
      pass
   def __func3():
      pass
   
   def func4():
      pass
      
   def __len__(self):
      # print(MyClass.__dict__)
      # lst = []
      # for i in MyClass.__dict__:
         # print(i)
         # if not(  i.startswith("__") and i.endswith("__")  ):
            # lst.append(i)
            
      # print(lst)   
      
      # 简写
      lst = [i for i in MyClass.__dict__ if not(  i.startswith("__") and i.endswith("__")  )]
      return len(lst)
      
obj = MyClass()
print(   len(obj)  )

1.7 与类相关的魔术属性

class Man():
   pass

class Woman():
   pass

class Children(Man,Woman):

   """
   成员属性: eye 
   成员方法: skylight moonread __makebaby
   完成的功能: 描述小孩天生神力.
   """

   eye = "血轮眼"
   
   def skylight(self):
      print("一下生,直接使用天照,让世界变得混乱")
      
   def moonread(self,func):
      print("一下生,使出了武功绝学,月读,世界都黑暗里~")
      print(func.__name__ , type(  func.__name__  )) # earth_boom
   
   def __makebaby(self):
      print("这一手招数,只能我自己用")

obj = Children()

(1) dict 获取对象或类的内部成员结构

print(obj.__dict__)
print(Children.__dict__)
{}
{'__module__': '__main__', '__doc__': '
	成员属性: eye 
	成员方法: skylight moonread __makebaby
	完成的功能: 描述小孩天生神力.
	', 'eye': '血轮眼', 'skylight': <function Children.skylight at 0x00000139CE28D8C8>, 'moonread': <function Children.moonread at 0x00000139CE28D950>, '_Children__makebaby': <function Children.__makebaby at 0x00000139CE28D9D8>}

(2) doc 获取对象或类的内部文档

print(obj.__doc__)
print(Children.__doc__)
	成员属性: eye 
	成员方法: skylight moonread __makebaby
	完成的功能: 描述小孩天生神力.
	

(3) name 获取类名,函数名

def earth_boom():
   print("使出一招地爆天星")
obj.moonread(earth_boom)
obj.moonread(Children)
一下生,使出了武功绝学,月读,世界都黑暗里~
earth_boom <class 'str'>
一下生,使出了武功绝学,月读,世界都黑暗里~
Children <class 'str'>

(4) class 获取当前对象所属的类

print(obj.__class__)
<class '__main__.Children'>

(5) bases 获取一个类直接继承的所有父类,返回元组

print(Children.__bases__) # (<class '__main__.Man'>, <class '__main__.Woman'>)