面向对象编程——类(class)2

1、类成员修饰符

公共成员：能够在类的外部访问到。咱们以前接触到的都是公共成员

私有成员：只能在该类的内部才能直接访问到的(子类也不能直接访问)；在外部，能够经过间接方法才能取得。 以字段(普通字段和静态字段相同)为例，开头加__(双下划线)使字段变为私有字段；方法也同样，方法名前面加__(双下划线)便可。

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方法才能拿到

 

2、类中的特殊成员

一、 构造方法 __init__方法

类() 自动执行

二、 相似构造方法，这里是一个特殊的调用方法 __call__方法

对象() 或者 类()() 自动执行

class foo:
    def __init__(self):
        print("in init")

    def __call__(self,*args,**kwargs):
        print("in call")

obj = foo()         # 建立对象 obj
obj()               # 对象后面加括号，调用，则执行类中的__call__方法

三、 特殊方法 __int__方法

class foo:
    def __init__(self):
        pass

    def __int__(self):
        return 123

obj = foo()
print(obj,type(obj))

print(int(obj))         # 将obj对象强制转换为int类型。返回123

在上面例子中，咱们执行 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打印这个返回值。

四、 __dict__方法 ，对象里自带的 　　　　　　　 重要

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为  _类名+该私有成员名

五、 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()

 

以上感谢武老师的博客。

反射

单例模式