一、类成员修饰符
公共成员：可以在类的外部访问到。我们之前接触到的都是公共成员
私有成员：只能在该类的内部才能直接访问到的(子类也不能直接访问)；在外部，可以通过间接方法才能取得。 以字段(普通字段和静态字段相同)为例，开头加__(双下划线)使字段变为私有字段；方法也一样，方法名前面加__(双下划线)即可。
-
class db: def __init__(self,ip,username,passwd): self.__ip = ip self.__username = username self.__passwd = passwd def show(self): return self.__ip obj = db('1.1.1.1','root','123456') print(obj.__ip) # 会报异常 ip = obj.show() print(ip) # 通过show方法才能拿到
二、类中的特殊成员
1、 构造方法 __init__方法
类() 自动执行
2、 类似构造方法，这里是一个特殊的调用方法 __call__方法
对象() 或者 类()() 自动执行
<pre>
class foo:
def __init__(self):
print("in init")
def __call__(self,*args,**kwargs):
print("in call")
obj = foo() # 创建对象 obj
obj() # 对象后面加括号，调用，则执行类中的__call__方法
</pre>
3、 特殊方法 __int__方法
<pre>
class foo:
def __init__(self):
pass
def __int__(self):
return 123
obj = foo()
print(obj,type(obj))
print(int(obj)) # 将obj对象强制转换为int类型。返回123
</pre>
在上面例子中，我们执行 int(对象)，则自动执行 对象的\_\_int__方法，并将返回值赋值给 int(对象)；
实际字符串强转整型时，就是这样。我们定义字符串时，其实是调用的str类，将我们定义的字符串的值传给了该类中。s = 'bashrunning' 就是 s = str('bashrunning'),可以看出，s就是一个对象。
同理，还有 __str__方法、列表的(__getitem__、__setitem__、__delitem__)方法。
我们用的比较多的是__str__方法。 使用案例：
class ourssh:
def __init__(self,ip,username,passwd):
self.ip = ip
self.username = username
self.passwd = passwd
def __str__(self):
return 'ip=%s\nusername=%s\npasswd=%s' %(self.ip,self.username,self.passwd)
obj = ourssh('1.1.1.1','root','123456')
print(obj) # 执行print时，实际上是执行的 str(obj)。如果ourssh类 中没有定义 __str__方法，则打印 <__main__.ourssh object at 0x0000018941FEB3C8>。定义了 __str__方法后，则打印 __str__方法返回的值
print操作，其实是两个步骤:print(abc) == print(str(abc))
步骤一： str(abc) ,调用 abc的__str__方法，得到返回值。 步骤二： print打印这个返回值。
4、 __dict__方法 ，对象里自带的 重要
<pre>
class foo:
def __init__(self,name,age):
self.name = name
self.age = age
self.id = None
obj = foo("bash",22)
print(obj.__dict__) # 返回一个字典 {'name': 'bash', 'age': 22, 'id': None} 这是这个对象的所有成员。如果成员是私有成员，则该成员的key为 _类名+该私有成员名
print(foo.__dict__) # 返回一个字典，这个类的所有成员。 如果成员是私有成员，则该成员的key为 _类名+该私有成员名
</pre>
5、 for循环拆解
for循环遇到的对象是一个迭代器，则直接执行该对象的__next__方法。
for循环遇到的对象是一个可迭代对象，则先执行__iter__方法来获取迭代器，然后再执行__next__方法。
metaclass，元类，原始类，类的祖先
在python中，一切事物皆是对象。
__new__ 和 __metaclass__ 方法
创建类就可以有两种方式：
-
a). 普通方式
class Foo(object): def func(self): print 'hello wupeiqi' -
b).特殊方式（type类的构造函数）
def func(self): print 'hello wupeiqi' Foo = type('Foo',(object,), {'func': func}) #type第一个参数：类名 #type第二个参数：当前类的基类 #type第三个参数：类的成员
类默认是由 type 类实例化产生，type类中如何实现的创建类？类又是如何创建对象？
答：类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看 类 创建的过程。
class MyType(type):
def __init__(self, what, bases=None, dict=None):
super(MyType, self).__init__(what, bases, dict)
def __call__(self, *args, **kwargs):
obj = self.__new__(self, *args, **kwargs)
self.__init__(obj)
class Foo(object):
__metaclass__ = MyType
def __init__(self, name):
self.name = name
def __new__(cls, *args, **kwargs):
return object.__new__(cls, *args, **kwargs)
# 第一阶段：解释器从上到下执行代码创建Foo类
# 第二阶段：通过Foo类创建obj对象
obj = Foo()
以上感谢武老师的博客。