一. 封装
class Room:
def __init__(self, name, length, width):
self.__name = name
self.__length = length
self.__width = 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('不合法的姓名')
def area(self):
return self.__length * self.__width
jin = Room('金老板的小窝', 5, 10)
print(jin.area())
jin.set_name('2')
print(jin.get_name())
# 假设父类的私有属性，能被 子类 调用吗？ 不能
class Foo:
__key = '123' # _Foo__key
class Son(Foo):
print(Foo.__key) # _Son__key
会用到私有的这个概念的场景
1. 隐藏起一个属性 不想让类的外部调用
2. 我想保护这个属性，不想让属性随意被改变
3. 我想保护这个属性，不被子类继承
二. 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 pi * self.r**2
c1 = Circle(10)
print(c1.area) # 圆的面积
print(c1.perimeter) # 圆的周长
class Count_bmi:
def __init__(self, name, weight, height):
self.name = name
self.weight = weight
self.height = height
@property
def bmi(self):
return self.weight / (self.height**2)
kidd = Count_bmi('KID', 51, 1.68)
print(kidd.bmi)
kidd.bmi = 23 # 不能改
class Person:
def __init__(self, name):
self.__name = name
@property
def name(self):
return self.__name + 'SB'
@name.setter
def name(self, newName):
self.__name = newName
p = Person('qqq')
print(p.name)
p.name = 'ppp'
print(p.name)
class Goods: # 定义一个超市物品
discount = 0.5 # 全场5折
def __init__(self, name, price):
self.name = name
self.__price = price
@property
def price(self):
return self.__price * Goods.discount
apple = Goods('苹果',4)
print(apple.price)
# 属性：查看 修改 删除
# 刚才学了 查看 修改 ，接下来看看怎么删除（不常用）
class Person:
def __init__(self, name):
self.__name = name
@property
def name(self):
return self.__name
@name.deleter
def name(self):
print('执行了这个方法')
del self.__name
@name.setter
def name(self,newName):
self.__name = newName
p = Person('二哥')
print(p.name)
del p.name
print(p.name) # 在查看就会报错，因为已经删除
三. 类方法
class Goods: # 定义一个超市物品
__discount = 0.5 # 全场5折
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, newDiscount): # 修改折扣
cls.__discount = newDiscount
apple = Goods('苹果',4)
print(apple.price)
Goods.change_discount(0.8) # Goods.change_discount(Goods)
print(apple.price)
当这个方法的操作只涉及静态属性时，就应该使用calssmethod来装饰这个方法
class Login:
def __init__(self, name, password):
self.name = name
self.password = password
def login(self):
pass
@staticmethod
def get_usr_pwd(): # 静态方法
usr = input('用户名：')
pwd = input('密码：')
Login(usr,pwd)
Login.get_usr_pwd()
在完全面向对象的程序中
如果一个函数既和对象没有关系 也和类没有关系 那么就用staticmethod 将这个函数改变成一个静态方法
类方法 和 静态方法 都是类调用的
那么对象可以调用 类方法 和 静态方法 吗？ 可以 一般情况下 推荐用类名调用
类方法 有一个默认参数 cls 代表这个类，可以改变这个名字，但不建议改变（与self代表对象似的）
静态方法 没有默认的参数 就像函数一样
四. 初识反射
name = 'alex'
class Teacher:
dic = {
'查看学生信息':'show_student',
'查看讲师信息':'show_teacher'
}
def show_student(self):
print('show_student')
def show_teacher(self):
print('show_teacher')
@classmethod
def func(self):
print('哈哈哈')
alex = Teacher()
for k in Teacher.dic:
print(k)
key = input('输入需求：')
# print(Teacher.dic[key])
if hasattr(alex,Teacher.dic[key]):
func = getattr(alex,Teacher.dic[key])
func()
# # alex.show_student() 'show_student'
# func = getattr(alex,'show_student')
# func()
# hasattr getattr delattr
# if hasattr(Teacher,'dic'):
# ret = getattr(Teacher,'dic') # Teacher.dic # 类也是对象
# ret2 = getattr(Teacher,'func') # 类.方法 Teacher.func
# print(ret)
# print(ret2)
# ret2()
# menu = Teacher.dic
# # for k in menu:
# # print(k)
# 通过反射
# 对象名 获取对象属性 和普通方法
# 类名 获取静态属性 和 类方法 和 静态方法
普通方法 带self
静态方法 @staticmethod
类方法 @classmethod
属性方法 @property
