#coding=utf-8
# specialfuns.py 操作符重載方法
# 類(class)通過(guò)使用特殊名稱的方法(__len__(self))來(lái)實(shí)現(xiàn)被特殊語(yǔ)法(len())的調(diào)用

# 構(gòu)造 與 析構(gòu) 方法
class demo1:

  # 構(gòu)造方法, 對(duì)象實(shí)例化時(shí)調(diào)用
  def __init__(self):
    print("構(gòu)造方法")

  # 析構(gòu)方法, 對(duì)象被回收時(shí)調(diào)用
  def __del__(self):
    print("析構(gòu)方法")


# new
class demo2(object):
  # __init__之前調(diào)用, 一般用于重寫父類的__new__方法, 具體使用見(jiàn) 類 文章的 元類 代碼部分(http://blog.csdn.net/rozol/article/details/69317339)
  def __new__(cls):
    print("new")
    return object.__new__(cls)


# 算術(shù)運(yùn)算
class demo3:
  def __init__(self, num):
    self.data = num
  # +
  def __add__(self, other):
    return self.data + other.data
  # -
  def __sub__(self, other):
    return self.data - other.data
  # *
  def __mul__(self, other):
    return self.data * other.data
  # /
  def __truediv__(self, other):
    return self.data / other.data
  # //
  def __floordiv__(self, other):
    return self.data // other.data
  # %
  def __mod__(self, other):
    return self.data % other.data
  # divmod()
  def __divmod__(self, other):
    # 商(10/5),余數(shù)(10%5)
    return self.data / other.data, self.data % other.data
  # **
  def __pow__(self, other):
    return self.data ** other.data
  # <<
  def __lshift__(self, other):
    return self.data << other.data
  # >>
  def __rshift__(self, other):
    return self.data >> other.data
  # &
  def __and__(self, other):
    return self.data & other.data
  # ^
  def __xor__(self, other):
    return self.data ^ other.data
  # |
  def __or__(self, other):
    return self.data | other.data


class none:
  def __init__(self, num):
    self.data = num
# 反算術(shù)運(yùn)算符(a+b, 若a不支持算術(shù)運(yùn)算符,則尋找b的算術(shù)運(yùn)算符)(注:位置變換, 在原始函數(shù)名前+r)
class demo4:
  def __init__(self, num):
    self.data = num
  # +
  def __radd__(self, other):
    return other.data + self.data
  # -
  def __rsub__(self, other):
    return other.data - self.data
  # *
  def __rmul__(self, other):
    return other.data * self.data
  # /
  def __rtruediv__(self, other):
    return other.data / self.data
  # //
  def __rfloordiv__(self, other):
    return other.data // self.data
  # %
  def __rmod__(self, other):
    return other.data % self.data
  # divmod()
  def __rdivmod__(self, other):
    return other.data / self.data, other.data % self.data
  # **
  def __rpow__(self, other):
    return other.data ** self.data
  # <<
  def __rlshift__(self, other):
    return other.data << self.data
  # >>
  def __rrshift__(self, other):
    return other.data >> self.data
  # &
  def __rand__(self, other):
    return other.data & self.data
  # ^
  def __rxor__(self, other):
    return other.data ^ self.data
  # |
  def __ror__(self, other):
    return other.data | self.data


# 增量賦值運(yùn)算,(注:位置同原始函數(shù),在原始函數(shù)名前+i)
class demo5():
  def __init__(self, num):
    self.data = num
  # +=
  def __iadd__(self, other):
    return self.data + other
  # -=
  def __isub__(self, other):
    return self.data - other
  # *=
  def __imul__(self, other):
    return self.data * other
  # /=
  def __itruediv__(self, other):
    return self.data / other
  # //=
  def __ifloordiv__(self, other):
    return self.data // other
  # %=
  def __imod__(self, other):
    return self.data % other
  # **=
  def __ipow__(self, other):
    return self.data ** other
  # <<=
  def __ilshift__(self, other):
    return self.data << other
  # >>=
  def __irshift__(self, other):
    return self.data >> other
  # &=
  def __iand__(self, other):
    return self.data & other
  # ^=
  def __ixor__(self, other):
    return self.data ^ other
  # |=
  def __ior__(self, other):
    return self.data | other

# 比較運(yùn)算符
class demo6:
  def __init__(self, num):
    self.data = num
  # <
  def __lt__(self, other):
    return self.data < other.data
  # <=
  def __le__(self, other):
    return self.data <= other.data
  # ==
  def __eq__(self, other):
    return self.data == other.data
  # !=
  def __ne__(self, other):
    return self.data != other.data
  # >
  def __gt__(self, other):
    return self.data > other.data
  # >=
  def __ge__(self, other):
    return self.data >= other.data


# 一元操作符
class demo7:
  def __init__(self, num):
    self.data = num
  # + 正號(hào)
  def __pos__(self):
    return +abs(self.data)
  # - 負(fù)號(hào)
  def __neg__(self):
    return -abs(self.data)
  # abs() 絕對(duì)值
  def __abs__(self):
    return abs(self.data)
  # ~ 按位取反
  def __invert__(self):
    return ~self.data
  # complex() 字符轉(zhuǎn)數(shù)字
  def __complex__(self):
    return 1+2j
  # int() 轉(zhuǎn)為整數(shù)
  def __int__(self):
    return 123
  # float() 轉(zhuǎn)為浮點(diǎn)數(shù)
  def __float__(self):
    return 1.23
  # round() 近似值
  def __round__(self):
    return 1.123


# 格式化
class demo8:
  # print() 打印
  def __str__(self):
    return "This is the demo."
  # repr() 對(duì)象字符串表示
  def __repr__(self):
    return "This is a demo."
  # bytes() 對(duì)象字節(jié)字符串表現(xiàn)形式
  def __bytes__(self):
    return b"This is one demo."
  # format() 格式化
  def __format__(self, format_spec):
    return self.__str__()



# 屬性訪問(wèn)
class demo9:
  # 獲取(不存在)屬性
  def __getattr__(self):
    print ("訪問(wèn)的屬性不存在")
  # getattr() hasattr() 獲取屬性
  def __getattribute__(self, attr):
    print ("訪問(wèn)的屬性是%s"%attr)
    return attr
  # setattr() 設(shè)置屬性
  def __setattr__(self, attr, value):
    print ("設(shè)置 %s 屬性值為 %s"%(attr, value))
  # delattr() 刪除屬性
  def __delattr__(self, attr):
    print ("刪除 %s 屬性"%attr)

# ===================================================================
# 描述器(類(test1)的實(shí)例出現(xiàn)在屬主類(runtest)中,這些方法才會(huì)調(diào)用)(注:函數(shù)調(diào)用,這些方法不會(huì)被調(diào)用)
class test1:
  def __init__(self, value = 1):
    self.value = value * 2
  def __set__(self, instance, value):
    print("set %s %s %s"%(self, instance, value))
    self.value = value * 2
  def __get__(self, instance, owner):
    print("get %s %s %s"%(self, instance, owner))
    return self.value
  def __delete__(self, instance):
    print("delete %s %s"%(self, instance))
    del self.value

class test2:
  def __init__(self, value = 1):
    self.value = value + 0.3
  def __set__(self, instance, value):
    print("set %s %s %s"%(self, instance, value))
    instance.t1 = value + 0.3
  def __get__(self, instance, owner):
    print("get %s %s %s"%(self, instance, owner))
    return instance.t1
  def __delete__(self, instance):
    print("delete %s %s"%(self, instance))
    del self.value

class runtest:
  t1 = test1()
  t2 = test2()

# ---

# 自定義property
class property_my:
  def __init__(self, fget=None, fset=None, fdel=None):
    self.fget = fget
    self.fset = fset
    self.fdel = fdel
  # 對(duì)象被獲取(self自身, instance調(diào)用該對(duì)象的對(duì)象(demo9), owner調(diào)用該對(duì)象的對(duì)象類對(duì)象(demo9))
  def __get__(self, instance, owner):
    print("get %s %s %s"%(self, instance, owner))
    return self.fget(instance)
  # 對(duì)象被設(shè)置屬性時(shí)
  def __set__(self, instance, value):
    print("set %s %s %s"%(self, instance, value))
    self.fset(instance, value)
  # 對(duì)象被刪除時(shí)
  def __delete__(self, instance):
    print("delete %s %s"%(self, instance))
    self.fdel(instance)

class demo10:
  def __init__(self):
    self.num = None
  def setvalue(self, value):
    self.num = value
  def getvalue(self):
    return self.num
  def delete(self):
    del self.num
  x = property_my(getvalue, setvalue, delete)

# ===================================================================

# 自定義容器
class lis:
  def __init__(self, *args):
    self.lists = args
    self.size = len(args)
    self.startindex = 0
    self.endindex = self.size
  # len() 容器元素?cái)?shù)量
  def __len__(self):
    return self.size;
  # lis[1] 獲取元素
  def __getitem__(self, key = 0):
    return self.lists[key]
  # lis[1] = value 設(shè)置元素
  def __setitem__(self, key, value):
    pass
  # del lis[1] 刪除元素
  def __delitem__(self, key):
    pass
  # 返回迭代器
  def __iter__(self):
    return self
  # rversed() 反向迭代器
  def __reversed__(self):
    while self.endindex > 0:
      self.endindex -= 1
      yield self[self.endindex]
  # next() 迭代器下個(gè)元素
  def __next__(self):
    if self.startindex >= self.size:
      raise StopIteration # 控制迭代器結(jié)束

    elem = self.lists[self.startindex]
    self.startindex += 1
    return elem

  # in / not in
  def __contains__(self, item):
    for i in self.lists:
      if i == item:
        return True
    return False


# yield 生成器(執(zhí)行一次返回,下次繼續(xù)執(zhí)行后續(xù)代碼返回)
def yielddemo():
  num = 0
  while 1: # 1 == True; 0 == False
    if num >= 10:
      raise StopIteration
    num += 1
    yield num

# 能接收數(shù)據(jù)的生成器
def yielddemo_1():
  while 1:
    num = yield
    print(num)


# with 自動(dòng)上下文管理
class withdemo:
  def __init__(self, value):
    self.value = value
  # 返回值為 as 之后的值
  def __enter__(self):
    return self.value
  # 執(zhí)行完成,退出時(shí)的數(shù)據(jù)清理動(dòng)作
  def __exit__(self, exc_type, exc_value, traceback):
    del self.value


if __name__ == "__main__":
  # 構(gòu)造與析構(gòu)
  d1 = demo1()
  del d1


  # new
  d2 = demo2()


  # 算術(shù)運(yùn)算符
  d3 = demo3(3)
  d3_1 = demo3(5)
  print(d3 + d3_1)
  print(d3 - d3_1)
  print(d3 * d3_1)
  print(d3 / d3_1)
  print(d3 // d3_1)
  print(d3 % d3_1)
  print(divmod(d3, d3_1))
  print(d3 ** d3_1)
  print(d3 << d3_1)
  print(d3 >> d3_1)
  print(d3 & d3_1)
  print(d3 ^ d3_1)
  print(d3 | d3_1)


  # 反運(yùn)算符
  d4 = none(3)
  d4_1 = demo4(5)
  print(d4 + d4_1)
  print(d4 - d4_1)
  print(d4 * d4_1)
  print(d4 / d4_1)
  print(d4 // d4_1)
  print(d4 % d4_1)
  print(divmod(d4, d4_1))
  print(d4 ** d4_1)
  print(d4 << d4_1)
  print(d4 >> d4_1)
  print(d4 & d4_1)
  print(d4 ^ d4_1)
  print(d4 | d4_1)


  # 增量賦值運(yùn)算(測(cè)試時(shí)注釋其他代碼)
  d5 = demo5(3)
  d5 <<= 5
  d5 >>= 5
  d5 &= 5
  d5 ^= 5
  d5 |= 5
  d5 += 5
  d5 -= 5
  d5 *= 5
  d5 /= 5
  d5 //= 5
  d5 %= 5
  d5 **= 5
  print(d5)


  # 比較運(yùn)算符
  d6 = demo6(3)
  d6_1 = demo6(5)
  print(d6 < d6_1)
  print(d6 <= d6_1)
  print(d6 == d6_1)
  print(d6 != d6_1)
  print(d6 > d6_1)
  print(d6 >= d6_1)


  # 一元操作符(測(cè)試時(shí)注釋其他代碼)
  d7 = demo7(-5)
  num = +d7
  num = -d7
  num = abs(d7)
  num = ~d7
  print(num)
  print(complex(d7))
  print(int(d7))
  print(float(d7))
  print(round(d7))


  # 格式化
  d8 = demo8()
  print(d8)
  print(repr(d8))
  print(bytes(d8))
  print(format(d8, ""))


  # 屬性訪問(wèn)
  d9 = demo9()
  setattr(d9, "a", 1) # => 設(shè)置 a 屬性值為 1
  print(getattr(d9, "a")) # => a / 訪問(wèn)的屬性是a
  print(hasattr(d9, "a")) # => True / 訪問(wèn)的屬性是a
  delattr(d9, "a") # 刪除 a 屬性
  # ---
  d9.x = 100 # => 設(shè)置 x 屬性值為 100
  print(d9.x) # => x / 訪問(wèn)的屬性是x
  del d9.x # => 刪除 x 屬性


  # 描述器
  r = runtest()
  r.t1 = 100 # => <__main__.test1> <__main__.runtest> 100
  print(r.t1) # => 200 / <__main__.test1> <__main__.runtest> <class '__main__.runtest'>
  del r.t1 # => <__main__.test1> <__main__.runtest>
  r.t2 = 200 # => <__main__.test2> <__main__.runtest> 200 / <__main__.test1> <__main__.runtest> 200.3
  print(r.t2) # => 400.6 / <__main__.test2> <__main__.runtest> <class '__main__.runtest'> / <__main__.test1> <__main__.runtest> <class '__main__.runtest'>
  del r.t2 # <__main__.test2> <__main__.runtest>
  # ---
  # 自定義property
  d10 = demo10()
  d10.x = 100; # => <__main__.property_my> <__main__.demo10> 100
  print(d10.x) # => 100 / <__main__.property_my> <__main__.demo10> <class '__main__.demo10'>
  del d10.x # => <__main__.property_my> <__main__.demo10>
  d10.num = 200;
  print(d10.num) # => 200
  del d10.num


  # 自定義容器(迭代器Iterator)
  lis = lis(1,2,3,4,5,6)
  print(len(lis))
  print(lis[1])
  print(next(lis))
  print(next(lis))
  print(next(lis))
  for i in lis:
    print (i)
  for i in reversed(lis):
    print (i)
  print(3 in lis)
  print(7 in lis)
  print(3 not in lis)
  print(7 not in lis)


  # yield 生成器(可迭代對(duì)象Iterable)
  for i in yielddemo():
    print (i)
  # ---
  iters = iter(yielddemo())
  print(next(iters))
  print(next(iters))

  # --- 發(fā)送數(shù)據(jù)給生成器 ---
  iters = yielddemo_1()
  next(iters)
  iters.send(6) # 發(fā)送數(shù)據(jù)并執(zhí)行
  iters.send(10)


  # with 自動(dòng)上下文管理
  with withdemo("Less is more!") as s:
    print(s)