Temel Python Kavramları

Python programlamaya başladığınızda, dilin temel kavramlarını anlamak, daha karmaşık projelere geçiş yaparken güçlü bir temel oluşturmanıza yardımcı olacaktır. Bu bölümde Python’un en önemli temel kavramlarını ele alacağız: değişkenler, veri tipleri, operatörler ve veri yapıları gibi konular üzerinde duracağız.

1. Değişkenler ve Veri Tipleri

a. Değişkenler

Değişkenler: Programda veriyi saklamak ve gerektiğinde bu verilere erişmek için kullanılan isimlendirilmiş bellek alanlarıdır. Python’da değişkenler, bir değer atanarak oluşturulur.
```
x = 5
y = "Merhaba"
```
Burada x, bir tamsayıyı, y ise bir string (metin) değeri saklar.

b. Veri Tipleri

Python’da yaygın olarak kullanılan bazı veri tipleri şunlardır:

Tamsayılar (int): Sayısal veri tipidir ve tam sayı değerlerini saklar.
```
age = 25
```
Ondalıklı Sayılar (float): Ondalık noktalı sayıları saklar.
```
price = 19.99
```
Stringler (str): Metin verilerini saklar. Stringler tırnak işaretleri (” veya ‘) ile tanımlanır.
```
name = "Ali"
```
Boolean (bool): İki değerden birini saklar: True veya False.
```
is_student = True
```
Listeler (list): Birden fazla değeri bir arada tutmak için kullanılır. Listeler köşeli parantez [] ile tanımlanır.
```
fruits = ["Elma", "Muz", "Çilek"]
```
Demetler (tuple): Listelere benzer, ancak demetlerin elemanları değiştirilemez. Parantez () ile tanımlanır.
```
coordinates = (10, 20)
```
Sözlükler (dict): Anahtar-değer çiftlerini saklamak için kullanılır. Sözlükler süslü parantez {} ile tanımlanır.
```
student = {"name": "Ayşe", "age": 22, "grade": "A"}
```
Setler (set): Benzersiz öğelerden oluşan koleksiyonlardır. Setler süslü parantez {} ile tanımlanır.
```
unique_numbers = {1, 2, 3, 4, 5}
```

c. Tip Dönüşümü

Python, veri tipleri arasında dönüşüm yapmanıza olanak tanır.

x = 5 # int
y = float(x) # x'in float versiyonu
z = str(x) # x'in string versiyonu

2. Operatörler

Python, çeşitli matematiksel ve mantıksal işlemleri gerçekleştirmek için operatörler sunar. İşte en yaygın kullanılan operatörler:

a. Aritmetik Operatörler

Toplama (+):
```
result = 10 + 5 # 15
```
Çıkarma (-):
```
result = 10 - 5 # 5
```
Çarpma (*):
```
result = 10 * 5 # 50
```
Bölme (/):
```
result = 10 / 5 # 2.0
```
Modülüs (%): Bölme işleminden kalanı verir.
```
result = 10 % 3 # 1
```
Üs Alma ()**: Bir sayının diğerinin kuvvetini alır.
```
result = 2 ** 3 # 8
```
Tam Bölme (//): Bölme işleminden tam kısmını verir.
```
result = 10 // 3 # 3
```

b. Karşılaştırma Operatörleri

Eşit mi? (==):
```
result = (10 == 5) # False
```
Eşit değil mi? (!=):
```
result = (10 != 5) # True
```
Büyük mü? (>):
```
result = (10 > 5) # True
```
Küçük mü? (<):
```
result = (10 < 5) # False
```
Büyük veya eşit mi? (>=):
```
result = (10 >= 5) # True
```
Küçük veya eşit mi? (<=):
```
result = (10 <= 5) # False
```

c. Mantıksal Operatörler

ve (and): Tüm koşullar doğruysa True döner.
```
result = (10 > 5 and 8 < 10) # True
```
veya (or): Koşullardan biri doğruysa True döner.
```
result = (10 > 5 or 8 > 10) # True
```
değil (not): Koşulun tersini alır.
```
result = not(10 > 5) # False
```

3. Listeler, Demetler ve Sözlükler

a. Listeler (list)

Liste Tanımlama: Listeler, birden fazla değeri bir arada tutmak için kullanılır.
```
fruits = ["Elma", "Muz", "Çilek"]
```
Listeye Eleman Ekleme: append() yöntemiyle listeye eleman ekleyebilirsiniz.
```
fruits.append("Portakal")
```
Liste Elemanlarına Erişim: İndeks numarasıyla liste elemanlarına erişebilirsiniz.
```
print(fruits[0]) # "Elma"
```

b. Demetler (tuple)

Demet Tanımlama: Demetler, listelere benzer ancak elemanları değiştirilemez.
```
coordinates = (10, 20)
```
Demet Elemanlarına Erişim: İndeks numarasıyla demet elemanlarına erişebilirsiniz.
```
print(coordinates[1]) # 20
```

c. Sözlükler (dict)

Sözlük Tanımlama: Anahtar-değer çiftleri saklamak için kullanılır.
```
student = {"name": "Ayşe", "age": 22, "grade": "A"}
```
Sözlük Elemanlarına Erişim: Anahtar kullanarak sözlük elemanlarına erişebilirsiniz.
```
print(student["name"]) # "Ayşe"
```
Sözlüğe Eleman Ekleme: Yeni bir anahtar-değer çifti ekleyebilirsiniz.
```
student["school"] = "XYZ Lisesi"
```

4. Koşullu İfadeler (if-elif-else)

Python’da karar yapıları, belirli koşulların doğruluğuna göre kod parçacıklarının çalıştırılmasını sağlar.

a. if İfadesi

if: Belirli bir koşul doğruysa bu kod bloğu çalıştırılır.
```
x = 10
if x > 5:
print("x 5'ten büyük")
```

b. elif İfadesi

elif: İlk koşul yanlışsa ve bu koşul doğruysa çalışır.

x = 10
if x > 10:
print("x 10'dan büyük")
elif x == 10:
print("x 10'a eşit")

c. else İfadesi

else: Tüm diğer koşullar yanlışsa çalışır.

x = 5
if x > 10:
print("x 10'dan büyük")
elif x == 10:
print("x 10'a eşit")
else:
print("x 10'dan küçük")

Bu temel python kavramları, programlamanın yapı taşlarını oluşturur. Bu kavramları anlamak, Python‘da daha karmaşık programlar geliştirmek için gerekli olan güçlü bir temel sağlar. Daha fazla uygulama yaparak bu konuları pekiştirebilir ve Python programlama becerilerinizi geliştirebilirsiniz.

Ozan Yıldırım