私有属性分为两类分别是对象的私有变量以及类的静态私有变量，除了变量外，还有私有方法；在类中，所有私有的属性和方法都是在变量的左边加上双下划线的方式定义，所有的私有变量和私有方法都不能在类的外部使用

class Person(): __pwd = "123456" # 私有静态变量 def __init__(self,name,price): self.name = name self.__price = price # 私有变量 # 私有方法 def __add_price(self): return self.__price*2eric= Person("eric",20000000)# 私有变量和方法无法在外部调用，虽然可以通过_类名__属性名方式调用私有变量,但不提倡使用print(eric._Person__price)print(eric._Person__pwd)print(eric._Person__add_price())

2000000012345640000000二、类的属性

python的属性其实是普通方法的变种
有两种定义方式：
1、普通方法加上property装饰器
2、在类中定义值为property对象的静态字段

property是一种特殊的属性，当我们访问被property装饰的函数时，执行函数内的代码，得到返回值。

from math import piclass 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*pic1 = 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_priceobj = 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和issubclass

isinstance(obj,cls)检查obj是否是cls的对象
issubclass(sub,super)检查sub类是否是super类的子类

classA():passclassB(A):passa=A()print(isinstance(a,A))print(issubclass(A,B))print(issubclass(B,A))六、类的内置方法1、__doc__

表示类的描述信息

class Person(): '''__doc__:description ''' passprint(Person.__doc__)__doc__:description 2、初始化方法__init__

类实例化对象时，自动执行类中的init方法

class Person(): def __init__(self,name,age): self.name = name self.age = agestu = Person("eric",20)3、析构方法__del__

析构方法，当对象在内存中被释放时，自动触发执行。
再删除一个对象之前进行一些收尾工作

对象后加括号，触发执行

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()5、__dict__

保存类或对象中的成员

classPerson():country="china"def__init__(self,name,age):self.name=nameself.age=age#获取类的成员--静态字段和方法print(Person.__dict__)#获取对象的成员obj=Person("eric",22)print(obj.__dict__)6、__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))7、getitem、setitem、delitem

用于索引操作，分别是获取，设置，删除

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__8、__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))9、构造方法__new__

通过类的构造方法创建对象

class Person(): def func(self):passeric=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.__instanceegon=A("eric",22)jonny=A("jonny",28)print(egon)print(jonny)

结果：
<main.A object at 0x0000015C2480E5C0>
<main.A object at 0x0000015C2480E5C0>

判断两个对象是否相等（通过内存地址）

class Person(): def __init__(self,name): self.name = nameobj1 = 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 Falseobj1 = Person("eric")obj2 = Person("eric")print(obj1 == obj2)