Python学习笔记-17.09.20

Python 面向对象编程

继承:是为了重用父类的代码
多继承:默认自雷不会调用父类构造，除非调用
多态:方法重写：从左往右，从下往上找重写的方法

class A:
    def __init__(self):
        print("A 的构造方法")

class A1:
    def __init__(self):
        print("A1 的构造方法")
class B(A,A1):
    def __init__(self):
        A.__init__(self)
        A1.__init__(self)
        print("B 的构造方法")
class B1:
    def __init__(self):
        print("B1 的构造方法")
    def foo(self):
        print("B1.foo")
class C(B,B1):
    def __init__(self):
        B.__init__(self)
        B1.__init__(self)
        # super(B1,self).__init__()
        #从左的第一个
        print("C 的构造方法")
        def foo(self):#方法重写
        print("C.foo")

c = C()
c.foo()

class 类名（*类名）说明Python支持多继承。
上面这段代码的运行结果：

A 的构造方法
A1 的构造方法
B 的构造方法
B1 的构造方法
C 的构造方法
C.foo

上面的5个类中，B继承了A和A1，而C继承了B和B1
首先可以看到

class B(A,A1):
    def __init__(self):
        A.__init__(self)
        A1.__init__(self)
        print("B 的构造方法")

这段代码中，B的构造方法中调用了A和A1的构造方法，输出结果是:

A 的构造方法
A1 的构造方法
B 的构造方法

而如果不调用两个父类的构造方法的话，就只会输出LB 的构造方法 :

B 的构造方法

这说明了，在Python中，子类是不会自己调用父类的构造方法的，所以当需要父类构造方法时要手动调用一下。
同时Python不支持构造方法的重载。

多态

class person:
    def __init__(self,name=None,age=None):
        self.name=name
        self.age=age
    def __str__(self):
        return "我是{0},今年{1}岁".format(self.name,self.age)

    #Python 中操作符可以重写(加减乘除等比较)
    def __add__(self, other):
        return person(self.name+other.name,self.age+other.age)

    def __lt__(self, other):
        if self.name == other.name :
            return  other.age < self.age
        else:
            return self.name < other.name


p = person(name="zs",age=19)
p1= person(name="zs",age=19)
print(p+p1)

#排序
ps=[person("zhangsan",19),person("lisi",16),person("zhangsan",21),person("wangwu",23),]
print("-----------未排序-----------------")
for p1 in ps:
    print(p1)
print("-----------排序后-----------")
for p1 in sorted(ps):
    print(p1)

这段代码中，我们直接print(p+p1)，最后输出结果

我是zszs,今年38岁

这是因为我们重写了__str__和__add__
如果不重写__str__的话，只会输出这个对象的内存地址，
而__add__则是让我们重写了+这个运算符，让两个对象可以相加并得到我们想要的数值然后return

最后__lt__的重写是重写了比较运算符，让我们在调用sorted函数的时候可以让两个对象进行我们需求的比较并排序。

Python实现简单List

'''
定义迭代器:
    两种:
        1.yield 生成器 函数编程方式
        2.类中提供 __iter__ __next__ 方法 面向对象编程方式
            __iter__ 的方法要返回一个具有__next__方法的对象引用

'''


class MyList:
    class Node:
        def __init__(self):
            self.data = None
            self.next = None
    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0
    def add(self,data):
        self.size += 1
        n = self.Node()
        n.data = data
        if self.head== None:
            self.head = n
        else:
            self.tail.next = n
        self.tail = n
    def getSize(self):
        return self.size
    def get(self,i):
        p = self.head
        for j in range(0,i):
            p = p.next
        return p.data
    def __iter__(self):
        self.p = self.head
        return self
    def __next__(self):
        pl = self.p
        self.p = self.p.next
        return pl.data

my = MyList()
my.add("abc")
my.add("sss")
my.add("cds")
my.add("432")
for i in range(0,my.getSize()):
    print(my.get(i))

it = iter(my)
print(next(it))

def myshow():
    for i in range(10,0,-1):
        yield i

for i in myshow():
    print(i)

it = iter(myshow())
print(next(it))

Python实现简单二叉树

class MyBTree:
    class node:
        def __init__(self):
            self.data = None
            self.left = None
            self.right = None
        def add(self,n):
            if self.data>n.data:
                if self.left is None:
                    self.left = n
                else:
                    self.left.add(n)
            if self.data <n.data:
                if self.right is None:
                    self.right = n
                else:
                    self.right.add(n)
        def zhong(self):
            if self.left is not None:
                self.left.zhong()

            if self.right is not None:
                self.right.zhong()
            print(self.data)


    def __init__(self):
        self.root = None
    def add(self,data):
        n = self.node()
        n.data = data
        if self.root is None:
            self.root = n
        else:
            self.root.add(n)
    def zhong(self):
        self.root.zhong()

t = MyBTree()
t.add(111)
t.add(33)
t.add(26)
t.add(200)
t.add(132)
t.zhong()