标签：base 字符 理论 类中访问 iter com 如何 查看 func
本节内容：
1、类的成员
1.1字段
1.2方法
1.3属性
2、成员修饰符
3、类的特殊成员
1、类的成员
类的成员可以分为三大类：字段、方法、属性。
字段分为：普通字段、静态字段。
方法分为：普通方法、静态方法、类方法。
所有成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份。
1.1字段
字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同。
语法如下
1 class Province: 2 # 静态字段，属于类 3 country = ‘中国‘ 4 5 def __init__(self, name): 6 # 普通字段，属于对象 7 self.name = name 8 9 #创建对象 10 henan = Province(‘河南‘) 11 hebei = Province(‘河北‘) 12 13 #直接访问静态字段 14 print(Province.country) #输出：中国 15 16 #直接访问普通字段 17 print(henan.name) #输出：河南
由上述代码可以看出【普通字段需要通过对象来访问】【静态字段通过类访问】，在使用上可以看出普通字段和静态字段的归属是不同的。
其在内容的存储方式类似如下图：
由上图可示：
应用场景： 通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段。
1.2方法
方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。
普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self。
类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls。
静态方法：由类调用；无默认参数。
普通方法
1 class Foo: 2 3 #普通方法 4 def func(self): 5 #定义普通方法，至少有一个self参数 6 print(‘do something...‘) 7 8 #调用普通方法 9 obj_1 = Foo() 10 obj_1.func()
类方法
1 class Foo: 2 3 #类方法 4 @classmethod 5 def func(cls): 6 #定义类方法，至少有一个cls参数 7 print(‘do something...‘) 8 9 #调用类方法，cls是类名 10 Foo.func()
静态方法
1 class Foo: 2 3 #静态方法 4 @staticmethod 5 def func(): 6 #定义静态方法，无默认参数 7 print(‘do something...‘) 8 9 #调用静态方法，不用通过对象调用 10 Foo.func()
1.3属性
Python中的属性其实是普通方法的变种。
属性方法的作用就是通过@property把一个方法变成一个静态属性。
语法
1 class Foo: 2 3 #普通方法 4 def func(self): 5 #定义普通方法，至少有一个self参数 6 print(‘do something...‘) 7 8 #定义属性 9 @property 10 def pro_func(self): 11 print(‘do something...‘) 12 13 #创建对象 14 obj_1 = Foo() 15 16 #调用普通方法 17 obj_1.func() 18 19 #调用属性，调用时不用括号，用则报错 20 obj_1.pro_func
由属性的定义和调用要注意一下几点：
属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象。
属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。
属性的其他操作
1 class Foo: 2 3 @property 4 def pro_func(self): 5 print(‘do something...‘) 6 7 @pro_func.setter 8 def pro_func(self,value): 9 print(‘do something...‘) 10 11 @pro_func.deleter 12 def pro_func(self): 13 print(‘do something...‘) 14 15 #调用 16 obj = Foo() 17 18 obj.pro_func #自动执行 @property 修饰的 pro_func 方法，并获取方法的返回值 19 20 obj.pro_func = 666 #自动执行 @pro_func.setter 修饰的 pro_func 方法，并将 666 赋值给方法的参数 21 22 del obj.pro_func #自动执行 @pro_func。deleter 修饰的 pro_func方法 23 24 #调用与方法一一对应，当出现此调用语句时，执行该方法，仅仅是执行该方法。而所执行的程序，由方法内部定义。
2、成员修饰符
对于每一个类的成员而言都有两种形式：
私有成员和公有成员的定义不同
私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）
1 class Foo: 2 def __init__(self,name,age): 3 self.name = name 4 #self.age = age #公有字段 5 self.__age = age #私有字段
私有成员和公有成员的访问限制不同：
静态字段
1 class C: 2 3 name = "公有静态字段" 4 5 def func(self): 6 print C.name 7 8 class D(C): 9 10 def show(self): 11 print C.name 12 13 14 C.name # 类访问 15 16 obj = C() 17 obj.func() # 类内部可以访问 18 19 obj_son = D() 20 obj_son.show() # 派生类中可以访问
1 class C: 2 3 __name = "公有静态字段" 4 5 def func(self): 6 print C.__name 7 8 class D(C): 9 10 def show(self): 11 print C.__name 12 13 14 C.__name # 类访问 ==> 错误 15 16 obj = C() 17 obj.func() # 类内部可以访问 ==> 正确 18 19 obj_son = D() 20 obj_son.show() # 派生类中可以访问 ==> 错误
普通字段
ps：如果想要强制访问私有字段，可以通过 【对象._类名__私有字段明 】访问（如：obj._C__foo），不建议强制访问私有成员。
1 class C: 2 3 def __init__(self): 4 self.foo = "公有字段" 5 6 def func(self): 7 print self.foo # 类内部访问 8 9 class D(C): 10 11 def show(self): 12 print self.foo ＃ 派生类中访问 13 14 obj = C() 15 16 obj.foo # 通过对象访问 17 obj.func() # 类内部访问 18 19 obj_son = D(); 20 obj_son.show() # 派生类中访问
1 class C: 2 3 def __init__(self): 4 self.__foo = "私有字段" 5 6 def func(self): 7 print self.foo # 类内部访问 8 9 class D(C): 10 11 def show(self): 12 print self.foo ＃ 派生类中访问 13 14 obj = C() 15 16 obj.__foo # 通过对象访问 ==> 错误 17 obj.func() # 类内部访问 ==> 正确 18 19 obj_son = D(); 20 obj_son.show() # 派生类中访问 ==> 错误
方法、属性的访问于上述方式相似，即：私有成员只能在类内部使用
ps：非要访问私有属性的话，可以通过 对象._类__属性名
3、类的特殊成员
3.1 __doc__
表示类的描述信息
1 class Foo: 2 """类的信息""" 3 4 def fnce(self): 5 pass 6 7 print(Foo.__doc__) #输出：类的信息
3.2 __module__和__class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
1 class Foo: 2 """类的信息""" 3 def __init__(self): 4 self.name="zhangsan" 5 6 def fnce(self): 7 pass 8 9 # print(Foo.__doc__) #输出：类的信息 10 11 obj = Foo() 12 print(obj.__module__) #输出：__main__，即输出模块 13 print(obj.__class__) #输出：<class ‘__main__.Foo‘>，即输出类
3.3 __init__
构造方法，通过类创建对象时，自动触发
1 class Foo: 2 """类的信息""" 3 def __init__(self,name): 4 self.name = name 5 self.age = 20 6 print(‘执行中...‘) 7 8 def fnce(self): 9 pass 10 11 obj = Foo(‘张三‘) #输出：执行中... 自动执行类中的 __init__ 方法
3.4 __del__
析构方法，当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
3.5 __call__
对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
1 class Foo: 2 """类的信息""" 3 def __init__(self,name): 4 self.name = name 5 self.age = 20 6 print(‘执行中...‘) 7 8 def __call__(self): 9 pass 10 11 obj = Foo(‘张三‘) #输出：执行中... 自动执行类中的 __init__ 方法 12 13 obj() # =>Foo()() 执行__call__方法
3.6 __dict__
查看类或对象中的所有成员，将 字段/类 成员通过字典展示。
类的普通字段属于对象；类中的静态字段和方法等属于类。
1 class Province: 2 3 country = ‘China‘ 4 5 def __init__(self, name, count): 6 self.name = name 7 self.count = count 8 9 def func(self, *args, **kwargs): 10 print ‘func‘ 11 12 # 获取类的成员，即：静态字段、方法、 13 print Province.__dict__ 14 # 输出：{‘country‘: ‘China‘, ‘__module__‘: ‘__main__‘, ‘func‘: <function func at 0x10be30f50>, ‘__init__‘: <function __init__ at 0x10be30ed8>, ‘__doc__‘: None} 15 16 obj1 = Province(‘HeBei‘,10000) 17 print obj1.__dict__ 18 # 获取 对象obj1 的成员 19 # 输出：{‘count‘: 10000, ‘name‘: ‘HeBei‘} 20 21 obj2 = Province(‘HeNan‘, 3888) 22 print obj2.__dict__ 23 # 获取 对象obj1 的成员 24 # 输出：{‘count‘: 3888, ‘name‘: ‘HeNan‘}
3.7 __str__
如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
1 class Foo: 2 3 def __str__(self): 4 return ‘这是__str__方法‘ 5 6 obj = Foo() 7 print(obj) #输出：这是__str__方法
3.8 __getitem__、__setitem__、__delitem
用于索引操作，如字典。以上分别表示获取、设置、删除数据
1 class Foo: 2 3 def __getitem__(self, key): 4 print ‘__getitem__‘,key 5 6 def __setitem__(self, key, value): 7 print ‘__setitem__‘,key,value 8 9 def __delitem__(self, key): 10 print ‘__delitem__‘,key 11 12 13 obj = Foo() 14 15 result = obj[‘k1‘] # 自动触发执行 __getitem__ 16 obj[‘k2‘] = ‘wupeiqi‘ # 自动触发执行 __setitem__ 17 del obj[‘k1‘] # 自动触发执行 __delitem__
执行命令与方法一一对应，出现该命令则执行对于方法。而其作用则由方法内部定义。
3.9 getattr()、hasattr()、setattr()、delattr()
通过字符串的形式操作对象中的成员
1 class Foo: 2 name = ‘李四‘ 3 age = 21 4 5 def func(self): 6 return 111 7 8 obj = Foo() 9 10 print(getattr(obj,‘name‘)) #输出：李四 11 print(getattr(obj,‘func‘)) #输出：<bound method Foo.func of <__main__.Foo object at 0x000001DB08168160>> 12 13 r = getattr(obj,‘func‘) 14 print(r()) #输出：111 15 # print(getattr(obj,‘country‘)) #属性 country 不存在，报错！ 16 print(getattr(obj,‘country‘,‘China‘)) #属性 country 不存在，但设置了默认值 17 18 print(hasattr(obj,‘name‘)) #True 19 print(hasattr(obj,‘show‘)) #False 20 21 print(getattr(obj,‘age‘)) #21 22 setattr(obj,‘age‘,30) #设置 age 属性，如果属性不存在会创建一个新的对象属性，并对属性赋值. 23 print(getattr(obj,‘age‘)) #30 24 25 print(getattr(obj,‘name‘)) #李四 26 delattr(obj,‘name‘) #删除 name 属性 27 print(getattr(obj,‘name‘)) #触发错误
3.10 __iter__
用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__。
1 #第一步 2 class Foo: 3 pass 4 5 obj = Foo() 6 7 for i in obj: 8 print(i) 9 #报错：TypeError: ‘Foo‘ object is not iterable 10 11 12 #第二步 13 class Foo: 14 15 def __iter__(self): 16 pass 17 18 obj = Foo() 19 20 for i in obj: 21 print(i) 22 # 报错：TypeError: iter() returned non-iterator of type ‘NoneType‘ 23 24 25 #第三步 26 class Foo: 27 28 def __init__(self, sq): 29 self.sq = sq 30 31 def __iter__(self): 32 return iter(self.sq) 33 34 obj = Foo([11,22,33,44]) 35 36 for i in obj: 37 print(i)
以上步骤可以看出，for循环迭代的其实是 iter([11,22,33,44]) ，所以执行流程可以变更为：
1 obj = iter([11,22,33,44]) 2 3 4 for i in obj: 5 print(i)
3.11 __new__ 和 __metaclass__
万物皆对象
1 class Foo(object): 2 3 def __init__(self): 4 pass 5 6 obj = Foo() # obj是通过Foo类实例化的对象
上述代码中，obj 是通过 Foo 类实例化的对象，其实，不仅 obj 是一个对象，Foo类本身也是一个对象，因为在Python中一切事物都是对象。
如果按照一切事物都是对象的理论：obj对象是通过执行Foo类的构造方法创建，那么Foo类对象应该也是通过执行某个类的 构造方法 创建。
1 print (type(obj)) # 输出：<class ‘__main__.Foo‘> 表示，obj 对象由Foo类创建 2 print (type(Foo)) # 输出：<type ‘type‘> 表示，Foo类对象由 type 类创建
所以，obj对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是通过type类的构造方法创建。
那么，创建类就可以有两种方式：
普通方法：
1 class Foo(object): 2 3 def func(self): 4 print(‘hello wupeiqi‘)
特殊方法（type类的构造函数）：
1 def func(self): 2 print(‘hello wupeiqi‘) 3 4 Foo = type(‘Foo‘,(object,), {‘func‘: func}) 5 #type第一个参数：类名 6 #type第二个参数：当前类的基类 7 #type第三个参数：类的成员
==>类 是由 type 类实例化产生
那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的创建类？类又是如何创建对象？
答：类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看 类 创建的过程。
1 class MyType(type): 2 3 def __init__(self, what, bases=None, dict=None): 4 super(MyType, self).__init__(what, bases, dict) 5 6 def __call__(self, *args, **kwargs): 7 obj = self.__new__(self, *args, **kwargs) 8 9 self.__init__(obj) 10 11 class Foo(object): 12 13 __metaclass__ = MyType 14 15 def __init__(self, name): 16 self.name = name 17 18 def __new__(cls, *args, **kwargs): 19 return object.__new__(cls, *args, **kwargs) 20 21 # 第一阶段：解释器从上到下执行代码创建Foo类 22 # 第二阶段：通过Foo类创建obj对象 23 obj = Foo()
执行流程：
1、首先创建Foo类时，执行type的__init__方法 => class Foo:
2、当创建对象obj时，执行type的__call__方法 => obj = Foo()
3、然后type的__call__方法指引Foo类执行__new__方法
4、接着由“object”创建出来对象
5、最后由type的__call__方法指引Foo类执行__init__方法
标签：base 字符 理论 类中访问 iter com 如何 查看 func
原文地址：https://www.cnblogs.com/Yan-night/p/11470176.html
