String Metotları

String nesneleri değişmezdir, yani bir listenin yapabildiği gibi yerinde değiştirilemezler. Bu nedenle, yerleşik str türü üzerindeki yöntemler her zaman yöntem çağrısının sonucunu içeren yeni bir str nesnesi döndürür. Python’da aşağıdaki metotlar bulunur.

• str.capitalize() -> str
• str.casefold() -> str [sadece Python > 3.3]
• str.center(width[, fillchar]) -> str
• str.count(sub[, start[, end]]) -> int
• str.decode(encoding=“utf-8”[, errors]) -> unicode [sadece Python 2.x]
• str.encode(encoding=“utf-8”, errors=“strict”) -> bytes
• str.endswith(suffix[, start[, end]]) -> bool
• str.expandtabs(tabsize=8) -> str
• str.find(sub[, start[, end]]) -> int
• str.format(*args, **kwargs) -> str
• str.format_map(mapping) -> str
• str.index(sub[, start[, end]]) -> int
• str.isalnum() -> bool
• str.isalpha() -> bool
• str.isdecimal() -> bool
• str.isdigit() -> bool
• str.isidentifier() -> bool
• str.islower() -> bool
• str.isnumeric() -> bool
• str.isprintable() -> bool
• str.isspace() -> bool
• str.istitle() -> bool
• str.isupper() -> bool
• str.join(iterable) -> str
• str.ljust(width[, fillchar]) -> str
• str.lower() -> str
• str.lstrip([chars]) -> str
• static str.maketrans(x[, y[, z]])
• str.partition(sep) -> (head, sep, tail)
• str.replace(old, new[, count]) -> str
• str.rfind(sub[, start[, end]]) -> int
• str.rindex(sub[, start[, end]]) -> int
• str.rjust(width[, fillchar]) -> str
• str.rpartition(sep) -> (head, sep, tail)
• str.rsplit(sep=None, maxsplit=-1) -> list of strings
• str.rstrip([chars]) -> str
• str.split(sep=None, maxsplit=-1) -> list of strings
• str.splitlines([keepends]) -> list of strings
• str.startswith(prefix[, start[, end]]) -> book
• str.strip([chars]) -> str
• str.swapcase() -> str
• str.title() -> str
• str.translate(table) -> str
• str.upper() -> str
• str.zfill(width) -> str

String büyük harf/küçük harf yazımını değiştirme

Python’un string türü, bir string’in büyük harfle yazılması üzerinde etkili olan birçok fonksiyon sağlar. Bunlar şunları içerir :

• str.casefold
• str.upper
• str.lower
• str.capitalize
• str.title
• str.swapcase

Unicode karakter dizileri ile (Python 3’te varsayılan), bu işlemler 1:1 eşleme veya tersine çevrilebilir değildir. Bu işlemlerin çoğu normalleştirmeden ziyade görüntüleme amaçlıdır.

str.casefold() 

str.casefold, büyük/küçük harfe duyarlı olmayan karşılaştırmalar için uygun olan küçük harfli bir dize oluşturur. Bu str.lower‘dan daha agresiftir ve zaten küçük harfli olan dizgeleri değiştirebilir veya dizgelerin uzunluğunun artmasına neden olabilir ve görüntüleme amaçlı değildir.

"XßΣ".casefold()
# 'xssσ'

"XßΣ".lower()
# 'xßς'

Büyük/küçük harf katlama kapsamında gerçekleşen dönüşümler Unicode Consortium tarafından web sitelerindeki CaseFolding.txt dosyasında tanımlanmıştır.

str.upper() 

str.upper bir dizedeki her karakteri alır ve büyük harf eşdeğerine dönüştürür:

"Bu bir 'string'.".upper()
# "BU BIR 'STRING'."

str.lower() 

str.lower bunun tam tersini yapar; bir dizedeki her karakteri alır ve küçük harf eşdeğerine dönüştürür:

"Bu BİR 'string'.".lower()
# "bu bir 'string'."

str.capitalize() 

str.capitalize, dizenin büyük harfle yazılmış bir sürümünü döndürür, yani ilk karakteri büyük, diğerlerini küçük harf yapar:

"bu Bir 'String'.".capitalize() # İlk karakteri büyük, diğerlerini küçük harfle yazar
# "Bu bir 'string'."

str.title() 

str.title, dizenin başlık harfli sürümünü döndürür; yani, bir sözcüğün başındaki her harf büyük harf yapılır ve diğerleri küçük harf yapılır:

"bu Bir 'String'".title()
# "Bu Bir 'String'"

str.swapcase() 

str.swapcase, tüm küçük harf karakterlerinin büyük harfe ve tüm büyük harf karakterlerinin küçük harfe değiştirildiği yeni bir dize nesnesi döndürür:

"this iS A STRiNG".swapcase() #Her karakterin büyük/küçük harfini değiştirir
# "THIS Is a strIng"

Str sınıfı yöntemleri olarak kullanım 

Bu yöntemlerin string nesneleri üzerinde (yukarıda gösterildiği gibi) ya da str sınıfının bir sınıf yöntemi olarak (str.upper vb. için açık bir çağrı ile) çağrılabileceğini belirtmek gerekir.

str.upper("Bu bir 'string'")
# "BU BIR 'STRING'"

Bu, en çok bu yöntemlerden birini örneğin bir map işlevinde aynı anda birçok dizeye uygularken kullanışlıdır.

map(str.upper,["These","are","some","'strings'"])
# ['THESE', 'ARE', 'SOME', "'STRINGS'"]

Bir dizenin nelerden oluştuğunu test etme

Python’un str türü ayrıca bir karakter dizisinin içeriğini değerlendirmek için kullanılabilecek bir dizi yöntem içerir. Bunlar str.isalpha, str.isdigit, str.isalnum, str.isspace’dir. Büyük harf kullanımı str.isupper, str.islower ve str.istitle ile test edilebilir.

str.isalpha 

str.isalpha hiçbir bağımsız değişken almaz ve örneğin verilen bir dizedeki tüm karakterler alfabetik ise True döndürür:

>>> "Hello World".isalpha()  # boşluk içerir
False
>>> "Hello2World".isalpha()  # sayı içerir
False
>>> "HelloWorld!".isalpha()  # noktalama işaretleri içerir
False
>>> "HelloWorld".isalpha()
True

Bir uç durum olarak, boş dize “”.isalpha() ile kullanıldığında False olarak değerlendirilir.

str.isupper, str.islower, str.istitle 

Bu yöntemler, verilen bir dizedeki büyük harf kullanımını test eder.

str.isupper, verilen bir dizedeki tüm karakterler büyük harf ise True, aksi takdirde False döndüren bir yöntemdir.

>>> "HeLLO WORLD".isupper()
False
>>> "HELLO WORLD".isupper()
True
>>> "".isupper()
False

Diğer taraftan, str.islower, verilen bir dizedeki tüm karakterler küçük harf ise True, aksi takdirde False döndüren bir yöntemdir.

>>> "Hello world".islower()
False
>>> "hello world".islower()
True
>>> "".islower()
False

str.istitle, verilen dize başlık türünde yazılmışsa True döndürür; yani, her sözcük büyük harfli bir karakterle başlar ve ardından küçük harfli karakterler gelir.

>>> "hello world".istitle()
False
>>> "Hello world".istitle()
False
>>> "Hello World".istitle()
True
>>> "".istitle()
False

str.isdecimal, str.isdigit, str.isnumeric 

str.isdecimal, dizenin ondalık bir sayıyı temsil etmeye uygun bir ondalık basamak dizisi olup olmadığını döndürür.

str.isdigit, üst simge rakamları gibi ondalık sayıyı temsil etmeye uygun bir biçimde olmayan rakamları içerir.

str.isnumeric, 0-9 aralığının dışındaki değerler gibi rakam olmasa bile tüm sayı değerlerini içerir.

isdecimal    isdigit   isnumeric

12345        True        True       True
១2߃໔5        True        True       True
①²³?₅       False       True       True
⑩⒓          False       False      True
Five         False       False      False

Bytestrings (Python 3’te bytes, Python 2’de str), yalnızca temel ASCII rakamlarını kontrol eden isdigit’i destekler.

str.isalpha işlevinde olduğu gibi, boş dize False olarak değerlendirilir.

str.isalnum 

Bu, str.isalpha ve str.isnumeric’in bir birleşimidir, özellikle verilen dizedeki tüm karakterler alfanümerik ise, yani alfabetik veya sayısal karakterlerden oluşuyorsa True olarak değerlendirilir:

>>> "Hello2World".isalnum()
True
>>> "HelloWorld".isalnum()
True
>>> "2016".isalnum()
True
>>> "Hello World".isalnum()  # boşluk içerir
False

str.isspace 

Dize yalnızca boşluk karakterleri içeriyorsa True olarak değerlendirilir.

>>> "\t\r\n".isspace()
True
>>> " ".isspace()
True

Bazen bir dize “boş” görünür ancak bunun sadece boşluk içerdiğinden mi yoksa hiç karakter içermediğinden mi kaynaklandığını bilemeyiz

>>> "".isspace()
False

Bu durumu kapsamak için ek bir teste ihtiyacımız olur

>>> my_str = ''
>>> my_str.isspace()
False
>>> my_str.isspace() or not my_str
True

Ancak bir dizenin boş olup olmadığını veya sadece boşluk karakterleri içerip içermediğini test etmenin en kısa yolu strip (argüman olmadan tüm önde ve sondaki boşluk karakterlerini kaldırır) kullanmaktır

>>> not my_str.strip()
True

Bir dizeyi bir sınırlayıcıya göre parçalama

str.split(sep=None, maxsplit=-1) 

str.split bir dize alır ve orijinal dizenin alt dizelerinin bir listesini döndürür. Bu metodun davranışı, sep bağımsız değişkeninin sağlanıp sağlanmamasına bağlı olarak farklılık gösterir.

sep belirtilmemişse veya None ise, bölme işlemi boşluk olan her yerde gerçekleşir. Ancak, baştaki ve sondaki boşluklar göz ardı edilir ve birden fazla ardışık boşluk karakteri tek bir boşluk karakteriyle aynı şekilde değerlendirilir:

>>> "This is a sentence.".split()
['This', 'is', 'a', 'sentence.']

>>> " This is    a sentence.  ".split()
['This', 'is', 'a', 'sentence.']

>>> "            ".split()
[]

sep parametresi bir sınırlayıcı dize tanımlamak için kullanılabilir. Orijinal dize, sınırlayıcı dizenin oluştuğu yerde bölünür ve sınırlayıcının kendisi atılır. Birden fazla ardışık sınırlayıcı tek bir sınırlayıcı ile aynı şekilde ele alınmaz, bunun yerine boş dizelerin oluşturulmasına neden olur.

>>> "This is a sentence.".split(' ')
['This', 'is', 'a', 'sentence.']

>>> "Earth,Stars,Sun,Moon".split(',')
['Earth', 'Stars', 'Sun', 'Moon']

>>> " This is    a sentence.  ".split(' ')
['', 'This', 'is', '', '', '', 'a', 'sentence.', '', '']

>>> "This is a sentence.".split('e')
['This is a s', 'nt', 'nc', '.']

>>> "This is a sentence.".split('en')
['This is a s', 't', 'ce.']

Varsayılan değer sınırlayıcının her geçtiği yerde bölme yapmaktır, ancak maxsplit parametresi meydana gelen bölme sayısını sınırlar. Varsayılan değer olan -1, sınır olmadığı anlamına gelir:

>>> "This is a sentence.".split('e', maxsplit=0)
['This is a sentence.']

>>> "This is a sentence.".split('e', maxsplit=1)
['This is a s', 'ntence.']

>>> "This is a sentence.".split('e', maxsplit=2)
['This is a s', 'nt', 'nce.']

>>> "This is a sentence.".split('e', maxsplit=-1)
['This is a s', 'nt', 'nc', '.']

str.rsplit(sep=None, maxsplit=-1) 

maxsplit belirtildiğinde str.rsplit (“sağa bölme”) str.split (“sola bölme”) işleminden farklıdır. Bölme işlemi dizenin başından değil sonundan başlar:

>>> "This is a sentence.".rsplit('e', maxsplit=1)
['This is a sentenc', '.']

>>> "This is a sentence.".rsplit('e', maxsplit=2)
['This is a sent', 'nc', '.']

Not: Python gerçekleştirilen maksimum bölme sayısını belirtirken, diğer programlama dillerinin çoğu oluşturulan maksimum alt dize sayısını belirtir. Bu, kodu taşırken veya karşılaştırırken karışıklık yaratabilir.

Bir dizeden istenmeyen baştaki/sondaki karakterleri silme

Bir dizeden baştaki ve sondaki karakterleri çıkarma olanağı sunan üç yöntem bulunur: str.strip, str.rstrip ve str.lstrip. Her üç yöntem de aynı imzaya sahiptir ve her üçü de istenmeyen karakterleri kaldırılmış yeni bir string nesnesi döndürür.

str.strip([chars]) 

str.strip, verilen bir dize üzerinde işlem yapar ve chars bağımsız değişkeninde bulunan tüm baştaki veya sondaki karakterleri kaldırır (çıkarır); chars sağlanmamışsa veya None ise, varsayılan olarak tüm boşluk karakterleri kaldırılır. Örneğin:

>>> "    a line with leading and trailing space     ".strip() 
'a line with leading and trailing space'

chars sağlanırsa, içerdiği tüm karakterler döndürülen dizeden kaldırılır. Örneğin:

>>> ">>> a Python prompt".strip('> ')  # '>' karakterini ve boşluk karakterini çıkarır 
'a Python prompt'

str.rstrip([chars]) ve str.lstrip([chars]) 

Bu yöntemler str.strip() ile benzer anlamsallığa ve argümanlara sahiptir, aralarındaki fark başladıkları yöndedir. str.rstrip() dizenin sonundan başlarken str.lstrip() dizenin başından böler.

Örneğin, str.rstrip kullanarak:

>>> "     spacious string      ".rstrip()
'     spacious string'

str.lstrip kullanırken:

>>> "     spacious string      ".rstrip()
'spacious string      '

Bir dizenin başlangıç ve bitiş karakterlerini test edin

Python’da belirli bir karakter dizisinin başlangıcını ve bitişini test etmek için str.startswith() ve str.endswith() yöntemleri kullanılabilir.

str.startswith(prefix[, start[, end]]) 

Adından da anlaşılacağı gibi, str.startswith, verilen bir dizenin önek olarak verilen karakterlerle başlayıp başlamadığını test etmek için kullanılır.

>>> s = "This is a test string"
>>> s.startswith("T")
True
>>> s.startswith("Thi")
True
>>> s.startswith("thi")  
False

İsteğe bağlı start ve end argümanları testin başlayacağı ve biteceği başlangıç ve bitiş noktalarını belirtir. Aşağıdaki örnekte, başlangıç değerini 2 olarak belirttiğimizde, dizemiz 2. konumdan itibaren ve sonrasında aranacaktır:

>>> s.startswith("is", 2)
True

Bu, s[2] == ‘i’ ve s[3] == ‘s’ olduğundan True sonucunu verir.

Bir tuple’ı, bir dizi dizeden herhangi biriyle başlayıp başlamadığını kontrol etmek için de kullanabilirsiniz

>>> s.startswith(('This', 'That'))
True
>>> s.startswith(('ab', 'bc'))
False

str.endswith(prefix[, start[, end]]) 

str.endswith, str.startswith ile tamamen benzerdir, tek farkı başlangıç karakterlerini değil bitiş karakterlerini aramasıdır. Örneğin, bir dizenin nokta ile bitip bitmediğini test etmek için şöyle yazabiliriz:

>>> s = "this ends in a full stop."
>>> s.endswith('.')
True
>>> s.endswith('!')
False

startswith’de olduğu gibi birden fazla karakter içeren bitiş dizisi de kullanılabilir:

>>> s.endswith('stop.')
True
>>> s.endswith('Stop.')
False

Yine, benzer şekilde, bir tuple’ı, bir dizi dizeden herhangi biriyle bitip bitmediğini kontrol etmek için de kullanabilirsiniz

>>> s.endswith(('.', 'something'))
True
>>> s.endswith(('ab', 'bc'))
False

str.translate Bir dizedeki karakterleri çevirme

Python, str türünde bir çeviri tablosunu (değiştirmeler için kullanılır) ve işlem sırasında silinmesi gereken karakterleri belirtmenize olanak tanıyan bir translate yöntemi destekler.

str.translate(table[, deletechars])

• tablo | bir karakterden diğerine eşlemeyi tanımlayan bir arama tablosu
• deletechars | dizeden kaldırılacak karakterlerin bir listesi

maketrans yöntemi (Python 3’te str.maketrans ve Python 2’de string.maketrans) bir çeviri tablosu oluşturmanızı sağlar.

>>> translation_table = str.maketrans("aeiou", "12345")
>>> my_string = "This is a string!"
>>> translated = my_string.translate(translation_table)
'Th3s 3s 1 str3ng!'

translate yöntemi, orijinal dizenin çevrilmiş bir kopyası olan bir dize döndürür.

Yalnızca karakterleri silmeniz gerekiyorsa tablo bağımsız değişkenini None olarak ayarlayabilirsiniz.

>>> 'this syntax is very useful'.translate(None, 'aeiou')
'ths syntx s vry sfl'

str.format ve f-strings dizeyi biçimlendirme

Python, 2.6 sürümünde tanıtılan str.format işlevi ve 3.6 sürümünde tanıtılan f-strings aracılığıyla dize enterpolasyonu ve biçimlendirme işlevselliği sağlar.

Aşağıdaki değişkenler göz önüne alındığında:

i = 10
f = 1.5
s = "foo"
l = ['a', 1, 2]
d = {'a': 1, 2: 'foo'}

Aşağıdaki ifadelerin hepsi eşdeğerdir

"10 1.5 foo ['a', 1, 2] {'a': 1, 2: 'foo'}"

>>> "{} {} {} {} {}".format(i, f, s, l, d)

>>> str.format("{} {} {} {} {}", i, f, s, l, d)

>>> "{0} {1} {2} {3} {4}".format(i, f, s, l, d)

>>> "{0:d} {1:0.1f} {2} {3!r} {4!r}".format(i, f, s, l, d)

>>> "{i:d} {f:0.1f} {s} {l!r} {d!r}".format(i=i, f=f, s=s, l=l, d=d)

>>> f"{i} {f} {s} {l} {d}"

>>> f"{i:d} {f:0.1f} {s} {l!r} {d!r}"

Ek olarak, Python’nun dize biçimlendirmesi için C tarzı niteleyicileri de desteklediğinden bahsetmek gerekir. Aşağıdaki örnekler yukarıdakilere eşdeğerdir, ancak str.format kullanımı esneklik, gösterim tutarlılığı ve genişletilebilirlik avantajları nedeniyle tercih edilir:

"%d %0.1f %s %r %r" % (i, f, s, l, d)

"%(i)d %(f)0.1f %(s)s %(l)r %(d)r" % dict(i=i, f=f, s=s, l=l, d=d)

Str.format’ta enterpolasyon için kullanılan parantezler, dizeleri biçimlendirirken yinelemeyi azaltmak için numaralandırılabilir. Örneğin, aşağıdakiler eşdeğerdir:

"I am from Australia. I love cupcakes from Australia!"

>>> "I am from {}. I love cupcakes from {}!".format("Australia", "Australia")

>>> "I am from {0}. I love cupcakes from {0}!".format("Australia")

Resmi python dokümantasyonu her zamanki gibi yeterince kapsamlı olsa da, pyformat.info ayrıntılı açıklamalarla harika bir örnek setine sahiptir.

Ayrıca, \{ ve \} karakterleri çift parantez kullanılarak önlenebilir:

"{'a': 5, 'b': 6}"

>>> "{{'{}': {}, '{}': {}}}".format("a", 5, "b", 6)

>>> f"{{'{'a'}': {5}, '{'b'}': {6}}"

Ek bilgi için; str.format() PEP 3101‘de ve f-strings PEP 498‘de önerilmiştir.

Dizede bul ve değiştir

Python’un str türünde, verilen bir dizedeki alt dizeyi başka bir alt dizeyle değiştirebiliriz Daha zorlu durumlar için re.sub kullanılabilir.

str.replace(old, new[, count]): 

str.replace, aranacak alt dize ve değiştirilecek yeni alt dize olmak üzere iki bağımsız değişken alır. İsteğe bağlı count bağımsız değişkeni, yapılacak değişikliklerin sayısını belirtir:

Örneğin, aşağıdaki dizede ‘foo’ ifadesini ‘spam’ ile değiştirmek için str.replace dosyasını old = ‘foo’ ve new = ‘spam’ ile çağırabiliriz:

>>> "Make sure to foo your sentence.".replace('foo', 'spam')
"Make sure to spam your sentence."

Verilen dize eski bağımsız değişkenle eşleşen birden fazla örnek içeriyorsa, tüm örnekler yeni sağlanan değerle değiştirilir:

>>> "It can foo multiple examples of foo if you want.".replace('foo', 'spam')
"It can spam multiple examples of spam if you want."

tabii ki count için bir değer sağlamadığımız sürece. Bu durumda, count kadar oluşumlar değiştirilecektir:

>> """İsterseniz birden fazla foo örneğini foo yapabilir, \
... ya da foo'yu üçüncü bağımsız değişkenle sınırlayabilirsiniz.""".replace('foo', 'spam', 1)
'İsterseniz birden fazla spam örneğini foo yapabilir ya da foo'yu üçüncü bağımsız değişkenle sınırlayabilirsiniz.

Bir dizeyi tersine çevirme

Bir dize, yineleyici döndüren yerleşik reversed() işlevi kullanılarak tersine çevrilebilir.

>>> reversed('hello')
<reversed object at 0x0000000000000000>
>>> [char for char in reversed('hello')]
['o', 'l', 'l', 'e', 'h']

reversed(), yineleyiciden bir dize oluşturmak için ”.join() çağrısına sarılabilir.

>>> ''.join(reversed('hello'))
'olleh'

reversed() kullanmak yeni Python kullanıcıları için daha okunabilir olsa da, -1’lik bir adımla kullanılan dilimleme yöntemi daha hızlı ve daha özlü olacaktır. Burada, bunu fonksiyon olarak uygulamaya çalışın:

>>> def reversed_string(main_string):
...     return main_string[::-1]
...
>>> reversed_string('hello')
'olleh'

String Contains

Python, bir dizenin belirli bir alt dizeyi içerip içermediğini kontrol etmeyi son derece sezgisel hale getirir. Basitçe in ifadesi ile bunu kontrol edebiliriz:

>>> "foo" in "foo.baz.bar"
True

Not: boş bir dizeyi test etmek her zaman True ile sonuçlanacaktır:

>>> "" in "test"
True

Dize listesini tek bir dizede birleştirme

Bir dize ayıraç olarak kullanıldığında, join() yöntemi ile bir dize listesini tek bir dize halinde birleştirmek için kullanılabilir. Örneğin, bir listedeki her öğenin bir boşlukla ayrıldığı bir dize oluşturabilirsiniz.

>>> " ".join(["once","upon","a","time"])
"once upon a time"

Aşağıdaki örnek, dize öğelerini üç tire ile ayırır.

>>> "---".join(["once", "upon", "a", "time"])
"once---upon---a---time"

Bir alt dizenin bir dize içinde kaç kez göründüğünü sayma

Bir alt dizenin başka bir dize içinde bulunma sayısını saymak için : str.count.

str.count(sub[, start[, end]]) 

str.count, sub alt dizesinin str dizesi içindeki oluşumlarının sayısını gösteren bir int döndürür. İsteğe bağlı argümanlar olan start ve end, aramanın yapılacağı başlangıç ve sonu belirtir. Varsayılan olarak start = 0 ve end = len(str), yani tüm dize aranacaktır:

>>> s = "She sells seashells by the seashore."
>>> s.count("sh")
2
>>> s.count("se")
3
>>> s.count("sea")
2
>>> s.count("seashells")
1

Başlangıç, bitiş için farklı bir değer belirterek daha yerelleştirilmiş bir arama ve sayım elde edebiliriz; örneğin, start değişkeni 13’e eşitse

>>> s.count("sea", start)
1

aşağıdaki ile eşdeğer bir sonuç alırız:

>>> t = s[start:]
>>> t.count("sea")
1

Büyük/küçük harfe duyarsız dize karşılaştırmaları

Karakter dizilerini büyük/küçük harfe duyarlı olmayan bir şekilde karşılaştırmak önemsiz bir şey gibi görünebilir, ancak öyle değildir. Bu bölüm sadece unicode stringleri (Python 3’te varsayılan) ele alır. Python 2’nin Python 3’e göre ince zayıflıkları olabileceğini unutmayın – ikincisinin unicode kullanımı çok daha eksiksizdir.

Dikkat edilmesi gereken ilk şey, unicode’da büyük-küçük harf dönüşümlerinin önemsiz olmadığıdır. “ß” karakterinde olduğu gibi text.lower() != text.upper().lower() olan metinler vardır:

>>> "ß".lower()
'ß'

>>> "ß".upper().lower()
'ss'

Ama diyelim ki “BUSSE” ve “Buße “yi tekil olarak karşılaştırmak istediniz. Muhtemelen “BUSSE” ve “BUẞE “yi de eşit olarak karşılaştırmak istersiniz – bu daha yeni büyük harf biçimidir. Önerilen yol casefold harf kullanmaktır:

>>> help(str.casefold)
"""
Help on method_descriptor:

casefold(...)
      S.casefold() -> str
    
     Return a version of S suitable for caseless comparisons.
"""

Sadece lower kullanmayın. Casefold mevcut değilse, .upper().lower() yapmak da yardımcı olabilir (ancak her zaman değil).

Aksanları da göz önünde bulundurmalısınız. Yazı tipi oluşturucunuz iyiyse, muhtemelen “ê” == “ê” olduğunu düşünürsünüz – ama öyle değildir:

>>> "ê" == "ê"
False

Bunun nedeni aslında

>>> import unicodedata

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E WITH CIRCUMFLEX']

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']

Bununla başa çıkmanın en basit yolu unicodedata.normalize’dir. Muhtemelen NFKD normalleştirmesini kullanmak istersiniz, ancak belgeleri kontrol etmekten çekinmeyin. O zaman şunu yaparız:

>>> unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")
True

Son örneği fonksiyon şeklinde ifade edelim:

import unicodedata

def normalize_caseless(text):
    return unicodedata.normalize("NFKD", text.casefold())

def caseless_equal(left, right):
    return normalize_caseless(left) == normalize_caseless(right)

string’i iki tarafa yaslama/hizalama

Python, çeşitli dizeleri hizalamayı çok daha kolay hale getirmek için metin dolgusu sağlayan dizeleri yaslamak için işlevler sağlar.

Aşağıda str.ljust ve str.rjust için bir örnek verilmiştir:

interstates_lengths = {
    5: (1381, 2222),
    19: (63, 102),
    40: (2555, 4112),
    93: (189,305),
}
for road, length in interstates_lengths.items():
    miles,kms = length
    print('{} -> {} mi. ({} km.)'.format(str(road).rjust(4), str(miles).ljust(4), str(kms).ljust(4)))

40 -> 2555 mi. (4112 km.)
19 -> 63   mi. (102  km.)
 5 -> 1381 mi. (2222 km.)
93 -> 189  mi. (305  km.)

ljust ve rjust birbirine çok benzer. Her ikisinin de bir width parametresi ve isteğe bağlı bir fillchar parametresi vardır. Bu fonksiyonlar tarafından oluşturulan herhangi bir dize en az fonksiyona aktarılan genişlik parametresi kadar uzun olur. Dize genişlikten daha uzunsa, kesilmez. Varsayılan olarak boşluk karakteri ‘ ‘ olan fillchar argümanı çok karakterli bir dize değil, tek bir karakter olmalıdır.

ljust fonksiyonu, çağrıldığı dizenin sonunu fillchar ile genişlik karakter uzunluğuna kadar doldurur. rjust fonksiyonu da benzer şekilde dizenin başını doldurur. Bu nedenle, bu fonksiyonların adlarındaki l ve r, çıktı dizesinde fillchar’ın değil orijinal dizenin konumlandırıldığı tarafı ifade eder.

String modülünndeki kullanışlı sabitler

Python’un string modülü string ile ilgili işlemler için sabitler sağlar. Bunları kullanmak için string modülünü içe aktarın:

>>> import string

string.ascii_letters: 

ascii_lowercase ve ascii_uppercase’in birleştirilmesi:

>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase: 

Tüm küçük harf ASCII karakterlerini içerir:

>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

string.ascii_uppercase: 

Tüm büyük harf ASCII karakterlerini içerir:

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.digits: 

Tüm rakam karakterlerini içerir:

>>> string.digits
'0123456789'

string.hexdigits: 

Tüm onaltılı rakam karakterlerini içerir:

>>> string.hexdigits
'0123456789abcdefABCDEF'

string.octaldigits: 

Tüm sekizli rakam karakterlerini içerir:

>>> string.octaldigits
'01234567'

string.punctuation: 

C yerel ayarında noktalama işareti olarak kabul edilen tüm karakterleri içerir:

>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

string.whitespace: 

Boşluk olarak kabul edilen tüm ASCII karakterlerini içerir:

>>> string.whitespace
' \t\n\r\x0b\x0c'

Kod modunda, print(string.whitespace) gerçek karakterleri yazdıracaktır, yukarıda döndürülen dizeyi almak için str kullanın.

string.printable: 

Yazdırılabilir olarak kabul edilen tüm karakterleri içerir; string.digits, string.ascii_letters, string.punctuation ve string.whitespace’in bir kombinasyonu.

>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

Str veya byte verileri ile unicode karakterler arasında dönüştürme

Dosyaların ve ağ mesajlarının içeriği kodlanmış karakterleri temsil edebilir. Düzgün görüntülenmeleri için genellikle unicode’a dönüştürülmeleri gerekir.

Python 2’de, str verilerini Unicode karakterlerine dönüştürmeniz gerekebilir. Varsayılan (”, “”, vb.) bir ASCII dizesidir ve ASCII aralığı dışındaki tüm değerler öncelenmiş değerler olarak görüntülenir. Unicode dizeleri u” (veya u””, vb.) şeklindedir.

# Bir dosyadan, ağdan veya başka bir veri kaynağından UTF-8 olarak kodlanmış "© abc" alırsınız

s = '\xc2\xa9 abc'  # s bir karakter dizisi değil, bir bayt dizisidir
                    # Orijinalin UTF-8 olduğunu bilmiyor
                    # Python 2'de dize değişmezlerinin varsayılan biçimi
s[0]                # '\xc2' - anlamsız bayt (kodlama gibi bir bağlam olmadan)
type(s)             # str - bilinen bir kodlamaya sahip olmadan kullanışlı olmasa da

u = s.decode('utf-8')  # u'\xa9 abc'
                       # Artık UTF-8 olarak okunabilen ve düzgün bir şekilde yazdırılabilen bir Unicode dizemiz var
                       # Python 2'de Unicode dize değişmezlerinin başında bir u
                       # str.decode, kaçan baytlar içerebilen bir dizeyi Unicode dizeye dönüştürür
u[0]                # u'\xa9' - Unicode Karakteri 'TELİF HAKKI İŞARETİ' (U+00A9) '©'
type(u)             # unicode

u.encode('utf-8')   # '\xc2\xa9 abc'
                    # unicode.encode, ASCII olmayan karakterler için kaçış baytları içeren bir dize üretir

Python 3’te bayt dizilerini (‘byte literal’ olarak adlandırılır) Unicode karakter dizilerine dönüştürmeniz gerekebilir. Varsayılan artık bir Unicode dizesidir ve bayt literalleri artık b”, b””, vb. olarak girilmelidir. Bir bayt değişmezi, isinstance(some_val, byte) için True değerini döndürür ve some_val’in bayt olarak kodlanabilecek bir dize olduğunu varsayar.

# Dosya veya ağdan UTF-8 ile kodlanmış "© abc" alırsınız

s = b'\xc2\xa9 abc' # s bir bayt dizisidir, karakter değil
                    # Python 3'te, varsayılan dize değişmezi Unicode'dur; bayt dizisi değişmezlerinin başında bir b olmalıdır
s[0]                # b'\xc2' - anlamsız bayt (kodlama gibi bir bağlam olmadan)
type(s)             # baytlar - artık bayt dizileri açık olduğu için Python bunu gösterebilir.

u = s.decode('utf-8')  # Unicode terminalinde '© abc'
                       # bytes.decode bir bayt dizisini bir dizeye dönüştürür (Python 3'te Unicode olacaktır)
u[0]                # '\u00a9' - Unicode Karakteri 'TELİF HAKKI İŞARETİ' (U+00A9) '©'
type(u)             # str
                    # Python 3'te varsayılan string literal UTF-8 Unicode'dur

u.encode('utf-8')   # b'\xc2\xa9 abc'
                    # str.encode, ASCII aralığındaki baytları yazılmamış karakterler olarak gösteren bir bayt dizisi üretir.