一.封装
1.封装的概念：
广义上的封装 : 属于一个类的静态和动态属性 总是出现在一个类中
#使用永远在类的内部用类名或者对象名调用
狭义上的封装 : 就是把变量方法私有化,在类的外部以及子类中不能直接使用了
2.私有变量：
在python中用双下划线开头的方式将属性隐藏起来
在内部中调用会自动变形：__x都会自动变形成：_类名__x的形式
2.1静态变量私有化
class A:
start="aaa" # 静态变量
__s="bbb" # 私有的静态变量
def wahaha(self):
print(A.__s) #A._A__s
1.在外部是无法通过__x这个名字找到变量
print(A.__s) AttributeError
print(A._A__s) #bbb 在类的外面调用私有的变量 但不使用此方法
2.不能在外部创建一个私有的变量
A.__B="ccc"
print(A.__dict__) #在A中并没有_A_B:CCC
2.2属性私有化
class B:
def __init__(self,name,pwd):
self.name = name
self.__pwd = pwd # 也可以创建对象的私有属性
def get_pwd(self):
print(self.__pwd)
b = B('alex','alex3714')
print(b.name) #alex
print(b.__pwd) AttributeError: 属性错误
print(b._B__pwd) #alex3714
2.3方法私有化
class C:
def __ppt(self): # 私有的方法
print('ppt')
self.age = 83
def open(self):
self.__ppt()
print('打开文件')
c = C()
c.open()
print(c.age)
总结：
私有的 静态变量 对象属性 方法：
1.只能在类的内部定义和使用
2.在类外部使用私有静态变量 _类名__私有的名字
3.私有的名字 不能被子类继承
3.java
private 私有的 - __变量名
protect 保护的 - N/A（python中没有）
public 公共的 - 正常的变量
4.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
class A:
def __fa(self): #在定义时就变形为_A__fa
print('from A')
def test(self):
self.__fa() #只会与自己所在的类为准,即调用_A__fa
class B(A):
def __fa(self):
print('from B')
b=B()
b.test() #from A
View Code二.内置函数property classmethod staticmethod
1.property ：将一个方法伪装成属性。在用时用对象属性的方式调用
2.classmethod:将一个普通方法装饰为一个类方法.操作都只能和类中的静态变量相关
3.staticmethod:将一个方法装饰成普通函数。在类中装饰一个不需要self参数 也不需要cls参数的函数
1.property
class Circle:
def __init__(self,r):
self.r=r
@property
def area(self):
return self.r**2
@property
def prmite(self):
return self.r*2
c=Circle(5)
print(c.area()) TypeError:此时area是属性
print(c.area) # 25 用属性方法调用。不能用c.area
#####property属性和setter.delete合用###
class Person:
def __init__(self,name):
self.__name=name
@property
def name(self):
return self.__name
@name.setter
def name(self,new_name):
if type(new_name)==str:
self.__name=new_name
@name.deleter
def name(self):
del self.__name
alex=Person("alex")
print(alex.name)
alex.name="alex_sb"
print(alex.name)
del alex.name
商品 价格 原价 打折 = 折后价
class Goods:
def __init__(self,name,price,discount):
self.name = name
self.__price = price
self.discount = discount
@property
def price(self):
return self.__price * self.discount
apple = Goods('apple',5,0.8)
print(apple.price)
View Code
2.classmethod
类方法是被@classmethod装饰的特殊方法:
1.被装饰之后,方法默认接收一个 类 作为参数
2.之后所有的操作都只能和类中的静态变量相关 而不应该和对象相关
3.类名 和 对象名 都可以直接调用类方法
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_dis): # 类方法
cls.__discount = new_dis
Goods.change_discount(1)
cig = Goods('cigrette',20)
print(cig.price)
cig.change_discount(0.2)
print(cig.price)
View Code
3.staticmethod
class Student:
def __init__(self,name):
self.name = name
@staticmethod #装饰一个不需要self参数 也不需要cls参数的函数
def login(a,b,c): # 普通的函数
usr = input('username>>>')
pwd = input('password>>>')
if usr == 'alex' and pwd == '123':
obj = Student(usr)
return obj
ret = Student.login(1,2,3)
print(ret)
View Code
房间类 : 所有人 价格 面积
class Room:
def __init__(self,owner,price,length,width,height):
self.owner = owner
self.__price_single = price #单价
self.__length = length
self.__width = width
self.height = height
def get_area(self):
return self.__length * self.__width
def get_price(self):
return self.__price_single * self.get_area()
alex = Room('alex',1000000,2,1,0.8)
print(alex.get_area())
print(alex.get_price())
View Code