Mesmo assim, ainda temos muito trabalho pela frente...
Segue aí a primeira página do nosso filhinho:
Minha vida na Coréia: mestrado, viagens, enfim, meus pensamentos com muito café e kimchi. ^^
#!/usr/bin/python
#encoding: utf-8
import sys, re, codecs
class ForestWalker:
def __init__(self, file):
self.file = file
def __iter__(self):
return self
def readtree(self):
# read sentence form line
line = self.readline()
tree = Tree(line.split(' ')[0])
# make list of nodes
list_of_nodes = []
line = self.readline()
while (line):
(ord, dep, tag1, tag2, wordform, morph_string) = line.split("\t")
morphs = self.parse_morph_string(morph_string)
word = Word(ord, wordform, morphs, morph_string)
list_of_nodes.append(Node(ord, dep, tag1, tag2, word))
line = self.readline()
# make tree with list of nodes
# set parent-child relations
for n in list_of_nodes:
if n.dep == n.ord:
tree.set_root(n)
else:
p = list_of_nodes[int(n.dep)-1]
n.parent = p
p.add_a_child(n)
tree.nodes = list_of_nodes
return tree
def parse_morph_string(self, morph_string):
morphs = []
m = morph_string
for m in morph_string.split('+'):
m = m.strip()
if m == "" :
pass
else :
if m == "/SW":
form, pos = "+", "SW"
elif m[0:2] == "//":
form, pos = "/", m[2:]
else :
try :
form, pos = m.split("/")
if pos == "" : pos = "_ERR_"
except :
form, pos = m, "_ERR_"
morphs.append(Morph(form,pos))
return morphs
def readline(self):
line = self.file.readline()
# EOF
if (line == '') : sys.exit(0)
return line.strip()
fields = line.strip().split("\t")
if len(fields) == 6 :
return fields
else :
return line.strip()
def next(self):
return self.readtree()
class TreeBank:
pass
class Tree:
def __init__(self, id):
self.id = id
self.nodes = []
self.root = None
self.terminals = []
def set_root(self, node):
self.root = node
def get_terminals(self):
if self.terminals :
pass
else:
for n in self.nodes:
if not n.children :
self.terminals.append(n)
return self.terminals
class Node:
def __init__(self, ord, dep, tag1, tag2, word):
self.parent = None
self.children = []
self.ord = ord
self.dep = dep
self.tag1 = tag1
self.tag2 = tag2
self.form = word.form
self.word = word
def add_a_child(self, node):
self.children.append(node)
class Morph:
def __init__(self, form, pos):
self.form = form
self.pos = pos
class Word:
def __init__(self, ord, form, morphs, morph_string):
self.ord = ord
self.form = form
self.morphs = morphs
self.morph_string = morph_string
def add_morph(self, morph):
self.morphs.append(morph)
def has_pos(self, pos):
for m in self.morphs:
if m.pos == pos :
return True
return False
def __str__(self):
str = ""
for m in self.morphs:
if str == "":
str = m.form
elif m.pos[0] == "S" :
str += m.form
else :
str += "-" + m.form
return str
#return reduce(lambda x,y: x.form+"-"+y.form, self.morphs)
class Encode:
def __init__(self, stdout, enc):
self.stdout = stdout
self.encoding = enc
def write(self, s):
self.stdout.write(s.encode(self.encoding))
def get_output_string1(morphs) :
str = ""
pos_arr = []
morphform_arr = []
for m in morphs:
pos_arr.append(m.pos)
morphform_arr.append(m.form)
str = ''.join(morphform_arr)
return str
def get_output_string2(morphs) :
str = ""
pos_arr = []
morphform_arr = []
for m in morphs:
pos_arr.append(m.pos)
morphform_arr.append(m.form)
str = ''.join(morphform_arr)
return str
def get_verbform(words):
v = re.compile(r".*?/")
w = ''.join(words)
arr = v.findall(w)
str = ''.join(arr)
return str
sys.stdout = Encode(sys.stdout, "utf8")
for s in ForestWalker(codecs.open(sys.argv[1], encoding="utf8")):
for n in s.nodes:
if re.compile(r'[ NV][PSQ]_[^C]').match(n.tag2):
if n.parent:
tg = re.compile('.*?_')
if re.compile(r'N.?').match(n.parent.tag2):
print "%s\t%s\t%sN" % (get_output_string1(n.word.morphs), tg.sub(r'', n.tag2), n.parent.word.morph_string.split(r'/')[0])
elif re.compile(r'V.?').match(n.parent.tag2):
print "%s\t%s\t%sV" % (get_output_string1(n.word.morphs), tg.sub(r'', n.tag2), get_verbform(n.parent.word.morph_string))
#!/usr/bin/python
# encoding: utf8
# projeto.py
#
# Copyright 2008 Juliano Paiva Junho <jpj@jpj-laptop>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.
import re, sys
# Expressão regular que separa só as palavras, deixando a pontuação de lado
p = re.compile(r'\b\W+\b', re.U)
# Abre o arquivo passado pela linha de comando
# Lê o arquivo todo (não é eficiente com arquivos muito grandes)
# Decodifica o arquivo como UTF-8
# Passa todas as letras para minúsculas
# Cria lista de palavras sem pontuação por meio da Regex acima
# Joga o resultado de tudo isso na variável "words"
words = p.split(open(sys.argv[1]).read().decode("utf8").lower()[:-1])
# Inicializa um dicionário vazio para unificar e contar as palavras repetidas
dic = {}
# Inicializa as chaves do dicionário para a posterior contagem de palavras
for i in words: dic[i] = 0
# Adiciona 1 a cada palavra repetida
for i in words: dic[i] += 1
# Cria uma lista com as chaves do dicionário seguidas por seus valores
# Ordena a lista pelos valores
# Inverte a ordem para mostrar as palavras com mais contagens primeiro
count = reversed(sorted([(dic[i], i) for i in dic]))
# Função para calcular a freqüência de cada palavra
freq = lambda x: float(x) / len(words)
# Recria a lista acima agora com mais um termo: a freqüência de cada palavra
count = [(j.encode("utf8"), i, freq(i)) for i, j in count]
# Imprime todos os resultados na tela (com possibilidade de redirecionamento ou piping)
print "\nNúmero de palavras do texto: %d" % len(words)
print "\nNúmero de palavras únicas: %d\n" % len(count)
for i in count: print "%s\t%d\t%F" % i