Python进阶-XVIII 封装、（属性、静态方法、类方法）语法糖、反射

1、封装

　　类中的私有化：属性的私有化和方法的私有化

　会用到私有的这个概念de场景
  　　1.隐藏起一个属性 不想让类的外部调用
  　　2.我想保护这个属性，不想让属性随意被改变
 　　 3.我想保护这个属性，不被子类继承

 class Room:
     """房间类"""

     def __init__(self, name, length, width, height):
         self.__name = name
         self.__length = length
         self.__width = width
         self.__height = height

     def get_name(self):
         return self.__name

     def set_name(self, new_name):
         if type(new_name) is str and new_name.isdigit() == False:  # 新名称是字符串且不能是数字
             self.__name = new_name

     def area(self):
         return self.__length * self.__width

     def volume(self):
         return self.__length * self.__width * self.__height

 room = Room('标准间', 3.6, 3.0, 3.2)

 print(room.get_name())
 room.set_name('豪华间')
 print(room.get_name())

 print(room.area())
 print(room.volume())

 # 子类无法继承父类中的私有属性和私有方法

 class Foo:
     __key = ''       # _Foo__key

 class Son(Foo):
     print(Foo.__key)     # _Son__key

 son = Son()
 # son.__key # AttributeError: type object 'Foo' has no attribute '_Son__key'

2、属性方法

　　@property语法糖的使用场景

　　如果方法不得不使用名词，而规矩是名词是属性，动词是方法。而使用名词是将运算后的值给它。

 class Room:
     """房间类"""

     def __init__(self, name, length, width, height):
         self.__name = name
         self.__length = length
         self.__width = width
         self.__height = height

     def get_name(self):
         return self.__name

     def set_name(self, new_name):
         if type(new_name) is str and new_name.isdigit() == False:  # 新名称是字符串且不能是数字
             self.__name = new_name

     @property
     def area(self):  # 名词一般是属性，动词才是方法，为了解决有了属性语法糖
         return self.__length * self.__width

     @property
     def volume(self):
         return self.__length * self.__width * self.__height

 room = Room('标准间', 3.6, 3.0, 3.2)
 print(room.volume)  # 有了@property可以像调用属性一样调用方法
 print(room.area)

 属性的 查看 修改 删除

 class Person:
     def __init__(self, name):
         self.__name = name

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

     @name.setter   # 修改
     def name(self, new_name):
         self.__name = new_name

     @name.deleter    # 删除
     def name(self):
         del self.__name

 tom = Person('Tom')
 print(tom.name)
 tom.name = 'Jone'
 print(tom.name)
 del tom.name  # 删除 有了@name.deleter才有效果
 # print(tom.name)              # AttributeError: 'Person' object has no attribute '_Person__name'

3、静态方法和类方法

　　method 方法
　　staticmathod  静态的方法 ***
　　classmethod   类方法    ****
　　类的操作行为

　　1）staticmethod  静态的方法

 class Login:
     def __init__(self, name, pwd):
         self.name = name
         self.__password = pwd

     def login(self):pass

     @staticmethod  # 该语法糖是声明该方法为静态方法
     def get_usr_pwd():
         usr = input('请输入登录名：》》》').strip()
         pwd = input('请输入密码：》》》').strip()
         Login(usr, pwd)

 Login.get_usr_pwd()

静态方法的应用场景：在完全面向对象的程序中，如果一个函数，既跟对象没有关系，
也跟类没有关系 那么就用staticmethod将这个函数变成一个静态方法

　　2）classmethod 类方法

 class Goods:
     """商品类"""
     discount_rate = 0.5

     def __init__(self, name, price):
         self.name = name
         self.__price = price

     @property
     def price(self):
         return self.__price * Goods.discount_rate

     @classmethod  # 把一个方法 变成一个类中的方法，这个方法就直接可以被类调用，不需要依托任何对象
     def change_discount_rate(cls, new_rate):
         cls.discount_rate = new_rate

 apple = Goods('apple', 9.8)
 print(apple.price)
 # apple.change_discount_rate(0.75) 如此调用合理，商品的折扣率是类的事，不应该由实例来控制！
 Goods.change_discount_rate(0.8)
 print(apple.price)

类方法的应用场景：
当这个方法的操作只涉及静态属性的时候 就应该使用classmethod来装饰这个方法

　　3）、小结

　　类方法和静态方法 都是类调用的
　　对象可以调用类方法和静态方法么？ 可以 一般情况下 推荐用类名调用
　　类方法 有一个默认参数 cls 代表这个类 cls
　　静态方法 没有默认的参数 就象函数一样

4、反射

　　（1）、简介

　　有此使用场景，知道一个类中的方法名的字符串形式，如何调用该方法？

　　通过反射
　　对象名 获取对象属性 和 普通方法
　　类名 获取静态属性 和类方法 和 静态方法

　　普通方法 self
　　静态方法 @staticmethod
　　类方法 @classmethod
　　属性方法 @property

　（2）、反射的使用场景

 class Dog:
     fur = 'golden'
     def __init__(self, name, kind):
         self.name = name
         self.kind = kind

     def bite(self):
         print(self.name + "is biting!")

     def walk(self):
         print(self.name + "is walking!"

　　　　1）反射对象

 dog = Dog('duck','harsci')

 #   1)、反射对象的属性
 if hasattr(dog, 'fur'):
     print(getattr(dog, 'fur'))

 #   2)、反射对象的方法
 if hasattr(dog, 'bite'):
     getattr(dog, 'bite')()

　　　　2）反射类

 class A:
     year = 2020
     @classmethod
     def get_year(cls):
         print(cls.year)
 # 1)获得类的属性
 A.year
 if hasattr(A, 'year'):
     print(getattr(A, 'year'))
 # 2）获得类的方法
 if hasattr(A, 'get_year'):
     getattr(A, 'get_year')() # 如果不加classmethod装饰器，会报错get_year() missing 1 required positional argument: 'self'

　　　　3）反射导入的模块

 import time

 t = ''
 if hasattr(time, 'time'):
     t = getattr(time, 'time')()  # 得到当前的时间的时间戳
     print(t)

 t = time.localtime(t)  # 将时间戳转化为结构时间

 if hasattr(time, 'asctime'):
     print(getattr(time, 'asctime')(t))  # asctime必须传结构时间

　　　　4）反射自身（坐在的模块）

 import sys
 # 查看系统中所有模块
 print(sys.modules)
 # 找到本模块对应的key
 # '__main__': < module'__main__'from' D:/python_bases/day27/2_反射进阶.py' >

 # 1)、获得本模块的属性
 print(getattr(sys.modules["__main__"], 'dog').fur)

 def get_year():
     print(time.asctime(time.localtime(time.time())))
 # 2)、获得本模块的方法
 getattr(sys.modules['__main__'], 'get_year')()

 # 如果别的模块引入该模块，会无法执行，因为写死了'__main__'，要改为变量
 __main__ = '__main__'

（3）、反射的剩余方法：

 method_str = ['bite', 'walk']

 dog = Dog('金毛', '狮子狗')

 if hasattr(Dog, 'bite'):  # 内置函数一
     bite = getattr(Dog, method_str[0])  # 内置函数二

 bite(dog)
 setattr(Dog, 'price', 999) # 内置函数三
 print(dog.price)

 delattr(Dog, 'price') # 内置函数四