���느����� ��������면 ���리는 ������
����� ���보 ¶
1��� 21��� ¶
��������(Parser)��� ��������� 보��� 동���를 ���는���.
VP를 ���는���.
VP를 ���는���.
1��� 20��� ¶
������를 ��������� 따��� ���������는 ��������� ������. ��� ������������ ���������(���본���)��� ������������ 동���를 ������낸���.
��������� 변���는 동���는 �������������� 변������ ������������ ���는���.
��������� 변���는 동���는 �������������� 변������ ������������ ���는���.
������ ¶
~cpp
# EazyWord.py
# coding: euc-kr
class EazyWord:
def __init__( self ):
self.cases = []
def setRoot( self, aRoot ):
self.root = aRoot
def addCase( self, aCase ):
self.cases.append(aCase)
def getCases( self ):
return tuple(self.cases)
def getRoot( self ):
return self.root
~cpp
# EazyWordTest.py
# coding: euc-kr
import unittest
from EazyWord import EazyWord
class EazyWordTestCase(unittest.TestCase):
def setUp(self):
self.word = EazyWord()
self.word.setRoot('먹')
self.word.addCase('AOV')
def testAddCase(self):
self.assertEquals( ('AOV',), self.word.getCases() )
if __name__ == '__main__':
unittest.main()
~cpp
# EazyDic.py
# coding: euc-kr
class EazyDic:
def __init__(self):
self.words = {}
def addWord( self, aWord):
self.words[aWord.getRoot()] = aWord.getCases()
def getRoots( self ):
return self.words.keys()
~cpp
# EazyDicTest.py
# coding: euc-kr
import unittest
from EazyWord import EazyWord
from EazyDic import EazyDic
class EazyDicTestCase(unittest.TestCase):
def setUp(self):
self.parser = EazyParser()
self.dic = EazyDic()
self.muk = EazyWord()
self.muk.setRoot('먹')
self.muk.addCase('AOV')
self.ga = EazyWord()
self.ga.setRoot('���')
self.ga.addCase('ALV')
if __name__ == '__main__':
unittest.main()
~cpp
# EazyParser.py
# coding: euc-kr
import hangul
import string
u = lambda x: unicode(x, "euc-kr")
class EazyParser:
def updateDictionary(self, aDict):
self.dic = aDict
def findFundermentalForm(self, aWord):
johabWord = hangul.disjoint(u(aWord))
roots = self.dic.getRoots()
for each in roots:
if hangul.disjoint(u(each)) in johabWord:
return each + '���'
def findVerb(self, aSentence):
lastToken = aSentence.split()[-1]
return self.findFundermentalForm(
self.removeMark(lastToken) )
def removeMark(self, aPhrase):
for mark in string.punctuation:
if mark in aPhrase:
aPhrase = aPhrase.replace(mark,'')
return aPhrase
def findVP(self, aSentence):
NP = self.findNP(aSentence)
temp = aSentence.split(' ')
temp.remove(NP)
return string.join( temp, ' ')
def findNP( self, aSentence ):
return aSentence.split(' ')[0]
~cpp
# EazyParserTest.py
# coding: euc-kr
import unittest
from EazyWord import EazyWord
from EazyDic import EazyDic
from EazyParser import EazyParser
class EazyParserTestCase(unittest.TestCase):
def setUp(self):
self.parser = EazyParser()
self.dic = EazyDic()
self.muk = EazyWord()
self.muk.setRoot('먹')
self.muk.addCase('AOV')
self.dic.addWord(self.muk)
self.parser.updateDictionary( self.dic )
self.ga = EazyWord()
self.ga.setRoot('���')
self.ga.addCase('ALV')
def testFindFundermentalForm(self):
self.assertEquals( '먹���', self.parser.findFundermentalForm('먹는���') )
self.dic.addWord(self.ga)
self.parser.updateDictionary( self.dic )
self.assertEquals( '������', self.parser.findFundermentalForm('������') )
def testFindVerb(self):
self.assertEquals( '먹���', self.parser.findVerb('��는 밥��� 먹는���.') )
self.assertEquals( None, self.parser.findVerb('��는 ��������� ������.') )
def testFindVP(self):
self.assertEquals( '밥��� 먹는���.', self.parser.findVP('��는 밥��� 먹는���.') )
def testFindNP(self):
self.assertEquals( '밥���', self.parser.findNP( '밥��� 내��� 먹는���.' ) )
if __name__ == '__main__':
unittest.main()
~cpp
# AllTest.py
from EazyParserTest import *
from EazyWordTest import *
from EazyDicTest import *
import unittest
if __name__=='__main__':
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(EazyParserTestCase, 'test'))
suite.addTest(unittest.makeSuite(EazyWordTestCase, 'test'))
suite.addTest(unittest.makeSuite(EazyDicTestCase, 'test'))
runner = unittest.TextTestRunner()
runner.run (suite)
