私有属性分为两类分别是对象的私有变量以及类的静态私有变量,除了变量外,还有私有方法;在类中,所有私有的属性和方法都是在变量的左边加上双下划线的方式定义,所有的私有变量和私有方法都不能在类的外部使用
庆安ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景,ssl证书未来市场广阔!成为成都创新互联的ssl证书销售渠道,可以享受市场价格4-6折优惠!如果有意向欢迎电话联系或者加微信:028-86922220(备注:SSL证书合作)期待与您的合作!
class Person():
__pwd = "123456" # 私有静态变量
def __init__(self,name,price):
self.name = name
self.__price = price # 私有变量
# 私有方法
def __add_price(self):
return self.__price*2
eric= Person("eric",20000000)
# 私有变量和方法无法在外部调用,虽然可以通过_类名__属性名方式调用私有变量,但不提倡使用
print(eric._Person__price)
print(eric._Person__pwd)
print(eric._Person__add_price())
20000000
123456
40000000
python的属性其实是普通方法的变种
有两种定义方式:
1、普通方法加上property装饰器
2、在类中定义值为property对象的静态字段
property是一种特殊的属性,当我们访问被property装饰的函数时,执行函数内的代码,得到返回值。
from math import pi
class Circle():
def __init__(self,radius):
self.radius = radius
@property
def perimeter(self):
return 2*pi*self.radius
@property
def area(self):
return self.radius**2*pi
c1 = Circle(5)
# 未带装饰器调用方法
# print(c1.area())
# 带装饰器时当成属性调用
print(c1.area)
使用property装饰器定义属性时,要注意被property装饰的普通方法只能有self一个参数,并且在调用时不需要加()。
在python3之后,所有的类默认继承了object,所以说,所有的类都是新式类,新式类的property有三种访问方式,并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法
class Goods(object):
def __init__(self):
# 原价
self.original_price = 100
# 折扣
self.discount = 0.8
@property
def price(self):
# 实际价格 = 原价 * 折扣
new_price = self.original_price * self.discount
return new_price
@price.setter
def price(self, value):
self.original_price = value
@price.deleter
def price(self):
del self.original_price
obj = Goods()
print(obj.price) # 获取商品价格
obj.price = 200 # 修改商品原价
del obj.price # 删除商品原价
静态字段方式没有新式类和经典类的区别;静态字段定义方式也有三种访问方式:分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法
class Person():
def __init__(self,name):
self.__name = name
def get_name(self):
return self.__name
def set_name(self,newname):
self.__name = newname
def del_name(self):
del self.__name
NAME = property(get_name,set_name,del_name) #定义property静态字段
obj = Person("eric")
print(obj.NAME) #调用get_name方法
obj.NAME = "111" #调用set_name方法
del Person.NAME #调用del_name方法
方法包括:普通方法、静态方法和类方法,三种方法在内存中都归属于类,区别在于调用方式不同。
普通方法:由对象调用;至少一个self参数;执行普通方法时,自动将调用该方法的对象赋值给self;
类方法:由类调用; 至少一个cls参数;执行类方法时,自动将调用该方法的类复制给cls;
静态方法:由类调用;无默认参数;
class Goods():
__discount = 0.8
def __init__(self,name,price):
self.name = name
self.__price = price
def price(self): # 普通方法
return self.__price*Goods.__discount
@classmethod
def change_discount(cls,new_discount): # 类方法
cls.__discount = new_discount
@staticmethod
def get_user_pwd(): #静态方法
user = input('please input username: ')
pwd = input('please input pwd: ')
apple = Goods('apple',10)
Goods.change_discount(0.9) # 类方法调用
Goods.get_user_pwd() # 静态方法调用
小结:
1、类方法
类方法是把一个方法,变成一个类中的方法,这个方法就直接可以被类调用,不需要通过对象来调用;
类方法一般用于只涉及操作静态变量时使用。
2、静态方法
一个函数,在与对象以及类没什么关系的情况下,要完全的面向对象编程,此时,就可以用staticmethod将这个函数变成类中的静态方法。
反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力(自省)。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。
反射在python中通过字符串的形式操作对象相关的属性,由四个内置函数hasattr(),getattr(),setattr(),delattr()来实现。
class Person():
country="zhongguo"
@classmethod
def sex(cls):
print(111)
#检测是否含有某属性
if hasattr(Person,"a1"):
getattr(Person,"a1")
#设置属性
setattr(Person,"country","meiguo")
#获取属性
ret=getattr(Person,"country")
#删除属性
delattr(Person,"country")
print(ret)
isinstance(obj,cls)检查obj是否是cls的对象
issubclass(sub,super)检查sub类是否是super类的子类
classA():pass
classB(A):pass
a=A()
print(isinstance(a,A))
print(issubclass(A,B))
print(issubclass(B,A))
__doc__
表示类的描述信息
class Person():
'''__doc__:description '''
pass
print(Person.__doc__)
__doc__:description
__init__
类实例化对象时,自动执行类中的init方法
class Person():
def __init__(self,name,age):
self.name = name
self.age = age
stu = Person("eric",20)
__del__
析构方法,当对象在内存中被释放时,自动触发执行。
再删除一个对象之前进行一些收尾工作
__call__
对象后加括号,触发执行
class Person():
def __init__(self,name,age):
self.name = name
self.age =age
def __call__(self, *args, **kwargs):
# 打印对象的所有属性
for key in self.__dict__:
print(key,self.__dict__[key])
eric = Person("eric",22)
eric()
__dict__
保存类或对象中的成员
classPerson():
country="china"
def__init__(self,name,age):
self.name=name
self.age=age
#获取类的成员--静态字段和方法
print(Person.__dict__)
#获取对象的成员
obj=Person("eric",22)
print(obj.__dict__)
__str__和__repr__
字符串显示
打印一个对象时,就是调用这个对象所属类的__str__
方法,
调用__str__
方法,会返回调用这个方法的对象的内存地址
字符串格式化%s以及str()直接打印实际上都是调用的__str__
方法
%r,repr()都是调用的__repr__
方法
repr时str的备份,str不能做repr的备份
print(obj)/%s/str(obj)的时候,实际上是内部调用了obj.__str__
方法,如果由str方法,那么他返回的必定是一个字符串
如果没有str方法,会先找本类中的__repr__
方法
class A:
def __str__(self):
return"Aobject"
def __repr__(self):
return"repr"
a=A()
#打印一个对象时,就是调用这个对象所属类的__str__方法,
print(a)
print(repr(a))
用于索引操作,分别是获取,设置,删除
class Person():
def __getitem__(self,key):
print("__getitem__",key)
def __setitem__(self,key,value):
print("__setitem__",key,value)
def __delitem__(self,key):
print("__delitem__",key)
obj=Person()
ret=obj['k1']#自动触发执行__getitem__
obj['k2']='eric'#自动触发执行__setitem__
delobj['k1']#自动触发执行__delitem__
__len__
统计数量,len(obj)其实就是调用自身所属类或父类的__len__
方法
class Person():
def __init__(self,name,age):
self.name=name
self.age=age
def __len__(self):
returnlen(self.__dict__)
eric=Person("eric",22)
print(len(eric))
__new__
通过类的构造方法创建对象
class Person():
def func(self):pass
eric=Person()
单例模式
通过new方法来实现的单例模式
单例模式:一个类始终只有一个实例,当你第一次实例化这个类的时候,就创建一个实例化的对象,当你之后再来实例化的时候,就用之前创建的对象
class A():
__instance=False
def __init__(self,name,age):
self.name=name
self.age=age
def __new__(cls,*args,**kwargs):
if cls.__instance:
return cls.__instance
cls.__instance=object.__new__(cls)
returncls.__instance
egon=A("eric",22)
jonny=A("jonny",28)
print(egon)
print(jonny)
结果:
<main.A object at 0x0000015C2480E5C0>
<main.A object at 0x0000015C2480E5C0>
__eq__
判断两个对象是否相等(通过内存地址)
class Person():
def __init__(self,name):
self.name = name
obj1 = Person("eric")
obj2 = Person("eric")
print(obj1 == obj2)
结果为False,是因为两个对象的值虽然一样,但是在内存中的地址不一样;我们可以重写__eq__
方法,使其比对对象的值而非内存地址。
class Person():
def __init__(self,name):
self.name = name
def __eq__(self, other):
if self.name == self.name:
return True
else:
return False
obj1 = Person("eric")
obj2 = Person("eric")
print(obj1 == obj2)