Task 7. 类、对象与魔法方法

1.类（包含方法定义和所有实例共享的数据。）

class Turtle:#类名约定以大写字母开头
	def cc(self):#必须有一个额外的第一个参数名称self（对应于该实例，即该对象本身）
		print('I am working.')
	
tt = Turtle()#tt为实例

1.1 类的魔法方法
1.1.1__init__(self[, param1, param2…])在类实例化时会自动调用。

class Ball:
    def __init__(self, name):
        self.name = name

    def kick(self):
        print("来踢我," % self.name)
 a = Ball("球A")
 a.kick()
#来踢我,球A

1.1.2__new__(cls[, …]) 在一个对象实例化的时候所调用的第一个方法
new__对当前类进行了实例化，并将实例返回，传给__init__的self。但是，执行了__new，并不一定会进入__init__，只有__new__返回了，当前类cls的实例，当前类的__init__才会进入。

class A(object):
    def __init__(self, value):
        print("into A __init__")
        self.value = value

    def __new__(cls, *args, **kwargs):
        print("into A __new__")
        print(cls)
        return object.__new__(cls)


class B(A):
    def __init__(self, value):
        print("into B __init__")
        self.value = value

    def __new__(cls, *args, **kwargs):
        print("into B __new__")
        print(cls)
        return super().__new__(cls, *args, **kwargs)


b = B(10)

# 结果：
# into B __new__
# into A __new__
# into B __init__

1.1.3__del__(self) 用来调用被系统回收的对象
_str(self)用来打印对象；使用%s格式化；强转数据类型
_repr(self)是str的备用；使用%r格式化

1.2 类的继承

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

其中BaseClassName为基类，DerivedClassName为派生类。
如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性。
子类中调用父类的构造函数，可以使用使用super函数super().init()

import random

class Fish:
    def __init__(self):
        self.x = random.randint(0, 10)
        self.y = random.randint(0, 10)
class Shark(Fish):  
    def __init__(self):
        Fish.__init__(self)
        self.hungry = True
    #或者
    def __init__(self):
        super().__init__()
        self.hungry = True

1.3 类的绑定
Python 对象的数据属性通常存储在名为.__ dict__的字典中，我们可以直接访问__dict__，或利用 Python 的内置函数vars()获取.__ dict__。

class CC:
    def setXY(self, x, y):
        self.x = x
        self.y = y

    def printXY(self):
        print(self.x, self.y)
dd.setXY(4, 5)
print(dd.__dict__)
# {'x': 4, 'y': 5}

1.4 内置函数
issubclass(class, classinfo) 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
isinstance(object, classinfo) 方法用于判断一个对象是否是一个已知的类型，类似type()：如果第一个参数不是对象，则永远返回False；如果第二个参数不是类或者由类对象组成的元组，会抛出一个TypeError异常。
hasattr(object, name)用于判断对象是否包含对应的属性。
getattr(object, name[, default])用于返回一个对象属性值。
setattr(object, name, value)对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
delattr(object, name)用于删除属性。
class property([fget[, fset[, fdel[, doc]]]])用于在新式类中返回属性值：fget – 获取属性值的函数；fset – 设置属性值的函数；fdel – 删除属性值函数；doc – 属性描述信息
2.运算符
算术运算符、反算术运算符、增量赋值运算符、一元运算符

具体运算符可以参看链接
3.属性访问
getattr(self, name): 定义当用户试图获取一个不存在的属性时的行为。
getattribute(self, name)：定义当该类的属性被访问时的行为（先调用该方法，查看是否存在该属性，若不存在，接着去调用__getattr__）。
setattr(self, name, value)：定义当一个属性被设置时的行为。
delattr(self, name)：定义当一个属性被删除时的行为。
4.描述符
将某种特殊类型的类的实例指派给另一个类的属性。
get(self, instance, owner)用于访问属性，它返回属性的值。
set(self, instance, value)将在属性分配操作中调用，不返回任何内容。
del(self, instance)控制删除操作，不返回任何内容。
5.定制序列
定制的容器是不可变的话，定义__len__()：返回容器中元素的个数和__getitem__()相当于self[key]方法
定制的容器是可变的话，除了__len__()和__getitem__()方法，还需要定义__setitem__(self,key,value)定义设置容器中指定元素的行为和__delitem__(self, key)定义删除容器中指定元素的行为两个方法。
6. 迭代器
iter(object) 函数用来生成迭代器。
next(iterator[, default]) 返回迭代器的下一个项目。
7.生成器
yield 的函数

def myGen():
    print('生成器执行！')
    yield 1
    yield 2


myG = myGen()# 生成器执行！
print(next(myG))# 1  
print(next(myG))  # 2
print(next(myG))  # StopIteration

练习题：
利用python做一个简单的定时器类
要求:

定制一个计时器的类。
start和stop方法代表启动计时和停止计时。
假设计时器对象t1，print(t1)和直接调用t1均显示结果。
当计时器未启动或已经停止计时时，调用stop方法会给予温馨的提示。
两个计时器对象可以进行相加：t1+t2。
只能使用提供的有限资源完成。

import time

class MT(object):
	def __init__(self):
		self.__info='未开始计时'
		self.__begin=None
		self.__end=None
		self.__jg=0
	def __str__(self):
		return self.__info
	def __repr__(self):
        return self.__info

    def start(self):
        print('计时开始')
        self.__begin = time.localtime()

    def stop(self):
        if not self.__begin:
            print('提示：请先调用start()开始计时！')
            return
        self.__end = time.localtime()
        self.__jg = time.mktime(self.__end) - time.mktime(self.__begin)
        self.__info = '共运行了%d秒' % self.__jg
        print('计时结束！')
        return self.__jg

    def __add__(self, other):
        return '共运行了%d秒' % (other.__jg + self.__jg)
t1 = Mytime()
print(t1)# 未开始计时！
t1.stop()# 提示：请先调用start()开始计时！
t1.start()# 计时开始
time.sleep(5)
t1.stop()# 计时结束！
print(t1)# 共运行了5秒
t2 = Mytime()
t2.start()# 计时开始
time.sleep(7)
t2.stop()# 计时结束！
print(t2)# 共运行了7秒
print(t1 + t2)# 共运行了12秒