Regex (Düzenli İfade) Nedir? Python ve Java'da Kullanımı

Regex nedir sorusunun kısa cevabı şudur: regex (düzenli ifade), bir metin içinde belirli bir deseni tanımlamak ve bu desene uyan parçaları bulmak, doğrulamak veya değiştirmek için kullanılan özel bir yazım dilidir. Bir e-posta adresinin doğru formatta olup olmadığını kontrol etmek, bir log dosyasında hata satırlarını yakalamak ya da uzun bir metinden telefon numaralarını ayıklamak gibi işler regex ile birkaç satırda çözülür. Python ve Java gibi diller regex'i kendi standart kütüphaneleriyle destekler; bu yazıda hem sözdizimini hem de iki dildeki pratik kullanımını adım adım göreceksiniz.

Regex (Düzenli İfade) Nedir ve Neden Kullanılır?

Bir web formunda kullanıcının girdiği e-posta adresinin "@" işareti içerip içermediğini, bir telefon numarasının doğru sayıda rakamdan oluşup oluşmadığını veya bir şifrenin en az bir büyük harf ve bir rakam taşıyıp taşımadığını kontrol etmeniz gerektiğini düşünün. Bunu klasik if-else ve karakter döngüleriyle yazmaya kalkarsanız kod hem uzar hem de okunması zorlaşır. Regex tam olarak bu noktada devreye girer: desen bir kez tanımlanır, ardından herhangi bir metne uygulanarak eşleşip eşleşmediği tek satırda anlaşılır.

Günlük yazılım geliştirme pratiğinde regex'in en sık karşılaşılan kullanım alanları şunlardır:

• Form doğrulama: e-posta, telefon numarası, posta kodu gibi alanların formatını kontrol etmek.
• Log dosyası analizi: binlerce satır arasından "ERROR" veya "WARNING" ile başlayan satırları bulmak.
• Metinden veri ayıklama: bir metin bloğu içindeki tüm tarihleri, URL'leri veya sayıları çekmek.
• Metin değiştirme: bir dosyadaki belirli bir kelime kalıbını başka bir ifadeyle toplu olarak değiştirmek.

Regex'in ne olmadığını bilmek de en az ne olduğunu bilmek kadar önemlidir. Regex, karmaşık bir cümlenin gramer yapısını çözümlemek veya bir programlama dilinin kaynak kodunu tam anlamıyla ayrıştırmak (parsing) için tasarlanmış bir araç değildir; bu tür işler için derleyici teorisi temelli ayrıştırıcılar kullanılır. Regex'in gücü, sınırlı ve tekrarlayan desenleri hızlıca yakalamaktır — iç içe geçmiş, bağlam gerektiren yapılarla uğraşırken zorlanır ve kod okunaksız hale gelir. Bu nedenle regex'i "basit ama tekrarlayan metin kalıplarını yakalayan bir filtre" olarak düşünmek en doğru yaklaşımdır.

Hem Python hem de Java, regex desteğini kendi standart kütüphanelerinin içine gömmüştür; Python'da bu iş re modülüyle, Java'da ise Pattern ve Matcher sınıflarıyla yapılır. İki dilde de kullanılan sembol seti neredeyse birebir aynıdır, farklılık daha çok bu sembolleri koda bağlama biçiminde ortaya çıkar; bu ayrıntılara ilerleyen bölümlerde tek tek değineceğiz.

Temel Regex Sözdizimi: Semboller ve Anlamları

Regex öğrenirken karşınıza çıkan sembollerin çoğu aslında birer kısayoldur: her biri "şu tür bir karakteri veya tekrarı ara" demenin kısa yoludur. Aşağıdaki tablo en sık kullanılan sembolleri ve gerçek hayattan örneklerini bir arada gösteriyor.

Bu sembollerin hepsi Python'da da Java'da da aynı şekilde çalışır; regex motoru desenin anlamını yorumlarken dil farkı gözetmez. Asıl fark, bu deseni koda nasıl yazdığınız ve sonuçları nasıl işlediğinizdedir — bunu bir sonraki iki bölümde göreceksiniz. Sembolleri ezberlemeden önce mantığını oturtmak isteyenler algoritma bilgi seviyesini ölçen ücretsiz test ile kendi başlangıç seviyesini görebilir; regex de sonuçta bir örüntü tanıma ve algoritmik düşünme egzersizidir.

Python'da Regex Kullanımı: re Modülü

Python'da regex işlemleri standart kütüphanenin bir parçası olan re modülü üzerinden yapılır. Modülün dört temel fonksiyonu vardır ve her biri farklı bir ihtiyaca cevap verir: re.match yalnızca dizenin başında eşleşme arar, re.search dizenin tamamını tarayarak ilk eşleşmeyi bulur, re.findall ise dizedeki tüm eşleşmeleri bir liste olarak döner. re.compile ise bir deseni önceden derleyip yeniden kullanılabilir bir nesneye dönüştürür; aynı deseni defalarca kullanacaksanız performans açısından tercih edilir.

re.match sadece dizenin başlangıcına bakar, dizenin ortasında bir eşleşme varsa bunu görmez:

import re

sonuc = re.match(r"d+", "123abc")
print(sonuc.group())  # "123"

sonuc2 = re.match(r"d+", "abc123")
print(sonuc2)  # None, çünkü dize rakamla başlamıyor

re.search ise dizenin tamamını tarar ve ilk eşleşmeyi bulduğu anda durur:

import re

metin = "Sipariş numaranız: 48213"
sonuc = re.search(r"d+", metin)
print(sonuc.group())  # "48213"

re.findall, metindeki tüm eşleşmeleri tek seferde bir liste olarak döndürür; birden fazla veri ayıklamak gerektiğinde en pratik seçenektir:

import re

metin = "Numaralar: 12, 45, 908"
sonuclar = re.findall(r"d+", metin)
print(sonuclar)  # ['12', '45', '908']

Aynı deseni birden fazla kez kullanacaksanız re.compile ile derleyip bir değişkende saklamak hem kodu sadeleştirir hem de tekrar eden derleme maliyetini ortadan kaldırır:

import re

desen = re.compile(r"d+")
print(desen.findall("2024 yılında 15 proje tamamlandı"))
# ['2024', '15']

Python'un regex kullanımındaki en belirgin özelliği, fonksiyonel ve tek satırlık yazım tarzına uygun olmasıdır; bir deseni tanımlamak, metne uygulamak ve sonucu almak genellikle tek satırda tamamlanır. Bu sadelik, regex'i yeni öğrenen biri için Python'u oldukça elverişli bir başlangıç noktası yapar. Bu mantığı sıfırdan, uygulamalı örneklerle pekiştirmek isteyenler için birebir Python eğitimi içinde regex konusu da veri doğrulama ve metin işleme başlıkları altında ele alınır.

Java'da Regex Kullanımı: Pattern ve Matcher Sınıfları

Java'da regex kullanımı Python'a göre daha nesne tabanlıdır ve iki ayrı adımdan oluşur: önce deseni derlemek, sonra bu derlenmiş desenle metin üzerinde eşleştirme yapmak. Bu işi java.util.regex paketindeki iki sınıf üstlenir: Pattern ve Matcher. Pattern.compile() metodu regex string'ini alır ve onu tekrar tekrar kullanılabilecek bir Pattern nesnesine dönüştürür; bu nesne üzerinden matcher() çağrılarak asıl eşleştirme işini yapan Matcher nesnesi elde edilir.

Matcher nesnesi üç temel metotla çalışır: matches() tüm string'in deseni baştan sona karşıladığını kontrol eder, find() string içinde desenle eşleşen bir parça arar ve bulduğunda ilerlemeye devam eder, group() ise bulunan eşleşmenin metnini döndürür. Bu üçlü, Python'daki re.match(), re.search() ve match.group() fonksiyonlarının kavramsal karşılığıdır ama Java'da bunlar tek bir fonksiyon çağrısı yerine ayrı nesneler üzerinden yürütülür.

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexOrnek {
    public static void main(String[] args) {
        String metin = "Iletisim: [email protected]";
        Pattern pattern = Pattern.compile("[a-zA-Z0-9._]+@[a-zA-Z0-9]+.[a-zA-Z]+");
        Matcher matcher = pattern.matcher(metin);

        if (matcher.find()) {
            System.out.println("Bulunan e-posta: " + matcher.group());
        } else {
            System.out.println("Eslesme bulunamadi.");
        }
    }
}

Python'da aynı işlem tek satırda re.search(desen, metin) şeklinde yazılabilirken, Java'da önce Pattern derlenir, sonra bu desenden bir Matcher üretilir ve ancak ondan sonra eşleştirme sonucu okunabilir. Bu fark rastgele değildir: Java'nın statik tipli ve nesne odaklı yapısı, deseni bir kere derleyip aynı Pattern nesnesini farklı metinler üzerinde defalarca kullanmayı teşvik eder. Özellikle döngü içinde aynı deseni tekrar tekrar kullanacaksanız, deseni döngü dışında bir kez derlemek performans açısından daha doğru bir alışkanlıktır. Java'nın nesne tabanlı yaklaşımını sözdizimi düzeyinde daha derinlemesine görmek isteyenler için birebir Java dersleri bu tür API'lerin mantığını örneklerle adım adım işler.

Adım Adım E-Posta Doğrulama Deseni Kurma

Karmaşık bir regex'i baştan yazmaya çalışmak yerine, deseni küçük parçalar halinde büyütmek hem hatayı azaltır hem de her sembolün neden orada olduğunu anlamanızı sağlar. Aşağıdaki adımlar basit bir e-posta doğrulama deseninin nasıl aşama aşama oluşturulduğunu gösterir.

1. Sadece harflerden oluşan basit desen: ^[a-zA-Z]+$ deseni yalnızca baştan sona harflerden oluşan bir metni kontrol eder. Bu aşamada henüz e-posta değil, sadece bir kullanıcı adının harflerden oluşup oluşmadığını doğruluyoruz; ^ ve $ işaretleri metnin başını ve sonunu sabitleyerek deseni tüm string'e zorunlu kılar.
2. @ işaretini ekleme: Desen ^[a-zA-Z]+@$ haline getirilir. Burada amaç henüz domain kısmını değil, sadece kullanıcı adından sonra @ karakterinin gelip gelmediğini görmektir. Gerçek bir e-postada bu adım tek başına yeterli olmaz ama deseni parça parça kurarken hangi bölümün ne işe yaradığını netleştirir.
3. Domain kısmını ekleme: @ işaretinden sonra da harflerden oluşan bir alan adı beklediğimiz için desen ^[a-zA-Z]+@[a-zA-Z]+$ şekline döner. Artık "kullanici@domain" biçimindeki basit bir yapıyı yakalayabiliyoruz, ama gerçek bir e-postada domain adının bir uzantısı (.com, .net gibi) da olması gerekir.
4. Nokta ve uzantıyı ekleme: Desen ^[a-zA-Z]+@[a-zA-Z]+.[a-zA-Z]+$ haline getirilir. Buradaki . ifadesi noktayı özel bir anlam taşımadan, gerçek bir nokta karakteri olarak aramak için kullanılır; regex sözdiziminde tek başına nokta "herhangi bir karakter" anlamına geldiği için kaçış (escape) işareti gereklidir.
5. Rakam ve ek karakterlere izin verme: Gerçek kullanıcı adları genellikle sadece harflerden oluşmaz; rakam, nokta veya alt çizgi de içerebilir. Bu yüzden kullanıcı adı kısmı [a-zA-Z0-9._]+ şeklinde genişletilir ve desen ^[a-zA-Z0-9._]+@[a-zA-Z0-9]+.[a-zA-Z]+$ halini alır. Bu, öğretici amaçlı basit bir e-posta doğrulama deseni olup üretim ortamındaki tüm uç durumları kapsamayı hedeflemez.

Bu beş adımı takip ederek kurulan desen, bir e-postanın temel yapısını (kullanıcı adı, @ işareti, domain, nokta ve uzantı) doğrulamak için yeterlidir. Regex öğrenirken bu tür kademeli yaklaşım, deseni ezberlemek yerine her parçanın işlevini kavramanızı sağladığı için çok daha kalıcı bir öğrenme yöntemidir.

İki Dilde Tam E-Posta Doğrulama Kodu ve Karşılaştırma

Bir önceki bölümde adım adım oluşturulan ^[a-zA-Z0-9._]+@[a-zA-Z0-9]+.[a-zA-Z]+$ deseni, hem Python hem Java tarafında çalışan basit bir doğrulama programına dönüştürülebilir. Aşağıdaki iki örnek aynı mantığı iki farklı dilde uygular ve girilen bir metnin bu basit e-posta kalıbına uyup uymadığını ekrana yazdırır.

import re

desen = r"^[a-zA-Z0-9._]+@[a-zA-Z0-9]+.[a-zA-Z]+$"
test_metni = "[email protected]"

if re.match(desen, test_metni):
    print("Gecerli e-posta formati.")
else:
    print("Gecersiz e-posta formati.")

import java.util.regex.Pattern;

public class EpostaDogrulama {
    public static void main(String[] args) {
        String desen = "^[a-zA-Z0-9._]+@[a-zA-Z0-9]+.[a-zA-Z]+$";
        String testMetni = "[email protected]";

        if (Pattern.matches(desen, testMetni)) {
            System.out.println("Gecerli e-posta formati.");
        } else {
            System.out.println("Gecersiz e-posta formati.");
        }
    }
}

İki kod da aynı deseni kullanır ve aynı sonucu üretir, ancak yazım yaklaşımları farklıdır. Python'da re.match() deseni ve metni doğrudan parametre olarak alıp sonucu tek adımda döndürürken, Java'da Pattern.matches() statik metodu benzer bir kısayolu sağlasa da büyük projelerde genellikle Pattern.compile() ve Matcher nesnesi ayrı ayrı kullanılır. Aşağıdaki tablo iki dilin regex söz dizimindeki temel kavramsal farkları özetler.

Bu karşılaştırma, regex mantığının dilden dile değişmediğini ama söz diziminin ve API akışının o dilin genel programlama felsefesine göre şekillendiğini gösterir. Python kısa ve fonksiyonel bir yaklaşım sunarken, Java daha açık ve nesne tabanlı bir akış izler; ikisini de bilmek, farklı projelerde hangi yaklaşımın daha uygun olduğunu görmenizi kolaylaştırır.

Yaygın Regex Hataları ve Nasıl Önlenir

Regex yazmayı öğrenen hemen herkesin karşılaştığı birkaç klasik hata vardır. Bu hataların çoğu, deseni çalıştırıp beklenmeyen bir sonuç görene kadar fark edilmez. En sık karşılaşılan üç problemi ve çözümlerini örneklerle inceleyelim.

Greedy ve Lazy Eşleşme Karışıklığı

Greedy (açgözlü) eşleşme, bir regex sembolünün mümkün olduğunca uzun bir metni yakalamaya çalışması demektir. * ve + sembolleri varsayılan olarak greedy çalışır. Bunun yanına bir ? eklendiğinde (*?, +?) desen "lazy" (tembel) moda geçer ve mümkün olan en kısa eşleşmeyi arar. HTML benzeri metinlerde bu fark çok net görülür:

import re

text = "<b>kalın</b> ve <i>italik</i>"

greedy = re.findall(r"<.*>", text)
lazy = re.findall(r"<.*?>", text)

print(greedy)  # ['<b>kalın</b> ve <i>italik</i>']
print(lazy)    # ['<b>', '</b>', '<i>', '</i>']

Greedy desen, ilk < ile son > arasındaki her şeyi tek parça olarak yutar. Lazy desen ise her etiketi ayrı ayrı yakalar. Etiket, parantez veya tırnak gibi çift sınırlayıcılarla çalışırken hangi modu kullandığınızı bilmemek, yanlış ve devasa eşleşmelere yol açar.

Kaçış Karakteri Unutma Hatası

Regex'te nokta işareti (.) satır sonu hariç herhangi bir karakteri temsil eder. Bir alan adı veya dosya uzantısı doğrularken gerçek bir nokta aramak istiyorsanız onu . ile kaçırmanız gerekir; aksi halde nokta yerine herhangi bir karakter de eşleşir:

import re

pattern_yanlis = r"www.berkakademi.com"      # nokta kaçırılmadı
pattern_dogru = r"www.berkakademi.com"     # nokta kaçırıldı

test1 = "www.berkakademi.com"
test2 = "wwwXberkakademiXcom"

print(bool(re.fullmatch(pattern_yanlis, test2)))  # True -> istenmeyen sonuç
print(bool(re.fullmatch(pattern_dogru, test2)))   # False -> doğru davranış

Bu tek karakterlik fark, yanlış verilerin geçerli sayılmasına neden olabilir. Bu yüzden desen içindeki her nokta, parantez veya artı işaretinin gerçekten özel bir anlam mı taşıması gerektiğini yoksa düz metin olarak mı aranması gerektiğini kontrol etmek gerekir.

Aşırı Genel Desen Yazmanın Riskleri

Yeni başlayanların en sık yaptığı hata, "nasılsa çalışsın" mantığıyla .* gibi her şeyi yakalayan geniş desenler kurmaktır. Bu yaklaşım kısa vadede işe yarasa da veri doğrulama söz konusu olduğunda ciddi riskler taşır:

• Geçersiz veya bozuk bir girdi, aslında hatalı olmasına rağmen "doğru" olarak kabul edilebilir.
• Desen ne aradığınızı net göstermediği için kodu sonradan okuyan biri (ya da siz) mantığı anlamakta zorlanır.
• Beklenmeyen karakterler (boşluk, özel işaret, birden fazla satır) sessizce eşleşmeye dahil olabilir.
• Hata ayıklarken hangi kısmın yanlış eşleştiğini bulmak zorlaşır, çünkü desen zaten her şeye izin veriyordur.

Bunun yerine ne aradığınızı net biçimde tanımlayan, dar ve spesifik desenler kurmak; hem daha güvenli hem de daha kolay bakım yapılabilir kod anlamına gelir.

Regex Bir Araçtır: Asıl Güç Dil Mantığında

Regex, metin içinde belirli bir kalıbı bulmak için gerçekten pratik bir araçtır; ama bir sınırı vardır. Regex tek başına karar veremez, döngü kuramaz, veritabanına bağlanamaz ya da bir işin akışını yönetemez. Yaptığı tek şey, verdiğiniz deseni metinle karşılaştırıp evet ya da hayır demektir. Bir e-posta adresinin formatını doğrulayabilir ama o adresin gerçekten var olup olmadığını, bir kullanıcıya ait olup olmadığını ya da sistemde tekrar edip etmediğini bilemez — bunlar programın kendi mantığının işidir.

Bu yüzden regex öğrenmek, iyi bir geliştirici olmanın tek şartı değil, araç kutusuna eklenen faydalı bir parçadır. Asıl fark yaratan şey; bu deseni ne zaman kullanacağınızı bilmek, doğrulama sonucunu koşullarla, döngülerle ve fonksiyonlarla nasıl birleştireceğinizi kurgulamak ve hatalı girdi geldiğinde programın ne yapacağına karar vermektir. Regex'i öğrenen ama onu çevreleyen kodu zayıf kuran bir geliştirici, doğru desenle bile kırılgan bir sistem üretebilir.

Bu noktada kendi seviyenizi görmek işe yarar. Hem regex mantığını hem de genel kod okuma ve problem çözme becerinizi ölçmek için ücretsiz kodlama bilgisi testi kısa sürede nerede güçlü, nerede eksik olduğunuzu gösterir. Sonuçlara göre hangi konuya daha çok zaman ayırmanız gerektiğini netleştirebilirsiniz.

Sonuç olarak regex, doğru yerde kullanıldığında zaman kazandıran küçük ama etkili bir araçtır. Onu ezberlemek yerine ne işe yaradığını ve nerede yetersiz kaldığını anlamak, uzun vadede çok daha değerlidir.

Sık Sorulan Sorular

Regex öğrenmek için önceden programlama bilmek gerekir mi?

Hayır, regex'in temel sembollerini kavramsal olarak öğrenmek başlı başına mümkündür. Ancak regex'i gerçek bir programda (veri doğrulama, dosya arama, form kontrolü gibi) kullanabilmek için en azından temel düzeyde bir programlama dili bilmeniz gerekir; çünkü regex tek başına bir program değil, bir dilin içinde çağrılan bir araçtır.

Python'daki re modülü ile Java'daki Pattern/Matcher arasındaki en büyük fark nedir?

İkisi de aynı temel regex mantığını kullanır, fark daha çok kullanım biçimindedir. Python'da re modülü fonksiyon tabanlı ve daha kısa yazımlıdır; Java'da ise önce Pattern sınıfıyla desen derlenir, sonra Matcher sınıfıyla metin üzerinde eşleştirme yapılır. Bu da Java tarafını biraz daha adım adım ama nesne yönelimli hale getirir.

Greedy ve lazy eşleşme arasındaki fark nedir?

Greedy eşleşme mümkün olan en uzun metni yakalamaya çalışır, lazy eşleşme ise mümkün olan en kısa metni yakalar. Örneğin etiketli bir metinde greedy desen ilk açılıştan son kapanışa kadar her şeyi tek parça alırken, lazy desen her etiketi ayrı ayrı yakalar.

E-posta doğrulama için gerçekten karmaşık regex desenleri kullanmak gerekir mi?

Günlük kullanım ve öğrenme amaçlı projeler için basit ve okunabilir bir desen genellikle yeterlidir. Aşırı karmaşık, üretim seviyesinde desenler hem okunması zor hem de bakımı zahmetli hale gelir; temel yapıyı doğru kurup gerektiğinde ek kontrollerle desteklemek daha sağlıklı bir yaklaşımdır.

re.match ile re.search arasındaki fark nedir?

re.match yalnızca metnin en başından itibaren eşleşme arar; metnin ortasında bir yerde eşleşme olsa bile başta değilse sonuç bulunmaz. re.search ise metnin tamamını tarar ve deseni bulduğu ilk yerde eşleşmeyi döndürür.

Regex her zaman en iyi çözüm müdür?

Hayır. Regex, kalıp tabanlı metin arama ve doğrulama için uygundur; ancak karmaşık yapısal veriyi (örneğin iç içe geçmiş JSON veya HTML) ayrıştırmak için uygun bir araç değildir. Böyle durumlarda dilin kendi kütüphaneleri veya ayrıştırıcıları regex'ten çok daha güvenilir sonuç verir.

Regex öğrenmeye nereden başlamalıyım?

En sağlıklı yol, önce temel sembolleri (nokta, yıldız, artı, karakter sınıfları) küçük örneklerle denemek, ardından bunları kendi kullandığınız dilin regex kütüphanesiyle (Python'da re, Java'da Pattern/Matcher) birleştirmektir. Ezber yerine her sembolü bir örnek üzerinde çalıştırarak görmek kalıcı öğrenmeyi hızlandırır.

Regex, doğru kullanıldığında metinle uğraşan her geliştiricinin işini kolaylaştıran pratik bir beceridir; ama tek başına yeterli değildir, asıl değeri onu iyi kurgulanmış bir kodun içinde kullanmaktan gelir. Bu temel mantığı Python ve Java üzerinden daha derinlemesine, uygulamalı biçimde pekiştirmek isterseniz 1-1 özel Python dersleri size adım adım eşlik edebilir.