Transparências do curso

Ferramentas PLN
Linguakit
Introdução à linha de comandos Linux
Linguagens de programação
Introdução a Perl
Tokenizador
Iniciação à programação (em Humanidades)
Pablo Gamallo
Centro de Investigação em Tecnologias da Informação (CITIUS)
Universidade de Santiago de Compostela
Programa de Doutormento de Linguística
Doutoramento
Intro
Ferramentas PLN
Linguakit
Introdução à linha de comandos Linux
Linguagens de programação
Introdução a Perl
Tokenizador
Objectivos
Aproximação ao ecossistema de programação em
PLN.
Primeiros passos na programação em linguagem de
scripts.
Doutoramento
Intro
Ferramentas PLN
Linguakit
Introdução à linha de comandos Linux
Linguagens de programação
Introdução a Perl
Tokenizador
Breve bibliografia
Levi Lúcio, Vasco Amaral (2001), Programação em PERL, FCA-Editora de Informática.
Hammond, Michael (2003), Programming for linguistics: Perl for language researchers, Blackwell
Publishing.
Tanguy, Ludovic (2007), Perl pour les linguistes, Hermès - Lavoisier.
http://perl.linguistes.free.fr/
Doutoramento
Intro
Ferramentas PLN
Linguakit
Introdução à linha de comandos Linux
Linguagens de programação
Introdução a Perl
Tokenizador
Índice de conteúdos
1
Ferramentas PLN
2
Linguakit
3
Introdução à linha de comandos Linux
4
Linguagens de programação
5
Introdução a Perl
6
Tokenizador
Doutoramento
Intro
Ferramentas PLN
Linguakit
Introdução à linha de comandos Linux
Linguagens de programação
Introdução a Perl
Tokenizador
Índice de conteúdos
1
Ferramentas PLN
2
Linguakit
3
Introdução à linha de comandos Linux
4
Linguagens de programação
5
Introdução a Perl
6
Tokenizador
Doutoramento
Intro
Ferramentas PLN
Linguakit
Introdução à linha de comandos Linux
Linguagens de programação
Introdução a Perl
Tokenizador
Ferramentas para o Processamento da
Linguagem Natural
Extracção
Análise
morfo-sintáctica
(PoS-taggers)
termos
entidades
sintáctica (parsers)
relações
semânticas
concordâncias
conceitos
opiniões
Doutoramento
Intro
Utilidades
resumo
erros / correção
(tradução)
Ferramentas PLN
Linguakit
Introdução à linha de comandos Linux
Linguagens de programação
Introdução a Perl
Tokenizador
Ferramentas para o Processamento da
Linguagem Natural
Extracção
Análise
morfo-sintáctica
(PoS-taggers)
termos
entidades
sintáctica (parsers)
relações
semânticas
concordâncias
conceitos
opiniões
Doutoramento
Intro
Utilidades
resumo
erros / correção
(tradução)
Ferramentas PLN
Linguakit
Introdução à linha de comandos Linux
Linguagens de programação
Introdução a Perl
Tokenizador
Ferramentas para o Processamento da
Linguagem Natural
Extracção
Análise
morfo-sintáctica
(PoS-taggers)
termos
entidades
sintáctica (parsers)
relações
semânticas
concordâncias
conceitos
opiniões
Doutoramento
Intro
Utilidades
resumo
erros / correção
(tradução)
Ferramentas PLN
Linguakit
Introdução à linha de comandos Linux
Linguagens de programação
Introdução a Perl
Tokenizador
Índice de conteúdos
1
Ferramentas PLN
2
Linguakit
3
Introdução à linha de comandos Linux
4
Linguagens de programação
5
Introdução a Perl
6
Tokenizador
Doutoramento
Intro
Ferramentas PLN
Linguakit
Introdução à linha de comandos Linux
Linguagens de programação
Introdução a Perl
Tokenizador
LinguaKit
Uso Web: https://linguakit.com
Instalação do código fonte:
https://github.com/citiususc/Linguakit
Doutoramento
Intro
Ferramentas PLN
Linguakit
Introdução à linha de comandos Linux
Linguagens de programação
Introdução a Perl
Tokenizador
Índice de conteúdos
1
Ferramentas PLN
2
Linguakit
3
Introdução à linha de comandos Linux
4
Linguagens de programação
5
Introdução a Perl
6
Tokenizador
Doutoramento
Intro
3. Introdução à linha de comandos
GNU/Linux
Pablo Gamallo
http://gramatica.usc.es/~gamallo/
Titoriais
http://aurelio.net/shell/
http://www.smaldone.com.ar/documentos/
misdocs/tutorial-gnu-linux/
GNU/LINUX
Alguns comandos básicos
- ls (lista os ficheiros e subdirectórios do directório actual)
- pwd (rota actual)
- mkdir (criar um subdirectório)
- cd (câmbio de directório)
- echo “olá” > prova.txt (criar um ficheiro de texto)
- cp, mv (copiar, mover e renomear ficheiros)
- rm (borrar ficheiros)
- cat (ler o conteúdo de um ou vários ficheiros de entrada)
- wc (conta linhas, palavras e caracteres dos ficheiros de entrada)
GNU/LINUX
Primeira práctica
- cria o subdirectório “corpus” (mkdir)
- coloca-te no subdirectório “corpus” (cd)
- cria nesse directório um ficheiro “prova.txt” que contenha
o texto “isto é uma prova” (echo)
- copia o ficheiro “prova.txt” criando outro chamado
“prova2.txt” (cp)
- renomea o ficheiro “prova.txt” como “prova1.txt” (mv)
- lê o conteúdo do ficheiro “prova1.txt” (cat, more)
- conta as linhas, palavras e caracteres de “prova1.txt” (wc)
- apaga o ficheiro “prova1.txt” (rm)
GNU/LINUX
Primeira práctica
Fai o mesmo utilizando ferramentas do
sistema gráfico e editores de texto como
gedit e OpenOffice
- Para listar, mover-te na hierarquia de directórios e criar novos
subdirectórios, utiliza um navegador.
- Para criar novos ficheiros, utiliza o editor gedit.
- Para contar palavras e caracteres, utiliza OpenOffice.
GNU/LINUX
Segunda práctica
Objectivo:
Procurade “El Quijote” por Internet,
guardade o ficheiro no directório “Corpus”
visualizade o ficheiro na consola
e contade as palavras e caracteres do texto
- busca com Firefox no site http://www.gutenberg.org/
- borra o metatexto que não pertence ao livro de Cervantes
- fai a contagem com OpenOffice e com o comando wc
- fazede o mesmo com cat usando a técnica dos pipes “|”
- provade também o comando more
GNU/LINUX
Segunda práctica
- visualizade o ficheiro:
cat ElQuijote.txt
- visualizade o ficheiro pantalha a pantalha:
more ElQuijote.txt
- Contade as linhas, palavras e bytes dum ficheiro:
wc ElQuijote.txt
GNU/LINUX
Segunda práctica
O shell permite a construção de comandos complexos
através da combinação de vários comandos simples.
O operador "|", conhecido como pipe, ou tubo, permite
conectar a saída de um comando à entrada de outro.
cat ElQuijote.txt | more
cat ElQuijote.txt | wc
GNU/LINUX
Segunda práctica
Como está codificado o ficheiro ElQuijote.txt ?
- lê o ficheiro com o comando cat
- comproba a codificação: “file --mime”
- a codificação é Latin 1 (ISO-8859-1).
- como o comando cat da shell lê o texto como se estivesse
codificado em Unicode, devemos convertir o texto do ficheiro
ao código Unicode (UTF-8)
cat ElQuijote.txt | iconv -f ISO-8859-1 -t
UTF-8
-c
Na seguinte prática, simplificaremos o procedimento
GNU/LINUX
Terceira práctica
Objectivo:
Cria 2 ficheiros executáveis:
- de Latin 1 a Unicode
- de Unicode a Latin 1
1. Cria um ficheiro LatinToUnicode.x contendo o seguinte comando:
iconv -f ISO-8859-1 -t UTF-8 -c
2. Cria um ficheiro UnicodeToLatin.x contendo o seguinte comando:
iconv -f UTF-8 -t ISO-8859-1 -c
GNU/LINUX
Terceira práctica
Podemos dar três tipos de permissões aos ficheiros:
- Podem ser lidos,
- Podem ser escritos
- Podem ter código executável
chmod +r ficheiro (permite a leitura)
chmod +w ficheiro (permite a escrita)
chmod +x ficheiro (permite a execução)
GNU/LINUX
Terceira práctica
Já podemos convertir o ficheiro codificado
em Latin 1 a Unicode:
cat ElQuijote.txt | ./LatinToUnicode.x > ElQuijote_Unicode.txt
GNU/LINUX
Quarta práctica
Objectivo:
Conta o número de ocorrências das expressões:
“Quijote”, “Don Quijote”, “Sancho”, “Sancho Panza”,
“Dulcinea”, “Dulcinea del Toboso”, ...
Comando “grep”:
selecciona as linhas do texto que contenham uma
sequência de caracteres (ou string) específica
cat ElQuijote_Unicode.txt | grep “Quijote” | wc
GNU/LINUX
Outros comandos de interesse
head -5 (escreve as primeiras 5 linhas do texto)
tail -11 (escreve as últimas 11 linhas do texto)
head -12 | tail -1 (escreve a linha 12)
head -N (escreve as primeiras N linhas do texto)
tail -N (escreve as últimas N linhas do texto)
head -N | tail -1 (escreve a N linha)
GNU/LINUX
Quinta práctica
Objectivo:
Criar um ficheiro executável, chamado “linha.x”, que escreva
a linha do texto que lhe digamos.
cat ElQuijote_Unicode.txt | ./linha.x 5
(escreve a linha 5 do texto)
Solução:
head -$1 | tail -1
GNU/LINUX
Sexta práctica
Objectivo:
Criar um ficheiro executável, chamado “linhas.x”, que escreva
as linhas do texto que lhe digamos.
cat ElQuijote_Unicode.txt | ./linhas.x 10 3
escreve as 3 últimas linhas até chegar à linha 10 (de 8 a 10)
cat ElQuijote_Unicode.txt | ./linhas.x 33 10
escreve as 10 últimas linhas até chegar à linha 33 (de 24 a 33)
Solução:
head -$1 | tail -$2
GNU/LINUX
Séptima práctica
Objectivo:
melhorar o “linhas.x” para criar linhas2.x
cat ElQuijote_Unicode.txt | ./linhas2.x 3 10
escreve da linha 3 à linha 10
cat ElQuijote_Unicode.txt | ./linhas2.x 10 33
escreve da linha 10 à linha 33
Solução:
((N = $2 - $1 + 1))
head -$2 | tail -$N
GNU/LINUX
Séptima práctica
Outra maneira de fazer linhas2.x
((N = $2 - $1 + 1))
linhas.x $2 $N
Colocade “linhas.x” num directório /bin
GNU/LINUX
Mais práticas
Podedes praticar mais em:
http://aurelio.net/shell/apostilha-introducao-shell.pdf
http://es.tldp.org/Manuales-LuCAS/AA_Linux_colegio1.1/AA_Linux_colegio-1.1-html/x3772.htm
http://www.ppgia.pucpr.br/~maziero/ensino/sei/shell-bash-basico.html
http://www.openslack.org/~piterpk/artigos/aposhell.ps
GNU/LINUX
Comandos mais interessantes
para processamento de texto
cat
tac
more
tr
head
tail
wc
sort
uniq
sed
grep
cut
rev
: concatena diversos arquivos.
: idem, mas inverte a ordem das linhas.
: permite a paginação.
: troca de caracteres entre dois conjuntos.
: seleciona as "n" linhas iniciais.
: seleciona as "n" linhas finais.
: conta o número de linhas, palavras e bytes.
: ordena as linhas segundo critérios ajustáveis.
: elimina linhas repetidas, deixando uma soa linha.
: para operações complexas de strings (trocas, etc).
: selecciona linhas contendo uma determinada expressão.
: selecciona colunas do fluxo de entrada.
: reverte a ordem dos caracteres de cada linha.
4. Lenguajes de
programación
Criterios de clasificación
 según
su nivel de abstracción
 según
la forma de ejecución
 según
el paradigma de
programación
 según
el propósito u objetivo
Clasificación según:
Nivel de abstracción
 lenguajes
de bajo nivel
 lenguajes
de medio nivel
 lenguajes
de alto nivel
Lenguajes de bajo nivel
Los lenguajes de bajo nivel son lenguajes de programación
que se acercan al funcionamiento de una computadora.
El lenguaje de más bajo nivel es el código máquina.
A éste le sigue el lenguaje ensamblador. Al programar en
ensamblador se trabajan con los registros de memoria de la
computadora de forma directa.
Lenguajes de medio nivel
Un lenguaje de medio nivel (como es el caso del lenguaje C)
tiene ciertas características que lo acerca a los lenguajes de bajo
nivel: pueden acceder a registros de memoria,
y al mismo tiempo, tiene ciertas cualidades que lo hacen un
lenguaje más cercano al humano y, por tanto, de alto nivel.
Lenguajes de alto nivel
Los lenguajes de alto nivel son normalmente fáciles de
aprender porque están formados por elementos de lenguajes
naturales, como el inglés: IF, ELSE, WHILE, THEN, FOR, etc.
Lenguajes de alto nivel
* Ada
* PHP
* ALGOL
* PL/SQL
* Basic
* Perl
* C++
* Prolog
* Clipper
* Python
* COBOL
* Fortran
* Java
* Modula-2
* Pascal
* Ruby
* Lenguajes funcionales
- Haskell
- Lisp
Clasificación según:
Forma de ejecución
Para ejecutar un programa fuente que se escribe en un
lenguaje de alto nivel, tiene que traducirse o
interpretarse en un código que pueda utilizar la
máquina (código máquina).
 lenguajes
compilados
 lenguajes
interpretados
Lenguajes compilados
Un lenguaje compilado traduce todo el programa fuente que se
quiere ejecutar en un fichero binario escrito en código máquina.
Este fichero tiene carácter permanente.
Los programas que hacen esta traducción se llaman
compiladores.
Al usar un lenguaje compilado, el programa fuente desarrollado
nunca se ejecuta sino después de haber compilado/traducido el
programa correctamente
(lo que se ejecuta es el programa traducido en código máquina)
Lenguajes interpretados
En vez de traducir el programa fuente y grabar en forma
permanente el código objeto, el programador sólo carga el
programa fuente en la computadora junto con los datos que se
van a procesar.
A continuación, un programa intérprete convierte cada
proposición del programa fuente en lenguaje de máquina
conforme vaya siendo necesario durante el proceso de los datos.
No se graba el código objeto para utilizarlo posteriormente.
Los lenguages interpretados se suelen llamar lenguajes de script.
Clasificación según:
Paradigma de programación
 lenguajes
imperativos / procedurales
 lenguajes
- funcionales
- lógicos
declarativos:
 lenguajes
orientados a objetos
Clasificación según:
el propósito u objetivo
 lenguajes
de propósito general
 lenguajes
de propósito específico
Propósito general
Son lenguajes que pueden ser usados para varios propósitos:
- acceso a bases de datos,
- comunicación entre computadoras,
- cálculos matemáticos,
- diseño de imágenes o páginas,
- compiladores,
- etc.
Propósito específico
Son lenguajes especializados en tareas concretas. Ejemplos:
- HTML: para Web
- PHP: para mejorar y enriquecer la Web
- Javascript: para mejorar y enriquecer la Web
- SQL: para base de datos
Otras clasificaciones
- lenguajes imperativos:
C, BASIC, Pascal, Fortran, ADA, Algol, Clipper, ML, Logo, Lua, Modula, COBOL, ...
- lenguajes de programación orientada a objetos:
C++, Java, C#, Smalltalk, Eiffel, Lexico, Oberon, Objective-C, Simula, Sather, ...
- lenguajes de programación funcional:
CAML, LISP, J, APL, Haskell, FP, ISWIN, Joy, Ocaml, Scheme, Miranda, ...
- lenguajes de shell y scripts:
Phyton, Perl, AWK, Ruby, tcl, Bash, sh, Javascript, ActionScript, MaxScript, ...
- lenguajes de programación web:
PHP, ASP, ASP.NET, ColdFusion, ...
- lenguajes de etiquetado:
HTML, XML, WAP, XHTML, XLS, PostScript, RTF, SMIL, SGML, Latex, XPath, ...
- lenguajes de programación visual
Visual Basic, Visual Basic.NET, Delphi (Object Pascal),
Otras clasificaciones
(siguiente)
- lenguajes de programación lógica
Prolog, Mercury, SAIL, ...
- lenguajes para el manejo de datos
SQL, MySQL, dBase, Visual FoxPro, ...
- lenguajes de Ensamblador
Intel 80x86, Motorola 680, PowerPC, ARM, StrongARM, ...
Bibliotecas
Existen bibliotecas para facilitar la programación
permitiendo la reutilización de código.
Los lenguajes más usados (com más “hablantes”) tienen
bibliotecas más ricas y estandarizadas.
5. Introdução a Perl
Bibliografia

Levi Lúcio, Vasco Amaral (2001), Programação em PERL, FCA-Editora de Informática.

Hammond, Michael (2003), Programming for linguistics: Perl for language researchers,
Blackwell Publishing.

Tanguy, Ludovic (2007), Perl pour les linguistes, Hermès - Lavoisier.
http://perl.linguistes.free.fr/.

TUTORIAIS ON LINE:
http://br.perlmaven.com/perl-tutorial
Vamos programar um pouco
A linguagem PERL
PERL =
Practical Extraction and Report Language.
Primeira versão em 1987, Larry Wall.
Objectivos
• ler o texto introduzido através do teclado
• processar o texto lido:
verificar o texto introduzido
colocar sufixos, prefixos, ...
• escrever os resultados (na consola ou
num ficheiro)
Estrutura do Programa “nome.perl”
• O script escreve na consola:
“Cómo te chamas?”
• O script lê o nome escrito polo usuário
• O script escreve na consola o nome
que foi lido.
Como tornar executável o script
“nome.perl” ?
chmod +x nome.perl
Atribuimos ao ficheiro “nome.perl” a propriedade:
ser executável
Estrutura do Programa “nome.perl”
• print
escreve texto (no terminal, num ficheiro...)
• <STDIN>
lê um conjunto de caracteres ou texto, introduzido através do
teclado.
• $x = <STDIN>
lê um conjunto de caracteres introzidos através do teclado e os
coloca na variável $x.
• chop $x
corta o carácter de nova linha (\n) que se encontra no valor de $x.
Que é um programa (ou script)?
• Um programa é um conjunto de
instruções (print, assignação, leitura, ...)
• As instruções simples sempre acabam
com o símbolo ‘;’ (ponto e vírgula)
• Quando executamos o programa, as
instruções são executadas sequencialmente.
Tipos de entidades dum programa
• escalares: números, sequências de caracteres
• instruções:
simples: print, =, chop, ...
complexas: if, while, ...
• Descritores Input/Output:
STDIN, STDOUT, arquivos de entrada, arq. de saída...
• listas (arrays)
• tabelas (hashes)
Tipos de variáveis
• escalares: $var
• listas: @var
• tabelas: %var
Estrutura do Programa
“morfo_numero.perl”
• O script escreve na consola:
“Introduza um nome em singular:”
• O script lê o nome escrito polo usuário
• A partir desse nome e o carácter “s”, criamos uma
variável com o nome em plural.
• O script escreve na consola o nome em plural.
Estrutura do Programa
“morfo_numero.perl”
• ENTRADA:
$pal = <STDIN>
lê um conjunto de caracteres ou texto, introduzido através do
teclado e o coloca na variável $pal.
• PROCESSAMENTO:
$plural = “$pal . “s”
engade o “s” ao texto armazenado na variável $pal. O resultado é
armazenado na variável $plural.
• SAÍDA:
print
escreve o texto processado.
Estrutura do Programa
“morfo_numero_generico.perl”
• mesma ENTRADA e SAÍDA que “morfo_numero.perl
• PROCESSAMENTO:
$ConsoanteFinal = “[dlnrs]”
if ($Palavra =~ /$ConsoanteFinal$/) {
$Plural = $Palavra . "es" ;
}
elsif ($Palavra =~ /$Zfinal$/) {
$Palavra =~ s/z$/c/;
$Plural = $Palavra . "es" ;
$Palavra =~ s/c$/z/;
}
else {
$Plural = $Palavra . "s" ;
}
Se a palavra acaba em consoante final(dlnrs), o plural fai-se com -es.
Senão, se a palavra acaba em -z, substituimos o -z final por -c e engadimos -es.
Senão, engadimos -s.
a instrução IF
if (expressão) { bloco do if }
else { bloco do else }
Se a expressão é verdade, executam-se as instruções contidas no
bloco do if. Caso contrário, executa-se o bloco de instruções do
else.
Expressões falsas:
1 > 2 ; 0 ; “”, 1-1
Expressões verdadeiras:
1 < 2 ; os números excepto o 0; as strings excepto “”
Expressões Regulares: exemplos 1
if ($x =~ m/s$/) {
print “é um plural!”;
}
Se a sequência de caracteres associada à variável $x contém um -s
final, então escrevemos: “é um plural!”.
$x =~ s/ble$/bel/;
Se a sequência de caracteres associada à variável $x contém a
subsequência final -ble, então é substituída por -bel.
Expressões Regulares: exemplos 2
if ($x =~ m/ca[sz]ar/) {
print $x;
}
Se a sequência de caracteres associada à variável $x contém uma subsequência
“casar” ou “cazar”, então escrevemos toda a sequência (que é o valor de $x).
if ($x =~ m/^[Qq]uijote$/) {
print $x;
}
Se a sequência de caracteres associada à variável $x é exactamente 'Quijote' ou
“quijote”, então escrevemos essa sequência.
Expressões Regulares: exemplos 3
if ($x =~ m/^Paulo$|^Pau$|^Paolo$/) {
print $x;
}
Se a sequência de caracteres associada à variável $x é exactamente “Paulo”,
“Pau” ou “Paolo”, então escrevemos o valor de $x.
if ($x =~ m/^in[a-z]+ble$/) {
print “é um adjectivo!”;
}
Se a sequência de caracteres associada à variável $x começa polo prefixo “in”,
seguido de um número indeterminado de caracteres, e finaliza por “ble”, então
a cadea $x é um adjectivo.
Instruções iterativas
while (expressão) { bloco }
O bloco será executado até que a expressão se torne falsa:
while ($cont < 5) {
print “$cont \n”;
$cont++;
}
Estrutura do Programa
“morfo_numero_iterativo.perl”
• Iterações de entrada e saídas:
Uma vez produzida a saída, o sistema solicita uma nova entrada.
Só vai finalizar o processo se o usuário lhe di que pare.
•PROCESSAMENTO:
while( $Palavra ne "q" ) {
print "Escreve um novo nome ou adjectivo (ou q pour finalizar): ";
$Palavra = <STDIN>;
chomp $Palavra;
if ($Palavra eq "q") {
print "gracinhas e adeus!! \n";
}
else {
$Plural = $Palavra . "s" ;
print "O plural de \"$Palavra\" e o seguinte: \n";
print "$Plural\n\n";
}
}
Mentres a palavra introduzida não seja o carácter “q”, então o script escreve o
plural dessa palavra e volta a pedir que o usuário introduza uma nova palavra.
6. Programando um
tokenizador
Objectivos
• ler o texto dum ficheiro linha a linha.
• processar o texto lido:
tokenizer: quebrar o texto em palavras ou
carácteres (letras).
contagem de frequências: ocurrências de letras,
palavras, formas, pares de palavras, etc.
• escrever num ficheiro os resultados.
Estrutura do tokenizer
• Lê linha a linha o texto de entrada.
• Escreve noutro ficheiro (ou na consola)
as palavras do texto de entrada.
Cada palavra aparece numa linha.
Resultado do tokenizer
“ A nena tem uma chupeta azul.”
A
nena
tem
uma
chupeta
azul
.
Estrutura do separador de caracteres
• Lê linha a linha o texto de entrada.
• Escreve noutro ficheiro (ou na consola)
os caracteres do texto de entrada.
Cada carácter aparece numa linha.
Resultado do separador de caracteres
“ A nena.”
A
n
e
n
a
.
Como executar o tokenizer?
cat arquivo_entrada.txt | ./tokenizer.perl
cat arquivo_entrada.txt | ./tokenizer.perl > arquivo_saída.txt
Instruções do tokenizer
while ($linha = <STDIN>) {
instrução1;
instrução2; ...
}
Lê uma a uma as linhas do ficheiro, e cada linha é colocada na
variável $linha.
Após a leitura de uma linha, executa-se o bloco de instruções
(entre chaves). Isto é repetido até chegar à última linha do ficheiro
Instruções do tokenizer
@pals = split (“ ”, $linha);
Divide-se a cadeia $linha cada vez que aparece um espaço em
branco. As sucessivas divisões são colocadas na lista @pals.
foreach $pal (@pals) {
instrução1;
instrução2...
}
Uma vez tomado um elemento da lista @pals e colocado na
variável $pal, executam-se as instruções do bloco. Isto é repetido
com todos os elementos da lista.
Instruções iterativas
foreach $var @lista { bloco }
O bloco de instruções será executado um número de vezes
correspondente ao número de elementos na lista, sendo que para
cada iteração uma variável conterá o valor do elemento da lista.
while (expressão) { bloco }
O bloco será executado até que a expressão se torne falsa:
while ($cont < 5) {
print “$cont \n”;
$cont++;
}
a instrução IF
if (expressão) { bloco do if }
else { bloco do else }
Se a expressão é verdade, executam-se as instruções contidas no
bloco do if. Caso contrário, executa-se o bloco de instruções do
else.
Expressões falsas:
1 > 2 ; 0 ; “”, 1-1
Expressões verdadeiras:
1 < 2 ; os números excepto o 0; as strings excepto “”
Pattern-Matching
if ($line =~ m/Maria/) {
print $line;
}
Se a subcadeia “Maria” se encontra dentro da cadeia $line, então
afichamos a cadeia $line.
$line =~ s/\,/ \,/;
Se aparece o caracter “,” na cadeia $line, então substituimos esse
caracter pelos dois caracteres “ ,” (i.e. introduzimos um espaço
antes da vírgula).
Estrutura de “freq.perl”
• Lê linha a linha o ficheiro tokenizado :
• Realiza as contagens:
- conta as ocorrências de cada token (palavras e marcas),
- conta o número total de ocorrências de palavras,
- conta as ocorrências da cadeia “relac”,
- conta o número total de formas de palavras.
• Escreve num ficheiro (ou no terminal) os resultados
das contagens.
Instruções de contagem.perl
while ($token = <STDIN>) {
$contar{$token}++;
}
Lê-se linha a linha o arquivo e construe-se uma tabela: %contar.
Cada elemento duma tabela é uma estrutura “chave -> valor”.
Cada chave da tabela é um token. O valor para cada chave é o
número de vezes que o token é lido:
$contar{“livro”} = 2
$contar{“Maria”} = 3
$contar{“,”} = 8
Listas e Tabelas
@notas = (“pedro”, 5, “maria”, 8)
$notas[0]
$notas[1]
$notas[2]
$notas[3]
=
=
=
=
“pedro”
5
“maria”
8
%notas = (“pedro” => 5, “maria” => 8)
$notas{“pedro”} = 5
$notas{“maria”} = 8
Instruções de contagem.perl
foreach $tokenDiff (keys %contar) {
$contarTokensDiff++;
print "$tokenDiff\t$contar{$tokenDiff}\n" }
Iteração: Percorremos a lista de chaves (keys) do hash
%contar. Cada elemento é colocado na variável $tokenDiff.
Bloco de Instrucções:
- contamos os tokens diferentes (formas de palavras)
- escrevemos o token (chave de %contar) e a frequência do
token (valor de %contar)