Python面向对象小结

最新推荐文章于 2022-11-20 15:19:00 发布

你先画个包络面

最新推荐文章于 2022-11-20 15:19:00 发布

阅读量647

点赞数 8

分类专栏： Python笔记文章标签： Python

本文链接：https://blog.csdn.net/qq_43549984/article/details/88245519

版权

Python笔记专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一、初阶使用

1.1 基本概念

我们将一个类型及其关联的一组操作组成的整体叫做类，并称这些操作为类的属性。如果类的属性是函数的话，我们也称它为类的方法。当我们用类创建了一个对象时，称这个对象为类的实例。

1.2 基本语法

1.2.1 类的定义

类在Python中通过class关键字定义，最简单的类就是空类：

class Firstclass:
	pass

上述代码创建了一个类，类名叫做Firstclass（在Python中，模块名一般小写字母开头，类名一般大写字母开头，请尽量遵循这一习惯），类的内部什么也没有，当我们在调试面板上调试该脚本时，会产生以下结果：

>>> x=Firstclass
>>> x
<class '__main__.Firstclass'>
>>> y=Firstclass()
>>> y
<__main__.Firstclass object at 0x000001E4350DAA58>

可以看到，Firstclass是class对象，而Firstclass()才是object对象。也就是说，Firstclass是类，Firstclass()是类的实例。

1.2.2添加属性

Python规定，只要是在类内部的顶层赋值的任何变量，都会成为类的属性（需要提醒的是，def也是一种赋值运算），比如以下脚本：

class Firstclass:
    version='1.0.0'
    def setdata(self,value):
        self.data=value
    def display(self):
        print(self.data)

当我们在调试面板上调试该脚本时，会产生以下结果：

>>> x=Firstclass()
>>> x.version
'1.0.0'
>>> x.setdata(2.71828)
>>> x.display()
2.71828
>>> y=Firstclass()
>>> y.version
'1.0.0'
>>> y.setdata('python')
>>> y.display()
python

我们给Firstclass类写了三个属性，version,setdata和display，其中，version是字符串对象，剩下两个都是函数对象。而在setdata方法内，我们又通过传入的self参数给Firstclass的实例（即self代表的对象）增加了一个data属性，data对象的类型由传入的value参数决定。
值得一提的是，这两个函数的self参数都不是必须叫self的，只不过按照惯例这样取而已。Python规定，在类方法函数内，第一个参数会引用正处理的实例对象，对self的属性做赋值运算会创建或修改实例内的数据。所以类的方法在定义的时候至少要有一个参数，且最好写为self。

1.2.3 使用属性

从刚才的调试代码中可以看出，Python中使用点号来访问类的属性。当解释器遇到object.attribute句式时，就会在类object中寻找是否存在attribute属性。如果存在，修改它，否则创建它。因此，在刚才的调试代码之后还可以追加：

>>> x.new_attri=3
>>> x.new_attri
3

这样做是不会报错的。

二、类的继承

2.1 概念

除了通过刚才的方式为类编写属性之外，类也可以引入其他类来进行定义。我们称被引用的类为父类，引用父类的类为父类的子类。由子类产生的实例会继承父类的属性，我们称这一行为为类的继承。在Python当中，实例继承自类，而类继承自超类。类在继承其他类以后还可以自行添加新的属性，或者修改父类的属性，我们称这样的修改为重载。请注意，重载不会修改父类的内容。

2.2 语法

2.2.1 如何继承

Python规定，要继承另一个类的属性，需要把该类列在class语句开头的括号中。如以下代码：

class Firstclass:
    version='1.0.0'
    def setdata(self,value):
        self.data=value
    def display(self):
        print(self.data)
class Secondclass(Firstclass):
    new_version='2.0.0'

调试代码如下：

>>> x=Secondclass()
>>> x.version
'1.0.0'
>>> x.new_version
'2.0.0'
>>> x.setdata(3.14)
>>> x.display()
3.14

我们可以看到，创建的Secondclass()实例拥有Firstclass()的所有属性，还可以添加自己新的属性new_version。

2.2.2 如何重载

上文提到，在Python中访问类的属性是通过查找的方式，而查找会优先查找当前类，当前类没有才会到父类里面找。因此，如果我们要在子类中重载父类的属性，只要赋一个与该属性相同的变量名即可。如以下代码：

class Firstclass:
    version='1.0.0'
    def setdata(self,value):
        self.data=value
    def display(self):
        print(self.data)
class Secondclass(Firstclass):
    new_version='2.0.0'
    def display(self):
        print('data='+self.data)

调试代码如下：

>>> x=Secondclass()
>>> x.setdata('6.62')
>>> x.display()
data=6.62

通过在Secondclass中也定义一个display()的方式，即可对Firstclass的display属性进行重载。

三、运算符重载

除了可以重载父类的属性，我们还可以重载内置类型的运算，如加法、切片、打印等。通过重载运算符，我们可以使得自己编写的类拥有类似于内置类型那样的行为。

3.1 基础知识

内置类型的运算也是通过其类的方法来实现的，在Python中，这些方法会以双下划线命名（即__X__的形式）以示区分。当实例对象继承了这些方法时，内置运算就会调用这些方法。比如，如果一个实例继承了__add__方法，则当对象出现在+表达式时，__add__方法就会被调用。如果一个实例继承了__init__方法，则当新的实例对象被构造时，__init__方法就会被调用。
比如以下代码：

class Firstclass:
    version='1.0.0'
    def setdata(self,value):
        self.data=value
    def display(self):
        print(self.data)
class Secondclass(Firstclass):
    new_version='2.0.0'
    def display(self):
        print('data='+self.data)
class Thirdclass(Secondclass):
    def __init__(self,value):
        self.data=value

调试代码如下：

>>> x=Thirdclass(6.67)
>>> x.data
6.67

可以看到，Thirdclass在生成实例时会传递一个参数（例如6.67），这是传给__init__构造函数内的参数value的，而__init__会将其赋值给self.data。直接效果是，Thirdclass在构建时自动设置data属性，而不需要构建之后请求setdata调用。
目前为止，我们已经基本写出了一个“像模像样”的类了，因为一般情况下，由于我们需要让类立即在其新建的实例内添加属性，几乎每个实际的类都会出现一个__init__方法的重载。此外，我们也需要注意，尽量不要给自己的类起双下划线命名的属性，这可能造成隐藏的错误。
再补充几点，在Python中，__X__定义的是特殊方法，一般是系统定义的变量 ;_X表示的是保护类型的变量，只能允许其本身与子类进行访问，不能用于 from module import *；__X表示的是私有类型变量, 只允许这个类本身进行访问。

3.2 常用的运算符重载

方法	重载	调用
`__init__`	构造函数	`X=Class(args)`
`__add__`	运算符`+`	`X+Y,X+=Y`
`__or__`	运算符`\|`	`X\|Y,X\|=Y`
`__str__`	打印	`print(X)`
`__getitem__`	索引运算	`X[key],X[i:j]`
`__setitem__`	索引赋值	`X[key]=value,X[i:j]=sequence`

3.2.1 索引和分片

如果在类中定义了（或继承了）__getitem__和__setitem__方法的话，解释器就可以在类的实例进行索引和索引赋值时拦截其操作，并调用用户自己写的方法。例如，以下的代码定义了一个类，它的索引将返回索引值的平方。

class Squares:
	def __getitem__(self,idx):
		return idx**2

调试代码如下：

>>> x=Squares()
>>> x[2]
4

不仅如此，我们还可以用同样的操作拦截切片。为了理解这一点，首先我们需要了解到，切片操作[i:j:k]本质上是一种语法糖，它真正传入__getitem__的参数是一个分片对象slice(i,j,k)。因此我们可以编写以下类，它将返回data列表中的对应索引或切片：

class Indexer:
    data=[1,2,3,4,5,6]
    def __getitem__(self,idxs):
        return self.data[idxs]

调试代码如下：

>>> x=Indexer()
>>> x[2]
3
>>> x[1:5:2]
[2, 4]

3.2.2 索引迭代

其实，__getitem__也是Python中一种重载迭代的方式，如果定义了这个方法，那么当for循环语句调用到这个类的实例的时候，for循环内的每次循环都会调用类的__getitem__，并持续传递更高的偏移值。对于刚才的Indexer类，如果我们将其生成的实例放在for循环中，像这样：

x=Indexer()
for i in x:
    print(i,end=' ')

会产生如下输出：

1 2 3 4 5 6

在Python中，任何支持for循环的类也会自动支持Python所有的迭代环境，例如成员关系测试in、列表解析、内置函数map等等。

3.2.3 迭代器对象

尽管__getitem__技术很有效，但在Python中，所有的迭代环境都会优先尝试__iter__方法，再尝试__getitem__。所以，一般来说，我们应该优先使用__iter__。
从技术角度来讲，迭代环境是通过调用内置函数iter去尝试寻找__iter__方法来实现的，这个方法返回的内容是一个迭代器。如果找到了，Python就会重复调用这个迭代器的next方法，直到遇到StopIteration异常。而如果没有找到，才会改用__getitem__机制，直到遇到IndexError异常。
下面，我们将使用__iter__机制来完成刚才生成平方值的操作。

class Squares:
    def __init__(self,start,stop):
        self.value=start-1
        self.stop=stop
    def __iter__(self):
        return self
    def __next__(self):
        if self.value==self.stop:
            raise StopIteration
        self.value+=1
        return self.value**2
x=Squares(1,5)
for i in x:
	print(i,end=' ')

输出：

1 4 9 16 25

此外，由于__iter__对象能够在调用的过程中保留状态信息（如果我们不用for循环而手动不断__next__也是可以实现相同的功能的，但这样的方法却不能用在__getitem__上），所以__iter__比__getitem__有更好的通用性。
但是，在有些时候，__iter__也有缺点。首先来说，__iter__只用于迭代，而不重载索引表达式，因而我们无法使用Squares(1,5)[0]的方式来调用它。其次，__iter__只会迭代一次，之后返回的都是空。比如以下的测试代码：

>>> x=Squares(1,5)
>>> [n for n in x]
[1, 4, 9, 16, 25]
>>> [n for n in x]
[]

四、实战

下面，我们将用以上知识编写一个程序。该程序包含一个数列类基类以及它的三个子类，等差数列类，等比数列类和斐波那契数列类。代码如下：

class Array:
    def __init__(self,start=0):
        self.start=start
    def _advance(self):
        return self.cur+1
    def __iter__(self):
        return self
    def __next__(self):
        if self.len>0:
            self.len-=1
            buf=self.cur
            self.cur=self._advance()
            return buf
        else:
            raise StopIteration
    def show(self,num):
        self.cur=self.start
        self.next=None
        self.len=num
        print(list(self))
class Arithmetic(Array):
    def __init__(self,start,increment):
        Array.__init__(self,start)
        self.increment=increment
    def _advance(self):
        return self.cur+self.increment
class Geometric(Array):
    def __init__(self,start,base):
        Array.__init__(self,start)
        self.base=base
    def _advance(self):
        return self.cur*self.base
class Fibonacci(Array):
    def __init__(self,first,second):
        Array.__init__(self,first)
        self.second=second
    def _advance(self):
        if self.next==None:
            self.next=self.second
        self.cur,self.next=self.next,self.cur+self.next
        return self.cur
a=Array(4)
a.show(9)
b=Arithmetic(3,2)
b.show(10)
c=Geometric(1,2)
c.show(3)
d=Fibonacci(2,1)
d.show(7)
d.show(5)

##输出如下：
##[4, 5, 6, 7, 8, 9, 10, 11, 12]
##[3, 5, 7, 9, 11, 13, 15, 17, 19, 21]
##[1, 2, 4]
##[2, 1, 3, 4, 7, 11, 18]
##[2, 1, 3, 4, 7]

下面，我们一个类一个类的分析一下这个程序：
首先先看基类：

class Array:
    def __init__(self,start=0):
        self.start=start
    def _advance(self):
        return self.cur+1
    def __iter__(self):
        return self
    def __next__(self):
        if self.len>0:
            self.len-=1
            buf=self.cur
            self.cur=self._advance()
            return buf
        else:
            raise StopIteration
    def show(self,num):
        self.cur=self.start
        self.next=None
        self.len=num
        print(list(self))

在这个类的构造函数中，我们初始化了类属性start，用来存储数列的首项。中间三个方法暂时不看，当我们调用了这个类的show方法时，我们会给这个类的实例先增加三个属性：cur，next和len，分别用来保存数列的当前值（用于输出和向后迭代）、后继值（为了妥协斐波那契数列）以及数列长度（用于控制什么时候迭代结束）。然后，我们就要调用list(self)。那么这个self是什么呢？由于我们重载了__iter__方法，因此这里的self是一个迭代器对象，而当我们使用到这个迭代器对象时，我们知道，它会不断调用__next__方法。那么再来看__next__，我们会发现，它会首先检查len数据是否合法，如果不合法，则抛出StopIteration异常停止迭代；否则，它会先将len，即数组的长度减一，再用buf缓冲变量保存当前值cur，然后用_advance方法更新cur，最后返回buf的值，也就是原本的cur值。至于为什么要如此大费周章而不是直接返回self._advance()，是因为我们无法先return掉cur的值再去更新cur（这里的实现确实有不够优美的地方，暂时还没想到解决方法）。
看完了最长的基类，下面几个类就很简单了。可以看到，子类都只是重载了__init__方法和_advance方法，用于它们各自需要的更新操作。等差数列的更新方式就是当前值cur加上公差increment；等比数列就是cur乘以公比base；斐波那契数列就是后继项next，并更新当前项cur为next，next为cur加next。