Python面向对象三要素-多态

　　　　　　　　　　　　　Python面向对象3要素-多态

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

 一.多态概述

　　OCP原则：多用“继承”，少修改。

　　继承的用途：在子类上实现对基类的增强，实现多态。

　　在面向对象这种，父类，子类通过继承联系在一起，如果可以通过一套方法，就可以实现不同表现，就是多态。

　　一个类继承自多个类就是多继承，它将具有多个类的特征。

　　

二.多态案例

　　我们之前已经学习过面向对象的三要素之封装和继承。多态就是一个很简单的定义，在Python中多态的表现需要满足两个要求即可。即继承父类且重写父类的方法。

 #！/usr/bin/env python
 #_*_conding:utf-8_*_
 #@author :yinzhengjie
 #blog:http://www.cnblogs.com/yinzhengjie

 class Animal:
     def __init__(self,name):
         self._name = name

     def shout(self):
         raise Exception("方法需要重写")

 class Cat(Animal):
     def shout(self):
         print("喵喵喵~")

 class Dog(Animal):
     def shout(self):
         print("汪汪汪~")

 c = Cat("布偶")
 c.shout()

 d = Dog("二哈")
 d.shout()

 #以上代码执行结果如下:
 喵喵喵~
 汪汪汪~

三.小试牛刀

1>.Shape基类，要求所有子类都必须提供面积的计算，子类有三角形，矩形，圆(多态应用)

2>.上体圆类的数据可序列化。(Mixin)

3>.链表实现

　　用面向对象实现LinkedList链表
　　单向链表实现append,iternodes方法
　　双向链表实现append,pop,insert,remove,iternodes方法

 #！/usr/bin/env python
 #_*_conding:utf-8_*_
 #@author :yinzhengjie
 #blog:http://www.cnblogs.com/yinzhengjie

 """
     用面向对象实现LinkedList链表
     单向链表实现append,iternodes方法
     双向链表实现append,pop,insert,remove,iternodes方法
 """

 class SingleNode:           #节点保存内容和下一条
     def __init__(self,item,next=None):
         self.item = item
         self.next = next

     def __repr__(self):
         return repr(self.item)

 class LinkList:
     def __init__(self):
         self.head = None        #用于存储上一个SingleNode的信息
         self.tail = None        #用于存储下一个SingleNode的信息

     def append(self,item):
         node = SingleNode(item)
         if self.head is None:
             self.head = node        #设置节点开头，以后不变
         else:
             self.tail.next = node   #当前最后一个节点关联下一个SingleNode
         self.tail = node            #更新结尾节点
         return self

     def iternodes(self):
         current = self.head
         while current:
             yield current
             current = current.next

 s = LinkList()
 s.append("尹正杰")
 s.append(100).append(200)
 s.append("Jason Yin")

 print(s.head)
 print(s.tail)

 print("{0} 我是分割线 {0}".format("*" * 15))

 for item in s.iternodes():
     print(item)

 #以上代码执行结果如下:
 '尹正杰'
 'Jason Yin'
 *************** 我是分割线 ***************
 '尹正杰'
 100
 200
 'Jason Yin'

参考案例一(单项链表)

 #！/usr/bin/env python
 #_*_conding:utf-8_*_
 #@author :yinzhengjie
 #blog:http://www.cnblogs.com/yinzhengjie

 """
     用面向对象实现LinkedList链表
     单向链表实现append,iternodes方法
     双向链表实现append,pop,insert,remove,iternodes方法
 """

 class SingleNode:               #节点保存内容和下一条
     def __init__(self,item,next=None):
         self.item = item
         self.next = next

     def __repr__(self):
         return repr(self.item)

 class LinkList:
     def __init__(self):
         self.head = None
         self.tail = None
         self.items = []                 #只有节点自己知道下一跳是谁，想直接访问某一个节点只能遍历。借助列表就可以方便的随机访问某一个结点了。

     def append(self,item):
         node = SingleNode(item)
         if self.head is None:
             self.head = node            #设置开头，以后不变
         else:
             self.tail.next = node       #当前最后一个节点关联吓一跳
         self.tail = node                #更新结尾结点

         self.items.append(node)
         return self

     def iternodes(self):
         current = self.head
         while current:
             yield current
             current = current.next

     def getitem(self,index):
         return self.items[index]

 s = LinkList()
 s.append("Python")
 s.append(200).append(300)
 s.append("Java")

 print(s.head,s.tail)

 print("{0} 我是分割线 {0}".format("*" * 15))

 for item in s.iternodes():
     print(item)

 print("{0} 我是分割线 {0}".format("*" * 15))

 for i in range(len(s.items)):
     print(s.getitem(i))

 #以上代码执行结果如下:
 'Python' 'Java'
 *************** 我是分割线 ***************
 'Python'
 200
 300
 'Java'
 *************** 我是分割线 ***************
 'Python'
 200
 300
 'Java'

参考案例二(单项链表基于列表实现)

 #！/usr/bin/env python
 #_*_conding:utf-8_*_
 #@author :yinzhengjie
 #blog:http://www.cnblogs.com/yinzhengjie

 """
     用面向对象实现LinkedList链表
     单向链表实现append,iternodes方法
     双向链表实现append,pop,insert,remove,iternodes方法
 """

 class SingleNode:           #节点保存内容和下一条
     def __init__(self,item,prev=None,next=None):
         self.item = item
         self.next = next
         self.prev = prev        #增加上一跳属性

     def __repr__(self):
         return "(prev:{}<==item:{}==>next:{})".format(
             self.prev.item if self.prev else None,
             self.item,
             self.next.item if self.next else None
         )

 class LinkList:
     def __init__(self):
         self.head = None
         self.tail = None
         self.size = 0

     def append(self,item):
         node = SingleNode(item)
         if self.head is None:
             self.head = node                #设置开头节点，以后不变
         else:
             self.tail.next = node           #当前最后一个节点关联下一跳
             node.prev = self.tail           #前后关联
         self.tail = node                    #更新尾结点
         return self

     def insert(self,index,item):
         if index < 0:                       #不接受负数
             raise IndexError("Not negative index {}".format(index))
         current = None
         for i,node in enumerate(self.iternodes()):
             if i == index:                  #找到了
                 current = node
                 break
         else:                               #没有break，尾部追加
             self.append(item)
             return

         node = SingleNode(item)
         prev = current.prev
         next = current
         if prev is None:            #首部
             self.head = node
         else:                       #不是首元素
             prev.next = node
             node.prev = prev

         node.next = next
         next.prev = node

     def pop(self):
         if self.tail is None:       #空
             raise Exception("Empty")

         node = self.tail
         item = node.item
         prev = node.prev

         if prev is None:
             self.head = None
             self.tail = None
         else:
             prev.next = None
             self.tail = prev
         return item

     def remove(self,index):
         if self.tail is None:       #空
             raise Exception("Empty")

         if index < 0:               #不接受负数
             raise IndexError("Not nagative index {}".format(index))

         current = None
         for i,node in enumerate(self.iternodes()):
             if i == index:
                 current = node
                 break
         else:
             raise IndexError("wrong index {}".format(index))

         prev = current.prev
         next = current.next

         if prev is None and next is None:
             self.head = None
             self.tail = None
         elif prev is None:      #头部
             self.head = next
             next.prev = None
         elif next is None:      #尾部
             self.tail = prev
             prev.next = None
         else:                   #在中间
             prev.next = next
             next.prev = prev

         del current

     def iternodes(self,reverse=False):
         current = self.tail if reverse else  self.head
         while current:
             yield current
             current = current.prev if reverse else current.next

 s = LinkList()
 s.append("")
 s.append(200).append(300)
 s.append("")

 print(s.head,s.tail)

 print("{0} 我是分割线 {0}".format("*" * 15))

 for item in s.iternodes(True):
     print(item)

 print("{0} 我是分割线 {0}".format("*" * 15))

 s.remove(1)
 s.remove(2)

 print("{0} 我是分割线 {0}".format("*" * 15))

 for item in s.iternodes():
     print(item)

 s.insert(3,520)
 s.insert(20,"")
 s.insert(0,"")

 print("{0} 我是分割线 {0}".format("*" * 15))

 for item in s.iternodes():
     print(item)

 #以上代码执行结果如下:
 (prev:None<==item:100==>next:200) (prev:300<==item:400==>next:None)
 *************** 我是分割线 ***************
 (prev:300<==item:400==>next:None)
 (prev:200<==item:300==>next:400)
 (prev:100<==item:200==>next:300)
 (prev:None<==item:100==>next:200)
 *************** 我是分割线 ***************
 *************** 我是分割线 ***************
 (prev:None<==item:100==>next:300)
 (prev:100<==item:300==>next:None)
 *************** 我是分割线 ***************
 (prev:None<==item:66666==>next:100)
 (prev:66666<==item:100==>next:300)
 (prev:100<==item:300==>next:520)
 (prev:300<==item:520==>next:888888)
 (prev:520<==item:888888==>next:None)

参考案例三(实现单向链表没有实现的pop,remove,insert方法)

4>.链表功能增强

    将前面的链表，封装成容器
    要求:
        提供__getitem__,__iter__,__setitem__方法。

5>.定义一个斐波拉契数列的类

    定义一个斐波拉契数列的类，方便调用，计算第n项。
    增加迭代数列的方法，返回数列长度，支持索引查找数列项的方法。