5.7笔记+day11作业

#常用魔术方法
#1、__del__当一个对象在内存中被销毁的时候自动执行

class A():
    count=0
    def __init__(self,name):
        self.name=name
        A.count+=1
    def __del__(self):
        A.count-=1
        print("删除了",self.name,"还剩",A.count)
a=A("张三")
b=A("李四")

#2、call：让类的实例具有函数的行为

class A():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __call__(self,x):
        print("我被调用了",x)
a=A("张三",13)
a(10)

#__call__的斐波那契函数应用

class Fib():
    def __init__(self):
        pass
    def __call__(self,num):
        a,b=1,1
        self.lb=[]
        if num==1:
            self.lb.append(1)
        elif num==2:
            self.lb.append(1)
            self.lb.append(1)
        else:
            x=1
            while x<=num:
                self.lb.append(a)
                a,b=b,a+b
                x+=1
        return self.lb

f=Fib()
print(f(10))

#__str__方法使用print（对象）或者str（对象）的时候触发
#repr()方法：改变对象的字符串显示，此方法是__str__的备胎

class Person():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return "我叫{}，今年{}".format(self.name,self.age)
    def __repr__(self):
        s="repr 我叫%s，年龄%d"%(self.name,self.age)
        return s
a=Person("刘德华",18)
x="%s"%(a)
y="%r"%(a)
print(x)
print(y)

#new()方法 在实例化时触发，没事不要用这个方法，先触发__new__才会触发__init

class Stu():
    def __new__(cls, *args, **kwargs):
        print("我在new",cls)
        return object.__new__(cls)
    def __init__(self,name):
        print("我在init")
        self.name=name
s=Stu("张三")

#单例模式

class Stu():
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,"inst"):
            cls.inst=object.__new__(cls )
        print(cls.inst)
        return cls.inst
    def __init__(self,name):
        print("我在init")
        self.name=name
a=Stu("张三")
b=Stu("李四")
print(a==b)#True
print(a is b)#True
print(a.name)#李四
print(b.name)#李四

# is 和 == 的区别
is比较的是两个对象的 id值是否相等，是否只想同一个内存地址
== 比较的是两个对象的内容是否相等，即内存地址可以不一样，内容一样就可以了
默认会调用__eq__()方法，继承自object的__eq__方法比较的是两个对象的id

class A():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __eq__(self, other):
        if self.name==other.name and self.age==other.age:
            print("姓名年龄值相同",end="")
            return True
        else:
            return False

a=A("张三",15)
b=A("李四",15)
c=A("张三",15)
#a和b的值相同
print(a==b)#False
print(a==c)#姓名年龄值相同True
#三个对象的id不同
print(id(a))
print(id(b))
print(id(c))

class A():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __eq__(self, other):
        print(self.__dict__)
        return self.__dict__==other.__dict__

a=A("张三",18)
b=A("李四",18)
c=A("张三",18)
print(a==b)
print(a==c)
print(id(a))
print(id(b))
print(id(c))

#hash(哈希)
a="123"
b=hash(a)
print(b)

a={"qwe":"qwe"}
print(a)

a={1:"we"}
print(a)

a={(1,2):"wer"}
print(a)

#以上几种形式都可以被哈希，但是下面的列表是不可以被哈希的
a={[1,2,3]:"sdfg"}
print(a)#报错 TypeError: unhashable type: 'list'

class Stu():
    def __init__(self,name):
        self.name=name
    def __eq__(self, other):
        return self.name==other.name
    def __hash__(self):
        return hash(self.name)
a=Stu("张三")
b=Stu("李四")
c=Stu("张三")
d={a,b,c}
print(a)
print(b)
print(c)
print(d)

#类的常用函数
#issubclass:检测一个类是否是另外一个类的子类
#isinstance：检测一个对象是否是某个类的对象
class A():

    pass
class B(A):
    pass
class C():
    pass
print(issubclass(B,A))#True
print(issubclass(C,A))#False

a=A()
c=C()
print(isinstance(a,A))#True
print(isinstance(c,A))#False

#反射方法
#hasattr 判断是否有此变量，返回bool值
#getattr 获取属性值或者获取方法变量的地址
#setattr 给类或者对象设置属性或方法
#delattr 删除类或对象的属性或方法

#1、hasattr

class A():
    dic={"查看学生信息":"func1","查看教师信息":"func2"}
    def func1(self):
        print("学生信息")
    def func2(self):
        print("教师信息")

zs=A()
func=input("请输入：")
if hasattr(zs,zs.dic.get(func)):
    f=getattr(zs,zs.dic[func])
    f()
else:
    print("无此功能")

#2、getattr

 class Teacher():
    dic={"name":"cc","age":18}
    def __init__(self,name,age):
        self.name=name
        self.age=age
    @classmethod
    def func1(cls):
        print("hehe")
    def func2(self):
        print("haha")
a=Teacher("张三",23)
d=getattr(Teacher,"dic")
e=getattr(a,"name")
print(d)
print(e)   

#3、setattr

class A():
    pass
setattr(A,"count",100)
print(A.count)#100

a=A()
setattr(a,"sxx",200)
print(a.sxx)#200

#4、delattr

class Teacher():
    Tax=100
    def __init__(self,name,age):
        self.name=name
        self.age=age
zs=Teacher("张三",32)
print(Teacher.Tax)#100
delattr(Teacher,"Tax")
print(Teacher.Tax)#报错，因为已经删除了
print(zs.name)#张三
delattr(zs,"name")
print(zs.name)#报错，同样是已经删除了

#反射导入模块中的属性，函数，类
#假设在test.py文件中有如下代码：

day="周一"
def func():
    print("哈哈")
class A ():
    def func1(self):
        print("1234")

#在本文件中反射这些属性、模块和类

import test
print(test.day)

func=getattr(test,"func")
func()

A=getattr(test,A)
a=A()
a.func1()

#反射自己模块中的属性和函数
#查看所有模块

import sys
print(sys.modules)

#反射函数
def func():
    print("哈哈哈")
fun=getattr(sys.modules['__main__'],"func")
func()

#反射内置模块
这里导入time 中的time（）

import time
print(time.time())
t=getattr(time,"time")
print(t())

#作业
魔术方法 __del__练习

class Dwj:

    # 打开文件(构造)
    def __init__(self, a):
        # 打开文件将文件io对象保存在对象成员
        self.fp = open(a, 'r')

    # 读取文件
    def fread(self):
        return self.fp.read()

    # 关闭文件(析构)
    def __del__(self):
        print('关闭文件操作')
        self.fp.close()

import os
one = Dwj(os.getcwd() + "\\dd.txt")
txt = one.fread()
print(txt)

魔术方法 eq 方法练习

class A(int):
    def __eq__(self, other):
        if self % 6 == 0 and other % 6 == 0:
            return True
        else:
            return False

a =A(24)
b =A(12)
print(a==b)

魔术方法 hash 和 __eq__练习
#设计二维坐标类Point，比较2个坐标是否相等？

class Point(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __hash__(self):
        return hash((self.x, self.y))

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y


p1 = Point(3,4)
p2 = Point(3,4)
print(hash(p1))
print(hash(p2))  # p1,p2 哈希值相同
print(p1 is p2)  # False
print(p1 == p2)  # True