Python Düzenli İfadeler (Regex) Eğitimi

Düzenli İfadeler (regular expressions), kısaca regex, bir metinde (string) belirli bir desenin var olup olmadığını kontrol etmek için kullanılan karakter dizileridir. Arama motorlarını, kelime işlemcilerin ve metin düzenleyicilerin bul-değiştir araçlarını kullandıysanız, düzenli ifadeleri zaten görmüşsünüzdür. Kayıt sırasında e-posta adreslerinin veya parolaların biçimini sunucu tarafında doğrulamak, belirli dizeleri bulmak, değiştirmek ya da silmek için metin veri dosyalarını ayrıştırmak gibi amaçlarla kullanılırlar. Metinsel verileri işleme konusunda yardımcı olurlar; bu da metin madenciliği içeren veri bilimi projeleri için çoğu zaman bir ön koşuldur.

Bu eğitim, Python ile düzenli ifadelerin önemli kavramlarını adım adım ele alacaktır. Önce düzenli ifadeleri destekleyen Python kütüphanesi olan re modülünü içe aktarmak ile başlayacaksınız. Ardından temel/sıradan karakterler ile eşleşmelerin nasıl yapıldığını, sonrasında ise joker ya da özel karakterleri göreceksiniz. Sonraki adımda düzenli ifadelerinizde tekrarların kullanımını öğreneceksiniz. Eşleşmelere kolay erişim sağlamak için aramanız içinde gruplar ve adlandırılmış gruplar oluşturmayı da göreceksiniz. Devamında açgözlü ve açgözlü olmayan eşleşme kavramına aşina olacaksınız.

Bu şimdiden çok gibi görünüyor; bu nedenle, şimdiye kadar gördüklerinizi kısa tanımlarla hatırlamanıza yardımcı olacak kullanışlı bir özet tablo da ekledik. Göz atmayı unutmayın!

Bu eğitim aynı zamanda re kütüphanesinin sunduğu, arama ve değiştirme için compile(), search(), findall(), sub(), split() ve daha bazı faydalı işlevleri de kapsar. Ayrıca regex’inizi daha iyi hale getirmek için kullanabileceğiniz derleme bayraklarını da öğreneceksiniz.

Son olarak bir vaka çalışması var — bilgilerinizi uygulamaya dökebileceksiniz! Haydi regex’e başlayalım...

Python’da Düzenli İfadeler

Python’da düzenli ifadeler re modülü tarafından desteklenir. Yani bunları Python betiklerinizde kullanmaya başlamak istiyorsanız, import ifadesiyle bu modülü içe aktarmanız gerekir:

import re

Python’daki re kütüphanesi, ustalaşmaya değer kılan çeşitli işlevler sunar. Bu eğitimde bunların bazılarını yakından göreceksiniz.

Temel Desenler: Sıradan Karakterler

Python’da pek çok temel deseni sıradan karakterlerle kolayca ele alabilirsiniz. Sıradan karakterler, en basit düzenli ifadelerdir. Kendileriyle tam olarak eşleşirler ve düzenli ifade sözdiziminde özel bir anlam taşımazlar.

Örneğin 'A', 'a', 'X', '5'.

Sıradan karakterler basit, birebir eşleşmeler yapmak için kullanılabilir:

pattern = r"Cookie"
sequence = "Cookie"
if re.match(pattern, sequence):
    print("Match!")
else: print("Not a match!")

Match!

Çoğu harf ve karakter, örnekte gördüğünüz gibi kendiyle eşleşir.

match() işlevi, metin desenle eşleşirse bir match nesnesi döndürür. Aksi takdirde None döndürür. re modülü başka pek çok işlev de içerir; bunlardan bazılarını eğitimin ilerleyen kısımlarında öğreneceksiniz.

Şimdilik, sıradan karakterlere odaklanalım!

Desenin başındaki r harfini fark ettiniz mi: Cookie?
Buna ham (raw) string literal denir. String literal’in nasıl yorumlandığını değiştirir. Bu tür literal’ler göründükleri gibi saklanır.

Örneğin, \ bir r önekiyle kaçış dizisi olarak yorumlanmak yerine sadece ters eğik çizgidir. Bunun özel karakterlerde ne anlama geldiğini göreceksiniz. Bazen sözdizimi ters eğik çizgiyle kaçırılmış karakterler içerir ve bu karakterlerin kaçış dizileri olarak yorumlanmasını önlemek için ham r önekini kullanırsınız.

İPUCU: Bu örnek için aslında gerekmez; ancak tutarlılık için kullanmak iyi bir pratiktir.

Joker Karakterler: Özel Karakterler

Özel karakterler, göründükleri gibi kendileriyle eşleşmeyen; düzenli ifadede kullanıldığında özel bir anlama sahip karakterlerdir. Basitçe, başka bir şeyi temsil eden, ayrılmış (rezerve) metakarakterler olarak düşünebilirsiniz.

Özel karakterleri iş başında görmek için birkaç örneğe bakalım...

Ama önce, aşağıdaki örnekler iki işlev kullanır: search() ve group().
search işlevi ile verilen dizi/metin içinde tarama yapar, düzenli ifadenin eşleşme ürettiği ilk konumu ararsınız.
group işlevi ise re tarafından eşleştirilen stringi döndürür. Bu iki işlevi ileride daha ayrıntılı göreceksiniz.

Şimdi yeniden özel karakterlere dönelim.

. - Nokta. Yeni satır karakteri dışında herhangi bir tek karakterle eşleşir.

re.search(r'Co.k.e', 'Cookie').group()

'Cookie'

^ - Şapka (caret). Stringin başlangıcı ile eşleşir.

Bir belgenin/cümlenin belirli karakterlerle başladığından emin olmak istediğinizde faydalıdır.

re.search(r'^Eat', "Eat cake!").group()

## Ancak aşağıdaki kod aynı sonucu vermez. Kendiniz deneyin:
# re.search(r'^eat', "Let's eat cake!").group()

'Eat'

$ - Stringin sonu ile eşleşir.

Bir belgenin/cümlenin belirli karakterlerle bittiğinden emin olmak istediğinizde faydalıdır.

re.search(r'cake$', "Cake! Let's eat cake").group()

## Sıradaki arama NONE değeri döndürecektir, deneyin:
# re.search(r'cake$', "Let's get some cake on our way home!").group()

'cake'

[abc] - a veya b veya c ile eşleşir.
[a-zA-Z0-9] - (a’dan z’ye) ya da (A’dan Z’ye) ya da (0’dan 9’a) herhangi bir harf/rakamla eşleşir.

İPUCU: Bir aralıkta yer almayan karakterler, kümeyi tamamlayarak (complement) eşleştirilebilir. Kümenin ilk karakteri ^ ise, kümede bulunmayan tüm karakterler eşleşir.

re.search(r'[0-6]', 'Number: 5').group()

'5'

## 5 dışındaki herhangi bir karakterle eşleşir
re.search(r'Number: [^5]', 'Number: 0').group()

## Bu eşleşmez ve bu yüzden NONE değeri döner
#re.search(r'Number: [^5]', 'Number: 5').group()

'Number: 0'

\ - Ters eğik çizgi.
Belki de en çeşitli metakarakter!

• Eğer ters eğik çizgiyi izleyen karakter bir tanınan kaçış karakteri ise, terimin özel anlamı alınır (Senaryo 1)
• Eğer \ sonrasındaki karakter tanınan bir kaçış karakteri değilse, \ diğer karakterler gibi değerlendirilir ve aynen geçirilir (Senaryo 2).
• \, tüm metakarakterlerin önüne getirilerek onların özel anlamını kaldırmak için kullanılabilir (Senaryo 3).

## (Senaryo 1) Bu kullanım '\s' ifadesini bir kaçış karakteri olarak ele alır; '\s' boşluğu tanımlar
re.search(r'Not a\sregular character', 'Not a regular character').group()

'Not a regular character'

## (Senaryo 2) '\' sıradan bir karakter olarak ele alınır çünkü '\r' tanınan bir kaçış karakteri değildir
re.search(r'Just a \regular character', 'Just a \regular character').group()

'Just a \regular character'

## (Senaryo 3) '\s' fazladan bir `\` ile kaçırılır, böylece '\s' düz (literal) string olarak yorumlanır
re.search(r'Just a \\sregular character', 'Just a \sregular character').group()

'Just a \\sregular character'

'\' ile başlayan ve arama/ eşleştirme yaparken çok yararlı olan önceden tanımlı özel diziler vardır. Bazılarını yakından inceleyelim...

\w - Küçük w. Herhangi bir tek harf, rakam veya alt çizgi ile eşleşir.
\W - Büyük W. \w’nin (küçük w) parçası olmayan herhangi bir karakterle eşleşir.

print("Lowercase w:", re.search(r'Co\wk\we', 'Cookie').group())

## Tek harf, rakam veya alt çizgi dışındaki herhangi bir karakterle eşleşir
print("Uppercase W:", re.search(r'C\Wke', 'C@ke').group())

## Büyük W tek harf, rakam ile eşleşmez
print("Uppercase W won't match, and return:", re.search(r'Co\Wk\We', 'Cookie'))

Lowercase w: Cookie
Uppercase W: C@ke
Uppercase W won't match, and return: None

\s - Küçük s. Boşluk karakteriyle (boşluk, yeni satır, sekme, geri dönüş) eşleşir.
\S - Büyük S. \s’nin (küçük s) parçası olmayan herhangi bir karakterle eşleşir.

print("Lowercase s:", re.search(r'Eat\scake', 'Eat cake').group())
print("Uppercase S:", re.search(r'cook\Se', "Let's eat cookie").group())

Lowercase s: Eat cake
Uppercase S: cookie

\d - Küçük d. 0-9 arası ondalık rakamla eşleşir.
\D - Büyük D. Ondalık rakam olmayan herhangi bir karakterle eşleşir.

# \d için örnek
print("How many cookies do you want? ", re.search(r'\d+', '100 cookies').group())

How many cookies do you want?  100

Yukarıdaki örnekte \d’den sonra kullanılan + sembolü tekrar için kullanılır. Bunu tekrarlar bölümünde biraz daha ayrıntılı göreceksiniz...

\t - Küçük t. Sekme ile eşleşir.
\n - Küçük n. Yeni satır ile eşleşir.
\r - Küçük r. Geri dönüş ile eşleşir.
\A - Büyük A. Yalnızca stringin başlangıcıyla eşleşir. Çok satırlı metinlerde de çalışır.
\Z - Büyük Z. Yalnızca stringin sonuyla eşleşir.
İPUCU: ^ ve \A pratikte aynıdır; $ ve \Z de öyle. MULTILINE kipinde farklılaşırlar. Daha fazlası için bayraklar bölümüne bakın.

\b - Küçük b. Yalnızca kelimenin başı veya sonuyla eşleşir.

# \t için örnek
print("\\t (TAB) example: ", re.search(r'Eat\tcake', 'Eat    cake').group())

# \b için örnek
print("\\b match gives: ",re.search(r'\b[A-E]ookie', 'Cookie').group())

\t (TAB) example:  Eat    cake
\b match gives:  Cookie

Tekrarlar

Bir dizide uzun desenler arıyorsanız bu epey zahmetli olabilir. Neyse ki re modülü tekrarları aşağıdaki özel karakterlerle ele alır:

+ - Önceki karakterin, bulunduğu konumdan itibaren bir veya daha fazla kez görünüp görünmediğini kontrol eder.

re.search(r'Co+kie', 'Cooookie').group()

'Cooookie'

* - Önceki karakterin, bulunduğu konumdan itibaren sıfır veya daha fazla kez görünüp görünmediğini kontrol eder.

# Verilen dizide a ya da o ya da her ikisinin herhangi bir tekrarını kontrol eder
re.search(r'Ca*o*kie', 'Cookie').group()

'Cookie'

? - Önceki karakterin, bulunduğu konumdan itibaren tam olarak sıfır veya bir kez görünüp görünmediğini kontrol eder.

# Verilen dizide a ya da o ya da her ikisinin tam olarak sıfır veya bir kez görünmesini kontrol eder
re.search(r'Colou?r', 'Color').group()

'Color'

Peki tam olarak belirli sayıda tekrar kontrol etmek isterseniz?

Örneğin, bir uygulamada telefon numarasının geçerliliğini kontrol etmek. re modülü bunu da aşağıdaki düzenli ifadelerle gayet şık biçimde ele alır:

{x} - Tam x kez tekrar et.
{x,} - En az x kez veya daha fazla tekrar et.
{x, y} - En az x, en fazla y kez tekrar et.

re.search(r'\d{9,10}', '0987654321').group()

'0987654321'

+ ve * niteleyicilerinin greedy (açgözlü) olduğu söylenir. Bunun ne anlama geldiğini ileride göreceksiniz.

Düzenli İfadelerde Gruplama

Düzenli ifadelerdeki grup özelliği, eşleşen metnin parçalarını almanıza olanak tanır. Parantez () ile sınırlandırılmış düzenli ifade desen parçalarına grup denir. Parantezler ifadenin neyle eşleştiğini değiştirmez; bunun yerine eşleşen dizide gruplar oluşturur. Bu eğitim boyunca örneklerde group() işlevini kullandınız. Argümansız match.group() hâlâ her zamanki gibi tüm eşleşen metindir.

Bu kavramı basit bir örnekle anlayalım. Diyelim ki e-posta adreslerini doğruluyorsunuz ve kullanıcı adını ve sunucuyu (host) kontrol etmek istiyorsunuz. Eşleşen metniniz içinde ayrı gruplar oluşturmak isteyeceğiniz durum budur.

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'([\w\.-]+)@([\w\.-]+)', statement)
if statement:
  print("Email address:", match.group()) # The whole matched text
  print("Username:", match.group(1)) # The username (group 1)
  print("Host:", match.group(2)) # The host (group 2)

Email address: support@datacamp.com
Username: support
Host: datacamp.com

Aynısını <> ayraçlarını kullanarak da yapabilirsiniz. Bu, adlandırılmış gruplar oluşturmanızı sağlar. Adlandırılmış gruplar kodunuzu daha okunabilir kılar. Adlandırılmış grup oluşturma sözdizimi: (?P<name>...). name kısmını grubunuza vermek istediğiniz adla değiştirin. ... ise geri kalan eşleşme sözdizimini temsil eder. Aynı örnek üzerinde bunu çalışırken görün...

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'(?P<email>(?P<username>[\w\.-]+)@(?P<host>[\w\.-]+))', statement)
if statement:
  print("Email address:", match.group('email'))
  print("Username:", match.group('username'))
  print("Host:", match.group('host'))

Email address: support@datacamp.com
Username: support
Host: datacamp.com

İPUCU: Adlandırılmış gruplara her zaman isim yerine numarayla da erişebilirsiniz. Ancak grup sayısı arttıkça sadece sayılarla yönetmek zorlaşır. Bu yüzden, alışkanlık edinip adlandırılmış grupları kullanın.

Açgözlü ve Açgözlü Olmayan Eşleşme

Özel bir karakter, arama dizisinin (stringin) mümkün olduğunca büyük bir kısmıyla eşleştiğinde buna "Açgözlü Eşleşme" denir. Bu, düzenli ifadelerin normal davranışıdır; ancak bazen istenmez:

pattern = "cookie"
sequence = "Cake and cookie"

heading  = r'<h1>TITLE</h1>'
re.match(r'<.*>', heading).group()

'<h1>TITLE</h1>'

<.*> deseni, ikinci > oluşumuna kadar tüm string ile eşleşti.

Oysa yalnızca ilk <h1> etiketini eşleştirmek istiyorsanız, mümkün olduğunca az metinle eşleşen *? açgözlü olmayan niteleyiciyi kullanabilirdiniz.

Niteleyiciden sonra ? eklemek, eşleşmeyi açgözlü olmayan ya da minimal bir şekilde yapar; yani mümkün olan en az karakter eşleşir. <.*> çalıştırdığınızda yalnızca <h1> ile eşleşme elde edersiniz.

heading  = r'<h1>TITLE</h1>'
re.match(r'<.*?>', heading).group()

'<h1>'

Özet Tablosu

Düzenli ifadelerde epey yol aldınız. Kavranması gereken çok bilgi ve kavram var! Aşağıdaki tablo bu eğitimde şimdiye kadar gördüklerinizi özetler. Tüm metakarakterleri bir çırpıda kavrayamazsanız endişelenmeyin. Zaman ve pratikle bu karakterlerin özgünlüklerini görecek ve ne zaman hangisini kullanacağınızı öğreneceksiniz...

Bu eğitim Python’daki tüm özel dizileri ele almıyor. Tam liste için Standart Kütüphane başvurusuna bakın.

Regex’in temellerini hallettiniz! Yine de arama ve eşleştirme için etkili düzenli ifadeler oluşturmanızda yardımcı olacak birkaç kavram daha var.

İPUCU: Düzenli ifadeler çok güçlü ve faydalı olsa da, başkalarının ve hatta sizin anlamakta ve zamanla bakımını yapmakta zorlanacağınız uzun, karmaşık ifadelerden kaçının.

're' Tarafından Sağlanan İşlevler

Python’daki re kütüphanesi, işlerinizi kolaylaştıracak çeşitli işlevler sunar. re.search(), re.match() gibi bazılarını zaten gördünüz. Biraz daha keşfedelim...

compile(pattern, flags=0)

Düzenli ifadeler Python tarafından string olarak ele alınır. Ancak compile() ile bir düzenli ifade desenini bir düzenli ifade nesnesine derleyebilirsiniz. Bir ifadeyi tek bir programda birkaç kez kullanmanız gerekiyorsa, sonucu yeniden kullanım için kaydetmek üzere compile() kullanmak, onu string olarak saklamaktan daha verimlidir. Bunun nedeni, compile()’a geçirilen ve modül düzeyindeki eşleştirme işlevlerine iletilen en son desenlerin derlenmiş sürümlerinin önbelleğe alınmasıdır.

pattern = re.compile(r"cookie")
sequence = "Cake and cookie"
pattern.search(sequence).group()

'cookie'

# Bu şuna denktir:
re.search(pattern, sequence).group()

'cookie'

search(pattern, string, flags=0)

Bu işlevle, verilen string/dizide tarama yapar, düzenli ifadenin eşleşme ürettiği ilk konumu ararsınız. Bulunursa karşılık gelen bir eşleşme nesnesi döndürür; aksi takdirde, stringde desenle eşleşen hiçbir konum yoksa None döner. None’ın, stringin bir noktasında sıfır uzunluklu bir eşleşme bulunmasından farklı olduğunu unutmayın.

pattern = "cookie"
sequence = "Cake and cookie"

re.search(pattern, sequence)

<re.Match object; span=(9, 15), match='cookie'>

match(pattern, string, flags=0)

Stringin başında sıfır veya daha fazla karakter desenle eşleşirse karşılık gelen bir eşleşme nesnesi döndürür. Aksi halde verilen desenle string eşleşmiyorsa None döner.

pattern = "C"
sequence1 = "IceCream"
sequence2 = "Cake"

# "C", "IceCream"in başında olmadığından eşleşme yok
print("Sequence 1: ", re.match(pattern, sequence1))
print("Sequence 2: ", re.match(pattern,sequence2).group())

Sequence 1:  None
Sequence 2:  C

search() ve match() karşılaştırması

match() işlevi (öntanımlı olarak) yalnızca stringin başlangıcında eşleşme ararken, search() işlevi stringin herhangi bir yerinde eşleşme arar.

findall(pattern, string, flags=0)

Tüm dizi boyunca olası tüm eşleşmeleri bulur ve bunları stringlerden oluşan bir liste olarak döndürür. Döndürülen her string bir eşleşmeyi temsil eder.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

#'addresses' olası tüm eşleşmeleri saklayan bir listedir
addresses = re.findall(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)

support@datacamp.com
xyz@datacamp.com

finditer(string, [position, end_position])

findall()’a benzer — tüm dizi boyunca olası tüm eşleşmeleri bulur ancak regex eşleşme nesnelerini bir yineleyici (iterator) olarak döndürür.

İPUCU: finditer(), aramanızla ilgili size daha fazla bilgi dönmesini istediğinizde harika bir seçenek olabilir. Dönen regex eşleşme nesnesi, yalnızca eşleşen diziyi değil, aynı zamanda orijinal metindeki konumlarını da taşır.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

#'addresses' olası tüm eşleşmeleri saklayan bir listedir
addresses = re.finditer(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)

<re.Match object; span=(22, 42), match='support@datacamp.com'>
<re.Match object; span=(44, 60), match='xyz@datacamp.com'>

sub(pattern, repl, string, count=0, flags=0)
subn(pattern, repl, string, count=0)

sub() bir yerine koyma (substitute) işlevdir. Stringdeki desenin, soldan sağa çakışmayan ilk oluşumlarını repl ile değiştirerek elde edilen stringi döndürür. Desen bulunamazsa, string değiştirilmeden döner.

subn() ise sub()’a benzer. Ancak, yeni string değerini ve ifadede gerçekleştirilen değişiklik sayısını içeren bir demet (tuple) döndürür.

statement = "Please contact us at: xyz@datacamp.com"
new_email_address = re.sub(r'([\w\.-]+)@([\w\.-]+)', r'support@datacamp.com', statement)
print(new_email_address)

Please contact us at: support@datacamp.com

split(string, [maxsplit = 0])

Desenin eşleştiği her yerde stringi böler ve bir liste döndürür. İsteğe bağlı maxsplit argümanı sıfır değilse, en fazla 'maxsplit' sayıda bölme yapılır.

statement = "Please contact us at: xyz@datacamp.com, support@datacamp.com"
pattern = re.compile(r'[:,]')

address = pattern.split(statement)
print(address)

['Please contact us at', ' xyz@datacamp.com', ' support@datacamp.com']

start() - Eşleşmenin başlangıç indeksini döndürür.
end() - Eşleşmenin bittiği indeksi döndürür.
span() - Eşleşmenin (başlangıç, bitiş) konumlarını içeren bir demet döndürür.

pattern = re.compile('COOKIE', re.IGNORECASE)
match = pattern.search("I am not a cookie monster")

print("Start index:", match.start())
print("End index:", match.end())
print("Tuple:", match.span())

Start index: 11
End index: 17
Tuple: (11, 17)

Derleme Bayrakları

Son örnekteki re.IGNORECASE terimini fark ettiniz mi? Önemini kavradınız mı?

Bir ifadenin davranışı bir bayrak değeri belirterek değiştirilebilir. Bu eğitimde gördüğünüz farklı işlevlere ek bir argüman olarak bayraklar ekleyebilirsiniz. Daha faydalı olanlardan bazıları şunlardır:

IGNORECASE (I) - Büyük/küçük harfe duyarsız eşleşmelere izin verir.
DOTALL (S) - .’ın yeni satır dahil herhangi bir karakterle eşleşmesine izin verir.
MULTILINE (M) - String başı (^) ve string sonu ($) çıpalarının yeni satırlarla da eşleşmesine izin verir.
VERBOSE (X) - Düzenli ifadeyi daha okunabilir kılmak için içine boşluklar ve yorumlar yazmanıza izin verir.

statement = "Please contact us at: support@DataCamp.com, xyz@DATACAMP.com"

# VERBOSE bayrağını kullanmak karmaşık düzenli ifadeleri anlamaya yardımcı olur
pattern = re.compile(r"""
[\w\.-]+ #First part
@ #Matches @ sign within email addresses
datacamp.com #Domain
""", re.X | re.I)

addresses = re.findall(pattern, statement)                       
for address in addresses:
    print("Address: ", address)

Address:  support@DataCamp.com
Address:  xyz@DATACAMP.com

İPUCU: Bit düzeyinde VEYA | kullanarak birden çok bayrağı birleştirebilirsiniz.

Vaka Çalışması: Düzenli İfadelerle Çalışma

Artık örnekler üzerinden Python’da düzenli ifadelerin nasıl çalıştığını gördüğünüze göre, işin pratiğine geçme zamanı! Bu vaka çalışmasında tüm bilginizi kullanacaksınız.

Fyodor Dostoyevski’nin Project Gutenberg’deki "Budala" adlı ücretsiz e-kitabının ilk kısmıyla çalışacaksınız. Roman, iyi yürekli, saf, içten doğası nedeniyle pek çok kişinin onun zekâsı ve sezgisinin eksik olduğunu düşünmesine yol açan Prens (Knyaz) Lev Nikolayeviç Mışkin hakkında. Başlık, bu genç adama yapılan ironik bir göndermedir.

Metni ayrıştırmak ve bazı alıştırmaları tamamlamak için düzenli ifadeler yazacaksınız.

import re
import requests
the_idiot_url = 'https://www.gutenberg.org/files/2638/2638-0.txt'

def get_book(url):
    # Sends a http request to get the text from project Gutenberg
    raw = requests.get(url).text
    # Discards the metadata from the beginning of the book
    start = re.search(r"\*\*\* START OF THIS PROJECT GUTENBERG EBOOK .* \*\*\*",raw ).end()
    # Discards the text starting Part 2 of the book
    stop = re.search(r"II", raw).start()
    # Keeps the relevant text
    text = raw[start:stop]
    return text

def preprocess(sentence):
    return re.sub('[^A-Za-z0-9.]+' , ' ', sentence).lower()

book = get_book(the_idiot_url)
processed_book = preprocess(book)
#print(processed_book)

• Alıştırma: Korpusta "the" zamirinin sayısını bulun. İpucu: len() işlevini kullanın.

len(re.findall(r'the', processed_book))

302

• Alıştırma: Korpustaki tek başına geçen her bir 'i' örneğini 'I' ile değiştirin. Kelime içinde geçen 'i' harflerini değiştirmediğinizden emin olun:

processed_book = re.sub(r'\si\s', " I ", processed_book)
#print(processed_book)

• Alıştırma: Korpusta herhangi birinin ("") kaç kez alıntı yapıldığını bulun.

len(re.findall(r'\”', book))

0

• Alıştırma: Korpusta '--' ile bağlanan kelimeler hangileri?
  Bunu kendiniz deneyin! Yanıtınızı aşağıdaki yorumlarda paylaşmaktan çekinmeyin.

Tebrikler!

Bu Python düzenli ifadeler eğitimini sonuna kadar tamamladınız! Python ile veri bilimi yolculuğunuzda ele alacak daha çok şey var.

Regex, veri ön işleme aşamasında önemli bir rol oynayabilir. DataCamp’in Python’da Veri Temizleme kursuna göz atın. Bu kurs, verilerinizi analiz için düzenleyip temizleyerek daha iyi keşfetmenin yollarını öğretir. Ayrıca sonunda yeni edindiğiniz bilgileri uygulayabileceğiniz bir vaka çalışması da içerir.

Python String Replace Eğitimimize de göz atın.