# 封装 把一些属性和方法放到类里，这本身就是一种封装
# 封装 把属性和方法藏在类里，只能在类内部调用，不能在外部使用
# class Dog:
# __role ='dog'#这时候变成私有的静态属性 # 加上双下划线就被隐藏了
# def func(self):
# print(Dog.__role)
# print(Dog.role) #当加上爽下划线的这时候不能打印了
# print(Dog.__dict__) 查看原形
# print(Dog._Dog__role)#从类的外面不能直接调用，在类内的使用加上了密码：_类名
# d=Dog()
# d.func() #这时候可以打印出内部func的结果了
# 私有动态的方法
# class Dog:
# __role ='dog'
# def __func(self):#此刻它是 私有的方法
# print('in_func')
# d=Dog()
# d._Dog__func()#这种调用方式一般不用
# 课上练习
# 定义一个私有变量，在类内部可以直接用，在类外部不能直接用，如果一定要用，
# 在私有方法之前加上_类名 在类外的名字通过__dict__可以查看
# class Cat:
# __sy = '喵喵'
# def __ps(self):
# print("老鼠")
# d=Cat()
# print(d._Cat__sy) #外部一定要用才这样操作
# print(Cat.__dict__) #类外的名字是什么 这么操作查看
# class Room:
# def __init__(self,name,price,length,width):
# self.name = name
# self.price = price
# self.__length =length# 私有的对象属性
# self.__width = width
#
# def area(self):
# return self.__length*self.__width
#
# house = Room('小超超',1000000,2,1)
# print(house.area())
# 下面的例子是验证私有的能不能被继承
# class A :
# def __func(self):
# print("__a_func")
#
# class B(A):
# def __init__(self):
# self.func()
# b=B()#结果是 'B' object has no attribute 'func'
#私有的 总结
#我们可以定义私有的静态属性，方法，对象属性
#使用__名字的方式调用，保证在类内部可以调用，外部不行
#私有的 不能被继承
#当有一个变量，不想被外部使用也不想被子类继承，只想在内部使用的时候就定义私有的
# property #它就是做伪装用的
# class Person:
# def __init__(self,name,height,weight):
# self.name = name
# self.__height =height
# self.__weight= weight
# @property
# def bmi(self): #将这个方法伪装成一个属性 调用的方式就变成了
# return self.__weight/(self.height**2)
# li = Person('李岩',1.75,85)
#
# # print(li.bmi()) #调用的方法
# print(li.bmi) #调用的方法 伪装后的调用
# @property把一个方法伪装成一个属性
#属性的值 是这个方法返回值
#上面的这个方法不能有参数了
# 课上练习把圆形类的面积和周长搞成伪装属性
# from math import pi
# class Circle:
# def __init__(self,r):
# self.radius= r
# @property
# def perimeter(self):
# return 2*pi*self.radius
# @property
# def area(self):
# return pi*(self.radius**2)
# a=Circle(10)
# print(a.perimeter)
# print(a.area)
# 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('苹果',10)
# print(apple.price) #伪装后的直接按照属性调用方式调用
# banana = Goods('香蕉',2.5)
# print(banana.price)
#
# apple.kind = '富士'
# print(apple.kind)
# apple.kind = '黄元帅'
# print(apple.kind) # 上面的四行代码说明类对象属性可以改变，而伪装的如何去改变呢？
# # 但是它伪装的价格不能改变 下面的代码来实现
# 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
# @price.setter
# def price(self,new_price): #修改原价
# if type(new_price) == int: #加上判断条件可以使你的代码更加安全可靠
# self.__price = new_price
#
# apple = Goods('苹果',10)
# apple.price = 6
# print(apple.price) #对象属性在伪装后改变的方法
# # __私有+property
# 让对象的属性变得更安全了
# 获取的对象的值可以进行一些加工
# 修改对象的值的同时进行一些验证
# 下面是扩展的 deleter
# class Foo:
# @property
# def AAA(self):
# print('get的时候运行我啊')
# @AAA.setter
# def AAA(self,value):
# print('set的时候运行我啊')
# @AAA.deleter
# def AAA(self):
# print('deleter的时候运行我啊')
# #只有在属性AAA定义property 后才能定义AAA.setter,AAA.deleter
# f1=Foo()
# f1.AAA #获取值 找property
# f1.AAA = 'aaa' #修改值找setter
# del f1.AAA # 删除值的时候找 deleter
# 下面演示的是deleter 的用法 删除苹果名字演示
# class Goods:
# __discount =0.8 #静态属性
# def __init__(self,name,price):
# self.__name = name
# self.__price = price #原价
# @property
# def name(self):
# return self.__name
#
# @name.setter
# def name(self,new_name):
# self.__name = new_name
#
# @name.deleter
# def name(self,new_name):
# del self.__name
#
# @property
# def price(self): #它提供折扣后的价格
# return self.__price * Goods.__discount
# @price.setter
# def price(self,new_price): #修改原价
# if type(new_price) == int: #加上判断条件可以使你的代码更加安全可靠
# self.__price = new_price
# apple = Goods('苹果',10)
# del apple.name
# 定义一个类
# 类里面的方法
# 并没有用到self
# 类方法演示如下
# class Goods:
# __discount = 0.8
# @classmethod #类方法
# def change_discount(cls,new_discount):
# cls.__discount =new_discount
# @classmethod
# def get_discount(cls): #显示一下
# return cls.__discount
# # apple =Goods()
# Goods.change_discount(0.75)
# print(Goods.get_discount())
#类方法 好处如下
# 调用 不需要实例化 直接用类名调用就好
# 定义 不用接受self参数，默认传cls，cls就代表当前方法所在的类
#什么时候用类方法啊？
# 需要使用静态变量 且不需要和对象相关的任何操作的时候
# 静态方法
# 如果这个方法 既不需要操作静态变量，
# 也不需要使用对象相关的操作，就是用静态方法
# class A:
# @staticmethod
# def func(name): #静态方法
# print(123)
# A.func('alex')
#面向对象编程 ：专门为面向对象编程提供的一个方法——staticmethod
#它完全可以当做普通函数去用，只不过这个函数要通过类名，函数名调用
#其他 传参 返回值 完全没有区别
# 类里面：一共可以定义这三种方法
# 普通方法 self
# 类方法 cls
# 静态方法
# 绑定方法和非绑定方法
# class A:
# @staticmethod
# def func1(name): #静态方法
# print(123)
#
# @classmethod
# def func2(cls): # 静态方法
# print(123)
#
# def func3(self):pass
# a=A()
# print(a.func1) # 静态方法 打印出来是静态方法
# print(a.func2) # 类方法 打印出来是绑定到A类上的func
# print(a.func3) # 普通方法 打印出来是绑定到A类对象的func
#静态方法和类方法 都是直接可以使用类名调用
#普通方法：对象调用
浙公网安备 33010602011771号