class nu:
	def __init__(self):
		#initialisation step
		pass
		
	def __del__(self):
		#Called when the instance is about to be destroyed. This is also called a destructor.
		pass
		
	def __len__(  	self):
		pass
		
	def __getitem__(self,key):
      # Get a book from the shelf object:
      # The [ ] brackets represent the get/set item operator.
      #myfavbook = Bookshelf["There and Back Again"]
      # This would like be the same as writing the following:
      #myfavbook = Bookshelf.getBook("There and Back Again")
		pass
		
	def __setitem__(self,key,value):
		# Get a book from the shelf object:
      # The [ ] brackets represent the get/set item operator.
      #mybook = Book(title="There and Back Again")
      #Bookshelf[mybook] # Put my book on the shelf
      # This would be like doing the following without __setitem__
      #Bookshelf.add(mybook)
		pass
      
	def __delitem__(self, key):
		pass
   	
	def __contains__(  	self, item):
   	#Called to implement membership test operators. 
   	#Should return true if item is in self, false otherwise. 
   	#For mapping objects, this should consider the keys 
   	#of the mapping rather than the values or the key-item pairs.
		pass
      
	def __call__(self):
   	#This is a the property of objects that makes a function a function.
   	#By defining __call__ you can actually make your object callable just as if it were a function.
		pass
   	
	def __eq__(self):
      	#This is the comparison operator for ==. 
      	#>>> a == b
        #True
        #>>> a.__eq__(b)
        #True
		pass
      	#x<y calls x.__lt__(y), 
      	#x<=y calls x.__le__(y), 
      	#x==y calls x.__eq__(y), 
      	#x!=y and x<>y call x.__ne__(y), 
      	#x>y calls x.__gt__(y), 
      	#and x>=y calls x.__ge__(y).
      	
	#__add__(  	self, other)
	#__sub__( 	self, other)
	#__mul__( 	self, other)
	#__floordiv__( 	self, other)
	#__mod__( 	self, other)
	#__divmod__( 	self, other)
	#__pow__( 	self, other[, modulo])
	#__lshift__( 	self, other)
	#__rshift__( 	self, other)
	#__and__( 	self, other)
	#__xor__( 	self, other)
	#__or__( 	self, other)
	#__div__(  	self, other)
	#__truediv__( 	self, other)
	#__iadd__(  	self, other) +=
	#__isub__( 	self, other)
	#__imul__( 	self, other)
	#__idiv__( 	self, other)
	#__itruediv__( 	self, other)
	#__ifloordiv__( 	self, other)
	#__imod__( 	self, other)
	#__ipow__( 	self, other[, modulo])
	#__ilshift__( 	self, other)
	#__irshift__( 	self, other)
	#__iand__( 	self, other)
	#__ixor__( 	self, other)
	#__ior__( 	self, other)
	#__neg__(  	self)
	#__pos__( 	self)
	#__abs__( 	self)
	#__invert__( 	self)
	
class victor(tuple):
	def __init__(self,item):
		self = item

	def __add__(self,other):
		if type(other) == (victor or tuple or list):
			if len(self) <= len(other):
				for key in range(len(self)):
					self[key] = self[key] + other[key]
			else:
				for key in range(len(other)):
					self[key] = self[key] + other[key]
		elif type(other) == (int or float):
			for key in range(len(self)):
				self[key] = self[key] + other
		return self
				
v = victor((1,2,3))
print v
v = v + (3,2,1)
print v