面向对象一些零散的知识点

print('封装的一些装饰器')
'''
BMI指数:
体脂指数:体重(KG) / 身高 的平方 (米)
过轻:低于18.5
正常:18.5-23.9
过重:24-27
肥胖:28-32
非常肥胖:高于32

'''
class People:
    def __init__(self,name,weight,height):
        self.name = name
        self.weight = weight
        self.height = height

    def bmi(self):
        BMI= self.weight / (self.height**2)
        return BMI

obj = People('szp',68.3,1.69)
print(obj.bmi())
###现在这样,我们要得到一个对象的BMI指数,就像调用一个函数功能一样
###但是事实是一个对象的BMI 指数和他的名称  年龄 体重一样,只是一个变量
##我们现在定义成这种函数,功能显然是不合理的,我们要把他变成可以直接使用的属性 而不是需要调用的功能

print('添加装饰器的做法:')
class People:
    def __init__(self,name,weight,height):
        self.name = name
        self.weight = weight
        self.height = height

    @property
    def bmi(self):
        BMI= self.weight / (self.height**2)
        return BMI

obj = People('szp',68.3,1.69)
print(obj.bmi)
##注意  之前我们得到BMI指数需要obj.bmi()  加括号执行才能得到,现在我们
###只需要直接obj.bmi就可以拿到相应的值,也就是把原来的函数功能装饰装饰
###成了一个属性,这样更好


"""
了解:
class People:
    def __init__(self,name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self,obj):
        if not type(obj)  == str:
            print('名字必须是字符串类型')
            return
        self.__name = obj
        print('修改成功')

    @name.deleter
    def name(self):
        # print('不能删除名字')
        del self.__name

obj = People('szp')
print(obj.name)
obj.name = 'owen'
print(obj.name)

# del obj.name
print(obj.name)

####用以上这种写法,就将查看名字  修改名字  删除名字 三个函数功能统一到一起了
###也可以采用下面这种做法
print('另一种比较老的做法')
class People:
    def __init__(self,name):
        self.__name = name

    def get_name(self):
        return self.__name

    def change_name(self,obj):
        if not type(obj)  == str:
            print('名字必须是字符串类型')
            return
        self.__name = obj
        print('修改成功')

    def del_name(self):
        # print('不能删除名字')
        del self.__name

    name = property(get_name,change_name,del_name)

obj = People('szp')
print(obj.name)
obj.name = 'owen'
print(obj.name)
del obj.name
print(obj.name)
###我个人觉得这种做法还好一些

绑定方法与非绑定方法
classmethod 与staticmethod 
类中定义的函数有两大类(三小种),一类是绑定方法,令一类是非绑定方法
1,绑定方法
特殊之处:绑定给谁,就应该由谁来调用,谁来调用,就会将谁当做第一个参数自动传入
    1.1 绑定给对象的 :类中定义的函数默认就是给绑定对象的
    1.2 绑定给类的  :在类中定义的函数加一个装饰器  classmethod  

2,非绑定方法
    staticmethod 静态方法 非绑定方法
    既不与对象绑定也不与类绑定,没有绑定关系,没有自动传值的功能,类和对象都可以调用,

"""
class Foo:

    def func1(self):
        print('绑定给对象的',self)
        pass
    ###什么操作也不做,这种默认是给对象绑定的方法
    ###默认由类来调用,第一个参数默认传对象名

    @classmethod
    def func2(cls):
        print('绑定给类的',cls)
        pass
    ####被@classmethod 修饰的方法是给类绑定的,默认由类来调用,第一个参数
    ###自动传值类名

    @staticmethod
    def func3():
        print('这就是一个普通的函数')

        pass
    ####被staticmethod装饰的称之为静态方法,这种静态方法不会自动传值

obj = Foo()
obj.func1()####绑定给对象的建议用对象调用
Foo.func2()###绑定给类的建议用类调用
obj.func3()
Foo.func3()###普通函数类和对象都可以调用

'''
两个内置函数
'''

class Foo:
    pass

class Bar(Foo):
    pass

obj = Bar()
print(isinstance(obj,Bar))###判断一个对象是否是属于该类
print(issubclass(Bar,Foo))####判断一个类是否是另一个类的子类

'''
面向对象高级:反射  
反射:指的是通过字符串来操作属性
# class Foo:
#     pass
#
# class Bar(Foo):
#     pass
#
# obj=Bar()
#
# # print(isinstance(obj,Bar))
# # print(isinstance([],list))
#
# print(issubclass(Bar,Foo))
# 反射:指的是通过字符串来操作属性
class Foo:
    def __init__(self,name):
        self.name=name


obj=Foo('egon')


# hasattr()
# print(hasattr(obj,'name')) #'name' in obj.__dict__

# getattr()
# print(getattr(obj,'name')) #obj.__dict__['name']
# print(getattr(obj,'age')) #obj.__dict__['age']
# print(getattr(obj,'age',None)) #obj.__dict__['age']

# setattr()
# setattr(obj,'age',18) #obj.age=18
# setattr(obj,'name','EGON') #obj.name='EGON'
# print(obj.__dict__)

# delattr()
# delattr(obj,'name')# del obj.name
# print(obj.__dict__)

class Ftp:
    def get(self):
        print('get')

    def put(self):
        print('put')

    def login(self):
        print('login')

    def run(self):
        while True:
            choice=input('>>>: ').strip()
            if hasattr(self,choice):
                method=getattr(self,choice)
                method()
            else:
                print('命令不存在')


obj=Ftp()
obj.run()

'''
'''
面向对象两个比较重要的内置方法

一,__str__
二.__del__


'''
# __str__：在对象被打印时自动触发，然后将该绑定方法的返回值(必须是字符串类型)当做本次打印的结果

# class People:
#     def __init__(self,name,age):
#         self.name=name
#         self.age=age
#
#     def __str__(self):
#         return '<name:%s age:%s>' %(self.name,self.age)
#
# obj1=People('egon',18)
# obj2=People('lxx',38)
#
# print(obj1) #print(obj1.__str__())
# print(obj2) #print(obj2.__str__())

# l=list([1,2,3])
# print(l)


# __del__：在对象被删除前自动触发, 在该方法内应该执行与该对象有关的系统资源的回收操作
class Foo:
    def __init__(self,filename,encoding='utf-8'):
        self.f=open(filename,'r',encoding=encoding)

    def __del__(self):
        # print('run.....')
        self.f.close()

obj=Foo()
del obj #obj.__del__()
print('其他代码1')
print('其他代码2')
print('其他代码3')
print('其他代码4')
#obj.__del__()