Частотный анализатор английских слов, написаный на python 3, умеющий нормализовывать слова с помощью WordNet и переводить с помощью StarDict

# -*- coding: utf-8 -*- 

import re
import os
from collections import Counter


class FrequencyDict:
	def __init__():
		
		# Определяем регулярное выражение для поиска английских слов
		self.wordPattern = re.compile("((?:[a-zA-Z]+[-']?)*[a-zA-Z]+)")
		
		# Частотный словарь(использум класс collections.Counter для поддержки подсчёта уникальных элементов в последовательностях) 		
		self.frequencyDict = Counter()
		
	# Метод парсит файл, получает из него слова
	def ParseBook(self, file):
		if file.endswith(".txt"): 
			self.__ParseTxtFile(file, self.__FindWordsFromContent)
		else:
			print('Warning: The file format is not supported: "%s"' %file)
			
	# Метод парсит файл в формате txt
	def __ParseTxtFile(self, txtFile, contentHandler):
		try:
			with open(txtFile, 'rU') as file:		
				for line in file: # Читаем файл построчно
					contentHandler(line) # Для каждой строки вызываем обработчик контента
		except Exception as e:
			print('Error parsing "%s"' % txtFile, e)	
						
	# Метод находит в строке слова согласно своим правилам и затем добавляет в частотный словарь
	def __FindWordsFromContent(self, content):
		result = self.wordPattern.findall(content) # В строке найдем список английских слов				
		for word in result:
			word = word.lower()	# Приводим слово к нижнему регистру	
				self.frequencyDict[word] += 1 # Добавляем в счетчик частотного словаря не нормализованное слово	
	
	
	# Метод отдает первые countWord слов частотного словаря, отсортированные по ключу и значению
	def FindMostCommonElements(self, countWord):
		dict = list(self.frequencyDict.items())
		dict.sort(key=lambda t: t[0])
		dict.sort(key=lambda t: t[1], reverse = True)
		return dict[0 : int(countWord)]

# -*- coding: utf-8 -*- 

import os

class BaseWordNetItem:
	# Конструктор
	def __init__(self, pathWordNetDict, excFile, indexFile):
	
		self.rule=() # Правила замены окончаний при нормализации слова по правилам.
		
		self.wordNetExcDict={}  # Словарь исключений
		self.wordNetIndexDict=[] # Индексный массив	
		
		self.excFile = os.path.join(pathWordNetDict, excFile) # Получим путь до файла исключений	
		self.indexFile = os.path.join(pathWordNetDict, indexFile) # Получим путь до индексного словаря
		
		self.__ParseFile(self.excFile, self.__AppendExcDict) # Заполним словарь исключений
		self.__ParseFile(self.indexFile, self.__AppendIndexDict) # Заполним индексный массив 

		self.cacheWords={} # Немного оптимизации. Кэш для уже нормализованных слов, ключ - ненормализованное слово, значение - нормализованное слово	
		
			
			
	# Метод добавляет в словарь исключений одно значение. 
	# Файл исключений представлен в формате: [слово-исключение][пробел][лемма]	
	def __AppendExcDict(self, line):			
		# При разборе строки из файла, каждую строку разделяем на 2 слова и заносим слова в словарь(первое слово - ключ, второе - значение). При этом не забываем убрать с концов пробелы
		group = [item.strip() for item in line.replace("n","").split(" ")]
		self.wordNetExcDict[group[0]] = group[1]

			
			
	# Метод добавляет в индексный массив одно значение.
	def __AppendIndexDict(self, line):			
		# На каждой строке берем только первое слово
		group = [item.strip() for item in line.split(" ")]
		self.wordNetIndexDict.append(group[0]) 
		

	# Метод открывает файл на чтение, читает по одной строке и вызывает для каждой строки функцию, переданную в аргументе
	def __ParseFile(self, file, contentHandler):	
		try:
			with open(file, 'r') as openFile: 
				for line in openFile:
					contentHandler(line)	# Для каждой строки вызываем обработчик контента
		except Exception as e:
			raise Exception('File does not load: "%s"' %file)	
			
			
	# Метод возвращает значение ключа в словаре. Если такого ключа в словаре нет, возвращается пустое значение. 
	# Под словарем здесь подразумевается просто структура данных 
	def _GetDictValue(self, dict, key):
		try:
			return dict[key]		
		except KeyError:
			return None
		
		
		
	# Метод проверяет слово на существование, и возвращает либо True, либо False.
	# Для того, чтобы понять, существует ли слово, проверяется индексный массив(там хранится весь список слов данной части речи).	
	def _IsDefined(self, word):
		if word in self.wordNetIndexDict:
			return True
		return False		
	
	
	
	# Метод возвращает лемму(нормализованную форму слова)			
	def GetLemma(self, word):
	
		word = word.strip().lower() 
	
		# Пустое слово возвращаем обратно
		if word == None:
			return None	

		# Пройдемся по кэшу, возможно слово уже нормализовывалось раньше и результат сохранился в кэше
		lemma = self._GetDictValue(self.cacheWords, word)
		if lemma != None:
			return lemma
			
		# Проверим, если слово уже в нормализованном виде, вернем его же
		if self._IsDefined(word):
			return word
			
			
		# Пройдемся по исключениям, если слово из исключений, вернем его нормализованную форму
		lemma = self._GetDictValue(self.wordNetExcDict, word)
		if lemma != None:
			return lemma
	
			
		# На этом шаге понимаем, что слово не является исключением и оно не нормализовано, значит начинаем нормализовывать его по правилам. 
		lemma = self._RuleNormalization(word)
		if lemma != None:
			self.cacheWords[word] = lemma # Предварительно добавим нормализованное слово в кэш
			return lemma		

		return None	
		
		
		
	# Нормализация слова по правилам (согласно грамматическим правилам, слово приводится к нормальной форме)
	def _RuleNormalization(self, word):
		# Бежим по всем правилам, смотрим совпадает ли окончание слова с каким либо правилом, если совпадает, то заменяем окончние.	
		for replGroup in self.rule:
			endWord = replGroup[0]			
			if word.endswith(endWord): 	
				lemma = word # Копируем во временную переменную
				lemma = lemma.rstrip(endWord) # Отрезаем старое окончание
				lemma += replGroup[1] # Приклеиваем новое окончание
				if self._IsDefined(lemma): # Проверим, что получившееся новое слово имеет право на существование, и если это так, то вернем его
					return lemma	
		return None

# -*- coding: utf-8 -*- 


from WordNet.BaseWordNetItem import BaseWordNetItem

# Класс для нормализации глаголов
# Класс наследуется от BaseWordNetItem

class WordNetVerb(BaseWordNetItem):
	def __init__(self, pathToWordNetDict):
	
		# Конструктор родителя (BaseWordNetItem)
		BaseWordNetItem.__init__(self, pathToWordNetDict, 'verb.exc', 'index.verb')


		# Правила замены окончаний при нормализации слова по правилам. К примеру, окончание "s" заменяется на "" , "ies" на и "y" тд.
		self.rule = (	
						["s"   , ""  ],
						["ies" , "y" ],
						["es"  , "e" ], 			
						["es"  , ""  ],	
						["ed"  , "e" ], 			
						["ed"  , ""  ],	
						["ing" , "e" ], 			
						["ing" , ""  ]	
					)

		# Метод получения нормализованной формы слова GetLemma(word) определен в базовом классе BaseWordNetItem

# -*- coding: utf-8 -*- 


from WordNet.BaseWordNetItem import BaseWordNetItem

# Класс для работы с нормализацией существительных
# Класс наследуется от BaseWordNetItem

class WordNetNoun(BaseWordNetItem):
	def __init__(self, pathToWordNetDict):
	
		# Конструктор родителя (BaseWordNetItem)
		BaseWordNetItem.__init__(self, pathToWordNetDict, 'noun.exc', 'index.noun')
		
		# Правила замены окончаний при нормализации слова по правилам. К примеру, окончание "s" заменяется на "", "ses" заменяется на "s" и тд.
		self.rule = (	
						["s"    , ""    ],
						["’s"   , ""    ],
						["’"    , ""    ],							
						["ses"  , "s"   ],
						["xes"  , "x"   ], 			
						["zes"  , "z"   ],	
						["ches" , "ch"  ], 			
						["shes" , "sh"  ],
						["men"  , "man" ], 			
						["ies"  , "y"   ]					
					)	 
					
					
	# Метод возвращает лемму сушествительного(нормализованную форму слова)
	# Этот метод есть в базовом классе BaseWordNetItem, но нормализация существительных несколько отличается от нормализации других частей речи, 
	# поэтому метод в наследнике переопределен
	def GetLemma(self, word):	
		
		word = word.strip().lower() 
		
		# Если существительное слишком короткое, то к нормализованному виду мы его не приводим	
		if len(word) <= 2:
			return None	

		# Если существительное заканчивается на "ss", то к нормализованному виду мы его не приводим	
		if word.endswith("ss"):
			return None	
			
		# Пройдемся по кэшу, возможно слово уже нормализовывалось раньше и результат сохранился в кэше
		lemma = self._GetDictValue(self.cacheWords, word)
		if lemma != None:
			return lemma
			
		# Проверим, если слово уже в нормализованном виде, вернем его же
		if self._IsDefined(word):
			return word
		
		# Пройдемся по исключениям, если слово из исключений, вернем его нормализованную форму
		lemma = self._GetDictValue(self.wordNetExcDict, word)
		if (lemma != None):
			return lemma

			
		# Если существительное заканчивается на "ful", значит отбрасываем "ful", нормализуем оставшееся слово, а потом суффикс приклеиваем назад.
		# Таким образом, к примеру, из слова "spoonsful" после нормализации получится "spoonful"
		suff = ""
		if word.endswith("ful"): 
				word = word[:-3] # Отрезаем суффикс "ful"
				suff = "ful" # Отрезаем суффикс "ful", чтобы потом приклеить назад
		
		
		# На этом шаге понимаем, что слово не является исключением и оно не нормализовано, значит начинаем нормализовывать его по правилам. 
		lemma = self._RuleNormalization(word)
		if (lemma != None):
			lemma += suff # Не забываем добавить суффикс "ful", если он был
			self.cacheWords[word] = lemma # Предварительно добавим нормализованное слово в кэш
			return lemma		

		return None	
	

# -*- coding: utf-8 -*- 


from WordNet.BaseWordNetItem import BaseWordNetItem

# Класс для нормалзации наречий
# Класс наследуется от BaseWordNetItem

class WordNetAdverb(BaseWordNetItem):
	def __init__(self, pathToWordNetDict):
	
		# Конструктор родителя (BaseWordNetItem)
		BaseWordNetItem.__init__(self, pathToWordNetDict, 'adv.exc', 'index.adv')
		
		# У наречий есть только списки исключений(adv.exc) и итоговый список слов(index.adv).	
		# Правила замены окончаний при нормализации слова по правилам у наречий нет. 

# -*- coding: utf-8 -*- 

from WordNet.BaseWordNetItem import BaseWordNetItem

# Класс для работы с нормализацией прилагательных
# Класс наследуется от BaseWordNetItem

class WordNetAdjective(BaseWordNetItem):
	def __init__(self, pathToWordNetDict):
	
		# Конструктор родителя (BaseWordNetItem)
		BaseWordNetItem.__init__(self, pathToWordNetDict, 'adj.exc', 'index.adj')


		# Правила замены окончаний при нормализации слова по правилам. К примеру, окончание "er" заменяется на "" или  "e" и тд.
		self.rule = (	
						["er"  , "" ],
						["er"  , "e"],
						["est" , "" ], 			
						["est" , "e"]	
					)

						
		# Метод получения нормализованной формы слова GetLemma(word) определен в базовом классе BaseWordNetItem

# -*- coding: utf-8 -*- 


from WordNet.WordNetAdjective import WordNetAdjective
from WordNet.WordNetAdverb import WordNetAdverb
from WordNet.WordNetNoun import WordNetNoun
from WordNet.WordNetVerb import WordNetVerb

class Lemmatizer:
	def __init__(self, pathToWordNetDict):
	
		# Разделитель составных слов	
		self.splitter = "-" 						
		
		# Инициализируем объекты с частям речи
		adj = WordNetAdjective(pathToWordNetDict)	# Прилагательные
		noun = WordNetNoun(pathToWordNetDict)		# Существительные
		adverb = WordNetAdverb(pathToWordNetDict)	# Наречия
		verb = WordNetVerb(pathToWordNetDict)		# Глаголы
		
		self.wordNet = [verb, noun, adj, adverb]
		

	# Метод возвращает лемму слова (возможно, составного)		
	def GetLemma(self, word):
		# Если в слове есть тире, разделим слово на части, нормализуем каждую часть(каждое слово) по отдельности, а потом соединим
		wordArr = word.split(self.splitter)
		resultWord = []
		for word in wordArr:
			lemma = self.__GetLemmaWord(word)
			if (lemma != None):
				resultWord.append(lemma)
		if (resultWord != None):
			return self.splitter.join(resultWord)
		return None		
		
		
		
	# Метод возвращает лемму(нормализованную форму слова)			
	def __GetLemmaWord(self, word):
		for item in self.wordNet:
			lemma = item.GetLemma(word)
			if (lemma != None):
				return lemma
		return None		
				

# -*- coding: utf-8 -*- 


import os

class BaseStarDictItem:
	def __init__(self, pathToDict, exp):
	
		# Определяем переменную с кодировкой
		self.encoding = "utf-8"
		
		# Получаем полный путь до файла
		self.dictionaryFile = self.__PathToFileInDirByExp(pathToDict, exp)
		
		# Получаем размер файла
		self.realFileSize = os.path.getsize(self.dictionaryFile)	

	
	
	# Метод ищет в папке path первый попапвшийся файл с расширением exp 
	def __PathToFileInDirByExp(self, path, exp):
		if not os.path.exists(path):
			raise Exception('Path "%s" does not exists' % path)	
		
		end = '.%s'%(exp)
		list = [f for f in os.listdir(path) if f.endswith(end)]
		if list: 
			return os.path.join(path, list[0]) # Возвращаем первый попавшийся
		else:
			raise Exception('File does not exist: "*.%s"' % exp)	
			

# -*- coding: utf-8 -*- 


from StarDict.BaseStarDictItem import BaseStarDictItem
from Frequency.IniParser import IniParser

class Ifo(BaseStarDictItem):
	def __init__(self, pathToDict):
		
		# Конструктор родителя (BaseStarDictItem)
		BaseStarDictItem.__init__(self, pathToDict, 'ifo')	

		# Создаем и инициализируем парсер
		self.iniParser = IniParser(self.dictionaryFile)
		
		# Считаем из ifo файла параметры
		# Если хотя бы одно из обязательных полей отсутствует, вызовется исключение и словарь не будет загружен
		self.bookName = self.__getParameterValue("bookname", None) # Название словаря [Обязательное поле]
		self.wordCount = self.__getParameterValue("wordcount", None)  # Количество слов в ".idx" файле [Обязательное поле]
		self.synWordCount = self.__getParameterValue("synwordcount", "")  # Количество слов в ".syn" файле синонимов [Обязательное поле, если есть файл ".syn"]
		self.idxFileSize = self.__getParameterValue("idxfilesize", None) # Размер (в байтах) ".idx" файла. Если файл сжат архиватором, то здесь указывается размер исходного несжатого файла [Обязательное поле]
		self.idxOffsetBits = self.__getParameterValue("idxoffsetbits", 32)  # Размер числа в битах(32 или 64), содержащего внутри себя смещение до записи в файле .dict. Поле пояилось начиная с версии 3.0.0, до этого оно всегда было 32 [Необязательное поле]
		self.author = self.__getParameterValue("author", "") # Автор словаря [Необязательное поле]
		self.email = self.__getParameterValue("email", "") # Почта [Необязательное поле]
		self.description = self.__getParameterValue("description", "") # Описание словаря [Необязательное поле]
		self.date = self.__getParameterValue("date", "") # Дата создания словаря [Необязательное поле]
		self.sameTypeSequence = self.__getParameterValue("sametypesequence", None) # Маркер, определяющий форматирование словарной статьи[Обязательное поле]
		self.dictType = self.__getParameterValue("dicttype", "") # Параметр используется некоторыми словарными плагинами, например WordNet[Необязательное поле]			
	

	def __getParameterValue(self, key, defaultValue):
		try:
			return self.iniParser.GetValue(key) 
		except:
			if defaultValue != None:
				return defaultValue
			raise Exception('n"%s" has invalid format (missing parameter: "%s")' % (self.dictionaryFile, key))	

# -*- coding: utf-8 -*- 


from struct import unpack
from StarDict.BaseStarDictItem import BaseStarDictItem


class Idx(BaseStarDictItem):

	# Конструктор
	def __init__(self, pathToDict, wordCount, idxFileSize, idxOffsetBits):

		# Конструктор родителя (BaseStarDictItem)
		BaseStarDictItem.__init__(self, pathToDict, 'idx')
		
		self.idxDict ={} # Словарь, self.idxDict = {'иностр.слово': [Смещение_до_записи_в_файле_dict, Размер_всей_записи_в_файле_dict], ...}	
		self.idxFileSize = int(idxFileSize) # Размер файла .idx, записанный в .ifo файле
		self.idxOffsetBytes = int(idxOffsetBits/8) # Размер числа, содержащего внутри себя смещение до записи в файле .dict. Переводим в байты и приводим к числу
		self.wordCount = int(wordCount) # Количество слов в ".idx" файле
		
		# Проверяем целостность словаря (информация в .ifo файле о размере .idx файла [idxfilesize] должна совпадать с его реальным размером)
		self.__CheckRealFileSize()
		
		# Заполняем словарь self.idxDict данными из файла .idx
		self.__FillIdxDict()
	
		# Проверяем целостность словаря (информация в .ifo файле о количестве слов [wordcount] должна совпадать с реальным количеством записей в .idx файле)
		self.__CheckRealWordCount()
	
	
	# Функция сверяет размер файла, записанный в .ifo файле, с ее реальным размером и в случае расхождений генерирует исключение	
	def __CheckRealFileSize(self):
		if self.realFileSize != self.idxFileSize:
			raise Exception('size of the "%s" is incorrect' %self.dictionaryFile)

			
	# Функция сверяет количестве слов, записанное в .ifo файле, с реальным количеством записей в файле .idx и в случае расхождений генерирует исключение			
	def __CheckRealWordCount(self):
		realWordCount = len(self.idxDict)
		if realWordCount != self.wordCount:
			raise Exception('word count of the "%s" is incorrect' %self.dictionaryFile)
	

	# Функция считывает из потока данных массив байтов заданной длины, затем преобазует байткод в число	
	def __getIntFromByteArray(self, sizeInt, stream):
		byteArray = stream.read(sizeInt) # Получили массив байтов, отведенных под число
		
		# Определим формат пробразования в числовой формат 
		formatCharacter = 'L'   # Формат означает "unsigned long" (для sizeInt = 4)
		if sizeInt == 8:
			formatCharacter = 'Q' # Формат означает "unsigned long long" (для sizeInt = 8)
		format = '>' + formatCharacter # Общий формат будет состоять из: "направление порядка байтов" + "формат числа"
		# Строка '>' - означает, что мы распаковываем байткод в число int(размера formatCharacter) от старшего бита к младшему.
		
		integer = (unpack(format, byteArray))[0] # Распаковываем массив байтов в заданном формате	
		return int(integer) 
		
		

	# Функция разделяет файл .idx на отдельные записи (запись состоит из 3-х полей) и каждую запись добавляет в словарь self.idxDict
	def __FillIdxDict(self):
		languageWord = ""
		with open(self.dictionaryFile, 'rb') as stream:
			while True:
				byte = stream.read(1)  # Читаем один байт
				if not byte: break # Если байтов больше нет, то выходим из цикла
				if byte != b'':	 # Если байт не является символом окончания строки '', то прибавляем его к слову
					languageWord += byte.decode("utf-8")
				else: 
					# Если дошли до '', то считаем, что слово закончилось и дальше идут два числа ("Смещение до записи в файле dict" и "Размер всей записи в файле dict")
					wordDataOffset = self.__getIntFromByteArray(self.idxOffsetBytes, stream)  # Получили первое число "Смещение до записи в файле dict"
					wordDataSize = self.__getIntFromByteArray(4, stream) # Получили второе число "Размер всей записи в файле dict"

					self.idxDict[languageWord] = [wordDataOffset, wordDataSize] # Добавим в словарь self.idxDict запись: иностранное слово + смещение + размер данных
					languageWord = "" # Обнуляем переменную, поскольку начинается следующая струтура
			

			
	# Функция возвращает расположение слова в файле .dict ("Смещение до записи в файле dict" и "Размер всей записи в файле dict").
	# Если такого слова в словаре нет, функция возвращает None
	def GetLocationWord(self, word):			
		try:
			return self.idxDict[word]		
		except KeyError:
			return [None, None]	

# -*- coding: utf-8 -*- 


from StarDict.BaseStarDictItem import BaseStarDictItem

# Маркер может быть составным (к примеру, sametypesequence = tm).
# Виды одно-символьныx идентификаторов  словарных статей (для всех строчных идентификаторов текст в формате utf-8, заканчивается ''):
# 'm' - просто текст в кодировке utf-8, заканчивается '' 
# 'l' - просто текст в НЕ в кодировке utf-8, заканчивается '' 
# 'g' - текст размечен с помощью языка разметки текста Pango
# 't' - транскрипция в кодировке utf-8, заканчивается '' 
# 'x' - текст в кодировке utf-8, размечен с помощью xdxf
# 'y' - текст в кодировке utf-8, содержит китайские(YinBiao) или японские (KANA) символы 
# 'k' - текст в кодировке utf-8, размечен с помощью  KingSoft PowerWord XML 
# 'w' - текст размечен с помощью  MediaWiki
# 'h' - текст размечен с помощью  Html
# 'n' - текст размечен формате для WordNet
# 'r' - текст содержит список ресурсов. Ресурсами могут быть файлы картинки (jpg), звуковые (wav), видео (avi), вложенные(bin) файлы и др.
# 'W' - wav файл
# 'P' - картинка
# 'X' - этот тип зарезервирован для экспериментальных расширений



class Dict(BaseStarDictItem):
	def __init__(self, pathToDict, sameTypeSequence):

		# Конструктор родителя (BaseStarDictItem)
		BaseStarDictItem.__init__(self, pathToDict, 'dict')
	
		# Маркер, определяющий форматирование словарной статьи
		self.sameTypeSequence = sameTypeSequence 
		

			
	def	GetTranslation(self, wordDataOffset, wordDataSize):
		try:
			# Убеждаемся что смещение и размер данных неотрицательны и находятся в пределах размера файла .dict
			self.__CheckValidArguments(wordDataOffset, wordDataSize)

			# Открываем файл .dict как бинарный
			with open(self.dictionaryFile, 'rb') as file:  # менеджер контекста
				file.seek(wordDataOffset) # Смешаемся внутри файла до начала текста, относящегося к переводу слова
				byteArray = file.read(wordDataSize) # Читаем часть файла, относящегося к переводу слова
				return byteArray.decode(self.encoding) # Вернем раскодированный в юникодную строку набор байтoв (self.encoding определен в базовом классе BaseDictionaryItem)
	
		except Exception:
			return None	

	
	

	def	__CheckValidArguments(self, wordDataOffset, wordDataSize):	
		if wordDataOffset is None:
			pass
		if wordDataOffset < 0:
			pass
		endDataSize = wordDataOffset + wordDataSize
		if wordDataOffset < 0 or wordDataSize < 0 or endDataSize > self.realFileSize:
			raise Exception

# -*- coding: utf-8 -*- 

import os
import xlwt3 as xlwt

from Frequency.IniParser import IniParser
from Frequency.FrequencyDict import FrequencyDict
from StarDict.StarDict import StarDict

ConfigFileName="Settings.ini"

class Main:
	def __init__(self):
	
		self.listLanguageDict = [] # В этом массиве сохраним словари StarDict
		self.result = [] # В этом массиве сохраним результат (само слово, частота, его перевод)

		try:
			# Создаем и инициализируем конфиг-парсер
			config = IniParser(ConfigFileName)	

			self.pathToBooks = config.GetValue("PathToBooks") # Считываем из ini файла переменную PathToBooks, которая содержит  путь до файлов(книг, документов и тд), из которых будут браться слова		
			self.pathResult = config.GetValue("PathToResult") # Считываем из ini файла переменную PathToResult, которая содержит путь для сохранения результата
			self.countWord = config.GetValue("CountWord") # Считываем из ini файла переменную CountWord, которая содержит количество первых слов частотного словаря, которые нужно получить
			self.pathToWordNetDict = config.GetValue("PathToWordNetDict") # Считываем из ini файла переменную PathToWordNetDict, которая содержит путь до словаря WordNet
			self.pathToStarDict = config.GetValue("PathToStarDict") # Считываем из ini файла переменную PathToStarDict, которая содержит путь до словарей в формате StarDict	
			
			# Отделяем пути словарей StarDict друг от друга и удаляем пробелы с начала и конца пути. Все пути заносим в список listPathToStarDict
			listPathToStarDict = [item.strip() for item in self.pathToStarDict.split(";")]

			# Для каждого из путей до словарей StarDict создаем свой языковый словарь
			for path in listPathToStarDict:
				languageDict = StarDict(path)
				self.listLanguageDict.append(languageDict) 
			
			# Получаем список книг, из которых будем получать слова
			self.listBooks = self.__GetAllFiles(self.pathToBooks)

			# Создаем частотный словарь		
			self.frequencyDict = FrequencyDict(self.pathToWordNetDict)			
	
			# Подготовка закончена, загружены словари StarDict и WordNet. Запускаем задачу на выполнение, то есть начинаем парсить текстовые файл, нормализовывать и считать слова			
			self.__Run()
		
		except Exception as e:
			print('Error: "%s"' %e)


	# Метод создает список файлов, расположенных в папке path	
	def __GetAllFiles(self, path):
		try:
			return [os.path.join(path, file) for file in os.listdir(path)]
		except Exception:
			raise Exception('Path "%s" does not exists' % path)		

		
	# Метод бежит по всем словарям, и возвращает перевод из ближайшего словаря. Если перевода нет ни в одном из словарей, возвращается пустая строка	
	def __GetTranslate(self, word):
		valueWord = ""
		for dict in self.listLanguageDict:
			valueWord = dict.Translate(word)
			if valueWord != "":
				return valueWord
		return valueWord
		
		
		
	# Метод сохраняет результат(само слово, частота, его перевод) по первым countWord словам в файл формата Excel  	
	def __SaveResultToExcel(self):	
		try:
			if not os.path.exists(self.pathResult):
				raise Exception('No such directory: "%s"' %self.pathResult)	
			
			if self.result:	
				description = 'Frequency Dictionary'
				style = xlwt.easyxf('font: name Times New Roman')			
				wb = xlwt.Workbook()
				ws = wb.add_sheet(description + ' ' + self.countWord)	
				nRow = 0
				for item in self.result:
					ws.write(nRow, 0, item[0], style)
					ws.write(nRow, 1, item[1], style)
					ws.write(nRow, 2, item[2], style)
					nRow +=1			
				wb.save(os.path.join(self.pathResult, description +'.xls'))
		except Exception as e:
			print(e)			
	
	
	
	# Метод запускает задачу на выполнение
	def __Run(self):					
		# Отдаем частотному словарю по одной книге	
		for book in self.listBooks:
			self.frequencyDict.ParseBook(book)		
			
		# Получаем первые countWord слов из всего получившегося списка английских слов			
		mostCommonElements = self.frequencyDict.FindMostCommonElements(self.countWord)
		
		# Получаем переводы для всех слов
		for item in mostCommonElements:
			word = item[0]
			counterWord = item[1]
			valueWord = self.__GetTranslate(word)
			self.result.append([counterWord, word, valueWord])	

		# Запишем результат в файл формата Excel 
		self.__SaveResultToExcel()		


if __name__ == "__main__":
	main = Main()

; Путь до файлов(книг, документов и тд), из которых будут браться слова
PathToBooks = e:BienneFrequencyBooks

; Путь до словаря WordNet(он нужен для нормализации слов)
PathToWordNetDict = e:BienneFrequencyWordNetwn3.1.dict

; Путь до словарей в формате StarDict(нужны для перевода слов)
PathToStarDict = e:BienneFrequencyDictstardict-comn_dictd04_korolew

; Количество первых слов частотного словаря, которые будут записаны в файл в формате Excel
CountWord = 100

; Путь, куда сохранить результат (файл в формате Excel с тремя заполненными колонками - само слово, частота, его перевод)
PathToResult = e:BienneFrequencyBooks