class User:
  def __new__(cls, *args, **kwargs):
    # 打印 __new__方法中的相关信息
    print('调用了 def __new__ 方法')
    print(args)
    # 最后返回父类的方法
    return super(User, cls).__new__(cls)

  def __init__(self, name, age):
    print('调用了 def __init__ 方法')
    self.name = name
    self.age = age

if __name__ == '__main__':
  user = User('小明', 18)

# 执行结果
调用了 def __new__ 方法
('小明', 18)
调用了 def __init__ 方法

def __setattr__(self, name, value):
    self.name = value
    # 每当属性被赋值的时候， ``__setattr__()`` 会被调用，这样就造成了递归调用。
    # 这意味这会调用 ``self.__setattr__('name', value)`` ，每次方法会调用自己。这样会造成程序崩溃。

def __setattr__(self, name, value):
    # 给类中的属性名分配值
    self.__dict__[name] = value
    # 定制特有属性

class User:
  def __getattr__(self, name):
    print('调用了 __getattr__ 方法')
    return super(User, self).__getattr__(name)

  def __setattr__(self, name, value):
    print('调用了 __setattr__ 方法')
    return super(User, self).__setattr__(name, value)

  def __delattr__(self, name):
    print('调用了 __delattr__ 方法')
    return super(User, self).__delattr__(name)

  def __getattribute__(self, name):
    print('调用了 __getattribute__ 方法')
    return super(User, self).__getattribute__(name)


if __name__ == '__main__':
  user = User()
  user.attr1 = True   # 设置属性值, 会调用 __setattr__ 方法
  user.attr1    # 属性存在, 只有 __getattribute__ 方法会调用
  try:
    user.attr2  # 属性不存在, 先调用 __getattribute__ 方法, 再调用 __getattr__ 方法
  except AttributeError:
    pass
  del user.attr1  # 删除属性, 会调用 __delattr__ 方法


# ------------  运行结果  -----------------
调用了 __setattr__ 方法
调用了 __getattribute__ 方法
调用了 __getattribute__ 方法
调用了 __getattr__ 方法
调用了 __delattr__ 方法

class User:
    def __init__(self, name='Pupper', sex='男'):
        self.name = name
        self.sex = sex

    def __get__(self, obj, objtype):
        print('获取 name 值')
        return self.name

    def __set__(self, obj, value):
        print('设置 name 值')
        self.name = value

class MyClass:
    x = User()
    y = 5


if __name__ == '__main__':
    m = MyClass()
    print(m.x)      # 调用的是 User.__get__ 方法
    print("------------------------------")
    m.x = 'Pupper Cheng'    # 调用的是 User.__set__ 方法
    print(m.x)      # 调用的是 User.__get__ 方法
    print("------------------------------")
    print(m.y)    # 直接获取 MyClass.y 的值


# -------------- 输出结果 -------------------
获取 name 值
Pupper
------------------------------
设置 name 值
获取 name 值
Pupper Cheng
------------------------------
5

class Meter:
    def __init__(self, value=0.0):
        self.value = float(value)

    def __get__(self, instance, owner):
        print('调用 meter 的 __get__ 方法')
        return self.value

    def __set__(self, instance, value):
        print('调用 meter 的 __set__ 方法')
        self.value = float(value)


class Foot:
    def __get__(self, instance, owner):
        print('调用 foot 的 __get__ 方法')
        return instance.meter * 3.2808

    def __set__(self, instance, value):
        print('调用 foot 的 __set__ 方法')
        instance.meter = float(value) / 3.2808


class Distance:
    meter = Meter()
    foot = Foot()


if __name__ == '__main__':
    d = Distance()
    print(d.meter, d.foot)
    print('----------------------------------------')
    d.meter = 1
    print(d.meter, d.foot)
    print('----------------------------------------')
    d.meter = 2
    print(d.meter, d.foot)


# -------------- 输出结果 ----------------------
调用 meter 的 __get__ 方法
调用 foot 的 __get__ 方法
调用 meter 的 __get__ 方法
0.0 0.0
----------------------------------------
调用 meter 的 __set__ 方法
调用 meter 的 __get__ 方法
调用 foot 的 __get__ 方法
调用 meter 的 __get__ 方法
1.0 3.2808
----------------------------------------
调用 meter 的 __set__ 方法
调用 meter 的 __get__ 方法
调用 foot 的 __get__ 方法
调用 meter 的 __get__ 方法
2.0 6.5616

class FunctionalList:
    """实现了内置类型 list 的功能，并丰富了一些其他方法: head, tail, init, last, drop, take"""
    def __init__(self, values=None):
        if values is None:
            self.values = []
        else:
            self.values = values

    def __len__(self):
        return len(self.values)

    def __getitem__(self, key):
        return self.values[key]

    def __setitem__(self, key, value):
        self.values[key] = value

    def __delitem__(self, key):
        del self.values[key]

    def __iter__(self):
        return iter(self.values)

    def __reversed__(self):
        return FunctionalList(reversed(self.values))

    def append(self, value):
        self.values.append(value)

    def head(self):
        # 获取第一个元素
        return self.values[0]

    def tail(self):
        # 获取除第一个元素外的所有元素
        return self.values[1:]

    def init(self):
        # 获取除最后一个元素外的所有元素
        return self.values[:-1]

    def last(self):
        # 获取最后一个元素
        return self.values[-1]

    def drop(self, n):
        # 获取除前 n 个元素外的所有元素
        return self.values[n:]

    def take(self, n):
        # 获取前 n 个元素
        return self.values[:n]

class Number(object):
    def __init__(self, value):
        self.value = value

    def __eq__(self, other):
        print('__eq__')
        return self.value == other.value

    def __ne__(self, other):
        print('__ne__')
        return self.value != other.value

    def __lt__(self, other):
        print('__lt__')
        return self.value < other.value

    def __gt__(self, other):
        print('__gt__')
        return self.value > other.value

    def __le__(self, other):
        print('__le__')
        return self.value <= other.value

    def __ge__(self, other):
        print('__ge__')
        return self.value >= other.value


if __name__ == '__main__':
    num1 = Number(2)
    num2 = Number(3)
    print('num1 == num2 ? --------> {} \n'.format(num1 == num2))
    print('num1 != num2 ? --------> {} \n'.format(num1 == num2))
    print('num1 < num2 ? --------> {} \n'.format(num1 < num2))
    print('num1 > num2 ? --------> {} \n'.format(num1 > num2))
    print('num1 <= num2 ? --------> {} \n'.format(num1 <= num2))
    print('num1 >= num2 ? --------> {} \n'.format(num1 >= num2))


# ---------------- 运行结果 ------------------
__eq__
num1 == num2 ? --------> False
__eq__
num1 != num2 ? --------> False
__lt__
num1 < num2 ? --------> True
__gt__
num1 > num2 ? --------> False
__le__
num1 <= num2 ? --------> True
__ge__
num1 >= num2 ? --------> False