Python学习笔记26：封装、@property、@staticmethod和@classmethod装饰器方法、反射getattr()

学习参考Eva-J女神姐姐的博客：https://www.cnblogs.com/Eva-J/，如有侵权，请联系删除！

封装

知识点整理：

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

#私有后的属性，可以定义方法get_name实现调用
#私有后的属性，可以定义set_name实现修改
#父类的私有属性，不能被子类调用
#

# step1
# class Room:
#     def __init__(self,name,length,width):
#         self.name = name
#         self.__length = length
#         self.__width = width
#
#     def area(self):
#         return self.__length * self.__width
#
# jin = Room('金老板',2,1)
# print(jin.area())

# step2
# class Room:
#     def __init__(self,name,length,width):
#         self.__name = name
#         self.__length = length
#         self.__width = width
#
#     def area(self):
#         return self.__length * self.__width
#
#     def get_name(self):  # 私有后如何调用它
#         return self.__name
#
#     def set_name(self,newName): # 私有后还可以进行修改
#         if type(newName) is str and newName.isdigit() == False:
#             self.__name = newName
#         else:
#             print('不合法的姓名')
#
# jin = Room('金老板',2,1)
# print(jin.area())
# print(jin.get_name())
# jin.set_name('2')
# print(jin.get_name())

# step3
# 假设父类的私有属性，能被子类调用吗？不能
# class Foo:
#     __key = '123'   # _Foo__key
#
# class Son(Foo):
#     print(Foo.__key)  # _Son__key

　　

@property装饰器

知识点整理：

# @property 用来对属性进行一些操作，如上面例子中的打折，那么这时候就可以把这个属性设置成
# 私有的，然后在调用@property来设置一个和属性同名的方法，在该方法中实现对属性的操作，且该方法的调用和类中属性的调用方式一样，属性的调用不用方法后面的括号
# 类中的属性值都是可以进行修改的，但是加入了@property装饰器的方法，不能进行修改，如果要进行修改，需要在加一个装饰器@属性_setter
# 本来类中不能加入同名字的方法，加入@name.setter后可以,还可以新增一个参数
# 如果要对属性进行删除，需先私有化，加上@property装饰器和@属性_deleter

# step1
# from math import pi
# class Circle:
#     def  __init__(self,r):
#         self.r = r
#
#     @property  # 把perimeter伪装为一个属性
#     def perimeter(self):
#         return  2*pi*self.r
#
#     @property  # 把area伪装为一个属性
#     def area(self):
#         return self.r**2*pi
#
# c1 = Circle(5)
# print(c1.area())  # 圆的面积应该是一个属性，但是却又是通过计算得到，如何把面积伪装为一个属性
# print(c1.perimeter())
# 加入装饰器后调用方式要改变
# print(c1.area)  # 属性的调用不用方法后面的括号
# print(c1.perimeter)


# step2
# 计算人的BMI指数
# class Person:
#     def __init__(self,name,high,weight):
#         self.name = name
#         self.high = high
#         self.weight = weight   # 此处是属性的赋值，不要参与计算
#
#     @property
#     def bmi(self):
#         return self.weight / self.high ** 2
#
# jin = Person('金老板',1.6,90)
# print(jin.bmi())
# print(jin.bmi) # 加入装饰器后调用方式和属性的调用方式相同
# 改名
# jin.name = '222' # 此处可以修改属性，
# print(jin.name)
# jin.bmi = 18  #不能修改加入了装饰器后面的方法
# jin.high = 1.8  # 可以修改属性
# print(jin.high)
# print(jin.bmi)

# step3
# class Person:
#     def __init__(self,name):
#         self.__name = name
#
#     @property  # 要用name.setter ,必须要先有property装饰器
#     def name(self):
#         return self.__name + 'sb'
#
#     @name.setter  # 本来类中不能加入同名字的方法，加入@name.setter后可以,还可以新增一个参数
#     def name(self,newname):
#         self.__name = newname
#
# tiger = Person('嗷嗷')
# print(tiger.name)  # 此时name不能在继续修改
# tiger.name = '欠缺'
# print(tiger.name)


# step4
# class Goods:
#     discount = 0.5
#     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)

# @property 用来对属性进行一些操作，如上面例子中的打折，那么这时候就可以把这个属性设置成
# 私有的，然后在调用@property来设置一个和属性同名的方法，在该方法中实现对属性的操作

# step5
# 属性可以查看、修改、删除
# class Person:
#     def __init__(self,name):
#         self.__name = name
#
#     @property  # 私有化一个属性方法
#     def name(self):
#         return self.__name
#
#     @name.deleter
#     def name(self):
#         del self.__name
#
# a = Person('aaa')
# print(a.name)
# del a.name
# print(a.name)

　　

@stacticmethod和 @classmethod

知识点整理：

# 当这个方法的操作只设计静态属性的时候，就应该使用classmethod来装饰这个方法，这个方法就可以直接被类来直接调用
# 在完全面向对象的程序中，如果一个函数类还有对象都没关系，那么就用staticmethod将这个函数变成一个静态方法

# step1
# 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
#
# a = Goods('苹果',5) # 如果不想先实例化，并且这个方法适用这个类中所有的情况，那么需要用到classmethod
# print(a.price)
# a.change_discount(0.5)
# print(a.price)
# 当这个方法的操作只设计静态属性的时候，就应该使用classmethod来装饰这个方法

# step2
# java
# class Login:
#     def __init__(self,name,password):
#         self.name = name
#         self.password = password
#
#     def login(self):pass
#
#     @staticmethod # 伪装成一个静态方法，这样这个方法和这个类和属性都没什么关系，不需要传默认的self
#     def get_usr_pwd():
#         usr = input('密码：')
#         pwd = input('账号：')
#         Login(usr,pwd)


# Login.get_usr_pwd() # 这样就可以直接调用这个方法了，且调用之前不需要实例化任何对象
# 在完全面向对象的程序中，如果一个函数类还有对象都没关系，那么就用staticmethod将这个函数变成一个静态方法

反射，getattr方法

知识点整理：

# 有一个字符串格式的名字存在命名空间里面，可以通过getattr拿到这个字符串的值
# 形式有类.属性、实例.方法
# hasattr和getattr是配套使用的，先判断有没有，没有也不报错，如果没有,没有就报错

# step1
# 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')

# hasattr, getattr, delattr
# ret = getattr(Teacher,'dic') # 字符串类型的数据类型,Teacher.dic,类.属性
# print(ret)
# 有一个字符串格式的名字存在命名空间里面，可以通过getattr拿到这个字符串的值

# ret1 = getattr(Teacher,'func')      # 类.方法
# print(ret1)   #  方法名，方法的内存地址
# ret1()        # 函数的内存地址加括号，就执行该方法

# if hasattr(Teacher,'dic1'):     # getattr是配套使用的，先判断有没有，没有也不报错，如果没有hasattr,没有就报错
#     ret = getattr(Teacher,'dic1')
#
# aa = Teacher()
# a_func = getattr(aa, 'show_teacher') # 这样拿到的是函数的内存地址
# a_func()

# alex = Teacher()
# for k in Teacher.dic:
#     print(k)
# 
# key = input('输入需求：')
# if hasattr(alex, Teacher.dic[key]):
#     func = getattr(alex, Teacher.dic[key])
#     func()

　　皑皑

实现计算机作业：

import re

# step2 提取括号里面没有其他括号的表达式
# findall 会找出来所有符合条件的，但是对于3*5*6 + 2*3，匹配乘法的化，上面这种情况会出现漏
def dealwith(express):
    '''
    将表达式中的符号替换，+- 替换为-，-，-替换为+
    :return:
    '''
    express = express.replace('+-','-')
    express = express.replace('--','+')
    return express

def cal_express_son(exp_son):
    '''
    只用来计算最小型的两个数的乘除法
    :return:
    '''
    if '/' in exp_son:
        a,b = exp_son.split('/')
        return str(float(a) / float(b))
    elif '*' in exp_son:
        a,b  = exp_son.split('*')
        return str(float(a)* float(b))


def cal_express_no_bracket(exp):
    '''
    计算没有括号的表达式
    exp:没有经过处理的最内层带括号的表达式
    :return:
    '''
    exp = exp.strip('()')
    # print(exp)
    # 先乘除后加减,找第一个出现的乘法或除法
    while 1:
        ret = re.search('d+.?d*[*/]-?d+.?d*',exp)
        if ret:  # 说明表达式中还有乘除法
            exp_son =  ret.group()  # 子表达式，最简单的乘除法
            print(exp_son)
            ret = cal_express_son(exp_son)
            exp =  exp.replace(exp_son,ret)
            exp = dealwith(exp)
        else:  # 说明表达式中没有乘除了
            ret = re.findall('-?d+.d*',exp)
            # print('***',ret)
            sum = 0
            for i in ret:
                sum += float(i)
            return str(sum)

def remove_bracket(new_express):
    while 1:
        ret = re.search('([^()]+)',new_express)
        if ret:
            express_no_bracket = ret.group() # 表达式没括号
            print('匹配到内部不在有括号的值',express_no_bracket)
            ret = cal_express_no_bracket(express_no_bracket)
            # print(new_express,express_no_bracket,ret)
            new_express = new_express.replace(express_no_bracket,ret)
            new_express = dealwith(new_express)
            print(new_express)
        else:
            print('表达式中已经没有括号了：',new_express)
            ret = cal_express_no_bracket(new_express)
            # print(ret)
            return ret
            break

express = '1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))'
# step1 去空格
new_express = express.replace('  ','')
res = remove_bracket(new_express)
print(res)