pyhton魔法方法2

1.如果我要继承的基类是动态的（有时候是 A，有时候是 B），我应该如何部署我的代码，以便基类可以随意改变。

BaseAlias = BaseClass  # 为基类取别名

class Derived(BaseAlias):
    def meth(self):
        BaseAlias.meth(self)  # 通过别名访问基类
        ...

2，定义一个类，当实例化该类的时候，自动判断传入了多少个参数，并显示出来

class C:
        def __init__(self,*age): # *age指针所指向地址的内容
            if not age: #没有参数的表达形式
                print("没有")
            else:
                print("参数长度为%d",len(age),end='')
                for each in age: #不是len(age),最后还是要显示each的
                    #遍历地址内容
                    print (each,end='')

3，对类的静态属性的理解

看完小甲鱼讲的类的静态属性，我发现我理解不了啊，看了几篇大佬的博客，大概的理解了一番

• 类方法和静态方法的区别在于，Python会自动绑定类方法的第一个参数，类方法的第一个参数（通常建议参数名为 cls）会自动绑定到类本身；但对于静态方法则不会自动绑定。
• 实例方法中可以调用类方法和静态方法，反之则不行
• 普通实例方法，第一个参数需要是self，它表示一个具体的实例本身。
  如果用了staticmethod，那么就可以无视这个self，而将这个方法当成一个普通的函数使用。
  而对于classmethod，它的第一个参数不是self，是cls，它表示这个类本身。

class Bird:
        # classmethod修饰的方法是类方法
    @classmethod
    def fly (cls):
        print('类方法fly: ', cls)
        # staticmethod修饰的方法是静态方法
    @staticmethod
    def info (p):
        print('静态方法info: ', p)
    # 调用类方法，Bird类会自动绑定到第一个参数
Bird.fly()  #①
    # 调用静态方法，不会自动绑定，因此程序必须手动绑定第一个参数
Bird.info('crazyit')
    # 创建Bird对象
b = Bird()
    # 使用对象调用fly()类方法，其实依然还是使用类调用，
    # 因此第一个参数依然被自动绑定到Bird类
b.fly()  #②
    # 使用对象调用info()静态方法，其实依然还是使用类调用，
    # 因此程序必须为第一个参数执行绑定
b.info('fkit')

类方法fly:  <class '__main__.Bird'>
静态方法info:  crazyit
类方法fly:  <class '__main__.Bird'>
静态方法info:  fkit 

4，简单定制

• 魔法方法  __str__()

class A:
    def __str__(self):
        return '小甲鱼是帅哥'

a=A()
print(a)
>>>小甲鱼是帅哥
a
>>> <__main__.A object at 0x0000012AF3D63610>

• 魔法方法 __repr__()

class B:
    def __repr__(self):
        return '小甲鱼是帅哥'

b=B()
b
>>>小甲鱼是帅哥

• 用魔法方法做一个简单计时器

import time as t
#引入time模块

class MyTimer:
    def __init__(self):
        self.unit=['年','月','小时','分钟','秒']
        self.prompt='未开始计时'
        self.lasted=[]
        #self.start=0
        #self.stop=0
        #会报错是因为类的属性名和方法名相同时，属性会覆盖方法
        #这里相当于属性，赋值0是整型，下面调用自然会出错
        self.begin=0
        self.end=0
    
    def __str__(self):
        return self.prompt

    __repr__=__str__

    def __add__(self,other):
        prompt='总共运行了'
        result=[]
        for index in range(6):
            result.append(self.lasted[index]+other.lasted[index])
            if result[index]:#为0时不输出
                prompt+=(str(result[index])+self.unit[index])#unit前面有定义
        return prompt
    #开始计时
    def start(self):
        self.begin=t.localtime()
        print("计时开始...")

     #结束计时
    def stop(self):
        self.end=t.localtime()
        self._calc()#调用内部方法格式
        print("计时结束...")

    #内部方法，计算运行时间
    def _calc(self):
    #内部方法前面加下划线
        self.lasted=[]
        self.prompt='总共运行了'
        for index in range(6):
            #添加列表的方式（记住）
            self.lasted.append(self.end[index]-self.begin[index])
            #localtime()函数返回的是一个时间元祖的结构,只需要前面6个元素一一相减。
            #因此后面用列表
            if lasted[index]:#为0时不输出
                self.prompt+=str(self.lasted[index]+self.unit[index])
            #为什么要变成字符串？--->字符串才可以拼接
        #为下一轮计时初始化变量
        self.bigin=0
        self.end=0