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()