# Python'da string (metin) işlemleri: split, replace, strip, join, dilimleme ve f-metinler

URL: https://skillaria.top/tr/guides/python/python-metin-islemleri

Python'da string (str) tipi Unicode karakterlerden oluşan değiştirilemez bir dizidir. split() metni listeye böler, join() listeyi tekrar birleştirir, replace() alt metni değiştirir, strip() kenarlardaki boşlukları siler; her metot yeni bir string döndürür. Değerleri yazdırmanın en kolay yolu f-string'dir: f"{name}: {price:.2f}".

Python'da stringler her programda karşınıza çıkar: kullanıcı girdisi, dosya adları, CSV satırları, API yanıtları. `str` tipi metni Unicode olarak tutar, bu yüzden Türkçe karakterler ve emojiler ek ayar gerektirmeden çalışır. En çok kullanılan metotlar `split`, `replace`, `strip` ve `join`'dir; değerleri yazdırmak için ise en uygun araç f-string'lerdir. Hepsini örneklerle inceleyelim.

## Python'da string nasıl çalışır

Stringler tek ya da çift tırnakla yazılır; fark yoktur: `'kahve'` ile `"kahve"` aynıdır. Üç tırnakla yazılan metin birden fazla satır olabilir ve satır sonları olduğu gibi korunur.

```
name = "Kahve"
note = """İlk satır
İkinci satır"""
print(len(name))  # 4 — karakter cinsinden uzunluk
```

Stringlerin temel özelliği değiştirilemez olmalarıdır. Bir metot stringi değiştirmez, yeni bir string döndürür. Bu yüzden `s.replace("a", "b")` tek başına bir şey yapmaz; `s = s.replace("a", "b")` yazmanız gerekir. Yeni başlayanların en sık yaptığı hata budur.

### Özel karakterler, satır sonu ve ham stringler

Satır sonu `\n`, sekme `\t`, ters eğik çizgi `\\` ile yazılır. Başına `r` konan string "ham" (raw) olur: içindeki ters eğik çizgiler işlenmez. Bu, Windows yolları ve düzenli ifadeler için kullanışlıdır.

```
print("Toplam:\n350 TL")
path = r"C:\new\table.csv"   # \n ve \t özel karaktere dönüşmez
```

Uzun bir ifadeyi parantez içinde birden fazla satıra bölebilirsiniz; parantez içindeki yan yana string sabitlerini Python kendisi birleştirir.

## split: metni listeye bölmek

`split()` metni bir ayraca göre böler ve liste döndürür. Argüman verilmezse her türlü boşluk karakterinden böler ve yinelenen boşlukları yok sayar; komutları ayrıştırırken çok işe yarar.

```
"ekle  Kahve 250".split()        # ['ekle', 'Kahve', '250']
"2026-10-16".split("-")          # ['2026', '10', '16']
"a,b,,c".split(",")              # ['a', 'b', '', 'c']
"anahtar=değer=x".split("=", 1)  # ['anahtar', 'değer=x']
```

Dikkat edin: açık bir ayraçla bölünce boş parçalar korunur. İkinci argüman `maxsplit` kesim sayısını sınırlar; `rsplit()` ise sağdan böler. Metni satırlara ayırmak için `splitlines()` kullanın: hem `\n` hem de `\r\n` satır sonlarını tanır ve sonda boş öğe bırakmaz.

```
text = "kahve\ntaksi\n"
text.split("\n")     # ['kahve', 'taksi', '']
text.splitlines()    # ['kahve', 'taksi']
```

## join: listeyi stringe birleştirmek

`join()` ters işlemdir. Ayraç olan stringde çağrılır ve argüman olarak string listesi alır:

```
items = ["kahve", "taksi", "öğle yemeği"]
print(", ".join(items))   # kahve, taksi, öğle yemeği
print("\n".join(items))   # her öğe ayrı satırda
```

Tüm öğeler string olmalıdır; aksi halde `TypeError: sequence item 0: expected str instance, int found` hatası alırsınız. Sayıları önce çevirin: `", ".join(str(x) for x in amounts)`.

### Birleştirme ve ekleme

İki stringi `+` ile toplayabilir, `*` ile tekrarlayabilirsiniz: `"-" * 20`. Ancak döngü içinde yüzlerce parçayı `+=` ile eklemek yavaştır, çünkü her seferinde yeni bir string oluşur. Parçaları bir listeye toplayıp tek bir `join()` ile birleştirin. Bir stringi sayıyla doğrudan toplayamazsınız: `"Toplam: " + 5` bir `TypeError` verir; `str()` fonksiyonunu ya da f-string'i kullanın.

## replace: alt metni değiştirmek

`replace(eski, yeni)` bir alt metnin tüm geçtiği yerleri değiştirir. Üçüncü argüman değiştirme sayısını sınırlar.

```
price = "1.250,50"
price = price.replace(".", "").replace(",", ".")
print(float(price))                  # 1250.5

"a-b-c".replace("-", "+", 1)         # 'a+b-c'
```

Metot büyük-küçük harfe duyarlıdır ve tam eşleşme arar. Desene göre değiştirme (örneğin "bütün rakamlar") için `re` modülü ve `re.sub()` fonksiyonu gerekir.

## strip, lstrip, rstrip: kenarları kırpmak

`strip()` iki uçtaki boşlukları, sekmeleri ve satır sonlarını siler. `lstrip()` yalnızca soldan, `rstrip()` yalnızca sağdan kırpar. Kullanıcı girdisi ve dosyadan gelen satırlarla yapılacak ilk iş budur.

```
raw = "  Kahve \n"
raw.strip()       # 'Kahve'
raw.rstrip()      # '  Kahve'
"xxKahvexx".strip("x")   # 'Kahve'
```

Argüman bir alt metin değil, karakter kümesidir: `"abcMetinabc".strip("abc")` uçlardaki a, b ve c karakterlerinin hepsini, sırası ne olursa olsun, siler. Yalnızca bir önek ya da sonek kesmek istiyorsanız `removeprefix()` ve `removesuffix()` kullanın (Python 3.9'dan itibaren).

## Diğer kullanışlı string metotları

| Metot | Ne yapar | Örnek → sonuç |
| --- | --- | --- |

| `lower()`, `upper()` | harf büyüklüğü | `"Kahve".lower()` → `'kahve'` |

| `startswith()`, `endswith()` | başlangıç ve bitiş kontrolü | `"a.csv".endswith(".csv")` → `True` |

| `find()` | alt metnin konumu ya da -1 | `"kahve".find("h")` → `2` |

| `count()` | geçiş sayısı | `"banana".count("a")` → `3` |

| `isdigit()` | yalnızca rakam mı? | `"250".isdigit()` → `True` |

| `zfill()` | başına sıfır ekler | `"7".zfill(3)` → `'007'` |

Bir stringin alt metin içerip içermediğini en kolay `in` operatörüyle kontrol edersiniz: `if "kahve" in text.lower():`. Stringler `==` ile karakter karakter ve büyük-küçük harfe duyarlı karşılaştırılır; harf duyarsız karşılaştırma için iki tarafı da `casefold()` ile dönüştürün.

## String dilimleme

String bir dizidir; karakterlere sıfırdan başlayan indeksle erişilir, negatif indeks sondan sayar. `s[başlangıç:bitiş:adım]` biçimindeki dilim bir alt string döndürür; bitiş sınırı dahil değildir.

```
s = "Python"
s[0]      # 'P'
s[-1]     # 'n'
s[0:3]    # 'Pyt'
s[2:]     # 'thon'
s[::2]    # 'Pto'
s[::-1]   # 'nohtyP' — stringi ters çevirir
```

Dilim, sınırların dışına çıksanız da hata vermez: `s[0:100]` tüm stringi döndürür. Ama `s[100]` bir `IndexError` verir. Bir karakteri indeksle değiştiremezsiniz (`s[0] = "J"` bir `TypeError` verir); yeni bir string kurmanız gerekir: `"J" + s[1:]`.

## f-string'ler

String başındaki `f` harfi, süslü parantez içindeki ifadelerin hesaplanıp metne yerleştirileceğini belirtir. Python 3.6'dan beri metin biçimlendirmenin ana yoludur: `format()`'tan daha kısadır ve eski `%` operatöründen daha hızlıdır.

```
item = "Kahve"
price = 250
print(f"{item}: {price} TL")              # Kahve: 250 TL
print(f"İndirimli: {price * 0.9} TL")     # İndirimli: 225.0 TL
print(f"{item=}")                          # item='Kahve' — hata ayıklama için kullanışlı
```

### Sayıların biçimlendirilmesi ve hizalama

Süslü parantez içinde iki nokta üst üste işaretinden sonra biçim belirleyicisi yazılır. Yuvarlama, binlik ayraçları, genişlik ve hizalamayı bu belirleyici ayarlar:

| Yazım | Sonuç | Anlamı |
| --- | --- | --- |

| `f"{3.14159:.2f}"` | `3.14` | 2 haneye yuvarlama |

| `f"{1250000:,}"` | `1,250,000` | binlik ayracı |

| `f"{1250000:_}"` | `1_250_000` | virgül yerine alt çizgi |

| `f"{0.256:.1%}"` | `25.6%` | yüzde |

| `f"{'kahve':<10}|"` | `kahve |` | sola yaslı, genişlik 10 |

| `f"{250:>8}"` | ` 250` | sağa yaslı |

| `f"{7:03d}"` | `007` | başına sıfır ekleme |

Hizalama terminaldeki tablolar için uygundur: `f"{name:<12}{amount:>10.2f}"` sütunları tam hizalar. Biçimlendirmeyi yalnızca çıktı verirken yapın. Parayı `float` yerine kuruş cinsinden tam sayı (`int`) ya da `Decimal` ile tutun: `0.1 + 0.2` sonucu `0.30000000000000004` çıkar.

### Tırnaklar ve f-string içinde satır sonu

Python 3.12 ile (PEP 701) f-string'ler resmi bir dilbilgisi kazandı: süslü parantez içinde dıştakiyle aynı tırnakları, ters eğik çizgileri ve satır sonlarını kullanabilirsiniz; iç içe yazım sınırı da kalktı. Parantez içindeki hatalar artık tam konumu gösteriyor. Eski sürümlerde içeride farklı tırnak türü kullanın: `f"{d['key']}"`; satır sonunu ise ayrı bir değişkenle ya da `chr(10)` ile verin.

Çok satırlı metin için üç tırnaklı f-string uygundur: `f"""Toplam: {total}\nKalem sayısı: {count}"""`.

### format() ve %: eski yöntemler

Başkalarının kodunda `"{}: {}".format(item, price)` ve `"%s: %d" % (item, price)` ile karşılaşırsınız. `format()` metodunun biçim belirleyicileri f-string'lerdekilerle aynıdır. `format()` yine de şablon veriden ayrı tutulduğunda, örneğin bir ayar dosyasında, kullanışlıdır.

## Pratik örnek: satır ayrıştırmak

Metotları birlikte kullanalım. Bir dosyadan `"  2026-10-16; Kahve ; 250,50 \n"` gibi satırlar geldiğini ve tarihi, adı ile tutarı kuruş cinsinden almak istediğinizi varsayın. Sıra şöyledir: kenarları temizle, ayraçtan böl, her parçayı düzelt, türleri dönüştür.

```
line = "  2026-10-16; Kahve ; 250,50 \n"

date, item, raw_amount = [p.strip() for p in line.strip().split(";")]
amount_kop = round(float(raw_amount.replace(",", ".")) * 100)

print(date, item, amount_kop)            # 2026-10-16 Kahve 25050
print(f"{item:10.2f}")
```

Parça sayısı üçten farklıysa açma işlemi `ValueError: not enough values to unpack` ya da `too many values to unpack` hatasıyla durur. Gerçek kodda bu satırları önceden kontrol edin ya da istisnayı yakalayın. Tırnak ve kaçış karakteri içeren gerçek CSV dosyaları için `split` yerine standart `csv` modülünü kullanın.

### Stringlerde tipik hatalar

- **Metodun sonucu kaydedilmemiş**: `s.strip()` tek başına hiçbir şeyi değiştirmez.
- **Sayı listesinde join** — `TypeError`; önce `map(str, ...)` kullanın.
- **strip ile alt metin**: argüman bir karakter kümesidir; önek için `removeprefix()` gerekir.
- **Büyük-küçük harf farkı**: `"Kahve" == "kahve"` değeri `False`'tur.
- **Windows yollarında ters eğik çizgi**, `r` öneki olmadan özel karaktere dönüşür.

## t-string'ler: hazır metin yerine şablon

Python 3.14 ile t-string'ler geldi. Görünüşleri f-string'e benzer, yalnızca başlarında `t` vardır; ama sonuç farklıdır: hazır bir string değil, `string.templatelib.Template` nesnesi döner. Bu nesnede metin parçaları (`.strings`) ve yerleştirilen değerler (`.values`) ayrı ayrı tutulur.

```
name = ""
tpl = t"Merhaba, {name}!"
print(tpl.strings)   # ('Merhaba, ', '!')
print(tpl.values)    # ('',)
```

Bunun faydası şudur: bir kütüphane değerleri birleştirilmeden önce alır ve işleyebilir; örneğin HTML'de köşeli parantezleri kaçırabilir ya da SQL sorgusuna parametreyi güvenle geçirebilir. f-string bu fırsatı vermez, çünkü her şeyi hemen birleştirir. Sıradan çıktı için f-string kullanmaya devam edin.

## Özet

Günlük string işleri için küçük bir metot seti yeterlidir: `split()` ve `join()` metni ayırıp birleştirir, `strip()` girdiyi temizler, `replace()` parçaları değiştirir, dilimler alt metinleri kesip alır, f-string'ler değerleri istediğiniz biçimde yazdırır. Değiştirilemezlik kuralını unutmayın: metot yeni bir string döndürür ve onu kaydetmeniz gerekir. Stringler, sayılar ve f-string'ler harcama takipçisi örneğiyle kursun Python dersinde uygulamalı olarak işlenir.

## FAQ

**Python'da bir stringin uzunluğu nasıl öğrenilir?**

len(s) fonksiyonu karakter sayısını verir. Türkçe karakterler ve emojiler Unicode karakter olarak sayılır; bayt cinsinden boyut için len(s.encode("utf-8")) kullanın.

**Sayıyı stringe, stringi sayıya nasıl çeviririm?**

str(250) değeri '250' yapar; int("250") ve float("2.5") ise tersini yapar. String sayıya benzemiyorsa int() bir ValueError verir, bu yüzden girdiyi kontrol edin.

**replace neden stringimi değiştirmiyor?**

Stringler değiştirilemez; replace yeni bir string döndürür. Sonucu atayın: s = s.replace("a", "b").

**Bir stringin boş olup olmadığı nasıl kontrol edilir?**

Boş string False gibi davranır; if not s: yeterlidir. Metin yalnızca boşluklardan oluşabiliyorsa if not s.strip(): kullanın.

**t-string ile f-string arasındaki fark nedir?**

f-string hemen hazır bir str döndürür; t-string (Python 3.14+) ise metin parçalarını ve değerleri ayrı tutan bir Template nesnesi döndürür. Bu sayede veriler HTML ve SQL için güvenle kaçırılabilir.


---
Source: Skillaria.Top (https://skillaria.top)