Narzędzia informatyczne w językoznawstwie

(1)

Narzędzia informatyczne w językoznawstwie

Perl - Struktury kontrolne i zmienne

Marcin Junczys-Dowmunt junczys@amu.edu.pl

Zakład Logiki Stosowanej http://www.logic.amu.edu.pl

05. listopada 2007

Marcin Junczys-Dowmunt Narzędzia informatyczne w językoznawstwie 1/24

Dzisiejszy wykład

I Dziś wprowadzimy różne typy danych oraz różne rodzaje zmiennych zawierające takie dane

I Omówimy podstawowe struktury kontrolne

I Na końcu przejdziemy do małych programików nadających się np. do eksperymentów psycholingwistycznych

Liczby i łańcuchy znaków

Na razie będziemy korzystać z dwóch podstawowych typów danych: liczb i łańcuchów znakowych.

Liczby

I Dopuszczalne są wartości całkowite, zmiennoprzecinkowe, ujemne, wykładnicze itp.

I Perl nie rozróżnia tych rodzajów liczb, jak to się dzieje np. w C Łańcuchy znakowe

I Wszystko co jest ujęte w podwójny lub pojedynczy cudzysłów nazywamy łańcuchem znakowym

I W Perlu nie wszystkie łańcuchy znakowe możemy nazwać stałymi (te w pojedynczym cudzysłowie na pewno)

Liczby i łańcuchy znakowe

1 p r i n t( 3 ) ; p r i n t(" ");

p r i n t(3 + 4);

p r i n t(" ");

5 p r i n t(" 3 + 4 ");

p r i n t(" \ n ");

p r i n t(5 * 2);

p r i n t(" ");

p r i n t( 9 / 3 ) ;

10 p r i n t(" ");

p r i n t(2 ** 8);

p r i n t(" \ n ");

Proszę opisać, co się dzieje w każdym wierszu.

Jaki działa cudzysłów podwójny a jak cudzysłów pojedynczy?

(2)

Operatory

Istnieją też operatory dla łańcuchów znakowych oraz operatory mieszane np.

1 p r i n t(" - " x 5 0 ) ; p r i n t(" \ n ");

p r i n t(" k o n k a t e n a c j a " . " " . " ł a ń c u c h ó w \ n ");

p r i n t(" - " x 5 0 ) ;

5 p r i n t(" \ n ");

Zmienne skalarne

Zmienne zawierające liczby, znaki łańcuchowe i referencje¹ nazywamy zmiennymi skalarnymi.

Struktura nazwy zmiennej skalarnej w Perlu:

I Pierwszy znak to przedrostek $ (podobny do s jak scalar)

I Drugi znak to dowolna litera lub znak podkreślenia

I Kolejne znaki to dowolne litery lub liczby lub znak podkreślenia

Przykłady:

$ , $a, $abc, $a12, $to jest zmienna, $a to zmienna o numerze 2

1o referencjach więcej innym razem

Zmienne skalarne

Na zmiennych możemy wykonywać takie same operacje jak na stałych plus operację przypisania (=):

1 $ o n e = 2;

$ t w o = 3;

$ t h r e e = $ o n e + $ t w o ; p r i n t( $ t h r e e . " \ n ");

1 $ h a t = " c h a i r ";

$ c h a i r = " hat ";

p r i n t( $ c h a i r . " " . $ h a t . " \ n ");

Jak widać, nazwa i treść zmiennej nie muszą być ze sobą powiązane.

Interpolacja zmiennych

Zamiast łączyć kilka zmiennych w większy łańcuch znakowy za pomocą operatora konkatenacji, możemy wykorzystać możliwości Perla w zakresie interpolacji zmiennych.

Interpolacja to operacja, która zamienia nazwę zmiennej w łańcuchu znakowym na jej wartość.²

1 $ h a t = " c h a i r ";

$ c h a i r = " hat ";

p r i n t(" $ c h a i r $ h a t \ n ");

Pytanie: Co stanie się, gdy zastąpimy podwójny cudzysłów pojedynczym cudzysłowem?

(3)

Zmienne tablicowe

I Zmienne tablicowe to zmienne złożone

I Dokładniej: to listy zmiennych skalarnych

I Każda z tych zmiennych skalarnych w tablicy ma jednoznacznie przyporządkowany indeks (numer)

I Tablica zawierająca n elementów jest indeksowana liczbami od 0 do n − 1

I Przedrostek tablicy w Perlu to @ (podobne do a jak array), np. @tablica

I Nie ma górnego ograniczenia liczby elementów tablicy (tylko pamięć danego komputera)

I Tablice są strukturami dynamicznymi (długość nie jest stała)

Ustawianie zmiennych tablicowych

1 @ r o k = (" s t y c z e n ", " l u t y ", " m a r z e c ");

p r i n t " T r z e c i m i e s i a c r o k u : ". $ r o k [ 2 ] ." \ n ";

p r i n t " P i e r w s z y m i e s i a c r o k u : $ r o k [ 0 ] \ n ";

I Kanoniczny sposób zapisywania wartości do tablicy

I Elementy zostaną ponumerowane od 0 do 2

I Odwołując się do wartości elementów tablicy korzystamy z $, ponieważ wartości tablicy to skalary!

I Wartości tablicy też podlegają interpolacji zmiennych

Ustawianie zmiennych tablicowych

4 $ r o k [3] = " k w i e c i e n ";

5 $ r o k [4] = " maj ";

$ r o k [5] = " c z e r w i e c ";

I Możemy zapisywać wartości bezpośrednio do elementów skalarnych tablicy

I Elementy tablicy nie różnią się niczym od normalnych zmiennych

I Jeśli taki indeks wcześniej nie istniał, zostanie stworzony

I Ewentualne wartości pośrednie zostaną wypełnione wartością undef (niezdefiniowana)

Ustawianie zmiennych tablicowych

7 @ k w a r t a l 3 = qw( l i p i e c s i e r p i e n w r z e s i e n );

@ r o k [6 .. 8] = @ k w a r t a l 3 ;

p r i n t j o i n(" - ", @ r o k [6 .. 8 ] ) ." \ n ";

I Skrótowy sposób inicjalizacji tablicy (dla listy łańcuchów znakowych)

I Białe znaki funkcjonują jak separatory

I Możemy też zapisywać do podprzedziału tablicy

I Wycinek tablicy jest tablicą, stąd przedrostek @

I Funkcja join łączy daną tablicę w łańcuch znakowy z podanym separatorem wstawionym między elementami

(4)

Ustawianie zmiennych tablicowych

10 @ r o k [9 ,10 ,11] = qw( p a z d z i e r n i k l i s t o p a d g r u d z i e n );

p r i n t " N a s t ę p u j ą c e m i e s i ą c e m a j ą 31 dni : \ n ";

p r i n t j o i n(" \ n ", @ r o k [0 ,2 ,4 ,6 ,7 ,9 ,11])." \ n "; p r i n t " N a s t ę p u j ą c e m i e s i ą c e m a j ą 30 dni : \ n ";

15 @ m 3 0 = (3 ,5 ,8 ,10);

p r i n t j o i n(" \ n ", @ r o k [ @ m 3 0 ])." \ n ";

p r i n t " A $ r o k [1] ma 28 dni \ n ";

I Wycinki tablic to nie tylko przedziały liczb. Możemy korzystać z list dowolnych liczb

I Lub nawet z innych tablic

Struktury kontrolne - warunki

1 if ( w y r a ż e n i e ) { b l o k } e l s e { b l o k } u n l e s s ( w y r a ż n i e ) { b l o k } e l s e { b l o k }

5 if ( w y r a ż e n i e 1 ) { b l o k } e l s i f ( w y r a ż e n i e 2 ) { b l o k }

...

e l s i f ( o s t a t n i e w y r a ż e n i e ) { b l o k } e l s e { b l o k }

I W Perlu nie ma typów logicznych jako takich, fałszywe są:

liczba zero, łańcuch zerowy, wartość undef, puste tablice (zywkłe i asocjacyjne). Pozostałe są prawdziwe

I W blokach możemy umieścić dowolną liczbę instrukcji

Operatory porównania

Numeryczne Łańcuchowe Znaczenie

== eq jest równe

!= ne nie jest równe

<=> cmp porównanie ze znakiem Numeryczne Łańcuchowe Znaczenie

> gt większe niż

>= ge większe-równe niż

< lt mniejsze niż

<= le mniejsze-równe niż

Porównując liczby korzystamy z operatorów numerycznych.

Porównując łańcuchy korzystamy z operatorów łańcuchowych.

Przykład if

1 @ t a b 1 = qw( A n t e k B a r t e k );

@ t a b 2 = (" E d e k ", " D u d e k ");

if( @ t a b 1 == @ t a b 2 ) {

5 if( $ t a b 1 [0] lt $ t a b 2 [ 0 ] ) {

p r i n t " $ t a b 1 [0] p o p r z e d z a $ t a b 2 [ 0 ] \ n "; }

e l s i f( $ t a b 1 [0] gt $ t a b [ 0 ] ) {

p r i n t " $ t a b 2 [0] p o p r z e d z a $ t a b 1 [ 0 ] \ n ";

10 }

e l s e {

p r i n t " $ t a b 1 [0] j e s t r ó w n e $ t a b 2 [ 0 ] \ n ";

} }

(5)

Pętle

W Perlu mamy trzy główne rodzaje pętli:

I pętlę typu while znamy z innych programów (np. Pascal)

1 w h i l e( w y r a ż e n i e ) { b l o c k

}

I pętla typu for w takiej postaci jest znana z języków podobnych do C

1 for( p i e r w s z a i .; w a r u n e k ; i . i t e r o w a n a ) { b l o c k

}

I pętla typu foreach jest konstrukcją typową dla Perla

1 f o r e a c h $ e l e m e n t ( l i s t a ) { b l o c k

}

Pętla while - przykład

1 @ p o k o j = qw( k r z e s l o s t o l l o z k o s z a f a );

p r i n t " P o k o j z a w i e r a n a s t . m e b l e : ".j o i n(" , ", @ p o k o j );

5 w h i l e( @ p o k o j > 2) {

$ m e b e l = pop @ p o k o j ;

p r i n t " W y r z u c i l e m p r z e z o k n o : $ m e b e l \ n "; p r i n t " P o k o j z a w i e r a n a s t . m e b l e : ";

10 p r i n t j o i n(" , ", @ p o k o j )." \ n "; }

I Zmienna @pokoj użyta w kontekscie numerycznym jest interpretowana jako liczba elementów

I funkcja pop usuwa ostatni element z podanej tablicy i zwraca ten element

I Pętla while działa dopóki warunek jest prawdziwy, tzn. póki tablica @pokoj zawiera więcej niż dwa elementy

Pętla for - przykład

1 for( $i = 0; $i < 10; $i ++) {

p r i n t " W a r t o ś ć \ $i to : $i \ n ";

}

Program podobny do while.pl :

1 @ p o k o j = qw( k r z e s l o s t o l l o z k o s z a f a );

p r i n t " P o k o j z a w i e r a n a s t . m e b l e : ";

p r i n t j o i n(" , ", @ p o k o j )." \ n ";

5 for( $i = pop @ p o k o j ; @ p o k o j > 1; $i = pop @ p o k o j ) { p r i n t " W y r z u c i l e m p r z e z o k n o : $i \ n ";

p r i n t " P o k o j z a w i e r a n a s t . m e b l e : ";

p r i n t j o i n(" , ", @ p o k o j )." \ n ";

10 }

Pętla foreach - eksperymenty psycholingwistyczne

Dla przykładu pętli foreach posłużymy się pewnym eksperymentem psycholingwistycznym. Napiszemy program generujący wszystkie sylaby pewnego polinezyjskiego języka o nazwie Tulu

W tym języku wszystkie sylaby mają postać CV z ograniczonego zestawu spółgłosek i samogłosek:

{a, e, i , k, l , m, o, p, t, u}

Sylaby będą wyglądały np. tak: po, ta, ku, me

(6)

Pętla foreach - eksperymenty psycholingwistyczne

1 @ c o n s o n a n t s = qw( k l m p t );

@ v o w e l s = qw( a e i o u );

5 f o r e a c h $c ( @ c o n s o n a n t s ) { f o r e a c h $v ( @ v o w e l s ) {

p r i n t(" $ c $ v \ n ");

} }

Pętla foreach - eksperymenty psycholingwistyczne

Teraz napiszemy program, który generuje wszystkie wyrazy Tulu.

Każdy wyraz ma postać CVCV. Jak tego dokonać?

5 f o r e a c h $c1 ( @ c o n s o n a n t s ) { f o r e a c h $v1 ( @ v o w e l s ) {

f o r e a c h $c2 ( @ c o n s o n a n t s ) { f o r e a c h $v2 ( @ v o w e l s ) {

p r i n t(" $ c 1 $ v 1 $ c 2 $ v 2 \ n ");

10 }

} } }

Pętla foreach - eksperymenty psycholingwistyczne

Zasady morfofonologiczne Tulu narzucają nam dodatkowe ograniczenie. Wszystkie samogłoski danego wyrazu muszą być takie same, np. paka, tulu

5 f o r e a c h $c1 ( @ c o n s o n a n t s ) { f o r e a c h $v ( @ v o w e l s ) {

f o r e a c h $c2 ( @ c o n s o n a n t s ) { p r i n t(" $ c 1 $ v $ c 2 $ v \ n ");

}

10 }

}

Pętla foreach - eksperymenty psycholingwistyczne

Kolejna reguła morfofonologiczna jęzka Tulu mówi, że spółgłoski muszą być różne. Tzn. ciągi typu tutu, papa itd. nie są

poprawnymi słowami języka Tulu

5 f o r e a c h $c1 ( @ c o n s o n a n t s ) { f o r e a c h $v ( @ v o w e l s ) {

f o r e a c h $c2 ( @ c o n s o n a n t s ) {

p r i n t(" $ c 1 $ v $ c 2 $ v \ n ") if( $c1 ne $c2 );

}

10 }

}