python基础 ---- property特性 使用

作业一：总结

1.什么是绑定到对象的方法，如何定义，如何调用，给谁用？有什么特性
  1.1 绑定到对象的方法：只要是在类内部定义的，没有被装饰器装饰过的方法，都是绑定到对象的。
  1.2 调用 ：对象.对象的绑定方法，
  1.3 给谁用：给对象用
  1.4 特性 ： （自动传值）调用时会把对象本身当做第一个参数自动传给绑定到对象方法

class Foo:
    def test(self):   #绑定到对象的方法
        print("hello world")
    def test1():  # 绑定到对象的方法，test1本身没有参数，调用时把对象本身自动传给test1，
                  # test1没有参数，会抛出不需要参数，但是给了一个参数的错误
        print("hello friend")
msg = Foo()  #把Foo类 实例化为msg对象
msg.test()   #使用方法 ，msg.test() ， msg是对象，test()是msg的绑定方法，调用时，把msg自动传给self
#msg.test1()   # 调用

2.什么是绑定到类的方法，如何定义，如何调用，给谁用？有什么特性

  2.1  绑定到类的方法：在类内部定义的，被@classmethod装饰器修饰过的方法，都是绑定到类的方法

  2.2 调用 ：1）类名.绑定到类的方法 2）对象.绑定到对象的方法， 都可以调用

  2.3 给谁用：给类本身用，也可以给对象用

  2.4 特性：（自动传值）调用时会把类本身当做第一个参数自动传给绑定到类的方法

class Foo:
    def test(self):   #绑定到对象的方法
        print("hello world")

    @classmethod   #把一个方法绑定给类
    def test1(cls):  # 绑定到类的方法，
        print("hello friend")
msg = Foo()  #把Foo类 实例化为msg对象
msg.test1()   #使用方法 ，msg.test1() ， msg是对象，test1()是msg的绑定方法，调用时，把msg自动传给self
Foo.test1()   #使用方法，Foo.test1(),Foo是类名，test1()是类的绑定方法，调用时会把Foo本身传给cls
# msg.test1() ,Foo.test1(),都是在调用类的绑定方法，结果是一样的

3.什么是解除绑定的函数，如何定义，如何调用，给谁用？有什么特性

  3.1 解除绑定的方法：在类内部定义的，使用@staticmethod装饰器修饰过的，就是解除绑定对象的函数方法

  3.2 特性：无论是类 或者对象，调用时 就不自动传值了,@staticmethod就是相当于一个普通的工具包

  3.3 既不与类绑定，也不与对象绑定，相当于一个普通的函数，对象可以用，类也可以用

class Foo:
    def test(self,name):  #绑定到对象的方法
        print("hello %s" %(name))
    @classmethod    #绑定到类的方法
    def test1(cls,name):
        print("hello %s" %(name))
    @staticmethod   #解除绑定的方法， 这时test2 就是一个普通的函数，既不与类绑定，也不与对象绑定
    def test2(name):
        print("hello %s" %(name))
msg = Foo()
msg.test("alex")  # 绑定到对象的方法：自动把msg这个对象传给self，alex传给name了
Foo.test1("egon")  # 绑定到类的方法：自动把Foo这个类名传给cls，egon传给name了
msg.test2("瞎驴")   #对象.test2 ：把瞎驴传给name，test2有几个参数，就需要传几个参数
Foo.test2("钢弹")   #类.test2 ：把钢弹传给name

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

  4.1 property是一个内置函数，在类内部的方法上，加上@property装饰器，name这个方法就变成一个属性了

  4.2 用法：@property 　　在类，或者可调用对象上面加上@property

  4.3 被@property装饰器装饰过的属性，在被调用时，会优先于对象的属性被使用，

  4.4 好处：对于使用者来说，把访问方法统一了，封装，把真实的逻辑伪装起来了，让使用者以为就是用的就是数据属性，美化程序

  

class People:
    '''计算BMI值'''
    def __init__(self,name,age,height,weight):
        '''初始化name,age,height,weight'''
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight
    @property
    def boyindex(self):
        BMI = self.weight/(self.height**2)
        if BMI < 18.5:
            print("体重过轻")
        elif BMI < 24 and BMI >=18.5:
            print("正常范围")
        elif BMI > 24:
            print("体重超重")
        return BMI

s1 = People("egon",25,1.75,56)
print(s1.boyindex)   #调用property修饰过的boyindex
#执行结果
# 体重过轻
# 18.285714285714285

 4.5 使用property 延伸出，setter，deletle  ，后面这俩函数，使用的时候需要加上被property修饰了的方法名

#被property 装束的属性 会优先于对象属性被使用
# 而被property装饰的属性，如sex分为三种
# 1，@property  查看
# 2，@sex.setter  修改
# 3，@sex.deleter  删除

class People:
    def __init__(self,name,sex):
        self.name = name
        self.__sex = sex

    @property  #查看
    def sex(self):
        return self.__sex

    @sex.setter  #修改
    def sex(self,value):
        if not isinstance(value,str):
            raise TypeError("sex is str")  #主动抛出异常
        self.__sex = value

    @sex.deleter  #删除
    def sex(self):
        del self.__sex

p1 = People("egon","male")
print(p1.sex)  #执行结果： male  调用的@property下的sex
p1.sex = "female"  # 把sex初始化的male修改成female
print(p1.sex)  #执行结果：female   调用@sex.seltter下的sex
del p1.sex    #  删除 __sex 
print(p1.sex)   #结果：报错，因为已经把__sex删除了，所以找不到
                # AttributeError: 'People' object has no attribute '_People__sex'

作业二：

要求一：自定义用户信息数据结构，写入文件，然后读出内容，利用eval重新获取数据结构

#要求一：自定义用户信息数据结构，写入文件，然后读出内容，利用eval重新获取数据结构

with open('user.db','w') as write_file:  #以覆盖写的模式打开user.db文件，存储到write_file变量中
    write_file.write(str({
        "egon":{"password":"123",'status':False,'timeout':0},
        "alex":{"password":"456",'status':False,'timeout':0},
        }))  #把上述内容以字符串格式写入到write_file文件中，保存 关闭文件

with open('user.db','r') as read_file: # 以的读的模式打开user.db文件，存储到read_file变量中
    data=read_file.read()     #读取文件的全部内容
    d=eval(data)              # 把字符串转化为dict类型
    print(d['egon']['password'])   #123
    print(d['egon']['status'])     #Flase
    print(d['egon']['timeout'])    #0

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

class User:
    '''查看用户信息'''
    db_path = "user.txt"  #只是把文件存到变量中，什么都没干
    def __init__(self,user_name,):
        '''初始化用户名字'''
        self.name = user_name

    @property      #修饰db，变成数据属性
    def db(self):
        data = open(self.db_path,"r").read()   #打开db_path变量中的文件，读取文件
        d = eval(data)   #把文件内容转换成dict数据类型
        return d
        data.close()      #关闭文件

e = User("egon",)
a = User("alex")
print("%s data :"%(e.name))
print(e.db["egon"])
print("%s data :"%(a.name))
print(a.db["alex"])

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

import time  #导入时间模块


class User_login:
    '''锁定用户，限制时间登录'''
    user_path = "user.txt"
    def __init__(self,user_name):
        self.name = user_name

    @property
    def tall_user(self):        #查看锁定时间
        with open("user.txt","r") as f:
            data = f.read()
            data = eval(data)
            ti = int(data[self.name]["timeout"]-time.time())# dict中的时间减去当前时间就是剩下多少秒才可以登陆
            if ti <= 0:
                ti = 0
                return ("%s 用户锁定时间还剩%s秒,可以登陆" %(self.name,ti))
            else:
                return ("%s 用户锁定时间还剩%s秒" %(self.name,ti))

    @property          #把下面db方法改成 数据属性
    def db(self):
        with open(self.user_path,"r") as read_file:
            info = read_file.read()   #读取文件
            return eval(info)     #返回dict类型
    @db.setter    # 修改属性
    def db(self,value):
        with open(self.user_path,"w") as write_file:
            write_file.write(str(value))    # 把下面传来的value 写入到文件
            write_file.flush()    #刷新文件

    def login(self):
        '''登录方法'''
        data = self.db    #把当前文件内dict的数据存到data中
        if data[self.name]["status"] is True:  # 判断 用户名下的status的value是否为True
            print("%s 用户已经登录"%(self.name))
            return True       #返回True

        if data[self.name]["timeout"] < int(time.time()):  #判断当前时间是否小于字典中的时间
            count = 0   #为下面循环 添加一个计数器
            while count < 3:  #进入主循环 ，循环3次
                password = input("please your input password :")  #输入密码
                if not password:   #不是字典中的密码，返回循环
                    continue
                if password == data[self.name]["password"]:  #判断输入的密码能否跟文件中的密码匹配匹配上
                    print("%s 用户登陆成功"%(self.name))
                    data[self.name]["status"] = True   #把字典中status的False改为True
                    data[self.name]["timeout"] = 0     #把字典中的时间改为0
                    self.db = data          # 把 改完的数据 在重新返回给self.db
                    break        #跳出循环
                count += 1   # 前面都没匹配上 ，循环次数加1

            else:
                print("密码错误,账号锁定100秒")    # 走到这里 说明前面都没匹配上
                data[self.name]["timeout"] = int(time.time())+100  #把字典中时间加上100秒
                self.db = data   # 把data数据重新传给self.db
        else:
            print("账户已锁定")





66 a = User_login("egon")
a.login()
#print(a.tall_user)

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

import time  #导入时间模块


class User:  #定义用户类  ，父类
    '''锁定用户，限制时间登录'''
    user_path = "user.txt"
    def __init__(self,user_name):
        self.name = user_name

    @property
    def tall_user(self):        #查看锁定时间
        with open("user.txt","r") as f:
            data = f.read()
            data = eval(data)
            ti = int(data[self.name]["timeout"]-time.time())# dict中的时间减去当前时间就是剩下多少秒才可以登陆
            if ti <= 0:
                ti = 0
                return ("%s 用户锁定时间还剩%s秒,可以登陆" %(self.name,ti))
            else:
                return ("%s 用户锁定时间还剩%s秒" %(self.name,ti))

    @property          #把下面db方法改成 数据属性
    def db(self):
        with open(self.user_path,"r") as read_file:
            info = read_file.read()   #读取文件
            return eval(info)     #返回dict类型
    @db.setter    # 修改属性
    def db(self,value):
        with open(self.user_path,"w") as write_file:
            write_file.write(str(value))    # 把下面传来的value 写入到文件
            write_file.flush()    #刷新文件

class User_login(User):  #定义用户登录类，子类，继承了User父类

    pass

    def login(self):
        '''登录方法'''
        data = self.db    #把当前文件内dict的数据存到data中
        if data[self.name]["status"] is True:  # 判断 用户名下的status的value是否为True
            print("用户%s已经登录".center(50,"-")%(self.name))

            return True       #返回True

        if data[self.name]["timeout"] < int(time.time()):  #判断当前时间是否小于字典中的时间
            count = 0   #为下面循环 添加一个计数器
            while count < 3:  #进入主循环 ，循环3次
                password = input("please your input password :")  #输入密码
                if not password:   #不是字典中的密码，返回循环
                    continue
                if password == data[self.name]["password"]:  #判断输入的密码能否跟文件中的密码匹配匹配上
                    print("用户 %s 登陆成功".center(50,"-")%(self.name))
                    print("welocome to %s ".center(55, "-") % (self.name))
                    data[self.name]["status"] = True   #把字典中status的False改为True
                    data[self.name]["timeout"] = 0     #把字典中的时间改为0
                    self.db = data          # 把 改完的数据 在重新返回给self.db
                    break        #跳出循环
                count += 1   # 前面都没匹配上 ，循环次数加1

            else:
                print("密码错误,账号锁定100秒")    # 走到这里 说明前面都没匹配上
                data[self.name]["timeout"] = int(time.time())+100  #把字典中时间加上100秒
                self.db = data   # 把data数据重新传给self.db
        else:
            print("账户已锁定")

class User_out(User):  #定义用户退出类，子类，继承了User父类

    pass

    def out(self):
        '''退出方法'''
        data = self.db
        while True:
            print("您是要退出吗？")
            choice = input("exit please input 'q':")

            if choice.isdigit():
                print("
 please not input number
")
                continue
            if data[self.name]["status"] is True:
                if choice == "q":
                    data[self.name]["status"] = False
                    self.db = data
                    print("记得再来啊".center(50,"-"))
                    print("bye bye %s".center(50,"-")%(self.name))
                    break
                else:
                    print("看来你还想在玩玩")
                    continue
            else:
                if data[self.name]["status"] is False:
                    print("用户没有登录, 请先登录")
                    break

l = User_login("egon")
o = User_out("egon")
print(l.tall_user)
l.login()
#o.out()

感慨：做作业花了快一天的时间了，从中午十二点，到现在快晚上十二点了，终于是做出来了，好高兴啊，继续努力，加油，坚持，坚持，在坚持