类 未修改

#子类与父类
class People:
    def __init__(self,name="爸爸"):
        self.age = 99
        self.name = name
        self.sex = "男"
        print("父类初始化")
    def out(self):
        print("父类下的name：%s"%(self.name))
    def outage(self):
        print(self.age)

class Student(People):
    def __init__(self,name,age):
        super().__init__(name)
        self.name = name
        self.age = age
        
        print("子类初始化")
    def out(self):
        print("子类下的name：%s"%(self.name))
        super().out()
        People(self.name).out()
        
        super().outage()
        print(super().outage())  # 这一行报错，我想在子类方法内输出父类属性
        print(People().name)
s = Student("wusen",18)
s.out()
"""
子类初始化父类：super().__init__(参数)  
子类内部不可以调用父类属性
子类内部可以调用父类方法 super().fun1()
"""

""" 组合：把一个类的 对象当成另外一个类的属性"""

""" Java里面的接口跟 python继承差不多"""
#https://pypi.org/project/zope.interface/
#抽象类只能被继承不可以被 实例化
import abc
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def eat(self):
        pass
    @abc.abstractmethod
    def sleep(self):
        pass
class Pig(Animal):
    def __init__(self):
        super().__init__()
        
    def eat(self):
        print("猪在吃 饭")
    def sleep(self):
        print("猪在睡觉")
pig1=Pig()
pig1.eat()

        








""" 第二特性 多态 """
#一个类有多个形态   就叫多态
#就跟上面那个抽象类接口里面的方法一样 就是多态性
#记住形参与实参  能把变量归一化
def function(animal):
    animal.sleep()


"""鸭子类型：就是不继承，跟上面效果一样"""
class Text:
    def read(self):
        pass
    def write(self):
        pass
class Disk:
    def read(self):
        pass
    def write(self):
        pass
        


""" 第三大特性 封装 """


    #属性隐藏
class A:
    __name="wusen"
    age=100
    
a=A()
a.age
A.__dict__
#在类内部可以直接使用
#他会把__name 变成 _类__name
#子类无法覆盖父类__开头的属性
a._A__name
#类之后定义就不会变形
a.__y="sadas"
print(a.__y)

""" 这样玩还可以 """
class A:
    def __fun1(self):
        print("A.fun1")
    def fun2(self):
        print("A.fun2")
        self.__fun1()
class B(A):
    def fun1(self):
        print("B.fun1")
b=B()
b.fun2()
""" 隐藏是为了分离内外，
不让他直接访问修改
比如：取款函数   将插卡细节隐藏

"""





""" 装饰器property"""
#把函数当成属性
class People:
    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)
p=People("wusen",1.70,70)
p.bmi
#不可以给p.bmi=22  不可以这样写
class People:
    def __init__(self,name,age):
        
        self.__name=name
        self.__age=age
        self.name
    @property
    def name(self):
        print("#"*100)
        return self.__name
    @name.setter
    def name(self,value):
        self.__name=value
    @name.deleter
    def name(self):
        print("不可以删除")
p=People("w",11)
p.name="wusen"
del p.name
p.name 
    
    

"""绑定与非绑定"""
#绑定
#非绑定
class Foo:
    def __init__(self):
        self.name="wusen"
        print("初始化")
    def fun1(self):
        print("fun1")
        print(self.name)
    @classmethod
    def fun2(a):#形参写啥都可以，一般他写cls
        print(a)
        print("fun2")
    @staticmethod#这就是非绑定方法
    def fun3():
        print("fun3")



f=Foo()
f.fun1
f.fun2
f.fun1()
f.fun2()

print(Foo.fun1)
print(Foo.fun2)
print(Foo.fun2())
print(Foo.fun1(f))

Foo.fun3
f.fun3
f.fun3(f)
"""
def   绑定对象:
绑定方法 classmethod 绑定类
非绑定 statucmethod 类和对象都可以调用 ==》就是把类外的函数封装到类内
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++
"""
import hashlib
import time
h=hashlib.md5(str(time.time()).encode("utf-8"))
h.hexdigest()









""" 反射 
需求：用户输入 s="name"
调用
obj.name
而不是obj."name"

"""
class People:
    def __init__(self):
        self.name="wusen"
        self.age=24
    def tell(self):
        print("dsada")
        
p=People()
hasattr(p,"tell") #判断p下有没有这个属性

getattr(p,"nameq","不存在")#不存在就报错了
    fun=getattr(p,"tell","不存在")
    fun()

setattr(p,"namae","asdasd")#不存在也没啥事创建新属性

delattr(p,"namaae")#不存在会报错
    

内置对象

一、isinstance(obj, cls)
检查obj是否是类 cls 的对象

class Foo(object):
    pass
obj = Foo()
isinstance(obj, Foo)
二、issubclass(sub,super)
检查sub类是否是 super 类的派生类

class Foo(object):
    pass
class Bar(Foo):
    pass
issubclass(Bar, Foo)




"item系列 去操作属性  变成字典"
class Foo:
    def __init__(self):
        self.name="wusen"
    def __getitem__(self,item):
        print("getitem",item)
        return self.__dict__[item]
    def __setitem__(self,key,value):
        print(key,value)
    def __delitem__(self,key):
        print(key)

obj=Foo()
obj.__dict__
obj.name
obj["namea"]

#将类变成字典
class People:
    def __init__(self):
        self.name="wusen"
        self.age=24
        
    def __str__(self):
        print("*")
        return "结束"
    def __del__(self):
        print("已删除")
p=People()
print(p)
del p






exec("""print("Nishigouu")""")