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

Posted 2021-01-25 hacker001

一、类成员修饰符

公共成员：可以在类的外部访问到。我们之前接触到的都是公共成员

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

• 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
username=%s
passwd=%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()

以上感谢武老师的博客。

反射

单例模式