注：所有成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份

class Foo:# 方法def __init__(self, name):# 实例变量/字段self.name = name# 方法def func(self):pass
# obj,Foo类的对象
# obj,Foo类的实例
obj = Foo('jiumo')

字段包括实例变量和静态变量，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同

由上图可是：

应用场景： 通过类创建对象时，如果每个对象都具有相同的变量，那么就使用静态变量

# 类变量/实例变量
class Foo:# 类变量/静态字段country = '中国'# 方法def __init__(self, name):# 实例变量/字段self.name = namedef func(self):passobj1 = Foo('jiumo')
obj2 = Foo('王XX')
obj1.country = '美国'
print(obj1.country)
print(obj2.country)obj1 = Foo('jiumo')
obj2 = Foo('王XX')
Foo.country = '美国'
print(obj1.country)
print(obj2.country)
==>美国
中国
美国
美国

实例变量（字段）

- 公有实例变量（字段）

# 公有实例变量(字段)
class Foo:def __init__(self, name):self.name = nameself.age = 123# 内部调用def func(self):print(self.name)
obj = Foo("jiumo")
# 外部调用
print(obj.name) # jiumo
print(obj.age)  # 123
obj.func()  # jiumo

- 私有实例变量（字段）

# 私有实例变量(字段)
class Foo:def __init__(self, name):# 定义为私有self.__name = nameself.age = 123# 内部调用def func(self):print(self.__name)
obj = Foo("jiumo")
# 外部不可直接调用
# print(obj.name)     # 报错AttributeError: 'Foo' object has no attribute 'name'
print(obj.age)
obj.func()  # 间接访问:让func帮助执行内部私有的__name  就相当在类的内部有认识的”关系” 间接的得到想要的内容

类变量（静态字段）

- 公有类变量（静态字段）

# 默认公有类变量(字段)
class Foo:country = "中国"def __init__(self):passdef func(self):# 内部调用print(self.country)print(Foo.country)  # 推荐
# 外部调用
print(Foo.country)    # 中国

- 私有类变量（静态字段）

# 私有
class Foo:__country = "中国"def __init__(self):passdef func(self):# 内部调用print(self.__country)print(Foo.__country)  # 推荐
# 外部无法直接调用
# print(Foo.__country)
obj = Foo()
obj.func(

准则：

实例变量（字段）访问时，使用对象访问，即：obj1.name

类变量（静态字段）访问时，使用类访问，即：Foo.country（实在不方便时才使用对象）

易错点：

obj1 = Foo('jiumo')
obj2 = Foo('王XX')obj1.name = '老王'
print(obj1.name)
print(obj2.name)
==>老王
王XX

什么时候用类变量：

当所有对象中有共同的字段，并且值永远同步，那么可以使用类变量

父类中的私有字段子辈无法知道，但是可以通过调用父类得到

# 子类也不能直接调用父类的私有字段
class Bsae(object):__secret = "RMB"
class Foo(Bsae):def func(self):# print(self.__secret)  # AttributeError: 'Foo' object has no attribute '_Foo__secret'print(Foo.__secret)     # AttributeError: type object 'Foo' has no attribute '_Foo__secret'
obj = Foo()
obj.func()
# 同样可以利用间接调用的方法得到私有字段
class Bsae(object):__secret = "RMB"def money(self):print(Bsae.__secret)
class Foo(Bsae):def func(self):pass
obj = Foo()
obj.money()

实例方法

静态方法

1. 定义时：

- 方法上方写 @staticmethod

- 方法参数可有可无

2. 调用时：

- 类.方法名() # 推荐使用

- 对象.方法名()

3. 什么时候使用静态方法：

- 无需调用对象中封装的值

- 类方法

1. 定义时：

- 方法上方写：@classmethod

- 方法的参数：至少有一个cls参数

2. 执行时：

- 类名.方法名 # 默认会将当前类传到参数中

3. 什么时使用类方法：

- 如果在方法中会使用到当前类，那么就可以使用类方法

# 没必要写实例方法
class Foo(object):def __init__(self, name):self.name = namedef func(self):print('实例方法')   # 没有用到构建方法中的值
obj = Foo('jiumo')
obj.func()
# 有意义的实例方法
class Foo(object):def __init__(self, name):self.name = name# 实例方法,最少有一个参数def func(self):print(self.name)    # wb# 静态方法,可以没有参数.  如果方法中无需使用对象中封装的值,那么就可以使用静态方法# 可以通过类直接调用,不需要实例化类这部操作
    @staticmethoddef display():print('静态方法')    # 静态方法# 类方法
    @classmethoddef train(cls, name):
print(cls)        # <class '__main__.Foo'>print(name)        # 类方法
# 实例方法
obj = Foo('wb')
obj.func()
# 静态方法的调用
Foo.display()
# 类方法的调用
Foo.train('类方法')==>实例方法
wb
静态方法
<class '__main__.Foo'>
类方法

方法的成员修饰符：方法也有公有方法和私有方法之分 用法同变量的成员修饰符

# 私有的实例方法
class Foo(object):def __init__(self):passdef __display(self,arg):print('私有方法',arg)def func(self):self.__display(123)
obj = Foo()
# obj.__display(123) # 无法访问
obj.func()
# 私有的静态方法
class Foo(object):def __init__(self):pass@staticmethoddef __display(arg):print('私有静态 方法',arg)    # 私有静态 方法 123def func(self):Foo.__display(123)@staticmethoddef get_display():Foo.__display(888)  #私有静态 方法 888
# Foo.__display(123) 报错
obj = Foo()
obj.func()Foo.get_display()

class Foo(object):def __init__(self):pass@propertydef start(self):return 1@propertydef end(self):return 10
obj = Foo()
print(obj.start)
print(obj.end)

1 编写时：

- 方法上方写@property

- 方法参数：只有一个self参数

2 调用时：

- 无需加括号 对象.方法

3 应运场景：

- 对于简单的方法，当无需传参且有返回值时

class Foo():# 1.def __init__(self,a1, a2):self.a1 = a1self.a2 = a2# 2.def __call__(self, *args, **kwargs):print('wb', args, kwargs)return 123# 3.def __getitem__(self, item):print(item)return 123# 4.def __setitem__(self, key, value):  # 无返回值print(key, value, 123)# 5.def __delitem__(self, key): # 无返回值print(key)# 6.def __add__(self, other):return self.a1 + other.a1# 7.def __enter__(self):print('开始代码')return 999# 8.def __exit__(self, exc_type, exc_val, exc_tb):print("结束代码")1.类名() 自动执行 __init__obj = Foo(1, 2)2.对象() 自动执行 __call__ret = obj(2018, 9, time = 2)print(ret)3.对象[] 自动执行 __getitem__ret = obj['wang']print(ret)4.对象['xx'] = 11 自动执行 __setitem__obj['k1'] = 1235.del 对象['xx'] = 11 自动执行 __delitem__del obj['wang']6.对象+对象       自动执行 __add__9. with 对象    自动执行__enter__ 和 __exit__obj = Foo(1, 2)with obj as f:print(f)print('内部代码')10.真正的构造方法 __new__class Foo(object):def __init__(self,a1, a2):print(1)self.a1 = a1self.a2 = a2def __new__(cls, *args, **kwargs):print(2)    # 执行到此处中断了Foo(1, 2)