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

Posted 2020-09-13

作业一：总结

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

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

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

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

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

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

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

 1 class Foo:
 2     def test(self):   #绑定到对象的方法
 3         print("hello world")
 4 
 5     @classmethod   #把一个方法绑定给类
 6     def test1(cls):  # 绑定到类的方法，
 7         print("hello friend")
 8 msg = Foo()  #把Foo类 实例化为msg对象
 9 msg.test1()   #使用方法 ，msg.test1() ， msg是对象，test1()是msg的绑定方法，调用时，把msg自动传给self
10 Foo.test1()   #使用方法，Foo.test1(),Foo是类名，test1()是类的绑定方法，调用时会把Foo本身传给cls
11 # msg.test1() ,Foo.test1(),都是在调用类的绑定方法，结果是一样的

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

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

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

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

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

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

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

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

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

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

  

 1 class People:
 2     ‘‘‘计算BMI值‘‘‘
 3     def __init__(self,name,age,height,weight):
 4         ‘‘‘初始化name,age,height,weight‘‘‘
 5         self.name = name
 6         self.age = age
 7         self.height = height
 8         self.weight = weight
 9     @property
10     def boyindex(self):
11         BMI = self.weight/(self.height**2)
12         if BMI < 18.5:
13             print("体重过轻")
14         elif BMI < 24 and BMI >=18.5:
15             print("正常范围")
16         elif BMI > 24:
17             print("体重超重")
18         return BMI
19 
20 s1 = People("egon",25,1.75,56)
21 print(s1.boyindex)   #调用property修饰过的boyindex
22 #执行结果
23 # 体重过轻
24 # 18.285714285714285

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

 1 #被property 装束的属性 会优先于对象属性被使用
 2 # 而被property装饰的属性，如sex分为三种
 3 # 1，@property  查看
 4 # 2，@sex.setter  修改
 5 # 3，@sex.deleter  删除
 6 
 7 class People:
 8     def __init__(self,name,sex):
 9         self.name = name
10         self.__sex = sex
11 
12     @property  #查看
13     def sex(self):
14         return self.__sex
15 
16     @sex.setter  #修改
17     def sex(self,value):
18         if not isinstance(value,str):
19             raise TypeError("sex is str")  #主动抛出异常
20         self.__sex = value
21 
22     @sex.deleter  #删除
23     def sex(self):
24         del self.__sex
25 
26 p1 = People("egon","male")
27 print(p1.sex)  #执行结果： male  调用的@property下的sex
28 p1.sex = "female"  # 把sex初始化的male修改成female
29 print(p1.sex)  #执行结果：female   调用@sex.seltter下的sex
30 del p1.sex    #  删除 __sex 
31 print(p1.sex)   #结果：报错，因为已经把__sex删除了，所以找不到
32                 # AttributeError: ‘People‘ object has no attribute ‘_People__sex‘

作业二：

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

 1 #要求一：自定义用户信息数据结构，写入文件，然后读出内容，利用eval重新获取数据结构
 2 
 3 with open(‘user.db‘,‘w‘) as write_file:  #以覆盖写的模式打开user.db文件，存储到write_file变量中
 4     write_file.write(str({
 5         "egon":{"password":"123",‘status‘:False,‘timeout‘:0},
 6         "alex":{"password":"456",‘status‘:False,‘timeout‘:0},
 7         }))  #把上述内容以字符串格式写入到write_file文件中，保存 关闭文件
 8 
 9 with open(‘user.db‘,‘r‘) as read_file: # 以的读的模式打开user.db文件，存储到read_file变量中
10     data=read_file.read()     #读取文件的全部内容
11     d=eval(data)              # 把字符串转化为dict类型
12     print(d[‘egon‘][‘password‘])   #123
13     print(d[‘egon‘][‘status‘])     #Flase
14     print(d[‘egon‘][‘timeout‘])    #0

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

 1 class User:
 2     ‘‘‘查看用户信息‘‘‘
 3     db_path = "user.txt"  #只是把文件存到变量中，什么都没干
 4     def __init__(self,user_name,):
 5         ‘‘‘初始化用户名字‘‘‘
 6         self.name = user_name
 7 
 8     @property      #修饰db，变成数据属性
 9     def db(self):
10         data = open(self.db_path,"r").read()   #打开db_path变量中的文件，读取文件
11         d = eval(data)   #把文件内容转换成dict数据类型
12         return d
13         data.close()      #关闭文件
14 
15 e = User("egon",)
16 a = User("alex")
17 print("%s data :"%(e.name))
18 print(e.db["egon"])
19 print("%s data :"%(a.name))
20 print(a.db["alex"])

 

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

 

 1 import time  #导入时间模块
 2 
 3 
 4 class User_login:
 5     ‘‘‘锁定用户，限制时间登录‘‘‘
 6     user_path = "user.txt"
 7     def __init__(self,user_name):
 8         self.name = user_name
 9 
10     @property
11     def tall_user(self):        #查看锁定时间
12         with open("user.txt","r") as f:
13             data = f.read()
14             data = eval(data)
15             ti = int(data[self.name]["timeout"]-time.time())# dict中的时间减去当前时间就是剩下多少秒才可以登陆
16             if ti <= 0:
17                 ti = 0
18                 return ("%s 用户锁定时间还剩%s秒,可以登陆" %(self.name,ti))
19             else:
20                 return ("%s 用户锁定时间还剩%s秒" %(self.name,ti))
21 
22     @property          #把下面db方法改成 数据属性
23     def db(self):
24         with open(self.user_path,"r") as read_file:
25             info = read_file.read()   #读取文件
26             return eval(info)     #返回dict类型
27     @db.setter    # 修改属性
28     def db(self,value):
29         with open(self.user_path,"w") as write_file:
30             write_file.write(str(value))    # 把下面传来的value 写入到文件
31             write_file.flush()    #刷新文件
32 
33     def login(self):
34         ‘‘‘登录方法‘‘‘
35         data = self.db    #把当前文件内dict的数据存到data中
36         if data[self.name]["status"] is True:  # 判断 用户名下的status的value是否为True
37             print("%s 用户已经登录"%(self.name))
38             return True       #返回True
39 
40         if data[self.name]["timeout"] < int(time.time()):  #判断当前时间是否小于字典中的时间
41             count = 0   #为下面循环 添加一个计数器
42             while count < 3:  #进入主循环 ，循环3次
43                 password = input("please your input password :")  #输入密码
44                 if not password:   #不是字典中的密码，返回循环
45                     continue
46                 if password == data[self.name]["password"]:  #判断输入的密码能否跟文件中的密码匹配匹配上
47                     print("%s 用户登陆成功"%(self.name))
48                     data[self.name]["status"] = True   #把字典中status的False改为True
49                     data[self.name]["timeout"] = 0     #把字典中的时间改为0
50                     self.db = data          # 把 改完的数据 在重新返回给self.db
51                     break        #跳出循环
52                 count += 1   # 前面都没匹配上 ，循环次数加1
53 
54             else:
55                 print("密码错误,账号锁定100秒")    # 走到这里 说明前面都没匹配上
56                 data[self.name]["timeout"] = int(time.time())+100  #把字典中时间加上100秒
57                 self.db = data   # 把data数据重新传给self.db
58         else:
59             print("账户已锁定")
60 
61 
62 
63 
64 
65 66 a = User_login("egon")
67 a.login()
68 #print(a.tall_user)
69

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

  1 import time  #导入时间模块
  2 
  3 
  4 class User:  #定义用户类  ，父类
  5     ‘‘‘锁定用户，限制时间登录‘‘‘
  6     user_path = "user.txt"
  7     def __init__(self,user_name):
  8         self.name = user_name
  9 
 10     @property
 11     def tall_user(self):        #查看锁定时间
 12         with open("user.txt","r") as f:
 13             data = f.read()
 14             data = eval(data)
 15             ti = int(data[self.name]["timeout"]-time.time())# dict中的时间减去当前时间就是剩下多少秒才可以登陆
 16             if ti <= 0:
 17                 ti = 0
 18                 return ("%s 用户锁定时间还剩%s秒,可以登陆" %(self.name,ti))
 19             else:
 20                 return ("%s 用户锁定时间还剩%s秒" %(self.name,ti))
 21 
 22     @property          #把下面db方法改成 数据属性
 23     def db(self):
 24         with open(self.user_path,"r") as read_file:
 25             info = read_file.read()   #读取文件
 26             return eval(info)     #返回dict类型
 27     @db.setter    # 修改属性
 28     def db(self,value):
 29         with open(self.user_path,"w") as write_file:
 30             write_file.write(str(value))    # 把下面传来的value 写入到文件
 31             write_file.flush()    #刷新文件
 32 
 33 class User_login(User):  #定义用户登录类，子类，继承了User父类
 34 
 35     pass
 36 
 37     def login(self):
 38         ‘‘‘登录方法‘‘‘
 39         data = self.db    #把当前文件内dict的数据存到data中
 40         if data[self.name]["status"] is True:  # 判断 用户名下的status的value是否为True
 41             print("用户%s已经登录".center(50,"-")%(self.name))
 42 
 43             return True       #返回True
 44 
 45         if data[self.name]["timeout"] < int(time.time()):  #判断当前时间是否小于字典中的时间
 46             count = 0   #为下面循环 添加一个计数器
 47             while count < 3:  #进入主循环 ，循环3次
 48                 password = input("please your input password :")  #输入密码
 49                 if not password:   #不是字典中的密码，返回循环
 50                     continue
 51                 if password == data[self.name]["password"]:  #判断输入的密码能否跟文件中的密码匹配匹配上
 52                     print("用户 %s 登陆成功".center(50,"-")%(self.name))
 53                     print("welocome to %s ".center(55, "-") % (self.name))
 54                     data[self.name]["status"] = True   #把字典中status的False改为True
 55                     data[self.name]["timeout"] = 0     #把字典中的时间改为0
 56                     self.db = data          # 把 改完的数据 在重新返回给self.db
 57                     break        #跳出循环
 58                 count += 1   # 前面都没匹配上 ，循环次数加1
 59 
 60             else:
 61                 print("密码错误,账号锁定100秒")    # 走到这里 说明前面都没匹配上
 62                 data[self.name]["timeout"] = int(time.time())+100  #把字典中时间加上100秒
 63                 self.db = data   # 把data数据重新传给self.db
 64         else:
 65             print("账户已锁定")
 66 
 67 class User_out(User):  #定义用户退出类，子类，继承了User父类
 68 
 69     pass
 70 
 71     def out(self):
 72         ‘‘‘退出方法‘‘‘
 73         data = self.db
 74         while True:
 75             print("您是要退出吗？")
 76             choice = input("exit please input ‘q‘:")
 77 
 78             if choice.isdigit():
 79                 print("\n please not input number\n")
 80                 continue
 81             if data[self.name]["status"] is True:
 82                 if choice == "q":
 83                     data[self.name]["status"] = False
 84                     self.db = data
 85                     print("记得再来啊".center(50,"-"))
 86                     print("bye bye %s".center(50,"-")%(self.name))
 87                     break
 88                 else:
 89                     print("看来你还想在玩玩")
 90                     continue
 91             else:
 92                 if data[self.name]["status"] is False:
 93                     print("用户没有登录, 请先登录")
 94                     break
 95 
 96 l = User_login("egon")
 97 o = User_out("egon")
 98 print(l.tall_user)
 99 l.login()
100 #o.out()

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