Python学习笔记：类

阳光穿透心脏的1/2处 2023-07-02 04:27 13阅读 0赞

### 文章目录 ###

*   *  1.自定义类
     *  2.私有属性
     *  3.超类
     *  4.构造函数
     *   *  定义
         *  重写构造函数

每个对象都属于特定的类，并被称为该类的实例

## 1.自定义类 ##

先写一个简单的示例:

class Person:
    
        def set_name(self, name):
            self.name = name
    
        def get_name(self):
            return self.name
    
        def greet(self):
            print("hello, world! I'm {}".format(self.name))

这个示例包含三个**方法**定义，他们类似于函数定义，但位于class语句内。Person是类的名称。  
其中**self**参数指向对象本身。下面通关过创建两个示例来说明这一点。

>>>foo = Person()
    >>>foo.set_name('tang')
    >>>foo.greet()
    hello, world! I am tang
    
    >>>bar = Person()
    >>>bar.set_name('li')
    >>>bar.greet()
    hello, world! I am li

对foo调用set\_name和greet时，foo都会作为第一个参数自动传递给给他们。实际上随便给这个参数命名都可以，但鉴于它总是指向对象本身，因此习惯上将其命名为self。  
显然，self必不可少，如果没有她，所有的方法都无法访问对象本身。

实际上，方法和函数的区别表现在参数self上。

## 2.私有属性 ##

私有属性不能从对象外部访问，而只能通过存取器方法（如get\_XXX和set\_XXX）来访问。  
Python没有为 私有属性提供直接的支持，要让方法或属性成为私有的，只需让其名称以两个下划线打头即可。（这样的方法就类似于其他语言中的标准私有方法。）

class Secretive:
    
        def __inaccessible(self):
            print("bet you can not see me")
    
        def accessible(self):
            print("the secret message is:")
            self.__inaccessible()

现在从 外部不能访问\_\_inaccessible，

>>>s = Secretive()
    >>>s.__inaccessible()
    Traceback (most recent call last):
      File "/Users/tangbincheng/PycharmProjects/untitled1/0123.py", line 12, in <module>
        s.__inaccessible()
    AttributeError: 'Secretive' object has no attribute '__inaccessible'

但在类中，依然可以使用它：

>>>s.accessible()
    the secret message is:
    bet you can not see me

在类的定义中，对所有以两个下划线打头的名称，都会进行转换，即在开头加上一个下划线和类名，通过这种方式，就可以在类外 访问私有方法：

>>>s._Secretive__inaccessible()
    bet you can not see me

## 3.超类 ##

子类扩展了超类的定义。要指定超类，可在class语句中的类名后加上超类类名：

class Filter:
        def init(self):
            self.blocked = []
    
        def filter(self, sequence):
            return [x for x in sequence if x not in self.blocked]
    
    
    class SPAMFilter(Filter):
        def init(self):
            self.blocked = ['SPAM']

Filter类是一个过滤序列的同类，实际上，他不会过滤任何东西：

>>>f = Filter()
    >>>f.init()
    >>>print(f.filter(['SPAM', 'eggs', 'SPAM','bacon']))
    ['SPAM', 'eggs', 'SPAM', 'bacon']

Filter类的用途在于可用于作其他类的基类，如SPAMFilter可将’SPAM’从序列中过滤掉：

>>>s = SPAMFilter()
    >>>s.init()
    >>>print(s.filter(['SPAM', 'eggs', 'SPAM','bacon']))
    ['eggs', 'bacon']

SPAMFilter类的定义中，有两个要点：

*  以提供新定义的方式重写了Filter类中方法init的定义。
 *  直接从Filter类继承了方法filter的定义，因此无需重新编写其定义。

## 4.构造函数 ##

### 定义 ###

构造函数（constructor）名为\_\_iniit\_\_，在对象创建后被自动调用。  
原先初始化调用：

class FooBar:
    
        def init(self):
            self.somevar = 42

>>>f = FooBar()
    >>>f.init()
    >>>print(f.somevar)
    42

使用构造函数：

class FooBar:
    
        def __init__(self):
            self.somevar = 42

>>>f = FooBar()
    >>>print(f.somevar)
    42

带参数的构造函数：

class FooBar:
    
        def __init__(self, value = 42):
            self.somevar = value

>>>f = FooBar()
    >>>print(f.somevar)
    42
    
    >>>f1 = FooBar('32')
    >>>print(f1.somevar)
    32

### 重写构造函数 ###

重写是继承机制的一个重要方面，重写构造函数时，必须调用超类的构造函数，否则可能无法正确的初始化对象；  
举例：  
定义一个基类，定义类鸟具有基本的能力是吃

class Bird:
        def __init__(self):
            self.hungry = True
    
        def eat(self):
            if self.hungry:
                print("Aaaaaaaaah....")
                self.hungry = False
            else:
                print('No, thanks!')

>>>b = Bird()
    >>>b.eat()
    Aaaaaaaaah....

再定义一个类继承Bird类

class SongBird(Bird):
        def __init__(self):
            self.sound = 'Squawk!'
    
        def sing(self):
            print(self.sound)

>>>sb = SongBird()
    >>>sb.sing()
    Squawk!

SongBird类是Bird类的子类，继承了eat()方法，但如果尝试 调用它，就会报错：

>>>sb.eat()
    Traceback (most recent call last):
      File "/Users/tangbincheng/PycharmProjects/untitled1/0123.py", line 25, in <module>
        sb.eat()
      File "/Users/tangbincheng/PycharmProjects/untitled1/0123.py", line 6, in eat
        if self.hungry:
    AttributeError: 'SongBird' object has no attribute 'hungry'

异常为：SongBird没有属性hungry。因为在SongBird中重写了构造函数，但新的构造函数没有包含任何初始化属性hungry的代码。  
要消除这种错误，SongBird的构造 函数 必须调用其超类（Bird）的构造函数，以确保基本的初始化得以执行：

class Bird:
        def __init__(self):
            self.hungry = True
    
        def eat(self):
            if self.hungry:
                print("Aaaaaaaaah....")
                self.hungry = False
            else:
                print('No, thanks!')
    
    class SongBird(Bird):
        def __init__(self):
            super().__init__()
            self.sound = 'Squawk!'
    
        def sing(self):
            print(self.sound)

在SongBird的构造函数中插入 **super().init()** 后，再次调用：

>>>sb.eat()
    Aaaaaaaaah....