Liste ve diziler

[tamerr89]

Liste ve diziler

LİSTE ve DİZİLER

Listeler:

Listeler parantezlerle sınırlandırılmış skalar değerler dizisidir.

Ör : (1, 5.3, "hello", 2)
Bu listenin 4 elemanı vardır. 1 , 5.3 , hello , ve 2. Elemanı olmayan liste boş listedir 
Ör : ()

Ör : (17, 26 << 2) listesi 2 elemanlıdır. 17 ve 104.
Ör : (17, $var1 + $var2) Bu örnekte 2 elemanlıdır. 17 ve $var1 ve $var2 toplamı.

Aşağıdaki kullanımlar listeler için geçerli diğer örneklerdir.

("string", 24.3, " string2")

($cevap, "cevap $cevap")

Liste elemanlarını Dizilere yerleştirme:
Öncelikle dizilerin tanımını görelim. Dizi değişkeni tanımı için o değişkenin başına @ karakteri konur.

Geçerli Adlandırma Örnekleri:
@my_array
@list2
@uzun_isim_de_ kullanılabilir

Geçerli olmayan adlandırma Örnekleri:
@1dizi # rakamla başlayamaz
@_dizi # alt-tire ile başlayamaz
@a.son.dizi # . kullanılamaz

Aşağıdaki örneği inceleyelim
$deger = 1;
@deger = (11, 27.1, "bir string"); 
Burada var isimli değişkenler tamamen farklı değişkenlerdir. $var skalar değişken olup,@var ise dizi değişkenidir.

Aşağıdaki örnekte, @array bir dizidir ve sırasıyla elemanlarına 1,2,ve 3 atanmıştır.
@array = (1, 2, 3);

Dizi elemanlarına erişim:

Erişim için o elemanın indisi(numarası) verilir.

Ör: $var = @array[0];
burada @array dizisinin 1.elemanının indis'i verilerek(Dizilerde ilk eleman numarası 0 dır) o elemanın değerine ulaşılıyor ve değer
$var değişkenine atanıyor.

Dizilerde 
@array[0], 1.elemanı
@array[1], 2.elemanı
@array[2], 3.elemanı
temsil eder ve sıralama bu şekilde devam eder.

Örnek:
@array = (1, 2, 3, 4);

yukarda @array elemanlarına, liste elemanlarının atanmasını görüyoruz.

dizi elemanları şu değerleri taşır:
@array[0], değeri 1
@array[1], değeri 2
@array[2], değeri 3
@array[3], değeri 4

Bu aşamada aşağıdaki atamayı yapalım.
$array[3] = 5;

Şimdi dizi elemanları dizilişi şu şekildedir;

@array[0], değeri 1
@array[1], değeri 2
@array[2], değeri 3
@array[3], değeri 5
yani (1, 2, 3, 5).

Eğer olmayan dizi elemanı atanmak istenirse veya negatif (-) değer verilirse atanacağı değişken değeri null stringidir ki 0 a eşittir.

Ör:
@array = (1, 2, 3, 4);
$skalar = $array[4]; 

dizide 5.eleman yani $array[4] yoktur dolayısıyla $skalar değeri null ("") dir.
benzer şekilde $skalar = $array[-1]; sonucu da aynıdır.

Bir de şu örneği inceleyelim.
@array = (1, 2, 3, 4);
$array[6] = 17; 
Dizinin görünümü şu şekildedir,
(1, 2, 3, 4, "", "", 17) 

İndis olarak değişken de kullanılır,
Ör:
$index = 1;
$skalar = $array[$index]; gibi...

Dizi elemanlarına erişimde dizi değişkeninin başında $ olduğuna dikkatinizi çekerim. Çünkü dizinin her bir elemanı skalar değişken olarak işlem görür.

Ör: $sebze[0] doğru 
@sebze[0] ise yanlış kullanımdır.

Örnek program: Program adı dizprg.pl olsun

#!/usr/local/bin/perl
@dizi = (1, "tavuk", 1.23, "\"Tamam mi?\"", 9.33e+23);
$say = 1;
while ($count <= 5) {
print ("$say . eleman @dizi[$say-1]\n");
$say++;
}

Çalısması :
>dizprg.pl
1 . eleman 1 
2 . eleman tavuk
3 . eleman 1.23
4 . eleman "Tamam mi?"
5 . eleman 9.3300000000000005+e23
>

Örnek program: program adı randiz.pl
# rand() fonksiyonu ile 1- 10 arası random sayı üreten program
#!/usr/local/bin/perl
$say = 1;
while ($say <= 100) {
$randnum = int( rand(10) ) + 1;
$randtoplam[$randnum] += 1;
$say++;
}
# Herbir sayı için toplamı yaz
$say = 1;
print ("Herbir sayı için toplam:\n");
while ($say <= 10) {
print ("\tsayi $say: $randtoplam[$say]\n");
$say++;
}

Çalısması:
>randiz.pl
Herbir sayı için toplam:
sayi 1: 11
sayi 2: 8
sayi 3: 13
sayi 4: 6
sayi 5: 10
sayi 6: 9
sayi 7: 12
sayi 8: 11
sayi 9: 11
sayi 10: 9
>

LİSTE gösterimi:
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) gösterimi ile (1..10) gösterimi aynıdır.
(2, 5..7, 11) örneğinden anlaşılan ise şudur:
listenin 5 elemanı vardır 2,5,6,7,11
String ifadeler içinde aynı kullanım geçerlidir

Ör:
("aaa", "aab", "aac","aad") ifadesi şu şekilde de gösterilebilir.
("aaa".."aad").
Benzer şekilde; ("BCY", "BCZ", "BDA", "BDB") ifadesi ("BCY".."BDB"), ile aynıdır.
@alphabet = ("a".."z"); ifadesi bir alfabe listesini gösterir.

Örnek program: Program adı lstprg.pl olsun.

#!/usr/local/bin/perl
print ("Baslangic numarasini gir:\n");
$basla = <STDIN>;
chop ($basla);
print ("Bitis numarasini gir:\n");
$bitis = <STDIN>;
chop ($bitis);
@liste = ($basla..$bitis);
$say = 0;
print ("Liste yaziliyor:\n");
while ($liste[$say] != 0 || $liste[$say-1] == -1
|| $liste[$say+1] == 1) #burada liste dizisinin sonu ve liste
#elemanı icinde 0 var mı kontrolu yapılıyor
{
print ("$liste[$say]\n");
$say++;
}

Çalısması:

>lstprg.pl
Baslangic numarasini gir:
-2
Bitis numarasini gir:
2
Liste yaziliyor
-2
-1
0
1
2
>

Örnek program : Program adı dizprg2.pl
#!/usr/local/bin/perl
@dizi1 = (14, "ekmek", 1.23, -7, "su");
@dizi2 = @dizi1;
$say = 1;
while ($say <= 5) {
print("eleman $say: $array1[$say-1] ");
print("$dizi2[$say-1]\n");
$say++;
}

Çalışması :
>dizprg2.pl
eleman 1: 14 14
eleman 2: ekmek ekmek
eleman 3: 1.23 1.23
eleman 4: -7 -7
eleman 5: su su
>


Aşağıdaki kullanım şeklini inceleyelim.

Ör :
@liste1 = (2, 3, 4);
@liste2 = (1, @liste1, 5);
Sonuçta @liste2 dizisinin içeriği (içerdiği liste) şu şekildedir.
(1,2,3,4,5)

Örnek program : Program adı dizprg3.pl
#!/usr/local/bin/perl
@al = " asla ";
@yaz = ("Ben", @al, "kaybetmem!\n");
print @yaz;

Çalışması :
>dizprg3.pl
Ben asla kaybetmem!
>

Aşağıdaki parantez kullanımını inceleyiniz
$ali = "Ali";
print (("Hey, " . $ali . "!\n") x 2); 
Bu kodlama sonucu çıktı şöyle olur;
Hey, Ali!
Hey, Ali!

Dizilerde yerine koyma:

Şu örneğe bakalım.
@a = (1, 2, 3);
print (@a, "\n");
Çıktı
> 123
Burada bir problem var gibi...

Bir de şuna bakın,
@a = (1, 2, 3);
print ("@a\n");
Çıktı
> 1 2 3

Böyle olacaktı..farkı belirleyen kodlamayı inceleyin.

LİSTENiN UZUNLUĞUNU ELDE ETME:

@a = (1, 2, 3);
$skalar = @a;

Bu kodlama şekliyle biz @a dizisinin(oluşturan listenin) uzunluğunu elde ederiz. $skalar içindeki bu değer 3 tür.

Not:
$skalar = @a;
($skalar) = @a; 
yukarıdaki satırlar farklıdır.
1.satırda $skalar,@a dizisinin uzunluğunu tutar.
2.satırda $skalar,@a dizisinin ilk elemanını tutar. 

Dikkat ediniz...
Dizilerle çalışmayı iyice anlamak için aşağıdaki programların kodlanışlarını iyi inceleyiniz.

Örnek program : Program adı dizprg4.pl
#!/usr/local/bin/perl
@dizi = (14, "Peynir", 1.23, -7, "elma");
$sayi = 1;
while ( $sayi <= @dizi) {
print("eleman $sayi: @dizi[ $sayi-1]\n");
$sayi++;
}
Çalışması:
>dizprg4.pl
eleman 1: 14
eleman 2: Peynir
eleman 3: 1.23
eleman 4: -7
eleman 5: elma
>

Alt dizilerin kullanımı:

Örnek program : Program adı dizprg5.pl
#!/usr/local/bin/perl
@dizi = (1, 2, 3, 4);
@altdizi = @dizi[1,2]; 
# dizinin 2 ve 3 .elemanından alt dizi olustu.
# hatırlayınız...dizinin 1.elemanı indisi $dizi[0] dır.
print ("Altdizinin 1.elemanı: $altdizi[0]\n");
print ("Altdizinin 1.elemanı: $altdizi[1]\n");
Çalışması:
>dizprg5.pl
Altdizinin 1.elemanı: 2
Altdizinin 2.elemanı: 3
>


Örnek program : Program adı dizprg6.pl
#!/usr/local/bin/perl
@dizi = ("bir", "iki", "üç", "dört", "beş");
@sira = (1, 2, 3);
@altdizi = @dizi[@sira];
print ("Dizi dilimi: @altdizi\n");

Çalışması :
>dizprg6.pl
Dizi dilimi: iki üç dört
>

DİZİ dilimlerine ATAMA:

@a [0,1] = ("string", 46);
bu örnekte @a dizisinin ilk 2 elemanı değeri string ve 46 olur.

Ör : aşağıdaki satır sonucu
@a [0..2] = ("string1", "string2");

3.eleman null stringtir.

Ör : Aşağıda ise listenin 4.elemanı diziye atanamaz(dikkate alınmaz).
@a [0..2] = (1, 2, 3, 4);

Örnek program : program adı dizprg7.pl

#!/usr/local/bin/perl
@dizi = ("a1", "a2", "a3", "a4");
@dizi[1,2] = ("b2", "b3");
print ("@dizi\n");

Çalışması:
>dizprg7.pl
a1 b2 b3 a4
>

Örnek program: Program adı dizsort.pl

#Okunan değerleri sıraladıktan sonra basan örnek
#!/usr/local/bin/perl
#giriş işlemi
print ("Değerleri giriniz\n");
print ("çıkış için boş satır giriniz.\n");
$say = 1;
$gir = <STDIN>;
chop ($gir);
while ($gir ne "") {
@a [$say -1] = $gir;
$say++;
$gir = <STDIN>;
chop ($gir);
}
# sıralama işlemi
$say = 1;
while ($say < @a) {
$x = 1;
while ($x < @a) {
if ($a [$x - 1] gt $a [$x]) {
@a [$x-1,$x] = @a [$x,$x-1];
}
$x++;
}
$say++;
}
#basma işlemi
print ("@a\n");

Çalışması:
>dizsort.pl
Değerleri giriniz
çıkış için boş satır giriniz.
fok
bebek
dil
bal
bal bebek dil fok
>


Standart giriş (klavye ) den dizi okuma:

giriş dizi değişkenine yapılır.
Ör:
@a = <STDIN>;

Örnek program : program adı dizkey.pl

#!/usr/local/bin/perl
@a = <STDIN>;
print (@a);

Çalışması:
>dizkey.pl
1.satır
2.satır
son satır.

^D (control ve D tuşu)

1.satır
2.satır
son satır.
>

DİZİ KÜTÜPHANE FONKSİYONLARI:

Dizilerde sıralama:
Bu işlem için kullanılan fonksiyon sort() dur.

Ör: liste = sort (array); 

Ör:
@array = ("Bu", "bir", "test", "dir");
dizi bu şekilde oluştu. Şimdi sort ile sıralayalım;
@array2 = sort (@array);
sonuçta @array2 dizisi içeriği listesi şu şekildedir.
("bir", "bu", "dir", "test")
@array dizisi içeriği ise değişmez...aynıdır.("Bu", "bir", "test", "dir")

veriler alfabetik değilse;

@a = (70, 100, 8);
@a = sort (@a);
o zaman sıralama şöyle gerçekleşir.
(100, 70, 8)

Dizi değişken veya listeleri ters sıraya sokma:
Bu işlemi reverse() fonksiyonu yapar.
Örnek:
@a = ("bal", "incir", "arı", "sinek");
@a2 = reverse(@a);
@a2 içeriği listesi şu şekildedir:
("sinek", "arı", "incir", "bal")

Örnek program: program adı tersdiz.pl 

#program klavyeden girilen bilgileri ters olarak
# (alfabetik olarakbuyukten kucuğe) sıralar
#!/usr/local/bin/perl
@input = <STDIN>;;
@input = reverse (sort (@input));
print (@input);

Çalışması :
>tersdiz.pl
fal
bal
dil
bez

^D

fal
dil
bez
bal
>

DİZİLERDE chop() FONKSİYONU:

chop() fonk.nun son karakteri sildiğini biliyoruz.

Ör :
$a = "Ala";
chop ($a); 
$var içeriği şu anda "Al" dır.

Dizi listelerinde kullanımı:

Ör:
@list = ("Aslan", "12345", "Geyik");
chop (@list);

Şu an @list içeriği liste şu şekildedir: ("Asla", "1234", "Geyi")

Başka bir örnek:

@a = <STDIN>;
chop (@a);

Bu şekilde klavyeden kullanımda yeni satır karakteri yok edilerek diziye alınır.

STRİNG LİSTESİNDEN TEK STRİNG OLUŞTURMA:

Bu görevi join() fonksiyonu yerine getirir.

Ör:
$string = join(" ", "bu", "bir", "liste", "dir");
$string içeriği şudur: "bu bir liste dir"

join da ilk " " kısmı stringler arasında kullanılacak karakteri bildirir. 
Yukarda ki örnekte bu karakter boş stringtir.

Aşağıdaki örneğe bakınca daha iyi anlayacaksınız.

$string = join("::", "kelime", "ve", "sütun");

sonuçta oluşan $string stringinin içeriği 
şöyle görünür : "kelime::ve::sütun" 

Bir başka örnek:
@liste = ("Bu", "bir");
$string = join(" ", @list, "stringdir");

$string içeriği : "Bu bir stringdir" olur. 

Örnek Program: program adı joprg.pl

#!/usr/local/bin/perl
@gir = <STDIN>;
chop (@gir);
$string = join(" ", @gir);
print ("$string\n");

Çalışması:
>joprg.pl
Ben 
perl
öğrenmeye
basladım.

^D

Ben perl öğrenmeye basladım.
>


STRİNGLERİ AYIRMA:

split()fonksiyonu: join tersi işlev görür.
stringler arası karakter iki adet / karakteri arasında belirtilir.
$string = "bu::bir::ayırma::örneği";
@dizi = split(/::/, $string);
sonuc olarak @dizi içeriği şu şekildedir:
("bu","bir","ayırma","örneği")


bununla ilgili bir kelime sayma programını inceleyelim
program adı kesay.pl olsun

#!/usr/local/bin/perl
$kelimesay = 0;
$gir = <STDIN>;
while ($gir ne "") {
chop ($gir);
@dizi = split(/ /, $gir);
$kelimesay += @dizi;
$gir = <STDIN>;
}
print ("Toplam kelime sayısı: $kelimesay \n");

Çalışması:

>kesay.pl
bu ilk satır
bu da ikincisi
son satır da bu olsun.

^D

Toplam kelime sayısı: 11
>

Şimdi de son öğrendiklerimizi içeren bir örnek :

Klavyeden girilen kelimeleri ters sırada yerleştirip yazalım. Program adı fnk.pl

#!/usr/local/bin/perl

# Klavyeden girişini yap

@giris = <STDIN>;
chop (@giris);

# Her bir satırdaki kelimeleri ters sırada yerleştir

$satir = 1;
while ($satir <= @giris) {
@kelime = split(/ /, $giris[$satir -1]);
@kelime = reverse(@kelime);
$giris[$satir -1] = join(" ", @kelime, "\n");
$satir ++;
}

#şimdi onların sırasını ters cevir ve yazdır

@giris = reverse(@giris);
print (@giris);


>fnk.pl
bir iki
üç dört
beş altı.

^D

altı. beş
dört üç
iki bir
>