Python ile Java Arasındaki Kod Farklılıkları

1. Dil Sözdizimi (Syntax) Farklılıkları

Python:
Python, sözdiziminde sadelik ve okunabilirlik ön planda tutulan bir dildir. Blok yapısı girinti
ile belirlenir ve satır sonlarında noktalı virgül gerekmez.

Örnek:
```python
for i in range(5):
print(i)
```

Java:
Java'da bloklar küme parantezleri ({}) ile belirtilir ve satır sonlarında noktalı virgül (;)
kullanılır.

Örnek:
```java
for (int i = 0; i < 5; i++) {
[Link](i);
}
```

2. Değişken Tanımlama

Python:
Python'da değişkenlerin veri tipi belirtilmez, otomatik olarak atanır.

Örnek:
```python
x = 10
name = "Ahmet"
```

Java:
Java'da değişkenlerin tipi belirtilmelidir.

Örnek:
```java
int x = 10;
String name = "Ahmet";
```

3. Fonksiyon Tanımlama

Python:
Python'da fonksiyon tanımlamak için `def` anahtar kelimesi kullanılır.

Örnek:
```python
def topla(a, b):
return a + b
```

Java:
Java'da fonksiyonlar metod olarak tanımlanır ve tip belirtmek zorunludur.

Örnek:
```java
public int topla(int a, int b) {
return a + b;
}
```

4. Nesne Yönelimli Programlama (OOP)

Python:
Python'da sınıf tanımlamak için `class` anahtar kelimesi kullanılır. Metotların ilk
parametresi genellikle `self` olur.

Örnek:
```python
class Araba:
def __init__(self, marka, model):
[Link] = marka
[Link] = model

def bilgi_ver(self):
print(f"Marka: {[Link]}, Model: {[Link]}")
```

Java:
Java'da sınıf tanımlamak için `class` anahtar kelimesi kullanılır ve sınıf içindeki özelliklere
erişim belirleyicilerle (public, private) karar verilir.

Örnek:
```java
public class Araba {
private String marka;
private String model;

public Araba(String marka, String model) {

[Link] = marka;
[Link] = model;
}

public void bilgiVer() {

[Link]("Marka: " + marka + ", Model: " + model);
}
}
```

5. Hata Yönetimi

Python:
Python'da hata yönetimi `try-except` blokları ile yapılır.

Örnek:
```python
try:
x = 10 / 0
except ZeroDivisionError as e:
print(f"Hata: {e}")
```

Java:
Java'da hata yönetimi `try-catch` blokları ile yapılır.

Örnek:
```java
try {
int x = 10 / 0;
} catch (ArithmeticException e) {
[Link]("Hata: " + [Link]());
}
```
6. Koleksiyonlar

Python:
Python'da listeler ve sözlükler gibi koleksiyon yapıları vardır.

Örnek:
```python
liste = [1, 2, 3, 4]
sozluk = {"ad": "Ahmet", "yas": 25}
```

Java:
Java'da diziler ve `ArrayList`, `HashMap` gibi koleksiyonlar kullanılır.

Örnek:
```java
int[] dizi = {1, 2, 3, 4};
ArrayList<Integer> liste = new ArrayList<>([Link](1, 2, 3, 4));
HashMap<String, Integer> sozluk = new HashMap<>();
[Link]("ad", 25);
```

7. Lambda Fonksiyonlar

Python:
Python'da lambda fonksiyonlar `lambda` anahtar kelimesi ile tanımlanır.

Örnek:
```python
topla = lambda a, b: a + b
print(topla(3, 5))
```

Java:
Java'da lambda fonksiyonlar `->` operatörü ile tanımlanır (Java 8 ve üzeri).

Örnek:
```java
BiFunction<Integer, Integer, Integer> topla = (a, b) -> a + b;
[Link]([Link](3, 5));
```
8. Modüler ve Kütüphaneler

Python:
Python'da kütüphaneler `import` anahtar kelimesi ile dahil edilir.

Örnek:
```python
import math
print([Link](16))
```

Java:
Java'da kütüphaneler `import` anahtar kelimesi ile dahil edilir.

Örnek:
```java
import [Link];
[Link]([Link](16));
```

Sonuç:
Python ve Java, farklı alanlarda öne çıkan güçlü diller olarak dikkat çeker. Python, esnek
yapısı ve kolay öğrenilebilirliği ile veri bilimi ve yapay zeka gibi alanlarda tercih edilirken,
Java daha çok büyük ölçekli kurumsal projelerde kullanılır. Python’un dinamik yapısı hızlı
geliştirme sağlarken, Java’nın statik yapısı tip güvenliği ve büyük projelerde
sürdürülebilirlik sunar.