Python ile C# Arasındaki Kod Farklılıkları

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

Python:
Python, sözdiziminde sadelik ve okunabilirlik ön planda tutularak tasarlanmış bir dildir.
Blok yapısı için girinti kullanılır ve noktalı virgül gerekmez.

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

C#:
C#, Java gibi daha geleneksel dillerin sözdizimine benzer. Bloklar, küme parantezleri ({}) ile
belirlenir ve satır sonlarında noktalı virgül (;) kullanılır.

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

2. Değişken Tanımlama

Python:
Python'da değişkenlerin tipi belirtmek gerekmez. Tip, atanan değerden otomatik olarak
belirlenir.

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

C#:
C#'da değişkenlerin tipi açık bir şekilde belirtilmelidir.

Örnek:
```csharp
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
```

C#:
C#'da fonksiyonlar `return_type fonksiyon_adi(parametreler)` formatında tanımlanır.

Örnek:
```csharp
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. Sınıf içindeki 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]}")
```
C#:
C#'da sınıf tanımlamak için `class` anahtar kelimesi kullanılır ve sınıf özellikleri genellikle
`public` veya `private` gibi erisim belirleyicilerle tanımlanır.

Örnek:
```csharp
class Araba
{
public string Marka;
public string Model;

public Araba(string marka, string model)

{
Marka = marka;
Model = model;
}

public void BilgiVer()

{
[Link]($"Marka: {Marka}, Model: {Model}");
}
}
```

5. Hata Yönetimi

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

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

C#:
C#'da hata yönetimi `try-catch` bloklarıyla yapılır.

Örnek:
```csharp
try
{
int x = 10 / 0;
}
catch (DivideByZeroException e)
{
[Link]($"Hata: {[Link]}");
}
```

6. Lambda Fonksiyonlar

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

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

C#:
C#'da lambda fonksiyonlar `=>` operatörü kullanılarak tanımlanır.

Örnek:
```csharp
Func<int, int, int> topla = (a, b) => a + b;
[Link](topla(3, 5));
```

7. Koleksiyonlar

Python:
Python'da listeler, sözlükler gibi koleksiyonlar yaygındır.

Örnek:
```python
liste = [1, 2, 3, 4]
sözlük = {"ad": "Ahmet", "yas": 25}
```

C#:
C#'da dizi ve `List`, `Dictionary` gibi koleksiyonlar kullanılır.
Örnek:
```csharp
int[] dizi = { 1, 2, 3, 4 };
List<int> liste = new List<int> { 1, 2, 3, 4 };
Dictionary<string, int> sözlük = new Dictionary<string, int>
{
{"ad", 25}
};
```

8. Modüler ve Kütüphaneler

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

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

C#:
C#'da kütüphaneler `using` anahtar kelimesi ile dahil edilir.

Örnek:
```csharp
using System;
[Link]([Link](16));
```

Sonuç:
Python ve C#, farklı ama birbirini tamamlayan iki programlama dilidir. Python daha hızlı
prototipleme ve veri bilimi için tercih edilirken, C# daha çok kurumsal uygulamalar ve oyun
geliştirme alanında kullanılır. Python'un sözdizimi daha yalın ve öğrenmesi kolayken, C#'da
daha fazla erisim kontrolü ve tip güvenliği sağlanır.