python学习day26 封装 property 类方法 静态方法 反射

封装

广义上面向对象的封装 ：代码的保护，面向对象的思想本身就是一种
只让自己的对象能调用自己类中的方法

狭义上的封装 —— 面向对象的三大特性之一
属性 和 方法都藏起来 不让你看见

私有属性

class Person:
    __key = 123  # 私有静态属性
    def __init__(self,name,passwd):
        self.name = name
        self.__passwd = passwd   # 私有属性

    def __get_pwd(self):         # 私有方法
        return self.__passwd   #只要在类的内部使用私有属性，就会自动的带上_类名

    def login(self):          # 正常的方法调用私有的方法
        self.__get_pwd()
alex = Person('alex','alex3714')
print(alex._Person__passwd)   # _类名__属性名 虽然能外部调用 但不建议用

 

所有的私有 都是在变量的左边加上双下划綫

• 对象的私有属性
• 类中的私有方法
• 类中的静态私有属性

所有的私有的 都不能在类的外部使用，只能在内部使用

父类的私有属性不能被子类调用

会用到私有的场景：

1.隐藏起一个属性 不想让类的外部调用
2.我想保护这个属性，不想让属性随意被改变
3.我想保护这个属性，不被子类继承

property内置装饰器函数

比较重要

@property只在面向对象中使用，将一个方法伪装成一个属性

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    @property
    def perimeter(self):
        return 2*pi*self.r
    @property
    def area(self):
        return self.r**2*pi

c1 = Circle(5)
print(c1.area)     # 圆的面积
print(c1.perimeter) # 圆的周长
# 如果不加property的话，调用需要方法名+括号：print(c1.perimeter()) 

被property装饰的方法不能传任何参数

 

 对对象属性的修改

一般情况下，会定义一个私有属性，再用property装饰一个与私有属性同名的方法，这样可以对这个属性进行查看或者用这个属性进行操作：

class Goods:
    discount = 0.8
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    @property
    def price(self):
        return self.__price * Goods.discount
apple = Goods('苹果',5)
print(apple.price)

 

# 属性 查看 修改 删除
class Person:
    def __init__(self,name):
        self.__name = name
        self.price = 20
    @property
    def name(self):
        return self.__name
    @name.deleter
    def name(self):
        del self.__name
    @name.setter
    def name(self,new_name):
        self.__name = new_name
brother2 = Person('二哥')
del Person.price  # 触发name.deleter下的方法
brother2.name = 'HAHA'  # 改名字时触发name.setter下的方法
print(brother2.name)  #  'HAHA'

 

class_static

classmethod 类方法  ****

通过类直接调用的方法 类.方法  有一个默认参数 cls

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

# 类的操作行为
class Goods:
    __discount = 0.8
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    @property
    def price(self):
        return self.__price * Goods.__discount
    @classmethod   # 把一个方法 变成一个类中的方法，这个方法就直接可以被类调用，不需要依托任何对象
    def change_discount(cls,new_discount):  # 修改折扣
        cls.__discount = new_discount
apple = Goods('苹果',5)
print(apple.price)
Goods.change_discount(0.5)  # 将类的静态属性修改
print(apple.price) # 2.5

 

staticmethod 静态方法  ***

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

 

class Login:
    def __init__(self,name,password):
        self.name = name
        self.pwd = password
    def login(self):pass

    @staticmethod
    def get_usr_pwd():   # 静态方法
        usr = input('用户名 ：')
        pwd = input('密码 ：')
        Login(usr,pwd)

Login.get_usr_pwd()

 

类方法和静态方法 都是类调用的

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

反射

比较重要

hasattr()和getattr()内置函数

通过字符串能够拿到所对应的属性或方法的值，方法后面要加()，值直接显示

hasattr()和getattr()总在一起，一个判断，一个执行

class Teacher:
    dic = {'查看学生信息':'show_student','查看讲师信息':'show_teacher'}
    def show_student(self):
        print('show_student')

    def show_teacher(self):
        print('show_teacher')

    @classmethod
    def func(cls):
        print('hahaha')
alex = Teacher()
for k in Teacher.dic:
    print(k)
key = input('输入需求 ：')
if hasattr(alex, Teacher.dic[key]):  # 判断这个Teacher.dic[key]字符在不在alex中
    func = getattr(alex, Teacher.dic[key])  
    func()  # 'hahaha'

也可以执行类.方法或类.对象

if hasattr(Teacher,'func'):
    ret2 = getattr(Teacher,'func')         # 类.方法  teacher.func
    ret2()

 

类中属性

静态属性

成员属性

私有属性

类中方法

普通方法 self

静态方法 @staticmethod

类方法 @classmethod

属性方法 @property

内置方法