property练习

作业一：总结
1.什么是绑定到对象的方法，如何定义，如何调用，给谁用？有什么特性
2.什么是绑定到类的方法，如何定义，如何调用，给谁用？有什么特性
3.什么是解除绑定的函数，如何定义，如何调用，给谁用？有什么特性

# 1.
#在类中定义的(self)方法都是绑定到对象的方法
#定义
class 人:
    def 中国人(self):#绑定到对象的方法
        pass
#调用:
c = 人() #实例化
c.中国人()#调用对象,传参

# 2.
#静态方法和类方法都是绑定到类的方法
#静态方法定义:
class 类的静态函数:
    @staticmethod#调用装饰器staticmethod
    def 静态函数():#静态方法
        pass
#调用:
类的静态函数.静态函数()#不用实例化直接类函数名.就可以调用静态方法,静态方法是让类去调用的方法


22  #类方法定义:
class 类函数:
    @classmethod#定义类方法,需要调用装饰器classmethod
    def 类的方法(cls):#被classmethod修饰过的类的方法就是一个类方法
        pass
#调用:
类函数.类的方法()#不用实例化直接类函数名.就可以调用类方法
#类方法是与类绑定的方法,也给类调用的方法
#当类调用类方法时,会将当前调用方法的类当做第一个参数传递到方法中
# 3.什么是解除绑定的函数，如何定义，如何调用，给谁用？有什么特性
#定义在类的内部,并且被staticmethod修饰过的方法
#定义:
class 不带功能:
    @staticmethod
    def 不带(a,b,c):
        pass
#调用:
没有功能 = 不带功能.不带(1,2,3)
#or:
没功能 = 不带功能()
没功能1 = 没功能.不带(1,2,3)
#解除绑定方法不在自动传值

4.什么是property，如何定义，如何使用，给谁用，什么情况下应该将一个属性定义成property，有什么好处？

#什么propert?
class 属性类:
    def __init__(自身, 取=None, 赋=None, 删=None):
        自身.取 = 取
        自身.赋 = 赋
        自身.删 = 删

    def __get__(自身, 触发者, 所有者):
        return 自身.取(触发者)

    def __set__(自身, 触发者, 值):
        自身.赋(触发者, 值)

    def __delete__(自身, 触发者):
        自身.删(触发者)


class C:
    def __init__(自身):
        自身._x = None

    def 取(自身):
        return 自身._x

    def 赋(自身, 值):
        自身._x = 值

    def 删(自身):
        del 自身._x

    x = 属性类(取, 赋, 删)


if __name__ == '__main__':
    c = C()
    print(c.x)
    c.x = 'X=man'
    print(c.x)
    print(c._x)
    del c.x
#一般在__属性的情况下使用property,这样可以有效的隐藏,展示,控制__属性对用户的影响

如何定义，如何使用，给谁用，什么情况下应该将一个属性定义成property，有什么好处？

property(fget=None, fset=None, fdel=None, doc=None)

条条大路通罗马，同样是完成一件事，Python 其实提供了好几个方式供你选择。

property() 是一个比较奇葩的BIF，它的作用把方法当作属性来访问，从而提供更加友好访问方式。

官方帮助文档代码: 

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x
    def setx(self, value):
        self._x = value
    def delx(self):
        del self._x
    x = property(getx, setx, delx, "I'm the 'x' property.")

property() 返回一个可以设置属性的属性，当然如何设置属性还是需要我们人为来写代码。第一个参数是获得属性的方法 名(例子中是 getx)，

第二个参数是设置属性的方法名(例子中是 setx)，第三个参数是删除属性的方法名(例子中是 delx)。

property() 有什么作用呢?举个例子，在上边的例题中，我们为用户提供 setx 方法名来设置 _x 属性，

提供 getx 方法名来 获取属性。但是有一天你心血来潮，突然想对程序进行大改，可能你需要把 setx 和

getx 修改为 set_x 和 get_x，那你不得 不修改用户调用的接口，这样子的体验就非常不好。

有了 property() 所有问题就迎刃而解了，因为像上边一样，我们为用户访问 _x 属性只提供了 x 属性。

无论我们内部怎么改 动，只需要相应的修改 property() 的参数，用户仍然只需要去操作 x 属性即可，对他们来说没有任何影响。 

使用属性修饰符创建描述符 

使用属性修饰符创建描述符，也可以实现同样的功能.

官方帮助文档代码: 

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

注意:三个处理 _x 属性的方法名要相同(参数不同)。

 要求二：定义用户类，定义属性db，执行obj.db可以拿到用户数据结构

#要求一：自定义用户信息数据结构，写入文件，然后读出内容，利用eval重新获取数据结构
with open('user.db','w') as write_file:#创建并以写入的方式打开一个文件user.db
    write_file.write(str({
        "egon":{"password":"123",'status':False,'timeout':0},
        "alex":{"password":"456",'status':False,'timeout':0},
        }))#在user.db中加入两个用户信息以字典的方式储存

with open('user.db','r') as read_file:#以只读的方式打开一个文件user.db
    data=read_file.read()#读取user.db中的数据
    d=eval(data)#将user.db中的数据转为字典
    print(d['egon']['password'])#打印字典中egon的password 对应value
    print(d['egon']['status'])
    print(d['egon']['timeout'])

定义文件结构
#要求二：定义用户类，定义属性db，执行obj.db可以拿到用户数据结构
class User: #定义User类
    db_path='user.db'
    def __init__(self,username): #在实例化User类时,传入Username参数的值
        self.username=username
    @property#将db()方法作为属性,让用户调用
    def db(self):
        data=open(self.db_path,'r').read()#以只读的方式打开文件user.db
        return eval(data)#以字典的方式返回user.db中的内容
u=User('egon')#实例化对象u,传入egon
print(u.db['egon'])#打印又u.db()返回的字典中,对应egon的value
print(u.db['egon']['password'])#打印又u.db()返回的字典中,对应egon的password,value

获取用户信息

要求三：分析下述代码的执行流程

#要求三：分析下述代码的执行流程
import time
class User:#定义User类
    db_path='user.db'
    def __init__(self,name): #在实例化User类时,传入name参数的值
        self.name=name
    @property#将db()方法作为属性,让用户调用,同时产生db.setter和db.del方法
    def db(self):
        with open(self.db_path,'r') as read_file:#当调用db方法时,打开文件user.db
            info=read_file.read()
            return eval(info)#以字典的方式返回user.db中的用户信息
    @db.setter#在对db属性进行修改操作的时候,调用此方法
    def db(self,value):
        with open(self.db_path,'w') as write_file:#创建并打开一个文件user.db
            write_file.write(str(value))#在文件中写入db属性得到的值
            write_file.flush()#刷新文件的缓冲区域,让数据立刻写入文件
    def login(self): #定义login方法
        data=self.db#data得到db方法(现在被@property修饰过的属性)返回的user.db中的数据
        if data[self.name]['status']:#判断name的status字段是否为Ture
            print('已经登录')
            return True
        if data[self.name]['timeout'] < time.time(): #判断name的timeout字段值是否小于....呃~1970年到现在的时间
            count=0
            while count < 3:
                passwd=input('password>>: ')#输入密码
                if not passwd:continue#如果密码为空,那么重新循环到输入密码
                if passwd == data[self.name]['password']: #输入密码正确
                    data[self.name]['status']=True#更改用户的登陆状态
                    data[self.name]['timeout']=0#超时字段归0
                    self.db=data#将改写过的值重新调用db.setter方法存入user.db文件中,在用户看来就是对db属性进行了重新的赋值操作
                    break
                count+=1#只允许用户输入三次错误的机会
            else:
                data[self.name]['timeout']=time.time()+10#如果三次输入错误,那么该用户将被锁定10秒
                self.db=data#将改写过的值重新调用db.setter方法存入user.db文件中,在用户看来就是对db属性进行了重新的赋值操作
        else:#如果判断用户的timeout大于1970年到现在的值
            print('账号已经锁定10秒')

u1=User('egon') #实例化u1传入name,egon
print("egon login:")
u1.login()#u1调用login的方法

要求四：根据上述原理，编写退出登录方法（退出前要判断是否是登录状态），自定义property，供用户查看自己账号的锁定时间

#要求四：根据上述原理，编写退出登录方法（退出前要判断是否是登录状态），自定义property，供用户查看自己账号的锁定时间
import time
class User:#定义User类
    db_path='user.db'
    def __init__(self,name): #在实例化User类时,传入name参数的值
        self.name=name
        print("%s Login:"%self.name)
    @property#将db()方法作为属性,让用户调用,同时产生db.setter和db.del方法
    def db(self):
        with open(self.db_path,'r') as read_file:#当调用db方法时,打开文件user.db
            info=read_file.read()
            return eval(info)#以字典的方式返回user.db中的用户信息
    @db.setter#在对db属性进行修改操作的时候,调用此方法
    def db(self,value):
        with open(self.db_path,'w') as write_file:#创建并打开一个文件user.db
            write_file.write(str(value))#在文件中写入db属性得到的值
            write_file.flush()#刷新文件的缓冲区域,让数据立刻写入文件
    @property
    def UserLockTime(self):
        return int(self.db[self.name]["timeout"]-time.time())
    def loginOut(self):
        data = self.db
        if(data[self.name]['status']):
            print(self.name, "正在登出.....")
            data[self.name]['status'] = False
            self.db = data
            time.sleep(2)
            print(self.name,"登出成功!")
        else:
            print(self.name,"并没有登陆")
    def login(self): #定义login方法
        data=self.db#data得到db方法(现在被@property修饰过的属性)返回的user.db中的数据
        if data[self.name]['status']:#判断name的status字段是否为Ture
            print('已经登录')
            return True
        if data[self.name]['timeout'] < time.time(): #判断name的timeout字段值是否小于....呃~1970年到现在的时间
            count=0
            while count < 3:
                passwd=input('password>>: ')#输入密码
                if not passwd:continue#如果密码为空,那么重新循环到输入密码
                if passwd == data[self.name]['password']: #输入密码正确
                    data[self.name]['status']=True#更改用户的登陆状态
                    data[self.name]['timeout']=0#超时字段归0
                    self.db=data#将改写过的值重新调用db.setter方法存入user.db文件中,在用户看来就是对db属性进行了重新的赋值操作
                    print("欢迎%s登陆,马上为您进行登出服务"%self.name)
                    time.sleep(3)
                    break
                count+=1#只允许用户输入三次错误的机会
            else:
                data[self.name]['timeout']=time.time()+20#如果三次输入错误,那么该用户将被锁定20秒
                self.db=data#将改写过的值重新调用db.setter方法存入user.db文件中,在用户看来就是对db属性进行了重新的赋值操作
        else:#如果判断用户的timeout大于1970年到现在的值
            print('账号已经锁定20秒,剩余%s秒'%self.UserLockTime)
u1=User('egon') #实例化u1传入name,egon
u1.login()#u1调用login的方法
u1.loginOut()#u1调用loginOut方法
u2=User('alex')
u2.login()

三次登陆Property功能升级版