python 学习之类和对象 MRO

python 学习之类和对象

类
可以理解为数组的升级版，不仅可以放数据，还可以函数（方法）
利用关键字 class 来定义
类中有属性和方法
就是变量和函数

对象
~~就是女朋友~~
先举个例子

class A:
	x=10
	def test(self):
		print('this is a test')
a=A()
a.x
a.test()

其中 a 就是对象，赋予了类的变量，就是对象
注意不能写成

a=A # 这不是建立了一个对象，a也变成了一个类
b=a()

注意到，上面还有个 self 关键字，它是每个函数的必备参数，也默认必须是第一个参数，（其实不一定用’ self ’这个名字，但习惯用它）

self 代指建立的对象
在上面就代指 a 这个建立的对象
在执行 a.test() 时候就相当于执行 a.test (a)
每个方法（函数），自动会调用对象作为第一个参数所以只用写成 a.test()

传入参数

class A:
	def test(self,x,y):
		self.x=x
		self.y=y
a=A()
a.test(4,5)
a.x
a.y

x,y 分别传给了 self.x 和 self.y 也就是 a.x ，a.y

面向对象有几个特性：继承，多态，封装
这篇文章介绍的很好：点击这里

单继承时可以有两种方法

class A:
    def test(self):
        print('A')
        print('A')
class B(A):
    def test(self):
        print('B')
        A.test(self)
        print('B')
class C(A):
    def test (self):
        print('C')
        super().test()
        print("C")
a=A()
b=B()
c=C()
a.test()
b.test()
c.test()

继承是可以同时继承多个
但多继承的时候使用super()
可能会出现于我们预想不符合
这就涉及到 MRO （Method Resolution Order）
python 中的MRO和多继承

重写的方法会覆盖继承的方法

定义类的时候，如果属性和方法的名字一样，方法会覆盖属性

定时器

import time
class Time():
    def __init__(self):
        
        self.flag=False
        self.starttime=0
        self.stoptime=0
        self.time=0
    def start(self):
        self.starttime=time.time()
        print("定时器启动")
        self.flag=True
    def stop(self):
        if self.flag :
            self.stoptime=time.time()
            print("定时器停止")
            self.flag=False
        else:
            print("定时器还未启动或已经停止")
    def __repr__(self):
        self.time= self.stoptime- self.starttime
        if self.time:
            return '定时时间为%d' % self.time
        else:
            print("定时器还未启动或已经停止")
    def __add__(self,other):
        return  self.time+other.time

python 学习之 类和对象 MRO

猜你喜欢

python 学习之类和对象 MRO