Python’da Veri Tabanı İşlemleri #2

Bu yazıda bir önceki yazımızda oluşturmuş olduğumuz MusteriTablosu isimli tablo üzerinde Python ile örnek uygulamalar yapacağız. Burada kullanacağım veri tabanı ile ilgili daha fazla bilgi için buraya tıklayarak bir önceki yazıya gidebilirsiniz.

Uygulama 1: Müşteri tablosunda taksit sayısı 6’dan küçük olanları listeleyelim.

INPUT: 

musteriler = sqlite3.connect("musteriler.sqlite")
imlec = musteriler.cursor()
secilenler = imlec.execute("Select * From MusteriTablosu WHERE MusteriTaksitsayisi < 6")
print(secilenler.fetchall())

OUTPUT:

[(127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440)]

Burada veri tabanına olan erişimimizi kapatmıyorum. Çünkü yazı boyunca aynı bağlantı kodunu tekrar tekrar yazmayalım.

Uygulama 2: Müşteri tablosunda geliri 3000 TL’den fazla ve yaşı 30’dan küçük olan müşterileri listeleyelim.

INPUT:

secilenler1 = imlec.execute("Select * From MusteriTablosu WHERE MusteriGeliri > 3000 AND MusteriYas < 30")
secilenler1.fetchall()

OUTPUT:

[(127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440),
 (518023, 'Gizem', 'Duyar', 23, 'K', 3500, 2750, 12, 229.17)]

Uygulama 3: Müşteri tablosunda cinsiyeti kadın olanları listeleyelim.

INPUT:

secilenler2 = imlec.execute("Select * From MusteriTablosu WHERE MusteriCinsiyet  = 'K'")
secilenler2.fetchall()

OUTPUT:

[(127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440),
 (518023, 'Gizem', 'Duyar', 23, 'K', 3500, 2750, 12, 229.17),
 (812503, 'Aslı', 'Çevik', 26, 'K', 3000, 1650, 6, 550),
 (356721, 'Betül', 'Çevreci', 26, 'K', 2800, 1400, 6, 233.34)]

Uygulama 4: Müşteri tablosunda aylık ödemesi 600 TL’den düşük olan müşterilerin borcunu, gelirini, adını ve soyadını listeleyelim.

INPUT:

secilenler3 = imlec.execute("Select MusteriAd, MusteriSoyad, MusteriGeliri, MusteriToplamBorc From MusteriTablosu WHERE MusteriAylikOdeme  < 600")
secilenler3.fetchall()

OUTPUT:

[('Ece', 'Gündüz', 3655, 1760),
 ('Gizem', 'Duyar', 3500, 2750),
 ('Aslı', 'Çevik', 3000, 1650),
 ('Betül', 'Çevreci', 2800, 1400)]

Uygulama 5: Insert komutunu kullanarak aşağıda verilen verileri veri tabanına ekleyelim.

(625173, “Salih”, “Güven”, 30, “E”, 2200.00, 1250.00, 6, 208.34)

(153294, “Melike”, “Özdemir”, 26, “K”, 4350.00, 4250.00, 12, 283.34)

(309852, “Berk”, “İnan”, 56, “E”, 3800.00, 2760.00, 12, 230.00)

Bu verileri liste olarak yazıp, bir önceki yazıda oluşturduğumuz fonksiyon içerisine yazalım.

INPUT:

yeniVeriler = [[625173, "Salih", "Güven", 30, "E", 2200.00, 1250.00, 6, 208.34], [153294, "Melike", "Özdemir", 26, "K", 4350.00, 4250.00, 12, 283.34], [309852, "Berk", "İnan", 56, "E", 3800.00, 2760.00, 12, 230.00]]
VeriGirisi(yeniVeriler)
musteriler.commit()
secilenler4 = imlec.execute("Select * From MusteriTablosu ")
secilenler4.fetchall()

OUTPUT:

[(136752, 'Ahmet', 'Yenidoğan', 36, 'E', 4500, 3800, 6, 633.34),
 (127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440),
 (201638, 'Ali', 'Çelik', 46, 'E', 6500, 8900, 12, 741.67),
 (518023, 'Gizem', 'Duyar', 23, 'K', 3500, 2750, 12, 229.17),
 (812503, 'Aslı', 'Çevik', 26, 'K', 3000, 1650, 6, 550),
 (437612, 'Mehmet', 'Bekçi', 35, 'E', 6500, 4800, 6, 800),
 (356721, 'Betül', 'Çevreci', 26, 'K', 2800, 1400, 6, 233.34),
 (971025, 'Cenk', 'Kahraman', 33, 'E', 4250, 9800, 12, 816.67),
 (625173, 'Salih', 'Güven', 30, 'E', 2200, 1250, 6, 208.34),
 (153294, 'Melike', 'Özdemir', 26, 'K', 4350, 4250, 12, 283.34),
 (309852, 'Berk', 'İnan', 56, 'E', 3800, 2760, 12, 230)]

Uygulama 6: Update komutunu kullanarak Melike Özdemir kişisinin borcunu 12800.00 TL ve taksit sayısını 8 olarak güncelleyelim. Buna bağlı olan sütunları da güncelleyelim.

INPUT:

imlec.execute("UPDATE MusteriTablosu SET MusteriToplamBorc = 12800.00, MusteriTaksitSayisi = 8, MusteriAylikOdeme = 1600.00 WHERE MusteriAd = 'Melike' AND MusteriSoyad = 'Özdemir'")
musteriler.commit()
Secilenler5 = imlec.execute("Select * From MusteriTablosu WHERE MusterID  = 153294")
Secilenler5.fetchall()

OUTPUT:

[(153294, 'Melike', 'Özdemir', 26, 'K', 4350, 12800, 8, 1600)]

Uygulama 7: MusteriID’si 625173 olan Salih Güven kişisini tablodan silelim.

INPUT:

imlec.execute("DELETE FROM MusteriTablosu WHERE MusterID = 625173")
musteriler.commit()
Secilenler6 = imlec.execute("Select * From MusteriTablosu")
Secilenler6.fetchall()

OUTPUT:

[(136752, 'Ahmet', 'Yenidoğan', 36, 'E', 4500, 3800, 6, 633.34),
 (127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440),
 (201638, 'Ali', 'Çelik', 46, 'E', 6500, 8900, 12, 741.67),
 (518023, 'Gizem', 'Duyar', 23, 'K', 3500, 2750, 12, 229.17),
 (812503, 'Aslı', 'Çevik', 26, 'K', 3000, 1650, 6, 550),
 (437612, 'Mehmet', 'Bekçi', 35, 'E', 6500, 4800, 6, 800),
 (356721, 'Betül', 'Çevreci', 26, 'K', 2800, 1400, 6, 233.34),
 (971025, 'Cenk', 'Kahraman', 33, 'E', 4250, 9800, 12, 816.67),
 (153294, 'Melike', 'Özdemir', 26, 'K', 4350, 12800, 8, 1600),
 (309852, 'Berk', 'İnan', 56, 'E', 3800, 2760, 12, 230)]

Uygulama 8: Müşteri tablosunda isminde A harfi olan kişileri listeleyelim.

INPUT:

Secilenler7 = imlec.execute("Select * From MusteriTablosu WHERE MusteriAd Like '%A%'")
Secilenler7.fetchall()

OUTPUT:

[(136752, 'Ahmet', 'Yenidoğan', 36, 'E', 4500, 3800, 6, 633.34),
 (201638, 'Ali', 'Çelik', 46, 'E', 6500, 8900, 12, 741.67),
 (812503, 'Aslı', 'Çevik', 26, 'K', 3000, 1650, 6, 550)]

Uygulama 9: Müşteri tablosunda soyadı Ç harfi ile başlayan kişileri listeleyelim.

INPUT:

Secilenler8 = imlec.execute("Select * From MusteriTablosu WHERE MusteriSoyad Like 'Ç%'")
Secilenler8.fetchall()

OUTPUT:

[(201638, 'Ali', 'Çelik', 46, 'E', 6500, 8900, 12, 741.67),
 (812503, 'Aslı', 'Çevik', 26, 'K', 3000, 1650, 6, 550),
 (356721, 'Betül', 'Çevreci', 26, 'K', 2800, 1400, 6, 233.34)]

Uygulama 10: Müşteri tablosunda ismi E harfi ile biten kişileri listeleyelim.

INPUT:

e("Select * From MusteriTablosu WHERE MusteriAd Like '%E'")
Secilenler9.fetchall()

OUTPUT:

[(127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440),
 (153294, 'Melike', 'Özdemir', 26, 'K', 4350, 12800, 8, 1600)]

Uygulama 11: Müşteri tablosunda geliri 3000 TL ya da 4500 TL olan kişilerin ad, soyad, maaş ve yaşını listeleyelim.

INPUT:

Secilenler10 = imlec.execute("Select MusteriAd, MusteriSoyad, MusteriGeliri, MusteriYas From MusteriTablosu WHERE MusteriGeliri IN(3000,4500)")
Secilenler10.fetchall()

OUTPUT:

[('Ahmet', 'Yenidoğan', 4500, 36), ('Aslı', 'Çevik', 3000, 26)]

Uygulama 12: Müşteri Tablosunda adında A harfi olmayan ve geliri 3500 TL, 4000 TL ya da 4800 TL olan kişilerin ad ve soyadlarını listeleyen sorguyu yazalım.

INPUT:

Secilenler11 = imlec.execute("Select MusteriAd, MusteriSoyad From MusteriTablosu WHERE MusteriAd NOT LIKE '%A%' AND MusteriGeliri IN(3500,4000,4800)")
Secilenler11.fetchall()

OUTPUT:

[('Gizem', 'Duyar')]

Uygulama 13: Müşteriler veri tabanına CihazTablosu isminde bir tablo oluşturalım. Bu tablonun içerisinde CihazID, CihazModel, CihazYıl ve CihazAd sütunlarını ekleyelim.

INPUT:

imlec.execute('''CREATE TABLE IF NOT EXISTS CihazTablosu(
                 CihazID INT NOT NULL, 
                 CihazModel Varchar(5), 
                 CihazYıl SMALLINT,
                 CihazAd Varchar(30))''')

Uygulama 14: Yeni oluşturduğumuz CihazTablosu isimli tabloya aşağıdaki verileri ekleyelim.

(“TBT16”, 2016, “Tablet”), (“BGR20”, 2020, “Bilgisayar”), (“TLN18”, 2018, “Telefon”), (“BZD19”, 2019, “Buzdolabı”), (“CMR21”, 2021, “Çamaşır Makinesi”), (“TVN21”, 2021, “Televizyon”)

INPUT:

cihazlar = [[1635,"TBT16", 2016, "Tablet"], [1654,"BGR20", 2020, "Bilgisayar"], [5643,"TLN18", 2018, "Telefon"], [4567,"BZD19", 2019, "Buzdolabı"], [1564,"CMR21", 2021, "Çamaşır Makinesi"], [4569,"TVN21", 2021, "Televizyon"]]
for cihaz in cihazlar:
 imlec.execute("INSERT INTO CihazTablosu VALUES (?,?,?,?)", cihaz)
musteriler.commit()
secilenler12 = imlec.execute("SELECT * FROM CihazTablosu")
secilenler12.fetchall()

OUTPUT:

[(1635, 'TBT16', 2016, 'Tablet'),
 (1654, 'BGR20', 2020, 'Bilgisayar'),
 (5643, 'TLN18', 2018, 'Telefon'),
 (4567, 'BZD19', 2019, 'Buzdolabı'),
 (4569, 'TVN21', 2021, 'Televizyon'),
 (1564, 'CMR21', 2021, 'Çamaşır Makinesi')]

Uygulama 15: Müşteri tablosuna SahipOlunanCihaz isimli ve veri türü INT olan bir sütun ekleyelim.

INPUT:

imlec.execute("ALTER TABLE MusteriTablosu ADD COLUMN SahipOlunanCihaz INT")
musteriler.commit()

Uygulama 16: Müşteri tablosuna yeni eklenen sütuna (1,3,5,6,2,4,3,5,1,6) değerlerini ekleyelim.

INPUT:

CihazNumaralari = [1,3,5,6,2,4,3,5,1,6]
MusteriNumaralari = [136752, 127650, 201638, 518023, 812503, 437612, 356721, 971025, 153294, 309852]
a = 0
for musteri in MusteriNumaralari:
 imlec.execute("UPDATE MusteriTablosu SET SahipOlunanCihaz = {} WHERE MusterID = {}" .format(CihazNumaralari[a], musteri))
 a += 1
musteriler.commit()
secilenler13 = imlec.execute("SELECT * FROM MusteriTablosu")
secilenler13.fetchall()

OUTPUT:

[(136752, 'Ahmet', 'Yenidoğan', 36, 'E', 4500, 3800, 6, 633.34, 1),
 (127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440, 3),
 (201638, 'Ali', 'Çelik', 46, 'E', 6500, 8900, 12, 741.67, 5),
 (518023, 'Gizem', 'Duyar', 23, 'K', 3500, 2750, 12, 229.17, 6),
 (812503, 'Aslı', 'Çevik', 26, 'K', 3000, 1650, 6, 550, 2),
 (437612, 'Mehmet', 'Bekçi', 35, 'E', 6500, 4800, 6, 800, 4),
 (356721, 'Betül', 'Çevreci', 26, 'K', 2800, 1400, 6, 233.34, 3),
 (971025, 'Cenk', 'Kahraman', 33, 'E', 4250, 9800, 12, 816.67, 5),
 (153294, 'Melike', 'Özdemir', 26, 'K', 4350, 12800, 8, 1600, 1),
 (309852, 'Berk', 'İnan', 56, 'E', 3800, 2760, 12, 230, 6)]

Bir sonraki yazımızda Python’dan bahsetmeye devam edeceğiz.

PYTN5JL10AJU0X299N
Java’da Döngüler

Bu yazıda sizlere JAVA’da yinelenen işlemlerin gerçekleştirildiği döngülerin neler olduğundan ve nasıl kullanıldığından bahsedeceğim. Genel olarak yazı içerisinde For ve while döngülerini inceleyeceğiz.

JAVA’da kod yazarken kodlarımızın içerisinde yinelenen işlemler olabilir. Örneğin 1’den 10’a kadar olan sayıları ekrana yazdırmak istediğimizi düşünelim. Bu durumda döngü kullanmadan 10 kez system.out.println() fonksiyonunu kullanmamız gerekir. Örnek olarak:

INPUT:

public class Main {
    public static void main(String[] args) {
        System.out.println(1);
        System.out.println(2);
        System.out.println(3);
        System.out.println(4);
        System.out.println(5);
        System.out.println(6);
        System.out.println(7);
        System.out.println(8);
        System.out.println(9);
        System.out.println(10);
    }
}

OUTPUT:

1
2
3
4
5
6
7
8
9
10

Ancak bu işlemi manuel olarak gerçekleştirmek bizim için ideal değildir çünkü kodlarımızı yazarken aynı işlemleri içeren kod satırlarını elle tekrar tekrar yazmamız gerekir. Bu hem zamandan kaybetmemize hem de yazdığımız kodun daha karışık ve uzun hale gelmesine yol açacaktır. Dolayısıyla, hem kodlarımızı daha az çaba harcayarak yazmalıyız hem de daha az kod satırı ile daha çok işlem gerçekleştirebiliyor olmalıyız. Bu sebeple yinelenen işlemlerde döngüleri kullanırız. Döngülerin amacı, aynı veya benzer kodu birkaç kez tekrarlamaktır. Bu tekrarlama belirli bir sayı kadar ya da bir koşul sağlanana kadar sürebilir. JAVA’da iki çeşit döngü mevcuttur. Bunlar for döngüsü ve while döngüsüdür.

İlk olarak while döngüsünden bahsedelim.

WHILE Döngüsü

While döngüsü, döngüde yazdığımız şart doğru olduğu sürece kod bloğu içerisindeki işlemleri gerçekleştirmeye devam eden döngü tipidir. While döngüsü aşağıdaki gibi yazılır:

public class Main {
    public static void main(String[] args) {
        while (kosul) {
            //Yazılan koşulun değeri true ise çalıştıralacak kod bloğu
        }

    }
}

While döngüsünün kullanımına ilişkin örnekler aşağıdaki gibidir:

INPUT:

public class Main {
    public static void main(String[] args) {
        int i = 0;
        while (i < 5) {
            System.out.println("i değeri : " + i);
            i += 1;
         }

    }
}

OUTPUT:

i değeri : 0
i değeri : 1
i değeri : 2
i değeri : 3
i değeri : 4
INPUT:

public class Main {
    public static void main(String[] args) {
        boolean deger = true;
        int sonuc = 0;
        while (deger == true) {
            sonuc += 3;
            if(sonuc > 40) {
                System.out.println("Limit Değere Aşıldı! Son Değer : " + sonuc);
                deger = false;
            }
            }
         }

    }

OUTPUT: 

Limit Değere Aşıldı! Son Değer : 42

While döngüsünde, koşul doğru ise kod bloğu çalışır.  Eğer döngüde yazılan şartın doğru ya da yanlış olduğuna bakılmaksızın kod bloğunun en az bir kez çalıştırılmasını istersek dowhile döngüsünü kullanmamız gerekir. Dowhile döngüsünün kullanımı ve mantığı while döngüsüne benzerdir. Ancak farkı, şartın durumuna bakmaksızın kod bloğunu bir kez çalıştırır. Dowhile döngüsü aşağıdaki gibi yazılır:

public class Main {
    public static void main(String[] args) {
        do {
            //çalıştırılmak istenen kod bloğu
        }
        while (kosul);

         }

    }

Dowhile döngünün kullanımına ilişkin örnek aşağıdaki gibidir:

INPUT:

public class Main {
    public static void main(String[] args) {
        int toplam = 0;
        do{
            System.out.println("Toplam : " + toplam);
            toplam += 10;
        }while(toplam < 100);
        }
}

OUTPUT:

Toplam : 0
Toplam : 10
Toplam : 20
Toplam : 30
Toplam : 40
Toplam : 50
Toplam : 60
Toplam : 70
Toplam : 80
Toplam : 90
INPUT:

import java.util.Scanner;

public class Main
{
	public static void main(String[] args) {
     int sayi1, sayi2, i, enBuyuk, enKucuk;
     
     Scanner input = new Scanner(System.in);
     
     System.out.println("Lutfen ilk sayiyi giriniz : ");
     sayi1 = input.nextInt();
     
     System.out.println("Lutfen ikinci sayiyi giriniz : ");
     sayi2 = input.nextInt();     
     
     int k = 2;
     i = 2;
     enBuyuk = 1;
     while(sayi1 >= i){
         
         if((sayi1 % i == 0) && (sayi2 % i == 0)){
                 enBuyuk = i;
         }
         
         i++;
     }
     
     enKucuk = (sayi1 * sayi2) / enBuyuk;
     
     System.out.println("En buyuk ortak bolen : " + enBuyuk);
     System.out.println("En kucuk ortak bolen : " + enKucuk);
	}
}

OUTPUT:

Lutfen ilk sayiyi giriniz : 
60
Lutfen ikinci sayiyi giriniz : 
70
En buyuk ortak bolen : 10
En kucuk ortak bolen : 420
For Döngüsü

For döngüsü, yazılan kod bloğunun istenilen sayı kadar yinelenmesini istediğimiz durumlarda kullanılan döngü tipidir. For döngüsü aşağıdaki gibi yazılabilir:

public class Main {
    public static void main(String[] args) {
        for (baslangıcDegeri; dongununDevamınıSaglayanSart; ArtısAzalısDegeri) {
            //çalıştırılmak istenen kod bloğu
        }

        }
}

For döngüsü yazılırken, döngü içerisindeki ilk alana bir değişken tanımlanır ve başlangıç noktası verilir. Ardından hangi koşul sağlanana kadar döngünün devam etmesi gerektiği yazılır. Son olarak, döngü her sonlandığında, başlangıç noktasından nasıl ilerleme ya da gerileme yapılacağı belirtilir. Bu değerlere göre for döngüsü çalışır ve istenilen işlemleri gerçekleştirir. For döngüsünün kullanımına ait aşağıdaki örnekleri inceleyebiliriz:

INPUT:

public class Main
{
    public static void main(String[] args) {

        boolean sorgu = true;

        for(int i = 2; i <= 100; i++){

            for(int k = 2; k < i; k++){

                if(i %k == 0){
                    sorgu = false;
                }
            }
            if(sorgu == true){
                System.out.print(" " + i);
            }
            sorgu = true;
        }
    }
}

OUTPUT:

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
INPUT:

import java.util.Scanner;

class HelloWorld {
    public static void main(String[] args) {
        int deger, us, sonuc;

        Scanner input = new Scanner(System.in);

        System.out.print("Lutfen bir deger giriniz : ");
        deger = input.nextInt();

        System.out.print("Lutfen bir us degeri giriniz : ");
        us = input.nextInt();

        sonuc = 1;

        for(int i = 0; i < us; i++){

            sonuc *= deger;

        }

        System.out.println("Sonuc : " + sonuc);

    }
}

OUTPUT:

Lutfen bir deger giriniz : 6
Lutfen bir us degeri giriniz : 2
Sonuc : 36

For döngüsü, bir başlangıç noktasından belirtilen koşul altında bir bitiş noktası boyunca belirli bir kod bloğunu tekrar tekrar çalıştırmanın dışında diziler üzerinde de kullanılabilir. Dizi üzerinde yazdığımız for döngüsü, dizinin her bir elemanını dolaşır ve istediğimiz işlemleri dizi elemanları üzerinde gerçekleştirir. Bu tip bir for döngüsünün kullanımı aşağıdaki gibidir:

class HelloWorld {
    public static void main(String[] args) {
        for (VeriTipi degiskenIsmı : diziIsmı) {
            //Çalıştırılması istenen kod bloğu
        }

    }
}

Yukarı yazdığımız for döngüsü tipine ait örnekler aşağıdaki gibidir:

INPUT:

class HelloWorld {
    public static void main(String[] args) {
      String[] dizi = {"Ahmet", "Mehmet", "Ali","Ayşe","Cansu","Gizem"};
      for(String eleman:dizi){
          if (eleman == "Ayşe"){
              System.out.println("Dizide " + eleman + " elemanına erişildi!");
              break;
          }
      }
    }
}

OUTPUT:

Dizide Ayşe elemanına erişildi!

Bu yazımızda son olarak while ve for döngüsünde kullanabileceğimiz break ve continue komutlarını kullanışlarından bahsedeceğiz. Break komutunun switchcase yapısında ne amaçla ve nasıl kullanıldığı görmüştük. Döngülerde de break komutunun kullanılma mantığı aynıdır.

Döngü içerisinde belli bir koşul sağlanmışsa ya da belli bir değere geldiğimizde döngünün sonlanmasını isteyebiliriz. Bu durumda döngü içerisinde break komutunu kullanabiliriz. Break komutu çalıştığı anda, döngünün devam etmesi gerekse bile döngüden çıkış yapılacaktır.

Örneğin, içerisinde 4 adet isim olan {“Ahmet”, “Mehmet”, “Ayşe”, “Fatma”} kümesini düşünelim. Bu küme üzerinde bir döngü yazalım. Öyle ki döngü, dizi içerisinde Ayşe ismine uğradığında döngüden çıkış yapsın. Bu döngüyü aşağıdaki gibi yazabiliriz:

INPUT:

public class Main {
    public static void main(String[] args) {
        String[] isimler = {"Ahmet", "Mehmet", "Ayşe", "Fatma"};
        for (String i : isimler) {
            if (i == "Ayşe"){
                System.out.println("Şu anki değer Ayşe olduğundan döngüden çıkıldı.");
                break;
            }else{
                System.out.println(i);
            }
        }
    }
}

OUTPUT:

Ahmet
Mehmet
Şu anki değer Ayşe olduğundan döngüden çıkıldı.

Yukarıda da görüldüğü gibi döngünün uğraması gereken Fatma ismi varken Ayşe’ye denk geldiğinde döngüden çıkıldı ve Fatma ismine hiç uğramadı.

Bu gibi durumlarda döngüden çıkılması istenirse break komutu kullanılabilir.

Continue komutu ise döngünün içerisinde herhangi değere ya da koşula denk gelindiğinde döngünün o basamağını atlamak için kullanılır. Döngü continue çalıştırdığı anda o an ki döngü basamağını atlar ve işlemleri gerçekleştirmeden sonraki döngü adıma geçiş yapar. Sonraki döngü adımında eğer continue’u içeren bloğa girmezse döngü bloğundaki işlemleri gerçekleştirir.

Örneğin, basit olarak 1’den 10’a kadar ekrana yazı yazdırmayı düşünelim. Ekrana bu sayıları yazdırırken 5 sayısının ekrana yazılmadan atlanmasını ve diğer sayıların ekrana yazılmasının devam etmesini isteyelim. Continue komutunu kullanarak bu isteği aşağıdaki gibi gerçekleştirebiliriz:

INPUT:

public class Main {
    public static void main(String[] args) {
    for(int i = 0; i <= 10; i++){
        if (i == 5){
            continue;
        }
        System.out.println(i);
    }
    }
}

OUTPUT:

0
1
2
3
4
6
7
8
9
10

Yazımızı for ve while döngüleri için birkaç örnek daha yaparak sonlandıralım.

INPUT:

import java.util.Scanner;

class HelloWorld {
    public static void main(String[] args) {
        int deger,toplam, basamak, deger1;

        Scanner input = new Scanner(System.in);
        System.out.print("Sayi Giriniz : ");
        deger = input.nextInt();

        deger1 = deger;
        toplam = 0;

        while (deger1 != 0) {
            basamak = deger1 % 10;
            toplam += basamak;
            deger1 /= 10;
        }

        System.out.println("Basamaklar toplami : " + toplam);
    }
}

OUTPUT:

Sayi Giriniz : 16
Basamaklar toplami : 7
INPUT:

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int ilkSayi = 0, ikinciSayi = 1, toplam,deger;
        System.out.print("N Sayısını Girin:");
        deger = input.nextInt();
        System.out.print(ilkSayi+" "+ikinciSayi);

        for(int i = 2 ; i < deger + 1; ++i){
            toplam = ilkSayi + ikinciSayi;
            System.out.print(" "+toplam);
            ilkSayi = ikinciSayi;
            ikinciSayi = toplam;

        }
        System.out.println();
    }

}

OUTPUT:

N Sayısını Girin:8
0 1 1 2 3 5 8 13 21
INPUT:

import java.util.Scanner;

public class Main
{
    public static void main(String[] args) {


        Scanner input = new Scanner(System.in);

        System.out.print("Lutfen kac sayi girilecek? : ");
        int n = input.nextInt();

        System.out.print("Lutfen deger giriniz : ");
        int ilkDeger = input.nextInt();

        int enKucuk = ilkDeger;
        int enBuyuk = ilkDeger;
        for(int i = 0; i < n-1; i++){

            System.out.print("Lutfen deger giriniz : ");
            int deger = input.nextInt();

            if(deger > enBuyuk){
                enBuyuk = deger;
            }
            if(deger < enKucuk){
                enKucuk = deger;
            }
        }
        System.out.println("En buyuk deger : " + enBuyuk);
        System.out.println("En kucuk deger : " + enKucuk);
    }
}

OUTPUT:

Lutfen kac sayi girilecek? : 5
Lutfen deger giriniz : 15
Lutfen deger giriniz : 45
Lutfen deger giriniz : 321
Lutfen deger giriniz : 54
Lutfen deger giriniz : 34
En buyuk deger : 321
En kucuk deger : 15
INPUT:

import java.util.Scanner;

class Patika_Java_101 {
    public static void main(String[] args) {
        int nBitis;
        double toplam;

        Scanner input = new Scanner(System.in);

        System.out.print("Lutfen n sayisinin bitis degerini yaziniz : ");
        nBitis = input.nextInt();

        toplam = 0;

        for(double i = 1; i <= nBitis; i++){
            toplam += (1/i);
        }

        System.out.println("Harmonik Toplam : " + toplam);

    }
}

OUTPUT:

Lutfen n sayisinin bitis degerini yaziniz : 6
Harmonik Toplam : 2.4499999999999997

JAVA’da dizilerden bahsettiğimiz bir sonraki yazımıza buradan ulaşabilirsiniz.

JAVA9US7B9AB2H5L3R
Java’da If-Else Blokları
If – Else Blokları

Bu yazıda sizlere JAVA’da koşul bloklarını kullanabilmemizi sağlayan ifelse ve switchcase bloklarından bahsedeceğim. ifelse blokları diğer programlama dillerinde olduğu gibi JAVA’da da sık sık kullanılan ve önemli bir yere sahip ifadelerdir. ifelse blokları sayesinde yazdığımız kodlar içerisine koşullara bağlı farklı çıktı veren ya da farklı işlemler gerçekleştiren kod blokları ekleyebiliriz.

ifelse blokları, programcı tarafından mantıksal bir boolean koşulunun doğru ya da yanlış olmasına göre belirtilen eylemleri gerçekleştirmeye yarayan özelliktir. ifelse bloklarının JAVA’daki kullanımları aşağıdaki gibidir:

if (kosul1) {

  //kosul1 koşulunun true olması durumunda çalıştırılacak kod bloku

}else if (kosul2) {

  //kosul1 koşulunun false ve kosul2 kosulunun true olması durumunda çalıştırılacak kodu bloku

}else{

  //kosul1 koşulunun false ve kosul2 kosulunun false olması durumunda çalıştırılacak kodu bloku

}

Eğer ki yazdığımız kodun tek bir koşul altında farklı bir aksiyon göstermesini istiyorsak sadece if bloğunu da kullanabiliriz. Örneğin, verdiğimiz bir sayı karşılığında programın o sayının çift olduğu durumlarda dışarıya “Bu bir çift sayıdır.” yazmasını isteyelim. Diğer durumlarda programın herhangi bir aksiyon göstermemesini isteyelim. Bu durumda aşağıdaki gibi bir kod bloğu isteğimizi gerçekleştirebilir.

INPUT:

public class Main {
    public static void main(String[] args) {
        int A = 4;

        if (A % 2 == 0){
            System.out.println("Girdiğiniz sayı çift sayıdır");
        }

        }
}

OUTPUT:

Girdiğiniz sayı çift sayıdır.

Aynı zamanda aynı if bloğu içerisinde birden fazla koşula bağlı kodlar da yazabiliriz. Bunun için else if bloğunu devreye sokabiliriz. Yukarıdaki örneği çift sayıların dışında tek sayılar girildiğinde de “Bu bir tek sayıdır.” cümlesini ekrana gösterecek şekilde güncelleyelim. Böylece bu örnek için 3 koşul yazmamız gerekecektir. Bunlardan ilki verilen sayının çift olduğu durumdur, ikincisi, sayının tek olduğu durumdur ve sonuncusu ise verilen sayının bu iki koşulu da sağlamayan bir sayı olması durumudur. Örneğin verdiğimiz sayı bir ondalıklı sayı olabilir. Bu durumda bu sayı için 3. koşul devreye girer. Örneği aşağıdaki kod bloğu ile inceleyelim.

INPUT: 

public class Main {
    public static void main(String[] args) {
        double A = -5.2;

        if (A % 2 == 0){
            System.out.println("Girdiğiniz sayı çift sayıdır.");
        } else if (A % 2 == 1 || A % 2 == -1) {
            System.out.println("Girdiğiniz sayı tek sayıdır.");
        }else{
            System.out.println("Girdiğiniz sayı tam sayı değildir!");
        }

    }
}

OUTPUT:

Girdiğiniz sayı tam sayı değildir!

else ifadesi, yazdığımız if ve else if bloklarının hepsinin False olduğu durumda devreye girer ve hiçbir koşulun sağlanmadığı durumlarda alması istenilen aksiyonları gerçekleştirir.

ifelse bloklarında eğer ki ilk if koşulu sağlanırsa, koşul sağlandığında gerçekleştirilecek işlemler gerçekleştirilir ve ifelse bloğundan çıkılır.  if koşulu sağlanmazsa, if bloğundan sonra varsa else if bloğu true ise çalıştırılır ancak false ise ve başka else if bloğu varsa o çalıştırılır. Hiçbir else if bloğu true olmazsa ve else bloğu varsa else bloğu çalıştırılarak program sonlandırılır. Yani ifelse blokları yukarıdan aşağı olacak şekilde ifelse if – else yolu izlenerek çalıştırılır.

if bloğunu çalıştırırken dikkat etmemiz gereken noktalardan biri de if’in yazılış şeklidir. Eğer ki “İf” ya da “İF” şeklinde yazacak olursak if bloğu çalışmaz ve çıktı olarak bize hata döndürür. Kod bloğunda “if” şeklinde yazılmalıdır.

INPUT:

public class Main {
    public static void main(String[] args) {
        int A = 3;
        int B = 5;
        int C = 7;

        if (A > B && A > C && B > C){
            System.out.println("En büyük değer : " + A + " Ortanca değer : " + B + " En küçük değer : " + C);
        } else if (A > B && A > C && C > B) {
            System.out.println("En büyük değer : " + A + " Ortanca değer : " + C + " En küçük değer : " + B);
        } else if (B > A && B > C && C > A) {
            System.out.println("En büyük değer : " + B + " Ortanca değer : " + C + " En küçük değer : " + A);
        } else if (B > A && B > C && A > C) {
            System.out.println("En büyük değer : " + B + " Ortanca değer : " + A + " En küçük değer : " + C);
        } else if (C > B && C > A && A > B) {
            System.out.println("En büyük değer : " + C + " Ortanca değer : " + A + " En küçük değer : " + B);
        }else{
            System.out.println("En büyük değer : " + C + " Ortanca değer : " + B + " En küçük değer : " + A);
        }

    }
}

OUTPUT:

En büyük değer : 7 Ortanca değer : 5 En küçük değer : 3

ifelse bloklarının dışında koşul blokları oluşturmak için switchcase bloklarını da kullanabiliriz.

Switch-Case Blokları

Eğer birden fazla koşul içeren kod blokları yazmak istersek ifelse blokları dışında switchcase kod bloklarını da kullanabiliriz. Bu kod bloklarının çalışma mantığı ifelse’e benzer olup sonucu true olan koşulun bloğu çalıştırıldıktan sonra blok sonlandırılır. Switchcase kullanımı aşağıdaki gibidir:

INPUT:

switch(expression) {

case x:

  //Koşul sağlandığında çalıştırılacak kod bloğu

case y:

  //Koşul sağlandığında çalıştırılacak kod bloğu

}

Switchcase kullanımı daha kolay anlayabilmek için aşağıdaki örneği inceleyebiliriz.

INPUT:

public class Main {
    public static void main(String[] args) {
        int gun = 4;
        switch(gun) {

            case 1:

                System.out.println("Pazartesi");
                break;

            case 2:

                System.out.println("Salı");
                break;

            case 3:

                System.out.println("Çarşamba");
                break;

            case 4:

                System.out.println("Perşembe");
                break;

            case 5:

                System.out.println("Cuma");
                break;

            case 6:

                System.out.println("Cumartesi");
                break;

            case 7:

                System.out.println("Pazar");
                break;
        }

    }
}

OUTPUT:

Perşembe

Birden çok koşulun dahil olduğu switchcase bloklarında bir koşul sağlandıktan ve sağlanan koşulun kod bloğu çalıştırıldıktan sonra, kod bloğundan çıkılmasını istersek break komutunu kullanabiliriz. Bu ifade ile birlikte blok içerisinde daha fazla kod çalıştırılmasının önüne geçebiliriz. Break komutunun kullanımına dair yukarıdaki örneği inceleyebiliriz.

Break komutunu bize kod bloğunun çalıştırılma süresinden kazanç sağlayabilir. Bunun sebebi sadece sonucu true olan koşulun kodunun çalıştırılmasından ve diğer blokların atlanmasından dolayıdır.

Break komutunun dışında switchcase bloklarında hiçbir koşulun sağlanmadığı durumlar için default anahtar kelimesini kullanabiliriz. Bu anahtar kelime, hiçbir koşul sağlanmadığında varsayılan olarak çalıştırılması istenen kod satırlarını içerebilir. default komutu switchcase bloklarının en sonunda kullanılırsa break komutu ile beraber çalıştırılmasına gerek yoktur. default komutunun kullanımına dair örneği aşağıda inceleyebilirsiniz.

INPUT:

public class Main {
    public static void main(String[] args) {
        String sehir = "Sivas";
        switch(sehir) {

            case "İstanbul":

                System.out.println("Marmara Bölgesi");
                break;

            case "İzmir":

                System.out.println("Ege Bölgesi");
                break;

            case "Antalya":

                System.out.println("Akdeniz Bölgesi");
                break;

            case "Samsun":

                System.out.println("Karadeniz Bölgesi");
                break;

            default:

                System.out.println("Girmiş olduğunuz şehir başka bir bölgeye aittir.");
                break;
        }

    }
}

OUTPUT:

Girmiş olduğunuz şehir başka bir bölgeye aittir.

ifelse ve switchcase dışında kısa koşul ifadeleri ile de koşul blokları oluşturmamız mümkündür. Önceki yazılarımızda da bahsettiğimiz bu yöntemin kullanılışı aşağıdaki gibidir:

degisken = (kosul) ? dogruİfade :  Yanlısİfade;

Yukarıda da görüldüğü gibi bu ifade üç işlenenden oluştuğundan üçlü operatör olarak da isimlendirilebilir.

INPUT:

public class Main {
    public static void main(String[] args) {
     //degisken = (kosul) ? dogruİfade :  Yanlısİfade;

        String kelime1 = "Edirne";
        String kelime2 = "Ankara";

        String degisken = (kelime1.length() == kelime2.length()) ? ("İki kelimenin uzunluğu aynıdır.") : ("İki kelimenin uzunluğu aynı değildir.");
        System.out.println(degisken);

    }
}

OUTPUT:

İki kelimenin uzunluğu aynıdır.

Bu yazımızda sizlere JAVA’da kullanabileceğimiz koşul bloklarından bahsettim. Bir sonraki yazımızda JAVA’dan bahsetmeye devam edeceğiz.

JAVAVBZ0921LHO19WO
Java’da Operatörler

Bu yazıda sizlere JAVA’da kullanılan operatörlerden bahsedeceğim. Genel olarak yazı içerisinde mantıksal, aritmetiksel, koşul, atama ve karşılaştırma operatörlerine ve örneklerine değineceğim.

Operatörler

Operatörler, JAVA’da pek çok işlem esnasında kullanabileceğimiz ifadelerdir. Operatörler sayesinde matematiksel işlemler, değişkenlerin sahip olduğu değerleri karşılaştırma işlemi veya mantıksal işlemleri gerçekleştirebiliriz.

JAVA’da operatörleri aşağıdaki gibi ifade edebiliriz:

  • Mantıksal Operatörler
  • Aritmetik Operatörler
  • Karşılaştırma Operatörleri
  • Atama Operatörleri

Yukarıda yer alan operatör grupları içerisindeki operatörleri tablolar halinde ifade edeceğiz. Ardından operatörlerin kullanımlarına ilişkin örnekleri inceleyeceğiz.

Karşılaştırma Operatörleri

Karşılaştırma Operatörleri iki değeri karşılaştırmak için kullanılır. Aşağıdaki tabloda karşılaştırma operatörlerini görebilirsiniz.

OperatörAçıklama
==Eşittir
!=Eşit değil
Büyüktür
Küçüktür
>=Büyük ya da eşit
<=Küçük ya da eşit

Yukarıdaki tabloda yer alan karşılaştırma operatörlerini kullandığımızda çıktı olarak True ya da False ifadelerini görürüz. Bu yaptığımız karşılaştırmanın doğru olduğunu ya da yanlış olduğunu ifade eder. Örnek vermek gerekirse girdi olarak 6 > 7 ifadesini verirsek çıktı olarak False değerini alırız. Bu 6’nın 7’den büyük olmadığını ifade eder.

Tabloda yer alan operatörlerin kullanımlarına ilişkin örnekler aşağıdaki gibidir:

INPUT:

public class Main {
    public static void main(String[] args) {
        int sayi1 = 5;
        int sayi2 = 1;

        System.out.println(sayi1==sayi2);
        System.out.println(sayi1!=sayi2);
        System.out.println(sayi1>sayi2);
        System.out.println(sayi1<sayi2);
        System.out.println(sayi1>=sayi2);
        System.out.println(sayi1<=sayi2);
    }
}

OUTPUT:

false
true
true
false
true
false

Atama Operatörleri

JAVA’da bir değişkene değer atamak için atama operatörlerini kullanılır. Sol tarafta yazılan değişkene sağ tarafta yazılan değer atanır. Başlıca atama operatörleri tablodaki gibidir:

OperatörÖrnekAçıklama
=x = 10x’e 10’u atar.
+=x += 10x’e 10 ekler.
-=x -= 10x’ten 10 çıkarır.
*=x *= 10x’i 10 ile çarpar.
/=x /= 10x’i 10’a böler.
%=x %= 10x’in 10 ile bölümünden kalanı x’e atar.
INPUT:

public class Main {
    public static void main(String[] args) {
        int sayi1 = 10;

        System.out.println(sayi1 += 10);
        System.out.println(sayi1 -= 10);
        System.out.println(sayi1 *= 10);
        System.out.println(sayi1 /= 10);
        System.out.println(sayi1 %= 10);

    }
}

OUTPUT:

20
0
100
1
0

Aritmetiksel Operatörler

Aritmetiksel operatörler, çoğunlukla matematiksel işlemleri gerçekleştirmek için kullanılan operatörlerdir. Bunun dışında string ifadelerin toplanması gibi işlemlerde de aritmetiksel operatör kullanılabilir. Aritmetiksel operatörleri aşağıdaki tabloda görebiliriz.

OperatörİsimKullanımı
+Toplamaa + b
Çıkartmaa – b
*Çarpmaa * b
/Bölmea / b
%Mod Almaa % b
INPUT:

public class Main {
    public static void main(String[] args) {
        int sayi1 = 4;
        int sayi2 = 2;

        System.out.println(sayi1 + sayi2);
        System.out.println(sayi1 - sayi2);
        System.out.println(sayi1 * sayi2);
        System.out.println(sayi1 / sayi2);
        System.out.println(sayi1 % sayi2);
        }
}

OUTPUT:

6
2
8
2
0

Mantıksal Operatörler

Mantıksal operatörler sayesinde birden fazla koşulun dahil olduğu kod blogları yazabiliriz. Bu operatörler kullanıldığında sonuç olarak True ya da False değerleri döner. Döngülerde ya da ifelse bloklarında mantıksal operatörler sıklıkla kullanılır. Aşağıdaki tablo ile mantıksal operatörleri inceleyebiliriz.

OperatörİsmiAnlamıKullanımı
&&Ve operatörüİki ifade doğruysa True döndürür.A > 5 && A < 10
||Veya operatörüİki ifadeden biri doğruysa True döndürür.A > 5 || A < 10
!Değil operatörüMantıksal durumu tersine çevirir. True ise False döndürür.not(A > 5 && A < 10)
INPUT:

public class Main {
    public static void main(String[] args) {
        int A = 4;
        int B = 2;

        System.out.println(A > 5 && B < 10);
        System.out.println(A > 5 || B < 10);
        System.out.println((!(A > 5 && B < 10)));

        }
}

OUTPUT:

false
true
true

Burada bahsettiklerimizin dışında ifelse bloklarını içermeden nasıl koşul ifadesi içeren kodlar yazabileceğimizden bahsedelim.

JAVA’da yazdığımız kodların belli koşullara göre farklı sonuçlar vermesini ya da farklı işlemler gerçekleştirmesini isteyebiliriz. Bu gibi durumlar ifelse bloklarının dışında koşul operatörlerini kullanabiliriz.

Koşul içeren bir ifadeyi aşağıdaki gibi yazabiliriz:

degisken = (kosul) ? (kosul sonunda True yapılması istenen) : (kosul sonunda False yapılması istenen)

Koşul ifadeleri sayesinde kodumuzu belli şartlara ya da verilere göre çalışabilir hale getirebiliriz. İstenen ya da istenmeyen şartlar altında kodlarımız kullanıcıya nasıl tepki vermesi gerektiğini belirleyebiliriz. Bunların dışında koşul ifadeleri ile birlikte daha büyük ve kompleks kod blokları oluşturabiliriz.

INPUT:

public class Main {
    public static void main(String[] args) {
        int A = 4;
        int B = 2;
        String sonuc = (A > 5 && B < 10) ? ("Bu kosul doğrudur"):("Bu kosul yanlıştır.");
        System.out.println(sonuc);


        }
}

OUTPUT:

Bu kosul yanlıştır.

Bir sonraki yazılarımızda Java’da gerçekleştirilen işlemlerden bahsetmeye devam edeceğiz.

JAVA3N3AQ4SI94U18Z
Java’da Veri Tipleri Ve String Fonksiyonları

Bu yazıda sizlere JAVA’da değişkenleri tanımlarken kullanabileceğimiz veri tiplerinden bahsedeceğim. Genel olarak yazı içerisinde ilkel ve ilkel olmayan veri tiplerinin neler olduğundan bahsedeceğim ve ardından birkaç örnek ile nasıl kullanılabileceklerini göstereceğim.

JAVA’da veri tipleri ikiye ayrılır. Bunlardan ilki JAVA’da varsayılan olarak gelen veri tipleridir. Bu veri tiplerine ilkel veri tipleri denir.

JAVA’da kullanılabilen diğer veri tipleri ise kullanıcı tarafından tanımlanabilen ilkel olmayan veri tipleridir.

Değişkenleri tanımlarken değişkenin veri tipini mutlaka belirtmemiz gerekir. Ayrıca bir değişken hangi veri tipinde tanımlanmışsa o veri tipinde değer ataması gerçekleştirilmelidir. Aksi takdirde programımız çalıştığında hata alacaktır.

İlk olarak JAVA’da varsayılan olarak gelen ilkel veri tiplerinden bahsedelim.

İlkel Veri Tipleri

JAVA’da ilkel olan 8 tane veri tipi vardır. Bunlar byte, short, int, long, float, double, boolean ve char’dır.

Byte: -128’den 127’e kadar olan tamsayıları saklar. Bellek’te 1 bayt boyutunda yer kaplar. byte anahtar kelimesi ile kullanılır.

byte sayi = 2;

Short: -32,768’den 32,767 kadar olan tam sayıları saklar. Bellek’te 2 bayt boyutunda yer kaplar. short anahtar kelimesi ile kullanılır.

short sayi = 30000;

integer: -2,147,483,648’den 2,147,483,647 kadar olan tam sayıları saklar. Bellek’te 4 bayt boyutunda yer kaplar. int anahtar kelimesi ile kullanılır.

int sayi = 50;

long: -9,223,372,036,854,775,808’den 9,223,372,036,854,775,807 kadar olan tam sayıları saklar. Bellek’te 8 bayt boyutunda yer kaplar. Long veri tipindeki bir değişkene değer atanırken değerin sonuna ‘L’ eklenmelidir. long anahtar kelimesi ile kullanılır.

Long sayi = 50L;

float: Ondalık sayıları saklamak için kullanılır. 1.4×10^-45 ile 3.4×10^38 aralığında bir değer tanımlanabilir. Float veri tipindeki bir değişkene değer atanırken değerin sonuna ‘f’ eklenmelidir. Bellek’te 4 bayt boyutunda yer kaplar. float anahtar kelimesi ile kullanılır.

float sayi = 36.70f;

Double: Ondalık sayıları saklamak için kullanılır. 4.9×10^-324 ile 1.8×10^308 aralığında bir değer tanımlanabilir. Bellek’te 8 bayt boyutunda yer kaplar. Double veri tipindeki bir değişkene değer atanırken değerin sonuna ‘d’ eklenmelidir. double anahtar kelimesi ile kullanılır.

double sayi = 36.7054354d;

Boolean: Mantıksal bir veri tipi olan boolean, True ve False olmak üzere iki değere sahiptir. Mantıksal olarak doğru olan duruma True, yanlış olan duruma ise False değeri karşılık gelir. boolean anahtar kelimesi ile kullanılır. Bellek’te 1 bit boyutunda yer kaplar.

boolean statu = true;

Char: Verilen herhangi bir karakterin kendisini ya da ASCII tablosunda karşılık gelen değerini saklamak için kullanılan veri tipidir. Bellek’te 2 bayt boyutunda yer kaplar. char anahtar kelimesi ile kullanılır.

char karakter = ‘C’;

char karakter = 65;

Buraya kadar ki bölümde ilkel veri tiplerinden ve örneklerinden bahsettik. Şimdi ise ilkel olmayan veri tiplerinden bahsedelim.

Java’da tanımladığımız değişkenlerin veri tiplerini öğrenmek için .getClass() metodunu ya da instanceOf ifadesini kullanabiliriz. Böylelikle tanımladığımız değişkenlerin sınıflarını görebiliriz. Örnek kullanım aşağıdaki gibidir:

INPUT:

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       System.out.println(dize.getClass());
    }
}

OUTPUT:

class java.lang.String
INPUT:

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       System.out.println(dize instanceof String);
    }
}

OUTPUT:

true
İlkel Olmayan Veri Tipleri

Daha öncede bahsettiğim gibi ilkel olmayan veri tipleri JAVA’da tanımlı olmayan programcı tarafından tanımlanan veri tipleridir.  Bu veri tiplerinin örnekleri aşağıdaki şekildeki gibidir:

İlkel Olmayan Veri Tipleri

Biz bu yazımızda sadece String veri tipinden bahsedeceğiz. Diğer başlıklara sonraki yazılarımızda değineceğiz.

String: String, çift tırnak içerisine yazılabilen bir ya da daha fazla harf, sayı veya özel karakterlerden oluşan bir dizidir. Tırnaklar arasına yazılan her karakter dizenin bir parçasıdır.

String dize = “Merhaba”;

JAVA’da String, dizeler üzerinde belirli işlemleri gerçekleştirebilen metodları içeren bir nesnedir. Bu sebeple string ifadeler üzerinde bazı fonksiyonları kullanarak işlemler gerçekleştirebiliriz.

String Fonksiyonları

length() Fonksiyonu : String ifadeler içerisindeki karakter sayısını bulmak için kullanılan fonksiyondur.

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       System.out.println(dize.length());
    }
}

toUpperCase() Fonksiyonu: String ifadeler içerisindeki tüm karakterleri büyük olarak yazmak için kullanılır.

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       System.out.println(dize.toUpperCase());
    }
}

toLowerCase() Fonksiyonu: String ifadeler içerisindeki tüm karakterleri küçük olarak yazmak için kullanılır.

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       System.out.println(dize.toLowerCase());
    }
}

indexOf Fonksiyonu: IndexOf fonksiyonu belirtilen ifadenin string içerisinde geçtiği ilk konumu bulmak için kullanılır. Çıktı olarak metnin string içerisinde başladığı index numarasını döndürür. Index numarasını sayarken boşluklarda dahil edilir.

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       System.out.println(dize.indexOf("a"));
    }
}

contains() Fonksiyonu: İçerisine yazdığımız karakterin ya da karakter grubunun string içerisinde var olup olmadığını sorgular. Çıktı olarak True ya da False döndürür.

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       System.out.println(dize.contains("a"));
    }
}

endsWith() Fonksiyonu: String ifadenin belirtilen karakter ya da karakter grupları ile bitip bitmediğini sorgular. Çıktı olarak True ya da False döndürür.

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       System.out.println(dize.endsWith("a"));
    }
}

equals() Fonskiyonu : İki string ifadeyi karşılaştırmak için kullanılır. Eğer string ifadeler eşitse True değilse False döndürür.

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       String dize1 = "Dünya";
       System.out.println(dize.equals(dize1));
    }
}

isEmpty() Fonksiyonu: Bir string ifadenin içerisinin boş olup olmadığını sorgulamak için kullanılır. Çıktı olarak True ya da False döndürür.

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       System.out.println(dize.isEmpty());
    }
}

replace() Fonksiyonu: Cümle içerisindeki bir karakteri ya da kelimeyi istenilen karakter veya kelime ile değiştirmek için kullanılan fonksiyondur.

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       System.out.println(dize.replace("e","a"));
    }
}

startsWith() Fonksiyonu: String ifadenin belirtilen karakter ya da karakter grupları ile başlayıp başlamadığını sorgular. Çıktı olarak True ya da False döndürür.

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       System.out.println(dize.startsWith("a"));
    }
}

trim() Fonksiyonu: String ifade içerisindeki sağdan ve soldan boşlukları silmek için kullanılır.

public class Main
{
    public static void main(String[] args) {
       String dize = " Merhaba ";
       System.out.println(dize.trim());
    }
}

concat() Fonksiyonu: İki string ifadeyi birleştirmek için kullanılan fonksiyondur.

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       String dize1 = " Dünya";
       System.out.println(dize.concat(dize1));
    }
}

İki veya daha fazla string ifadeyi birleştirmek için concat() fonksiyonunun dışında “+” operatörü de kullanılabilir.

public class Main
{
    public static void main(String[] args) {
       String dize = "Merhaba";
       String dize1 = "Dünya";
       System.out.println(dize + " " + dize1);
    }
}

İlkel veri tipleri ile ilkel olmayan veri tiplerinden bahsettiğimize göre şimdi bu iki grubun arasındaki farklara göz atalım.

İlkel Veri Tipleri İle İlkel Olmayan Veri Tipleri Arasındaki Farklar

İlkel veri tipleri ile ilkel olmayan veri tipleri arasındaki temel farklara aşağıdaki tablodan göz atabiliriz.

İlkel Veri Tipleriİlkel Olmayan Veri Tipleri
Java’da tanımlıdır.Kullanıcı tarafından tanımlanır.
Boş değer alamaz.Boş değer alabilir.
Boyutu veri türüne bağlıdır.Tümü aynı boyuta sahiptir.
Küçük harf ile başlar.Büyük harfle başlar.

Bu yazımızda JAVA’daki ilkel ve ilkel olmayan veri türlerinden bahsedip örnek kullanımlarını gördük. Aynı zamanda ilkel ve ilkel olmayan veri türleri arasındaki farkları da incelemiş olduk. Bir sonraki yazımızda JAVA’dan bahsetmeye devam edeceğiz.

JAVAG33L1R9L08D32S
Java ile Temel Programlama #2

Bu yazımızda sizlere JAVA’da temel ifadelerden bahsetmeye devam edeceğim. Genel olarak yazı içerisinde yorum satırları, kaçış ifadeleri, değişkenler ve veri tiplerinden bahsedeceğim.

Java’da yazdığımız her ifadenin derleyici tarafından kod olarak algılanması istemeyiz. Bunun nedeni yazdığımız kodun ya da yaptığımız işlemlerin, kodu okuyanlar tarafından daha iyi bir şekilde anlaşılması için yorumlar eklemek isteyebiliriz. Bu gibi durumlar için JAVA bizlere yorum satılarını kullanma imkanı sunar. Bir ya da daha fazla satırı yorum satırı olarak işaretlediğimizde derleyici tarafından o satırların kod olarak değerlendirilmemesini sağlarız.

Yorum satırları kod yazarken herhangi bir anda kullanılabilir. Bu kullanma sıklığı kodu yazan kişiye bağlıdır. Herhangi bir hazır fonksiyonun detaylarını incelediğinizde ya da orta-büyük projelere göz attığınızda yorum satılarının sıklıkla kullanıldığını görebilirsiniz.

JAVA’da Yorum Satırları

Programlama dillerine göre yorum satılarının kullanım şekillleri değişebilir. JAVA’da yorum satırının 3 farklı kullanım şekli vardır. Bunlardan ilki tek satırlık yorum satırı oluşturmak için kullanılan // işaretidir. Bu işareti kullandığımız satır farklı bir renkte yorum satırı olarak gözükür. Buraya Türkçe karakter içeren ifadelerde yazılabilir. Tek satırlık yorum satırı örneği aşağıdaki gibidir:

public class HelloWorld{

     public static void main(String []args){
      //Bu bir yorum satiridir.
     }
}

Eğer ki birden fazla satırı kullanarak kodumuzu açıklamak istersek /* … */ ifadelerini kullanabilir. /* ile başlayan ve */ ile biten satırlar arasına istediğimiz şekilde açıklamalar yazabilir. Bu yazılan açıklamalarda derleyici tarafından kod statüsüne alınmaz. Yukarıdaki tek satırlık yorum satırında olduğu gibi bu alanlara da Türkçe karakterli ifadeler yazılabilir. /* … */ ifadesinin kullanım örneği aşağıdaki gibidir:

public class HelloWorld{

     public static void main(String []args){
      /*
      Bu bir yorum satırıdır.
      
      Bu da bir yorum satırıdır.
      
      Bu da yorum satırıdır.
      
      */
      
     }
}

Son olarak /** … */ ifadesinden bahsedelim. Bu ifade genel olarak kod içi dökümantasyon amacıyla kullanılır. Uygulamalar yazıldıktan sonra raporlamaları yapılır. Kod geliştirmesi yapılırken kullanılan bu ifadeler arasına yazılan açıklamalar, özel etiketler içerebilirler. Kullanılan özel etiketleri tanıyan uygun bir araç vasıtasıyla bu açıklamalar dökümantasyonlara dönüştürülebilir. Bu dökümantasyonlar raporlar arasına eklenerek yazılım geliştiren ekibin rapor yükünü hafifletir.

/** … */ ifadesi içerisinde kullanılabilecek bazı özel etiketler aşağıdaki tabloda verilmiştir.

EtiketAçıklamaKullanış Şekli
@authorSınıfı oluşturan kişiyi ifade eder.@author yazar adı
{@code}Yazılan kodun derleyici tarafından kod olarak değerlendirilmeden kullanım örneğini vermek için kullanılır.{@code …}
@exceptionDökümantasyona, yazılan kodun istisnai durumlarını yazmak ve açıklamak için kullanılır.@exception istisnai durum
@paramKullanılan parametreleri ve bu parametlerin açıklamaları için kullanılır.@param parametre ismi – açıklaması
@returnKullanılan metodlardan döndürülen ifadelerin açıklaması için kullanılır.@return açıklama
@seeHerhangi başka bir ifadeyi referans göstermek için kullanılır. Örneğin başka bir metot.@see referans
@sinceDökümantasyonda, oluşturulan ifadeler için tarih bilgisi eklenilmesinde kullanılır.@since tarih
@versionOluşturulan dökümantasyonlara versiyon bilgisi eklemek için kullanılır.@version versiyon numarası
/**
* @author  Erhan Eskin
* @version 1.0
* @since   01-01-2022
*/

public class OrtalamaHesaplama{
    /** 
    *Bu sinif icerisinde tanimlayacagimiz uc degisken ile
    *degiskenlere atadigimiz degerleri toplayip
    * toplam degisken sayisina bolecegiz
    * bu islemi simdilik statik olarak gerceklestirecegiz
    * @param sayi1 bizim ilk degiskenimiz olacak
    * @param sayi2 bizim ikinci degiskenimiz
    * @param sayi3 bizim ucuncu degiskenimiz
    * @param toplam bizim dorduncu degiskenimiz
    * @param ortalama bizim besinci degiskenimiz
    * bu islemlerin ardindan sonuc olarak
    * @return ortalama ifadesini ekranda gorecegiz
    * 
    */ 
    
    public int ortalamaHesaplama (int sayi1, int sayi2, int sayi3) {
            int toplam,ortalama;
            toplam = sayi1 + sayi2 + sayi3;
            ortalama = toplam / 3;
            return ortalama;
   }


    public static void main(String[] args) {
        int hesap1;
        OrtalamaHesaplama nesne = new OrtalamaHesaplama();
        hesap1 = nesne.ortalamaHesaplama(20,30,40);
        System.out.println("ortalama :" + hesap1);
    }
}

Kodlama yaparken kullanabileceğimiz yorum satırlarımızdan bahsettiğimize göre şimdi kaçış operatörlerinden bahsedelim.

JAVA’da Kaçış Operatörleri

JAVA’da kullanılabilen kaçış operatörlerinden bazılarını aşağıdaki tablodan inceleyebilirsiniz.

Kaçış OperatörüAçıklaması
\tBir tab boşluğu ekler.
\nBir satır aşağı atlar.
\rSatır başı ekler.
\fSayfa sonunu belirtir.
\’Tek tırnak ekler.
\’’Çift tırnak ekler
\\Ters eğik çizgi ekler.

JAVA’da kaçış operatörlerini kullanarak yazdığımız kodların okunabilirliğini artırabiliriz. Kaçış operatörlerinin kullanımlarına ait örnek aşağıdaki gibidir:

INPUT:

public class Main
{
    public static void main(String[] args) {
        System.out.println("Bu bir\ndeneme boşluğudur");
    }
}

OUTPUT:

Bu bir
deneme boşluğudur
INPUT:

public class Main
{
    public static void main(String[] args) {
        System.out.println("Bu bir\tdeneme boşluğudur");
    }
}

OUTPUT:

Bu bir	deneme boşluğudur

Bu yazımızın son bölümünde değişkenler ve veri tiplerinden bahsederek yazımızı sonlandıralım.

JAVA’da Değişkenler Ve Veri Tipleri

Değişken (variable), girdiğimiz ya da atadığımız bazı değerlerin geçiçi olarak hafızada saklanması için oluşturulan alanlara denir. Bir değişkene herhangi bir değer atamak için “ = ” ifadesi kullanılır. Örnek olarak:

int deger = 4

Değişkenler sayesinde kullanacağımız ifadeleri hafıza saklar ve gerektiği durumlarda kullanırız. Bir değişken tanımlanırken belirtilen veri tipindeki değerleri saklayabilir. Örneğin int olarak tanımladığımız bir değişkene string(dize) bir değer ataması gerçekleştirirsek program bize çıktı olarak hata verir. Böyle durumlarda yazdığımız programımız basit bir sebepten dolayı kesintiye uğramış olur.

Eğer tanımlamış ve değer atamış olduğumuz bir değişkene tekrar değer ataması yapılırsa son atanan değer o değişkenin değeri olur.

JAVA’da değişkenlerin tanımlabileceği farklı veri tipleri vardır. Bu veri tipleri JAVA’da varsayılan olarak gelen ilkel veri tipleri olabilirken kullanıcının kendi tanımlayabileceği veri tipleri de olabilir. İlkel veri tiplerinin her zaman bir değeri vardır. İlkel olmayan veri tipleri boş olarak tanımlanabilir.

Bunların dışında ilkel veri tiplerinin boyutları veri tipine göre değişikleri gösterirken ilkel olmayan veri tiplerinin boyutları aynıdır.

JAVA’da değişken aşağıdaki gibi tanımlanabilir:

veri tipi değişken adı = deger

Aşağıdaki tabloda JAVA’da var olan 8 ilkel veri tipini inceleyebilirsiniz.

Veri TipiBoyutAçıklama
byte1 bayt-128’den 127 kadar olan tam sayıları saklar.
short2 bayt-32,768’den 32,767 kadar olan tam sayıları saklar.
int4 bayt-2,147,483,648’den 2,147,483,647 kadar olan tam sayıları saklar.
long8 bayt-9,223,372,036,854,775,808 ile 9,223,372,036,854,775,807 aralığında olan tam sayıları saklar.
float4 baytOndalık sayıları saklamak için kullanılır. 1.4×10^-45 ile 3.4×10^38 aralığında bir değer tanımlanabilir.
double8 baytOndalık sayıları saklamak için kullanılır. 4.9×10^-324 ile 1.8×10^308 aralığında bir değer tanımlanabilir.
boolean1 bitTrue ya da False adında mantıksal bir değer saklamak için kullanılır.
char2 baytHerhangi bir karakterin ASCII tablosundaki değerini saklar.

Yukarıdaki tabloyu incelediğimizde JAVA’da var olan ilkel veri tiplerini özetle incelemiş olduk. Bir sonraki yazımızda JAVA’da var olan bu ilkel veri tiplerinde örneklerden ve ilkel olmayan veri tiplerinden bahsedeceğiz. Bir sonraki yazıya buradan erişebilirsiniz.

JAVAECWJQP43S6OG9J
Java ile Temel Programlama #1

Bu yazımızda sizlere pek çok alanda kullanılan ve popüler bir programlama dili olan Java’dan bahsedeceğim. Genel olarak yazı içerisinde Java’nın ne olduğundan, nerelerde kullanılabildiğinden, yazım ve isimlendirme kurallarından bahsedeceğim. Son olarak da Java ile ilk kodumuzu yazarak yazımızı sonlandıracağım. O halde Java’nın ne olduğundan ve nerelerde kullanabileceğinden bahsetmeye başlayalım.

Java Nedir ve Nerelerde Kullanılabilir?

James Gosling

Java 1995 yılından çıkış yapan ve Sun Microsystems mühendislerinden James Gosling tarafından geliştirilen açık kaynak kodlu, nesne yönelimli ve yüksek seviyeli bir programlama dilidir. Java’yı Windows, MAC OS ve UNIX gibi işletim sistemlerinde kullanmak mümkündür. Syntax, üzerinde çalıştığımız programlama dilinin kendine has program yapısını ve bu yapının kurulmasında kullanılan kuralları ifade eder. Java’nın söz dizimi yapısı C/C++’a benzerdir. Bunun sebebi Gosling’in, programcılar için Java’nın kolay öğrenilebilen bir dil olmasını sağlamak istemesiydi.

Gosling, Java projesini ilk olarak 1991 yılında İnteraktif televizyonlar için geliştirmeye başlamıştı. Java’ya ilk olarak OAK ismini vermişti. Bu isim Gosling’in ofisinin yanında bulunun bir meşe ağacından gelmekteydi. Daha sonralarında ise projenin ismi Green olsa da son olarak Java ismini aldı.

Java’nın şu anda kullanılan en güncel sürümü 22 Mart 2022 tarihinde yayınlanan Java SE 18’dir.

Java kodlarını kullanarak program yazabilmek için IDE’lere ihtiyaç duyarız. Bir IDE (Integrated Development Environment, Tümleşik Geliştirme Ortamı), yazılım geliştirme için bilgisayar programcılarına kapsamlı olanaklar sağlayan bir yazılım uygulamasıdır. Java için Eclipse ve IntelliJ IDEA gibi ücretsiz IDE’ler kullanabiliriz. Bu IDE’leri indirmek ve bilgisayarınıza kurmak için resmi sayfalarını ziyaret edebilirsiniz.

Java Kullanım Alanları

Java programlama dilini kullanarak mobil, web ve masaüstü uygulamalar geliştirmek mümkündür. Günümüzde telefon, tablet ve bilgisayarlardan oynayabildiğimiz oyunlarda Java ile yazılabilir. Örnek olarak, popüler oyunlardan biri olan Minecraft, Java ile yazılmıştır. Bunlar dışında bilimsel uygulamaların yazımında, büyük veri teknolojilerinde, gömülü sistemlerde ya da finans uygulamalarında Java kullanmak mümkündür. Tabii ki bu alanlar için farklı programlama dilleri de mevcut fakat Java da bu alanlarda kullanılabilen programlama dillerinden biridir.

Java’da Yazım ve İsimlendirme Kuralları

Yazım Kuralları

Java’da var olan yazım kuralları aşağıdaki gibidir:

  • Değişken isimleri rakamlar ile başlayamaz.
  • Türkçe karakter metin ifadeleri dışında kullanılamaz.
  • Var olan fonksiyon veya özel isimler değişken ismi olarak tanımlanamaz.
  • Değişken isimleri birden fazla kelimeden oluşuyorsa arada boşluk kullanılamaz. Bu durumda araya ‘_’ eklenebilir ya da kelimeler birleştirilebilir.
  • Java küçük-büyük harfe duyarlı bir dildir. Örneğin ‘degisken’ isimli değişken ile ‘Degisken’ isimli bir değişken aynı değildir.
  • Bir değişken tanımlanırken önce değişkenin veri tipi ardından değişken ismi yazılmadır.
  • Komutların sonuna ‘ ; ’ ifadesi eklenir.
  • Değişken isimleri rakam ile başlamadığı taktirde kelime içerisinde rakam kullanılabilir.
  • Sınıf ismi yazılırken uyulması gereken kurallar, değişken tanımlanırken kullanılması gereken kurallar ile aynıdır.

İsimlendirme Kuralları

Java’da değişkenler, metotlar, sınıflar ve sabit değerler için isimlendirme kuralları vardır. Bu kurallara uyulmadığında program hata vermez ancak bu kurallar sayesinde okunabilirlik artar. Bu isimlendirme kurallarında kullanılan isimlendirme türlerini inceleyelim.

Upper Camel Case: Birden çok kelimenin bir araya gelerek oluşturduğu birleşik kelimedeki her bir kelimenin ilk harfinin büyük olması kuralıdır. Örneğin;

BirlesikKelime

Lower Camel Case: Birden çok kelimenin bir araya gelerek oluşturduğu birleşik kelimedeki ilk kelime hariç diğer kelimelerinin ilk harflerinin büyük olması kuralıdır. Örneğin;

birlesikKelime

Snake Case: Birden çok kelimenin bir araya gelerek oluşturduğu birleşik kelimelerin her birinin ‘_’ ile birbirine bağlanması kuralıdır. Kendi içerisinde Lower Snake Case ve Upper Snake Case olarak ikiye ayrılır.

Lower Snake Case Örneği; birlesik_kelime

Upper Snake Case Örneği; Birlesik_Kelime

Screaming Snake Case: Birden çok kelimenin bir araya gelerek oluşturduğu birleşik kelimelerin her birinin ‘_’ ile birbirine bağlandığı ve her bir kelimenin her harfinin büyük yazıldığı kuralıdır. Örneğin;

BIRLESIK_KELIME

Aşağıdaki tabloyu inceleyerek değişkenler, metotlar, sınıflar ve sabit değerler için isimlendirme kurallarını görebilirsiniz.

TürKuralÖrnek
SınıfUpper Camel Casepublic class ClassName{}
DeğişkenLower Camel CasevariableName
MetotLower Camel Casepublic int numberOfClasses{}
Sabit DeğerScreaming Snake Casefloat VALUE_OF _PI

Java’da isimlendirme kurallarının da neler olduğunu öğrendiğimize göre artık ilk çalışan programımızı yazabiliriz. İlk çalışan programımız, programlama dili öğrenirken adeta klasikleşen ekrana ‘Merhaba Dünya’ yazdırmak olsun.

Java’da Ekrana Veri Gösterme

Java’da ekrana çıktı bastırmak için ‘system.out.println()’ komutu kullanılabilir. Bu komutun içerisine yazacağımız herhangi bir değeri program çalıştırıldığında çıktı ekranında görürüz.

Burada bir diğer önemli nokta ise bu komutlarımızı Java’da nereye yazmamız gerektiğidir. Programı çalıştırdığımız anda bu komutlar okunmalı ve bize çıktı olarak istediğimiz değerler yansımalıdır. Bunun için aşağıdaki görsele göz atalım.

public class ClassName {
    public static void main(String[] args) {
        System.out.println("Merhaba Dünya");
   }
}

Kod bloğunda da görüldüğü gibi kodlar Java’da sınıf içerisine yazılır. Main metodu ise program çalıştığı anda çalıştırılan bir metottur. Main metodunun içerisine gövde (body) adı verilir. Kodumuzu bu main metodunun gövdesinin içerisine yazarak program çalıştırıldığı anda system.out.println() komutunu çalıştır demiş olduk. Buraya yazdığımız kod derleyici tarafından yorumlandıktan sonra bize çıktı olarak gösterilir.

System.out.println() komutu ile ekrana pek çok veriyi çıktı olarak gösterebilir, değişken sonuçlarını yansıtabilir veya matematiksel sonuçları yazdırabiliriz.

public class ClassName {
    public static void main(String[] args) {
      int deger = 8;  
      System.out.println("Sayinin degeri : " + deger);
   }
}
public class ClassName {
    public static void main(String[] args) {
      int sayi1 = 8;
      double sayi2 = 1.2;  
      System.out.println("Toplam Deger : " + (sayi1 + sayi2));
   }
}

Bu yazımızda sizlere Java’da temel bilgilerden bahsettim. Bir sonraki yazımızda Java’da yorum satırlarından, kaçış karakterlerinden, değişken ve veri tiplerinden bahsedeceğiz. Bir sonraki yazıya buradan erişebilirsiniz.

JAVASWO142JCV14919

Matlab’de Matematiksel İşlemler

Bu yazıda sizlere limit, türev, integral ve diferansiyel denklemlerin Matlab’de nasıl çözüldüğünden bahsedeceğim.

Matlab’de Limit

Matematikte çok önemli bir yere sahip olan limit problemlerini Matlab’de çözmek mümkündür. Bunun için limit() komutunu kullanmamız gerekir. Komutun içerisine yazmamız gereken fonksiyon sembolik nesnelerden oluşmalıdır. Eğer sembolik nesne ile ilgili herhangi bir fikriniz yoksa buradan bir önceki yazımızı okumanızı tavsiye ederim. Komutun kullanılışı,

limit(fonksiyon,değişken,değer,left-right)

şeklindedir. Burada eğer fonksiyonumuz x değişkenine bağlı ise değişken yerine x yazılır. x değişkeninin yaklaşmaya çalıştığı değer b ise  değer yerine b yazılmalıdır. Eğer ki b değerine b+(sağdan) ya da b(soldan) yaklaşıyorsak left veya right değerlerinden biri yazılmalıdır.

    \[lim_{x\to b^+}f(x)\]

ifadesinin limitini bulmak için komut satırına limit(f(x),x,b,right) ifadesi yazılmalıdır. Eğer değer yerine herhangi bir şey yazılmaz ise 0 olarak kabul edilir.

Limit x→∞ ise değer yerine inf, x→-∞ ise –inf yazılmalıdır.  Böylece limit bulunmuş olacaktır. Birkaç örnek yapalım.

Örnekler

    \[lim_{x \to \infty}\frac{7^{2x+1}-49.7^{x+3} }{49^{x-1}+77 }    =?\]

INPUT:
 >> syms x;
 >> f = (7^(2*x+1) - 49*(7^(x+3)))/(49^(x-1) + 77);
 >> sonuc = limit(f,x,inf);
 >> sonuc
 OUTPUT:
 sonuc =
  343 

    \[lim_{x \to {0}^{-}}\frac{9x}{|x|} =?   \hspace{3em} lim_{x \to 1}\frac{3x^2-3}{x-1} =? \]

 INPUT:
 >> syms x;
 f1 = (9*x)/abs(x);
 >> sonuc1 = limit(f1,x,0,'left');
 >> sonuc1
 OUTPUT:
 sonuc1 =
 -9 

INPUT:
>> syms x;
>> f2 = (3*(x^2) - 3)/ (x-1);
>> sonuc2 = limit(f2,x,1);
>> sonuc2
OUTPUT:
sonuc2 = 
6

    \[lim_{x \to a}\frac{x^3-a^3}{sin(3x-3a)} =? \hspace{3em} lim_{x \to {1}^{+}}\frac{6x^2+5x+3}{9x} =? \]

INPUT:
syms x a;
f3 = ((x^3) - (a^3))/(sin(3x -3a));
sonuc3 = limit(f3,x,a) ;
sonuc3
OUTPUT:
sonuc3 =
a^2    

INPUT:
>> syms x;
>> f4 = (6*(x^2) + 5*x + 3) / (9*x);
>> sonuc4 = limit(f4,x,1,'right');
>> sonuc4
OUTPUT:
sonuc4 =
14/9 

Matlab’de Türev

Mühendislik ve matematik başta olmak üzere birçok alanda karşımıza çıkan türev problemlerini matlab ile çözmek için diff() komutunu kullanmamız yeterlidir. Türevini hesaplama ihtiyacı duyduğumuz fonksiyonu diff() komutuna yazarken, fonksiyonun değişkenini matlab’de sembolik nesne olarak tanımlamış olmamız gerekir. Komutun kullanışı diff(fonksiyon,derece,değişken) şeklindedir. Fonksiyon ve değişken kısımlarına neler yazılması gerektiği limit() komutundan biliyoruz. Derece yerine ise fonksiyonun kaçıncı mertebeden türevinin olmaması gerektiği yazılmalıdır. Örnek olarak f(x) fonksiyonunun 2.mertebeden türevi hesaplanmak isteniyorsa komut satırına diff(f(x),2,x) yazılması yeterlidir. Matlab sonucu bize çıktı olarak gösterecektir.

Örnekler

    \[f(x)=7x^6+ 6x^5 + 10x^4 + 2x^2+ 1  \quad ise  \quad f'(x) = ?\]

INPUT:
>> syms x;
>> f = 7*(x^6) + 6*(x^5) + 10*(x^4) + 2*(x^2) + 1;
>> sonuc = diff(f,1,x);
>> sonuc
OUTPUT:
sonuc = 
42*x^5 + 30*x^4 + 40*x^3 + 4*x 

    \[f(x)=x^2tan(x)+cos^2(4x^2) \quad  ise  \quad f'(x) = ?\]

INPUT:
>>syms x;
>>f = (x^2)tan(x) + (cos(4(x^2)))^2;
>>sonuc = diff(f,1,x);
>>sonuc
OUTPUT:
>>sonuc =
>>2xtan(x) + x^2(tan(x)^2 + 1) - 16xcos(4x^2)sin(4x^2)    

    \[f(x)=e^xsin(5x) \quad  ise  \quad f^3(x) = ?\]

INPUT:
>>syms x;
>>f = exp(x)(sin(5x));
>>sonuc = diff(f,3,x);
>>sonuc
OUTPUT:
>>sonuc =
>>-110cos(5x)exp(x) - 74sin(5x)exp(x)         

    \[f(x)=\frac{1}{2+sin(2x)}\hspace{0.2 cm}ise\hspace{0.2 cm}f^2(x)=?\hspace{0.2 cm}ve\hspace{0.2 cm}x=5\hspace{0.2 cm}noktasındaki\hspace{0.2 cm}2. türevi\hspace{0.2 cm}nedir?\]

INPUT:
>>syms x;
>>f = (1)/(2 + sin(2x)); 
>>turevin_sonucu = diff(f,2,x);
>>sonuc = subs(turevin_sonucu,5);  %x = 5 noktasındaki 2.türevin sonucuna bakıyoruz.  
>>sonuc 
>>OUTPUT: 
>>sonuc =  (4sin(10))/(sin(10) + 2)^2 + (8*cos(10)^2)/(sin(10) + 2)^3       

Matlab’de İntegral

Matlab’de int() komutunu kullanarak herhangi bir integral probleminin çözümünü bulabiliriz. Bu komutun içerisine yazacağımız fonksiyonun değişkeninin yine önceki iki komut gibi sembolik nesne olarak tanımlanmış olması gerekir. int() komutu ile belirli veya belirsiz integraller çözdürülebilir. Eğer belirsiz integral çözmek istiyorsak int(fonksiyon) komutunu kullanmalıyız. Fakat belirli integral çözmek istiyorsak int(fonksiyon,başlangıç değeri,bitiş değeri) komutunu kullanmamız yeterlidir. Bazı durumlarda matlab integrali hesaplayamayabilir. Bu durumda quad() komutunu kullanarak integralin yaklaşık değerini hesaplayabiliriz.

Örnekler

    \[\int (3x^5+2x^2+1)dx\hspace{0.2 cm}integralini\hspace{0.2 cm}hesaplayınız.\]

INPUT:
>> syms x;
>> f = 3*(x^5) + 2*(x^2) + 1;
>> sonuc = int(f);
OUTPUT:
sonuc =
x^6/2 + (2*x^3)/3 + x 

    \[\int (x^2sin(x))dx\hspace{0.1 cm}integralini\hspace{0.1 cm}hesaplayınız.\]

INPUT:
>> syms x;
>> f = (x^2)*sin(x);
>> sonuc = int(f);
>> sonuc
OUTPUT:
sonuc =
2*x*sin(x) - cos(x)*(x^2 - 2) 

    \[\int_{0}^1 \frac{2}{2+3x}dx\hspace{0.1 cm}integralini\hspace{0.1 cm}hesaplayınız.\]

INPUT:
>>syms x;
>>f = (2)/(2 + 3*x);
>>sonuc = int(f,0,1);
>>sonuc
OUTPUT:
>>sonuc =
>>log(50^(1/3)/2)    

    \[\int_{0}^{\pi/2} sin^2(3x)cos(x)dx\hspace{0.1 cm}integralini\hspace{0.1 cm}hesaplayınız.\]

INPUT:
>>syms x;
>>f = ((sin(3x))^2)cos(x);
>>sonuc = int(f,0,pi/2);
>>sonuc
OUTPUT:
>>sonuc =
>>17/35    

Bu tip integral hesaplamalarının dışında iki katlı ya da üç katlı integraller hesaplanabilir.

Çok Katlı İntegraller

    \[\int_{a}^{b}\int_{b}^{a}f(x,y)dxdy\]

biçimindeki iki katlı integrali hesaplamak için int(int(f(x,y),x,c,d),y,a,b) komutunun kullanılması yeterlidir. Burada dikkat edilmesi gereken husus, integral probleminde hangi değişkene göre integral önce hesaplanması gerekiyorsa, int(f(x,y),x,c,d) komutunun değişkeni ve sınırları ona göre belirlenmelidir. Eğer integral problemi ilk y değişkenine göre hesaplanması gerekseydi, içerideki komut int(f(x,y),y,c,d) şeklinde olurdu. Benzer şekilde üç katlı

    \[\int_{a}^{b}\int_{c}^{d}\int_{e}^{f}f(x,y,z)dxdydz\]

integralini hesaplamak için int(int(int(f(x,y,z),x,e,f),y,c,d),z,a,b) komutunu kullanmamız gerekir.

Örnekler

    \[\int_{0}^{3}\int_{0}^{x/4}(x^2+y^2)dydx\hspace{0.1 cm}integralini\hspace{0.1 cm}hesaplayınız.\]

INPUT:
>>syms x y;
>>f = (x^2) + (y^2);
>>sonuc = int(int(f,y,0,x/4),x,0,3);
>>sonuc
OUTPUT:
>>sonuc =    
>>1323/256

    \[\int_{0}^{4}\int_{0}^{5}\int_{0}^{3}(x^2y^2z^2)dxdydz\hspace{0.1 cm}integralini\hspace{0.1 cm}hesaplayınız.\]

INPUT:
>>syms x y z;
>>f = (x^2)(y^2)(z^2);
>>sonuc = int(int(int(f,x,0,3),y,0,5),z,0,4);
>>sonuc
OUTPUT:
>>sonuc =    
>>8000

Bu şekilde matlab’de herhangi bir integral problemini hesaplayabiliriz. Son olarak diferansiyel denklem çözümlerinden bahsedip yazıyı sonlandıracağım.

Matlab’de Diferansiyel Denklemler

Limit, türev, integral gibi matematik, fizik ve mühendislik alanlarında önemli bir yere sahip olan diferansiyel denklemleri matlab üzerinde çözebilmek mümkündür. Bilinmeyen fonksiyonun bir bağımsız değişkene bağlı olduğu adi diferansiyel denklemleri çözmek için Dsolve() komutu kullanılabilir. Komut içerisindeki d/dt ifadesi ‘D’ ile temsil edilir. Dsolve komutunun kullanımı Dsolve(‘Diferansiyel denklem’,başlangıç koşulları) şeklindedir. Diferansiyel denklemin matlab’de temsili aşağıdaki gibidir:

    \[y' = Dy,    y'' = D2y,     y''' = D3y,    y'''' = D4y,  … ,  = Dny\]

Örnekler

    \[y'' - 6y' + 25y = 0\hspace{0.1 cm}diferansiyel\hspace{0.1 cm}denklemini\hspace{0.1 cm}çözünüz.\]

INPUT:
>>syms x y;
>>x=dsolve('D2y-6Dy+25y=0');
>>x
OUTPUT:
>>x =
>>C1cos(4t)exp(3t) + C2sin(4t)exp(3t)    

    \[y'' - y' - 2y = e^{4t}\hspace{0.1 cm}diferansiyel\hspace{0.1 cm}denklemini\hspace{0.1 cm}çözünüz.\]

INPUT:
>>syms x y t;
>>x=dsolve('D2y-Dy-2y=exp(4t)');
>>x
OUTPUT:
>>x =
>>exp(4t)/10 + C1exp(2t) + C2exp(-t)    

    \[y'' - 8y' + 2y + 1= t\hspace{0.1 cm}diferansiyel\hspace{0.1 cm}denklemini\hspace{0.1 cm}\hspace{0.1 cm}y(0) =0\hspace{0.1 cm}ve\hspace{0.1 cm}y'(0) = -1\]

    \[koşulları\hspace{0.1 cm}altında\hspace{0.1 cm}çözünüz\hspace{0.1 cm}ve\hspace{0.1 cm}grafiğini\hspace{0.1 cm}çiziniz.\]

INPUT:
>>syms x y t;
>>x=dsolve('D2y+8Dy+2y+1=t','y(0)=0','Dy(0)=-1'); 
>>x
>>ezplot(x)
OUTPUT:
>>x =
>>t/2 + exp(t(14^(1/2) - 4))((1714^(1/2))/56 + 5/4) + (14^(1/2)exp(-t(14^(1/2) + 4))(5*14^(1/2) - 17))/56 - 5/2    

MTLBI7J25966U28A3H

Python ile Dosya İşlemleri

Önceki yazılarda yazdığımız Python kodları, program sonlandığı andan itibaren kaybolur. Program yeniden başlatıldığında daha önceden yazdığımız kodlar eğer kaydedilmemiş ise erişilemezdir. Bilgisayarların temel görevi ve bizlerin istediği verilerimizin depolanmasıdır. Bir veriyi kalıcı olarak depolayabilmek için ya sabit disklerde ya da kalıcı belleklerde saklanması gerekir. Verilerimizi disk üzerlerinde saklamanın en iyi yolu, verileri dosya olarak kaydetmektir.

Dosya Oluşturma

Bu bölümde sizlere Python ile dosyaları nasıl oluşturabileceğimizden ve düzenleyebileceğimizden bahsedeceğim. Bunun için bilgisayarımızda bir metin dosyası oluşturabilir ya da bu işlemi kod ile gerçekleştirebiliriz. open() fonksiyonu bilgisayarda oluşturulan bir dosyayı açmak için ya da dosya oluşturmak için kullanılır. open() fonksiyonunun içerisine, eğer bilgisayarınıza yüklü bir Python IDE’si kullanıyorsanız dosyanın bilgisayardaki konumunu yazmanız yeterlidir. Eğer Jupyter gibi tarayıcıda çalışan IDE’ler kullanıyorsanız, dosyayı kullandığınız IDE ortamına yükleyip dosya yolunu open() fonkiyonuna yazmanız yeterlidir. Eğer adını yazdığınız dosya oluşturulmamış ise open() fonksiyonu dosyayı oluşturacaktır. Bu şekilde dosya Python içerisine aktarılmış olacaktır.

INPUT:
open("/content/drive/MyDrive/Colab Notebooks/İstiklal Marşı.txt")

Dosya Okuma

Python’a yüklediğimiz dosyayı bir değişkene atayıp satır satır okumak için readline() komutunu kullanabiliriz.

INPUT:
file = open("/content/drive/MyDrive/Colab Notebooks/İstiklal Marşı.txt")
file.readline().rstrip()

OUTPUT:
  'Korkma, sönmez bu şafaklarda yüzen al sancak;'

Programı her çalıştırdığımızda diğer satırlar ekrana gelmeye devam eder. Eğer herhangi bir satırda, baştan okuma işlemi yapmak istiyorsak seek(0) fonksiyonunu kullanabiliriz. Eğer seek() fonksiyonun içerisine farklı bir değer yazarsak, o değerin karşılık geldiği karakterden sonrasını okuma işlemi yapar. Örnek olarak:

INPUT:
file.seek(2)
file.readline().rstrip()

OUTPUT:
'rkma, sönmez bu şafaklarda yüzen al sancak;'

Dosya Üzerinde For Döngüsü Oluşturma

Dosya üzerinde for döngüsü oluşturup, bütün satırlara erişmek mümkündür.

INPUT:
file.seek(0)
for i in file:
     print(i)


OUTPUT:

Korkma, sönmez bu şafaklarda yüzen al sancak;

Sönmeden yurdumun üstünde tüten en son ocak.

O benim milletimin yıldızıdır, parlayacak;

O benimdir, o benim milletimindir ancak.

Eğer dosya üzerinde yaptığımız işlemler sona erdiyse close() fonksiyonunu kullanıp, dosyayı kapatabiliriz.

INPUT:
file.close()

readlines() fonksiyonunu kullanıp, tüm dosya içeriğini bir listeye dönüştürebiliriz. Örnek olarak:

INPUT:
file = open("/content/drive/MyDrive/Colab Notebooks/İstiklal Marşı.txt")
file_list = file.readlines()
for i in range(0, len(file_list)):
   file_list[i] = file_list[i].rstrip()
file_list  

OUTPUT:

['Korkma, sönmez bu şafaklarda yüzen al sancak;',
 'Sönmeden yurdumun üstünde tüten en son ocak.',
 'O benim milletimin yıldızıdır, parlayacak;',
 'O benimdir, o benim milletimindir ancak.'] 

Örnek

Üyeler adlı bir dosya oluşturalım ve bu dosya içerisine aşağıdaki bilgileri yazalım.

12345-Ali-10-5

6789-Ayşe-20-7

10112-Mustafa-50-15

12134-Gönül-5-8

Kitap satın alma sitesinde üyelerin bilgilerinin bulunduğu bu dosyayı Python’a aktaralım ve listeye dönüştürelim. Ardından Üye bilgilerini sorguladığımız bir program yazalım.

INPUT:
members = open("/content/drive/MyDrive/Colab Notebooks/Üyeler.txt").readlines()
for member in range(len(members)):
    members[member] = members[member].rstrip()
    members[member] = members[member].split("-")
members



OUTPUT:

[['12345', 'Ali', '10', '5'],
 ['6789', 'Ayşe', '20', '7'],
 ['10112', 'Mustafa', '50', '15'],
 ['12134', 'Gönül', '5', '8']]

Böylece dosyadaki üyeleri listeye atıp düzenlemiş olduk. Üye numarası, para ve kitap adedi gibi değerlerin tiplerini for döngüsü ile integer’a dönüştürebiliriz.

INPUT:
for i in members:
  i[0] = int(i[0])
  i[2] = int(i[2])
  i[3] = int(i[3])
members 


OUTPUT:

[[12345, 'Ali', 10, 5],
 [6789, 'Ayşe', 20, 7],
 [10112, 'Mustafa', 50, 15],
 [12134, 'Gönül', 5, 8]]

Şimdi ise gireceğimiz üye numarası ile üyelik bilgilerini sorgulayalım.

INPUT:
MemberNo = input("Lütfen sorgulamak istediğiniz üye numarasını giriniz : ")
if MemberNo.isnumeric():
   for member in members:
       if int(MemberNo) == member[0]:
          print("Üye numarası {0} olan,\nadlı kişinin hesabından {2} Türk lirası bakiye bulunmaktadır.\nŞu zamana kadar {3} adet kitap satın almıştır.".format(member[0],member[1],member[2],member[3]))
          break;
       else:
         print("Üye numarasına ait kişi bulunamadı.")
else:
  print("HATA! SANIRIM YANLIŞ BİR ŞEY OLDU\nÜye numarası sayılardan oluşmalıdır.")


OUTPUT:

Lütfen sorgulamak istediğiniz üye numarasını giriniz : 12345h
HATA! SANIRIM YANLIŞ BİR ŞEY OLDU
Üye numarası sayılardan oluşmalıdır.

Dosya üzerine yazmaya geçmeden evvel şunu hatırlatmakta fayda var; şu ana kadar yaptıklarımız var olan bir dosya üzerinden, yani daha önceden oluşturup veriler girdiğimiz dosya üzerinden gerçekleşmektedir.

Dosya Üzerine Yazma

Dosya oluşturmak ya da var olan bir dosyayı açmak için open() fonkisyonunu kullanıyorduk. open() fonksiyonun içerisine aşağıdaki tabloda yer alan argümanlardan birini girerek dosyanın ne şekilde açılacağına karar verebiliriz.

ArgümanAçıklama
r Salt okuma
w Yazma
aSonuna ekleme
bİkili kip
tSalt metin
+Dosya güncelleme

Eğer var olan bir dosyayı w argümanı ile açarsak, dosyanın içerisindeki tüm içerikler silinir ve boş bir dosya olarak açılmış olur. Açtığımız dosya içerisine write() fonksiyonu ile satır eklemesi yapabilirsiniz. Dosya üzerinde yaptığınız değişiklikleri kaydetmek için flush() fonksiyonu kullanılabilir. Açılan dosya flush() fonksiyonu ile kaydedilmeden kapatılırsa, otomatik kayıt yapılır. Örnek olması için bir dosya oluşturup içerisine bilgiler yazalım.

INPUT:
customers = open("customers.txt","w")
customers_list = [[1245,"Gizem","Borcu yok"],[6789,"Aslı","Borcu Yok"],[6123,"Kerim","Borcu var"]]
for customer in customers_list:
    for i in customer:
        customers.write(str(i)+"-")
    customers.write("\n")    
customers.close()   

customers = open("customers.txt",”r”)
customers.seek(0)
customers_list1 = customers.readlines()
for i in range(0,len(customers_list1)):
   customers_list1[i] = customers_list1[i].rstrip()
customers_list1 


OUTPUT:

['1245-Gizem-Borcu yok-', 
'6789-Aslı-Borcu Yok-', 
'6123-Kerim-Borcu var-']

Örnekler

Aşağıdaki şekilde bir mat.txt dosyası oluşturalım.

   No      Ad-soyad        mat      fizik      kimya

11      Ayşe Gök         60         50         70

12      Ahmet altun   20         40         50

13      Can Emek        80         60         70

14      Nesrin Ay        90          60         20

a) Yukarıdaki şekilde mat.txt dosyası oluşturulması ve verilerin girilmesini sağlayan bir program yazınız.

INPUT:
#Dosyanın Oluşturulması
open("mat.txt", "w")
#Dosyayı yazmak için açıyoruz ve içerisine veri ekliyoruz.
with open("mat.txt", "a")  as  dosya:
    dosya.write("No      Ad-Soyad       Mat     Fizik   Kimya\n")
    dosya.write("11      Ayşe Gök       60       50      70\n")
    dosya.write("12      Ahmet Altun    20       40      50\n")
    dosya.write("13      Can Emek       80       60      70\n")
    dosya.write("14      Nesrin Ay      90       60      20\n")
dosya.close()  

b) Ekrana sadece Numara ad-soyad ve kimya notunu listeleyen bir program yazınız.

INPUT:
with open("mat.txt")  as  dosya:
  dosya.seek(0) 
  liste = dosya.readlines()
  for x in range(0,5):
      a = liste[x:x+1]  
      print(a[0][0:2],"\t",a[0][8:20],"\t",a[0][39:44])

OUTPUT:

No 	 Ad-Soyad     	 Kimya
11 	 Ayşe Gök     	  70

12 	 Ahmet Altun  	  50

13 	 Can Emek     	  70

14 	 Nesrin Ay    	  20

c) Ekrana her üç dersten 50 nin altında alanları listeleyınız.



INPUT:
with open("mat.txt")  as  dosya:
  dosya.seek(0) 
  liste = dosya.readlines()
  Fizikten_Kalanlar = []
  Matematikten_Kalanlar = []
  Kimyadan_Kalanlar = []
  for x in range(1,5):
      a = liste[x:x+1]
      Mat_Not = int(a[0][23:26]) 
      Kimya_Not = int(a[0][39:44])
      Fizik_Not = int(a[0][30:35])
      if Mat_Not < 50: 
         Matematikten_Kalanlar.append("{} kişisi Matematikten {} alarak bu dersten kalmıştır.".format(a[0][8:20],a[0][23:26].rstrip()))
      if Kimya_Not < 50: 
         Kimyadan_Kalanlar.append("{} kişisi Kimyadan {} alarak bu dersten kalmıştır.".format(a[0][8:20],a[0][39:44].rstrip()))
      if Fizik_Not < 50: 
         Fizikten_Kalanlar.append("{} kişisi Fizikten {} alarak bu dersten kalmıştır.".format(a[0][8:20],a[0][30:35].rstrip()))
  print("Matematikten kalanlar : ",Matematikten_Kalanlar)
  print("Fizikten kalanlar : ",Fizikten_Kalanlar)
  print("Kimyadan_Kalanlar : ",Kimyadan_Kalanlar)


OUTPUT:

Matematikten kalanlar :  ['Ahmet Altun  kişisi Matematikten 20 alarak bu dersten kalmıştır.']
Fizikten kalanlar :  ['Ahmet Altun  kişisi Fizikten   40 alarak bu dersten kalmıştır.']
Kimyadan_Kalanlar :  ['Nesrin Ay    kişisi Kimyadan  20 alarak bu dersten kalmıştır.']

PYTNFEXVD4K26M2510
Python’da Dizeler ve Dize Fonksiyonları

Dize, bir karakter setidir. Bilgisayarlar karakterleri 0’ların ve 1’lerin bir kombinasyonu olarak saklayıp işlerler. Karakterlerin bu şekilde ikili sayılara dönüştürülmesine kodlama denir. ASCII ve Unicode, popüler kodlamalardan bazılarıdır. Klavyeden bir karakter girildiğinde bilgisayarın anladığı o karakterin ASCII (ya da Unicode) tablosundaki 0 ve 1’lerden oluşan kombinasyonudur. Daha önceki yazılarda da bahsedildiği gibi çift tırnak (“ ”) ya da tek tırnak (‘ ’) arasına karakterler yazılarak string (dize) tanımlanabilir. Bu string değişkenin içerisindeki her bir karaktere indeks numarası kullanılarak erişilebileceğini daha önceki yazılarda bahsetmiştim. Örnek olması için bu yazıda da bir değişken tanımlayıp, indeks numarasını yazdığımız bir karaktere erişelim.

Örnekler

INPUT:
  isim = "Mehmet" 
  isim[2]

OUTPUT:
   'h'

Bu yazıda sizlere bahsetmek istediğim bu string ifadeler üzerinde kullanabileceğimiz fonksiyonlardır. Bunlardan ilki len() fonksiyonudur. Bu fonksiyon dizenin uzunluğunu verir.

INPUT:
  sehir = "istanbul"
  len(sehir)

OUTPUT:
  8

in ve not in operatörlerini kullanarak, bir dize içerisindeki herhangi bir karakterin varlığını sorgulayabiliriz. in operatörü, karakter dize içerisindeyse True, değilse False sonucunu döndürür. Tam tersi olarak, not in operatörü, karakter dize içerisinde değilse True sonucunu, içindeyse False sonucunu döndürür.

INPUT:
  ulke = "Türkiye"  
  k in ulke
 
OUTPUT:
  True
INPUT:
  ulke = "Türkiye"  
  y not in ulke

OUTPUT:
  False

Diğer yandan, satır sonu karakterini (\n) kullanarak satırın sonlandığını belirtebilirsiniz. Böylece aynı dize içerisine yazılan ikinci cümle, bir satır aşağı alınarak çıktı olarak gösterilir. Örnek olarak:

INPUT:
  print("Bugün hava yağmurluydu.\nAncak yarın güneşli olabilir.")

OUTPUT:
   Bugün hava yağmurluydu. 
   Ancak yarın güneşli olabilir.

Sekme karakterini (\t) kullanırsak, dize içerisindeki kelimeler arasından belirgin bir boşluk bırakılır. Bu cümlelerin daha düzgün görünmesi için kullanılabilir. Örnek olarak:

INPUT:
  aday_listesi = [["Gökhan","İstanbul",3.42],["Aslı","Balıkesir",1.96], 
  ["Canan","Ankara",2.97],["Gizem","Tokat",1.96]]
  print("Aday","\t","Şehir","\t","\t","Ort.")
  for aday in aday_listesi:
      print(aday[0],"\t",aday[1],"\t",aday[2])

OUTPUT:
  Aday     Şehir       Ort. 
  Gökhan   İstanbul    3.42
  Aslı     Balıkesir   1.96
  Canan    Ankara      2.97
  Gizem    Erzurum     1.96

Cümle içerisinde, bir değişkene ait değeri kullanabilmek için format() fonksiyonunu kullanabiliriz. Bu fonksiyonu kullanmadan da değişkenin değerini cümle içerisine yazdırabiliriz. Ancak bu her veri tipi için farklı bir karakter kullanılmasını gerektirecektir. Burada yazılanları örnek ile gösterelim.

INPUT:
  gün1 = 26
  gün2 = "salı"
  print("Bugün ayın {0}’sı  ve günlerden {1}’dır.".format(gün1,gün2))
  print("---------------------------------------")
  macSaati = "23.00"
  print("Şampiyonlar ligi maçı %s’de başlar."%macSaati)
  print("---------------------------------------")
  piSayisi = 3.14
  print("pi sayını %f alınız."%piSayisi)
  print("---------------------------------------")
  KacTL = 200
  print("Yunus Emre’nin resmi %d TL’nin arka yüzünde vardır."%KacTL)
  print("---------------------------------------")
  print("Bugün kredi faizleri %s%f azaldı."%("%",1.5)) 
  print("---------------------------------------")
OUTPUT:
   Bugün ayın 26’sı ve günlerden salı’dır.
   ---------------------------------------
   Şampiyonlar ligi maçı 23.00’de başlar.
   ---------------------------------------
   pi sayını 3.140000 alınız.
   ---------------------------------------
   Yunus Emre’nin resmi 200 TL’nin arka yüzünde vardır.
   ---------------------------------------
   Bugün kredi faizleri %1.500000 azaldı.
   ---------------------------------------

upper() ve lower Fonksiyonu

Bir dizedeki tüm karakterleri büyük harfe ya da  küçük harfe dönüştürmek için kullanılan fonksiyonlardır. Örnek olarak:

INPUT:
  sehir1 = "Adıyaman"
  sehir1.upper() 

OUTPUT:
  'ADIYAMAN'
INPUT:
  sehir1 = "Adıyaman"
  sehir1.lower() 

OUTPUT:
   'adıyaman'

find() Fonksiyonu

Bir kelimenin cümle içerisinde olup olmadığını kontrol edebilmek için kullanılan fonksiyondur. find() fonskiyonunun avantajı aradığımız kelimelerin hangi konumda başladığını bize söylemesidir. Yukarıda da bahsettiğim gibi in operatörü kullanarak kelimenin ya da karakterin cümle içerisinde olup olmadığını sorgulayabilirdik. Ancak, in operatörü bize aranan kelimenin ya da karakterin konumunu vermez. Örnek olarak:

INPUT:
  sentence = "En sevdiğim gün Cuma’dır."
  sentence.find("Cuma") 

OUTPUT:
  16

Aradığımız kelime ya da karakter cümle içerisinde yok ise -1 değerini sonuç olarak döndürür.

Eğer bir kelimenin herhangi bir alt kelime ya da karakter ile başlayıp başlamadığını ya da bitip bitmediğini sorgulamak istersek startswith()  ve endswith() fonksiyonlarını kullanabiliriz. startswith(), kelimenin aradığımız alt kelime ya da karakter ile başlayıp başlamadığını kontrol ederken, endswith() ise bitip bitmediğini kontrol eder. True ya da False değerlerini döndürür.

INPUT:
  sentence.startswith("Benim") 

OUTPUT:
  False
INPUT:
  sentence.endswith("r.")

OUTPUT:
  True

split() Fonksiyonu

Cümleyi belirli bir karakter ya da kelimeye göre parçalamak için kullanılan fonksiyondur. Cümleyi parçalayıp bir liste olarak bize geri verir. Örnek olarak:

INPUT: 
  sentence = "Gizemli, bir sıfattır"
  sentence.split(" ")

OUTPUT:
  ['Gizemli', 'bir', 'sıfattır'] 

join() Fonksiyonu

split() fonksiyonu ile parçalara ayrılan ya da liste halinde verilen kelimeleri ya da karakterleri bir karakter ya da alt cümle kullanarak birleştirmek için kullanılan fonksiyondur. Örnek olarak:

INPUT:
  sentence1 = "Haritanın fiziki şartları gereği 25derece görünmektedir."
  words = sentence1.split(" ") 
  print("Ayrılmış hali :",words)
  bosluk = " "
  print("Birleştirilmiş hali : ", bosluk.join(words)) 

OUTPUT:
   Ayrılmış hali : ['Haritanın', 'fiziki', 'şartları', 'gereği', '25', 'derece', 'görünmektedir.']
   Birleştirilmiş hali :  Haritanın fiziki şartları gereği 25 derece görünmektedir.      

replace() Fonksiyonu

Cümle içerisindeki bir karakteri ya da kelimeyi istenilen karakter veya kelime ile değiştirmek için kullanılan fonksiyondur. Örnek olarak:

INPUT:
  cumle = "Bu-bir-python-yazısıdır"  
  cumle.replace("-",".")

OUTPUT:
  'Bu.bir.python.yazısıdır' 

strip() Fonksiyonu

Kullanıcı tarafından girilen ya da metin dosyalarından alınan cümlelerin başında veya sonundaki boşlukları atmak için kullanılır. Eğer cümlelerin sadece başındaki boşluklar atılmak isteniyorsa .rstrip() fonksiyonu, eğer sadece cümle sonundaki boşluklar atılmak isteniyorsa .lstrip() fonksiyonu kullanılabilir. Örnek olarak:

INPUT:
  x = "  Bu cümlenin başında ve sonunda boşluklar vardır.  "
  x.strip()

OUTPUT:
  'Bu cümlenin başında ve sonunda boşluklar vardır.'  

isnumeric() Fonksiyonu

Kullanıcı tarafından girilen cümlelerin sayı değerlerinden oluşup oluşmadığını kontrol etmek için kullanılan fonksiyondur. Eğer cümle sayılardan oluşuyorsa True, oluşmuyorsa False değerini döndürür. Örnek olarak:

INPUT:
  sayi = "1102" 
  sayi.isnumeric( )

OUTPUT:
   True
INPUT:
  uyeler = [["12345","Ali","10","5"],["67890","Gizem","20","7"],["10112","Mustafa","50","15"],["12134","Aslı","5","8"]]
  uyeNo = input("Lütfen üye numarasını giriniz : ")
  if uyeNo.isnumeric():
      for deger in uyeler:
          if deger[0] == uyeNo:
             print("Üye numarası {0} olan, {1} adlı kişinin hesabında {2} TL bakiye bulunmaktadır. Şu zamana kadar {3} adet kitap satın
             almıştır.".format(deger[0],deger[1],deger[2],deger[3]))
             break;
      else:
           print("Bu üye numarasına ait kişi bulunmamıştır.")
  else:
       print("Üye Numarası sayılardan oluşmalıdır.") 

OUTPUT:
   Lütfen üye numarasını giriniz : 12345
   Üye numarası 12345 olan, Ali adlı kişinin hesabında 10 TL bakiye bulunmaktadır. Şu zamana kadar 5 adet kitap satın almıştır.                                    

PYTNVK3L0T72C14L2U