key_base = base.Base()
key_base.init(base_size, overflow_area_size, package_size,1)  
    
key_set = key_generator.generate_keys(base_size)
hash_set = []
for key in key_set:
	hashcode = hashing.summing_hashing(key,2)
	hashcode %= number_of_packages
	hash_set.append(hashcode)  
elements = []	
for i in range(len(key_set)):
	elements.append([ hash_set[i], key_set[i] ])    
elements.sort()	

tstart = time.time()
for element in elements:
	key_base.add(element)
tend = time.time()
		 
print 
print "База 1 заполнена за %f секунд" %(tend - tstart)
key_base.stats()
  
search_set = key_generator.generate_keys(SEARCH_SEQ_LENGTH)
    
print "Набор ключей для поиска сгенерирован"
  
tstart = time.time()
for key in search_set:
	key_base.search(key)
end = time.time()
    
print "Поиск всех ключей из набора занял %f секунд" %(tend - tstart)    
    
del key_base, key_set, hash_set, elements

key_base_2 = base.Base()
key_base_2.init(base_size, overflow_area_size, package_size,2)  

# Вот тут я получаю содержание первого объекта
key_base_2.view()

class Base:
    '''Класс для базы данных'''
    __id = 0
    __keys_space = []
    __basesize = 0
    __overflow_area_size = 0
    __overall_base_size = 0
    
    def init(self, basesize, over_area_size, package_size, iden):	
		self.__basesize = basesize
		self.__overflow_area_size = over_area_size
		self.__overall_base_size = basesize + over_area_size
		self.__id = iden		

		for i in range(basesize):
			empty_element = baseElement()
			empty_element.set_address(i)			
			segment_number = int(i / package_size)
			empty_element.set_segment(segment_number)
			self.__keys_space.append(empty_element)
			
		for i in range(basesize, basesize + over_area_size):
			empty_element = baseElement()
			empty_element.set_address(i)
			empty_element.set_segment(-1)
			self.__keys_space.append(empty_element)	
				
    		
    def view(self):

		if not self.__keys_space:
			print "Base is empty!"
			return
		print "id is %d" %self.__id	
		print "Segment\tAddress\tHashcode\tKey\tOverflow_address"
			
		for element_for_printing in self.__keys_space:
			print element_for_printing.get_segment(),'\t',\
			      element_for_printing.get_address(),'\t',\
			      element_for_printing.get_hashcode(),'\t\t',\
			      element_for_printing.get_key(),'\t',\
			      element_for_printing.get_overflow_key(),'\t'
      
    def add(self, element):
		for index, key in enumerate(self.__keys_space):
			previous_index = index - 1
			previous_key = self.__keys_space[previous_index]
			
			if key.get_key() == "-" and element[0] == key.get_segment():
				key.set_key(element[1])
				key.set_hashcode(element[0])
				break

			elif element[0] == previous_key.get_segment()\
			and element[0] != key.get_segment():

				for i in range(self.__basesize, self.__overall_base_size):
					if self.__keys_space[i].get_key() == "-"\
					and self.__keys_space[i].get_segment() == -1:
						self.__keys_space[i].set_key(element[1])
						self.__keys_space[i].set_hashcode(element[0])					
						current_address = self.__keys_space[i].get_address()
						previous_key.set_overflow_key(current_address)
						break
					elif self.__keys_space[i].get_key() != "-"\
					and self.__keys_space[i].get_hashcode() == element[0]:
						previous_key = previous_key = self.__keys_space[i]
					
    def stats(self):
		counter = 0
		for key in self.__keys_space:
			if key.get_key() != "-":
				counter += 1 
		print "Заполнение базы: %i / %i" %(counter, self.__overall_base_size)
	
    def search(self, userkey):
		if not self.__keys_space:
			print "Base is empty!"
			return
		for index, key in enumerate(self.__keys_space):
			if key.get_key() == userkey:
				return index
		return -1

class Base:
    '''Класс для базы данных'''
    def __init__(self):
       self.__id = 0
       self.__keys_space = []
       self.__basesize = 0
       self.__overflow_area_size = 0
       self.__overall_base_size = 0