Gömülü Türler
*************

Aşağıdaki bölümlerde, yorumlayıcıda yerleşik olarak yer alan standart
türler açıklanmaktadır.

Başlıca gömülü türler sayısallar, diziler, eşleşmeler, sınıflar,
örnekler ve kural dışı durumlardır.

Bazı koleksiyon sınıfları değişebilirdir.  Üyelerini yerinde ekleyen,
çıkaran veya yeniden düzenleyen ve belirli bir öğe döndürmeyen
metotlar, her zaman koleksiyon örneğini değil "None" değerini
döndürür.

Bazı işlemler birkaç nesne türü tarafından desteklenir; özellikle, tüm
nesneler eşitlik için karşılaştırılabilir, doğruluk değeri için test
edilebilir ve bir dizeye dönüştürülebilir ("repr()" fonksiyonu veya
hafif farklı olan "str()" fonksiyonu ile).  İkinci fonksiyon, bir
nesne "print()" ile yazdırıldığında dolaylı olarak kullanılır.


Doğruluk Değeri Testi
=====================

Herhangi bir nesne, "if" veya "while" koşulunda veya aşağıdaki Boolean
işlemlerinin işleneni olarak kullanımında doğruluk değeri için test
edilebilir.

Varsayılan olarak, bir nesne, sınıfı "False" döndüren bir "__bool__()"
metodunu veya nesneyle birlikte çağrıldığında sıfır döndüren bir
"__len__()" metodunu tanımlamadıkça doğru kabul edilir. [1] Yanlış
olarak kabul edilen yerleşik nesnelerin çoğu:

* false olarak tanımlanan sabitler: "None" ve "False".

* herhangi bir sayısal türden sıfır: "0", "0.0", "0j", "Decimal(0)",
  "Fraction(0, 1)"

* boş diziler ve koleksiyonlar: "''", "()", "[]", "{}", "set()",
  "range(0)"

Boolean sonucu olan işlemler ve gömülü fonksiyonlar, aksi
belirtilmedikçe her zaman false için "0" veya "False" ve true için "1"
veya "True" döndürür. (Önemli istisna: Boolean işlemleri "or" ve "and"
her zaman işlenenlerinden birini döndürür.)


Boolean İşlemleri --- "and", "or", "not"
========================================

Bunlar artan önceliğe göre sıralanmış Boolean işlemleridir:

+---------------+-----------------------------------+---------+
| İşlem         | Sonuç                             | Notlar  |
|===============|===================================|=========|
| "x or y"      | if *x* is true, then *x*, else    | (1)     |
|               | *y*                               |         |
+---------------+-----------------------------------+---------+
| "x and y"     | *x* yanlışsa, *x*, aksi halde *y* | (2)     |
+---------------+-----------------------------------+---------+
| "not x"       | *x* yanlışsa, "True", aksi halde  | (3)     |
|               | "False"                           |         |
+---------------+-----------------------------------+---------+

Notlar:

1. Bu bir kısa devre operatörüdür, bu nedenle ikinci argümanı yalnızca
   birincisi yanlışsa değerlendirir.

2. Bu bir kısa devre operatörüdür, bu nedenle sadece ilki doğruysa
   ikinci argümanı değerlendirir.

3. "not" Boolean olmayan operatörlerden daha düşük bir önceliğe
   sahiptir, bu nedenle "not a == b", "not (a == b)" olarak yorumlanır
   bu sebeple "a == not b" bir söz dizimi hatasıdır.


Karşılaştırmalar
================

Python'da sekiz karşılaştırma işlemi vardır.  Hepsinin önceliği
aynıdır (Boolean işlemlerinden daha önceliklidir).  Karşılaştırmalar
isteğe bağlı olarak zincirlenebilir; örneğin, "x < y <= z", "x < y and
y <= z" ile eş değerdir, ancak *y* yalnızca bir kez değerlendirilir
(ancak her iki durumda da "x < y" yanlış olduğu tespit edildiğinde *z*
hiç değerlendirilmez).

Bu tablo karşılaştırma operatörlerini özetlemektedir:

+--------------+---------------------------+
| İşlem        | Anlamı                    |
|==============|===========================|
| "<"          | kesinlikle daha az        |
+--------------+---------------------------+
| "<="         | daha az veya eşit         |
+--------------+---------------------------+
| ">"          | kesinlikle daha büyük     |
+--------------+---------------------------+
| ">="         | daha büyük veya eşit      |
+--------------+---------------------------+
| "=="         | eşit                      |
+--------------+---------------------------+
| "!="         | eşit değil                |
+--------------+---------------------------+
| "is"         | nesne kimliği             |
+--------------+---------------------------+
| "is not"     | olumsuz nesne kimliği     |
+--------------+---------------------------+

Farklı sayısal türler dışında, farklı türdeki nesneler hiçbir zaman
eşit olarak karşılaştırılmaz. "==" operatörü her zaman tanımlanır,
ancak bazı nesne türleri için (örneğin, sınıf nesneleri) "is" ile eş
değerdir. "<", "<=", ">" ve ">=" operatörleri yalnızca anlamlı
oldukları yerde tanımlanır; örneğin, argümanlardan biri karmaşık bir
sayı olduğunda bir "TypeError" hatası oluştururlar.

Normalde, bir sınıfın özdeş olmayan örnekleri, sınıf "__eq__()"
metodunu tanımlamadığı sürece eşit olmayan olarak karşılaştırılır.

Bir sınıfın örnekleri, sınıf yeterli metotları tanımlamadıkça, aynı
sınıfın diğer örneklerine veya diğer nesne türlerine göre sıralanamaz
"__lt__()", "__le__()" , "__gt__()" ve "__ge__()" (karşılaştırma
operatörlerin geleneksel anlamlarını istiyorsanız, "__lt__()" ve
"__eq__()" genellikle yeterli olacaktır).

"is" ve "is not" operatörlerinin davranışı özelleştirilemez; ayrıca
herhangi iki nesneye uygulanabilirler ve asla bir hata oluşturmazlar.

Aynı söz dizimsel önceliğe sahip iki işlem daha, "in" ve "not in",
*iterable* olan veya "__contains__()" metodunu uygulayan türler
tarafından desteklenir.


Sayısal Türler --- "int", "float", "complex"
============================================

There are three distinct numeric types: *integers*, *floating point
numbers*, and *complex numbers*.  In addition, Booleans are a subtype
of integers.  Integers have unlimited precision.  Floating point
numbers are usually implemented using "double" in C; information about
the precision and internal representation of floating point numbers
for the machine on which your program is running is available in
"sys.float_info".  Complex numbers have a real and imaginary part,
which are each a floating point number.  To extract these parts from a
complex number *z*, use "z.real" and "z.imag". (The standard library
includes the additional numeric types "fractions.Fraction", for
rationals, and "decimal.Decimal", for floating-point numbers with
user-definable precision.)

Sayılar, sayısal değişmezlerle veya, gömülü fonksiyonlar ve
operatörlerin sonucu olarak oluşturulur.  Sade tam sayı değişmezleri
(onaltılı, sekizli ve ikili sayılar dahil) tam sayıları verir.
Ondalık nokta veya üs işareti içeren sayısal değişmezler, gerçel
sayıları verir.  Sayısal bir değişmeze "'j'" veya "'J'" eklemek, tam
veya gerçel bir sayıya eklenince gerçek ve hayali kısımları olan bir
karmaşık sayı ortaya çıkaran, hayali bir sayı üretir.

Python fully supports mixed arithmetic: when a binary arithmetic
operator has operands of different numeric types, the operand with the
"narrower" type is widened to that of the other, where integer is
narrower than floating point, which is narrower than complex. A
comparison between numbers of different types behaves as though the
exact values of those numbers were being compared. [2]

"int()", "float()" ve "complex()" yapıcıları belirli bir türde sayılar
üretmek için kullanılabilir.

Tüm sayısal türler (karmaşık sayılar hariç) aşağıdaki işlemleri
destekler (işlemlerin öncelikleri için bkz. Operator precedence):

+-----------------------+-----------------------------------+-----------+----------------------+
| İşlem                 | Sonuç                             | Notlar    | Tam dokümantasyon    |
|=======================|===================================|===========|======================|
| "x + y"               | *x* ve *y* 'nin toplamı           |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x - y"               | *x* ve *y* 'nin farkı             |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x * y"               | *x* ve *y* 'nin çarpımı           |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x / y"               | *x* 'in *y* 'ye bölümü            |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x // y"              | *x* ve *y* 'nin kat bölümü        | (1)       |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x % y"               | "x / y" işleminde kalan           | (2)       |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "-x"                  | *x* 'in negatifi                  |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "+x"                  | *x* 'in değişmemişi               |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "abs(x)"              | *x* 'in mutlak değeri             |           | "abs()"              |
+-----------------------+-----------------------------------+-----------+----------------------+
| "int(x)"              | *x* 'in integer tam sayıya        | (3)(6)    | "int()"              |
|                       | (integer) dönüştürülmüş hali      |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "float(x)"            | *x* 'in gerçel sayıya (float)     | (4)(6)    | "float()"            |
|                       | dönüştürülmüş hali                |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "complex(re, im)"     | gerçek kısmı *re*, sanal kısmı    | (6)       | "complex()"          |
|                       | *im* olan bir karmaşık sayı. *im* |           |                      |
|                       | varsayılan olarak sıfırdır.       |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "c.conjugate()"       | *c* karmaşık sayısının eşleniği   |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "divmod(x, y)"        | "(x // y, x % y)" ifadesinin      | (2)       | "divmod()"           |
|                       | ikilisi                           |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "pow(x, y)"           | *x* üzeri *y*                     | (5)       | "pow()"              |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x ** y"              | *x* üzeri *y*                     | (5)       |                      |
+-----------------------+-----------------------------------+-----------+----------------------+

Notlar:

1. Tam sayılı bölümü olarak da adlandırılır.  Elde edilen değer bir
   tam sayıdır, ancak sonucun türü her zaman int olmayabilir.  Sonuç
   her zaman eksi sonsuza yuvarlanır: "1//2" = "0", "(-1)//2" = "-1",
   "1//(-2)" = "-1", ve "(-1)//(-2)" = "0".

2. Karmaşık sayılar için değil.  Bunun yerine uygunsa "abs()"
   kullanarak gerçel sayılara dönüştürün.

3. Conversion from "float" to "int" truncates, discarding the
   fractional part. See functions "math.floor()" and "math.ceil()" for
   alternative conversions.

4. float also accepts the strings "nan" and "inf" with an optional
   prefix "+" or "-" for Not a Number (NaN) and positive or negative
   infinity.

5. Python, diğer programlama dillerinde de olduğu gibi "pow(0, 0)" =
   "1" ve "0 ** 0" = "1" şeklinde tanımlar.

6. Kabul edilen sayısal değişmezler, "0" ile "9" arasındaki rakamları
   veya herhangi bir Unicode eş değerini ("Nd" özelliğine sahip kod
   noktaları) içerir.

   "Nd" özelliğine sahip kod noktalarının tam listesi için https://ww
   w.unicode.org/Public/13.0.0/ucd/extracted/DerivedNumericType.txt
   adresine bakın.

Tüm "numbers.Real" türleri ("int" ve "float") ayrıca aşağıdaki
işlemleri içerir:

+----------------------+-----------------------------------------------+
| İşlem                | Sonuç                                         |
|======================|===============================================|
| "math.trunc(x)"      | *x* "Integral" şeklinde kısaltıldı            |
+----------------------+-----------------------------------------------+
| "round(x[, n])"      | *x* *n* haneye yuvarlanır, yarıdan çifte      |
|                      | yuvarlanır. *n* atlanırsa, *n* varsayılan     |
|                      | olarak 0 olur.                                |
+----------------------+-----------------------------------------------+
| "math.floor(x)"      | en büyük "Integral" <= *x*                    |
+----------------------+-----------------------------------------------+
| "math.ceil(x)"       | en küçük "Integral" >= *x*                    |
+----------------------+-----------------------------------------------+

Ek sayısal işlemler için "math" ve "cmath" modüllerine bakın.


Tam sayı Türlerinde Bit Düzeyinde İşlemler
------------------------------------------

Bit düzeyinde işlemler yalnızca tam sayılar için anlamlıdır. Bit
düzeyinde işlemlerin sonucu, sonsuz sayıda işaret biti ile ikiye
tümleyende gerçekleştiriliyormuş gibi hesaplanır.

İkili bit düzeyinde işlemlerin öncelikleri, sayısal işlemlerden daha
düşük ve karşılaştırmalardan daha yüksektir; "~" tekli işlemidiğer
tekli sayısal işlemlerle ("+" ve "-") aynı önceliğe sahiptir.

Bu tablo, artan önceliğe göre sıralanmış bit düzeyinde işlemleri
listeler:

+--------------+----------------------------------+------------+
| İşlem        | Sonuç                            | Notlar     |
|==============|==================================|============|
| "x | y"      | bit düzeyinde *x* *or* *y*       | (4)        |
+--------------+----------------------------------+------------+
| "x ^ y"      | bit düzeyinde *x* *exclusive or* | (4)        |
|              | *y*                              |            |
+--------------+----------------------------------+------------+
| "x & y"      | bit düzeyinde *x* *and* *y*      | (4)        |
+--------------+----------------------------------+------------+
| "x << n"     | *x*, *n* bit kadar sola          | (1)(2)     |
|              | kaydırıldı                       |            |
+--------------+----------------------------------+------------+
| "x >> n"     | *x*, *n* bit kadar sağa          | (1)(3)     |
|              | kaydırıldı                       |            |
+--------------+----------------------------------+------------+
| "~x"         | *x* 'in bitleri ters çevrildi    |            |
+--------------+----------------------------------+------------+

Notlar:

1. Negatif kaydırma sayıları geçersizdir ve "ValueError" hatasına
   sebep olur.

2. *n* bitlik sola kaydırma, "pow(2, n)" ile çarpmaya eş değerdir.

3. *n* bitlik sağa kaydırma, "pow(2, n)" ile kat bölümü işlemine eş
   değerdir.

4. Bu hesaplamaları, sonlu ikinin tümleyen temsilinde en az bir ekstra
   işaret uzatma biti ile yapmak ( "1 + max(x.bit_length(),
   y.bit_length())" veya daha fazla çalışan bit genişliği), sonsuz
   sayıda işaret biti varmış gibi aynı sonucu elde etmek için
   yeterlidir.


Integer (Tam sayı) Türlerinde Ek Metotlar
-----------------------------------------

Int türü, "numbers.Integral" *abstract base class* 'ı uygular. Ek
olarak, birkaç metot daha sağlar:

int.bit_length()

   İşaret ve baştaki sıfırlar hariç, ikili sistemde bir tam sayıyı
   (integer) temsil etmek için gereken bit sayısını döndürür:

      >>> n = -37
      >>> bin(n)
      '-0b100101'
      >>> n.bit_length()
      6

   More precisely, if "x" is nonzero, then "x.bit_length()" is the
   unique positive integer "k" such that "2**(k-1) <= abs(x) < 2**k".
   Equivalently, when "abs(x)" is small enough to have a correctly
   rounded logarithm, then "k = 1 + int(log(abs(x), 2))". If "x" is
   zero, then "x.bit_length()" returns "0".

   Eşittir:

      def bit_length(self):
          s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
          s = s.lstrip('-0b') # remove leading zeros and minus sign
          return len(s)       # len('100101') --> 6

   3.1 sürümünde geldi.

int.bit_count()

   Tam sayının mutlak değerinin ikili gösterimindeki birlerin sayısını
   döndürün. Buna nüfus sayımı da denir. Örneğin:

      >>> n = 19
      >>> bin(n)
      '0b10011'
      >>> n.bit_count()
      3
      >>> (-n).bit_count()
      3

   Eşittir:

      def bit_count(self):
          return bin(self).count("1")

   3.10 sürümünde geldi.

int.to_bytes(length, byteorder, *, signed=False)

   Bir tam sayıyı temsil eden bir bayt dizisi döndürür.

   >>> (1024).to_bytes(2, byteorder='big')
   b'\x04\x00'
   >>> (1024).to_bytes(10, byteorder='big')
   b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
   >>> (-1024).to_bytes(10, byteorder='big', signed=True)
   b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
   >>> x = 1000
   >>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
   b'\xe8\x03'

   Tam sayı, *length* bayt kullanılarak temsil edilir.  Tam sayı
   verilen bayt sayısıyla gösterilemezse "OverflowError" hatası ortaya
   çıkar.

   *byteorder* argümanı, tam sayıyı temsil etmek için kullanılan bayt
   sırasını belirler.  *byteorder* ""big"" ise, en önemli bayt, bayt
   dizisinin başındadır. *byteorder* ""little"" ise, en önemli bayt,
   bayt dizisinin sonundadır. Ana sistemin yerel bayt sırasını istemek
   için bayt sırası değeri olarak "sys.byteorder" kullanın.

   *signed* argümanı, tam sayıyı temsil etmek için ikinin tümleyeninin
   kullanılıp kullanılmayacağını belirler.  *signed* "False" ise ve
   negatif bir tam sayı verilirse, bir "OverflowError" hatası ortaya
   çıkar. *signed* için varsayılan değer "False" şeklindedir.

   3.2 sürümünde geldi.

classmethod int.from_bytes(bytes, byteorder, *, signed=False)

   Verilen bayt dizisi tarafından temsil edilen tam sayıyı döndürür.

   >>> int.from_bytes(b'\x00\x10', byteorder='big')
   16
   >>> int.from_bytes(b'\x00\x10', byteorder='little')
   4096
   >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
   -1024
   >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
   64512
   >>> int.from_bytes([255, 0, 0], byteorder='big')
   16711680

   The argument *bytes* must either be a *bytes-like object* or an
   iterable producing bytes.

   *byteorder* argümanı, tam sayıyı temsil etmek için kullanılan bayt
   sırasını belirler.  *byteorder* ""big"" ise, en önemli bayt, bayt
   dizisinin başındadır. *byteorder* ""little"" ise, en önemli bayt,
   bayt dizisinin sonundadır. Ana sistemin yerel bayt sırasını istemek
   için bayt sırası değeri olarak "sys.byteorder" kullanın.

   *signed* argümanı, tam sayıyı temsil etmek için ikinin tümleyeninin
   kullanılıp kullanılmadığını gösterir.

   3.2 sürümünde geldi.

int.as_integer_ratio()

   Oranı, orijinal tam sayıya tam olarak eşit ve pozitif bir paydaya
   sahip bir tam sayı çifti döndürür. Integerlerin tam sayı oranı her
   zaman pay olarak tam sayı ve payda olarak "1" dir.

   3.8 sürümünde geldi.


Gerçel Sayılarda Ek Metotlar
----------------------------

Float türü, "numbers.Real" *abstract base class* 'ı uygular. Float
ayrıca aşağıdaki ek metotlara sahiptir.

float.as_integer_ratio()

   Oranı tam olarak orijinal gerçel sayıya eşit ve pozitif bir paydaya
   sahip bir çift tam sayı döndürür. Sonsuzluklarda "OverflowError" ve
   NaN'lerde (SayıDeğil) "ValueError" hataları ortaya çıkar.

float.is_integer()

   Float örneği integral değeriyle sonluysa "True", aksi takdirde
   "False" döndürür:

      >>> (-2.0).is_integer()
      True
      >>> (3.2).is_integer()
      False

İki yöntem, onaltılık dizelere dönüştürmeyi destekler. Python'un
floatları dahili olarak ikili sayılar olarak depolandığından, bir
kayan noktayı *decimal* (ondalık) dizgeye dönüştürmek veya bu karakter
dizisinden dönüştürmek genellikle küçük bir yuvarlama hatası içerir.
Buna karşılık, onaltılık diziler, gerçel sayıların tam olarak
gösterilmesine ve belirtilmesine izin verir. Bu, hata ayıklama
sırasında ve sayısal çalışmalarda yararlı olabilir.

float.hex()

   Bir gerçel sayının temsilini, onaltılık bir dize olarak döndürür.
   Sonlu gerçel sayılar için, bu gösterim her zaman başında bir "0x"
   ve sonunda bir "p" ve üs içerecektir.

classmethod float.fromhex(s)

   Gerçel sayıyı temsil eden bir onaltılık dize *s*'yi döndüren için
   sınıf (class) metodu. *s* dizesinin başında ve sonunda boşluk
   olabilir.

"float.hex()" 'in bir örnek (instance) metodu olduğunu,
"float.fromhex()" 'in ise bir sınıf (class) metodu olduğunu unutmayın.

Onaltılık bir dize şu biçimi alır:

   [sign] ['0x'] integer ['.' fraction] ['p' exponent]

where the optional "sign" may by either "+" or "-", "integer" and
"fraction" are strings of hexadecimal digits, and "exponent" is a
decimal integer with an optional leading sign.  Case is not
significant, and there must be at least one hexadecimal digit in
either the integer or the fraction.  This syntax is similar to the
syntax specified in section 6.4.4.2 of the C99 standard, and also to
the syntax used in Java 1.5 onwards.  In particular, the output of
"float.hex()" is usable as a hexadecimal floating-point literal in C
or Java code, and hexadecimal strings produced by C's "%a" format
character or Java's "Double.toHexString" are accepted by
"float.fromhex()".

Üssün onaltılık değil ondalık olarak yazıldığına ve katsayıyı çarpmak
için 2'nin gücünü verdiğine dikkat edin. Örneğin, "0x3.a7p10"
onaltılık dizesi, "(3 + 10./16 + 7./16**2) * 2.0**10" veya "3740.0"
gerçel sayısını temsil eder:

   >>> float.fromhex('0x3.a7p10')
   3740.0

"3740.0" 'a ters dönüştürme uygulamak, aynı sayıyı temsil eden farklı
bir onaltılık dize verir:

   >>> float.hex(3740.0)
   '0x1.d380000000000p+11'


Sayısal türlerin hashlemesi
---------------------------

Muhtemelen farklı türlerdeki "x" ve "y" sayıları için, "x == y"
olduğunda "hash(x) == hash(y)" olması bir gerekliliktir (bkz.
"__hash__()"). Çeşitli sayısal türler arasında uygulama kolaylığı ve
verimlilik için ("int", "float", "decimal.Decimal" ve
"fractions.Fraction" dahil) Python'un sayısal türler için hash'i,
herhangi bir rasyonel sayı için tanımlanmış tek bir matematiksel
fonksiyona dayanır ve bu nedenle "int" ve "fractions.Fraction" 'ın tüm
örnekleri ve "float" ve "decimal.Decimal" öğelerinin tüm sonlu
örnekleri için geçerlidir. Esasen, bu fonksiyon sabit bir asal sayı
olan "P" için "reduction modulo" "P" ile verilir. "P" değeri Python'a
"sys.hash_info" 'nun "modulus" özelliği olarak sunulur.

**CPython uygulama ayrıntısı:** Şu anda kullanılan asal sayı, 32 bit C
uzunluğundaki makinelerde "P = 2**31 - 1" ve 64-bit C uzunluğundaki
makinelerde "P = 2**61 - 1" şeklindedir.

İşte ayrıntılı kurallar:

* "x = m / n" negatif olmayan bir rasyonel sayıysa ve "n" "P" ile
  bölünemiyorsa, "hash(x)" 'i "m * invmod(n, P) % P" olarak
  tanımlayın, bu durumda "invmod(n, P)", "n" modül "P" 'nin tersini
  verir.

* "x = m / n" negatif olmayan bir rasyonel sayıysa ve "n", "P" ile
  bölünebiliyorsa (ancak "m" değildir), o zaman "n" 'nin "P" şeklinde
  ters modülü yoktur ve yukarıdaki kural geçerli değildir; bu durumda
  "hash(x)" i "sys.hash_info.inf" olarak tanımlayın.

* "x = m / n" negatif bir rasyonel sayıysa, "hash(x)" 'i "-hash(-x)"
  olarak tanımlayın. Elde edilen "hash" "-1" ise, bunu "-2" ile
  değiştirin.

* "sys.hash_info.inf" ve "-sys.hash_info.inf", pozitif sonsuz veya
  negatif sonsuz (sırasıyla) için "hash" değerleri olarak kullanılır.

* For a "complex" number "z", the hash values of the real and
  imaginary parts are combined by computing "hash(z.real) +
  sys.hash_info.imag * hash(z.imag)", reduced modulo
  "2**sys.hash_info.width" so that it lies in
  "range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width -
  1))".  Again, if the result is "-1", it's replaced with "-2".

Yukarıdaki kuralları açıklığa kavuşturmak için, "float" veya "complex"
olan rasyonel bir sayının "hash" 'ini hesaplamak için gömülü "hash" 'e
eş değer örnek Python kodu:

   import sys, math

   def hash_fraction(m, n):
       """Compute the hash of a rational number m / n.

       Assumes m and n are integers, with n positive.
       Equivalent to hash(fractions.Fraction(m, n)).

       """
       P = sys.hash_info.modulus
       # Remove common factors of P.  (Unnecessary if m and n already coprime.)
       while m % P == n % P == 0:
           m, n = m // P, n // P

       if n % P == 0:
           hash_value = sys.hash_info.inf
       else:
           # Fermat's Little Theorem: pow(n, P-1, P) is 1, so
           # pow(n, P-2, P) gives the inverse of n modulo P.
           hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
       if m < 0:
           hash_value = -hash_value
       if hash_value == -1:
           hash_value = -2
       return hash_value

   def hash_float(x):
       """Compute the hash of a float x."""

       if math.isnan(x):
           return object.__hash__(x)
       elif math.isinf(x):
           return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
       else:
           return hash_fraction(*x.as_integer_ratio())

   def hash_complex(z):
       """Compute the hash of a complex number z."""

       hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
       # do a signed reduction modulo 2**sys.hash_info.width
       M = 2**(sys.hash_info.width - 1)
       hash_value = (hash_value & (M - 1)) - (hash_value & M)
       if hash_value == -1:
           hash_value = -2
       return hash_value


Yineleyici Türleri
==================

Python, konteynerler üzerinde yineleme kavramını destekler. Bu, iki
farklı metot kullanılarak uygulanır; bunlar, kullanıcı tanımlı
sınıfların yinelemeyi desteklemesine izin vermek için kullanılır.
Aşağıda daha ayrıntılı olarak açıklanan diziler, her zaman yineleme
metotlarını destekler.

Container nesnelerinin *iterable* desteği sağlaması için bir metodun
tanımlanması gerekir:

container.__iter__()

   Bir *iterator* nesnesi döndürür.  Nesnenin aşağıda açıklanan
   yineleyici protokolünü desteklemesi gerekir.  Bir container, farklı
   yineleme türlerini destekliyorsa, bu yineleme türleri için özel
   olarak yineleyiciler istemek için ek yöntemler sağlanabilir.
   (Birden çok yineleme biçimini destekleyen bir nesneye örnek olarak
   hem genişlik öncelikli hem de derinlik öncelikli geçişi destekleyen
   bir ağaç yapısı verilebilir.)  Bu metot, Python/C API'sindeki
   Python nesneleri için tür yapısının "tp_iter" yuvasına karşılık
   gelir.

Yineleyici nesnelerinin kendilerinin, birlikte *iterator protocol* 'ü
oluşturan aşağıdaki iki metodu desteklemesi gerekir:

iterator.__iter__()

   *iterator* nesnesinin kendisini döndürür.  Bu, hem containerların
   hem de yineleyicilerin "for" ve "in" ifadeleriyle birlikte
   kullanılmasına izin vermek için gereklidir.  Bu metot, Python/C
   API'sindeki Python nesneleri için tür yapısının "tp_iter" yuvasına
   karşılık gelir.

iterator.__next__()

   *iterator* 'den sonraki öğeyi döndürür.  Başka öğe yoksa,
   "StopIteration" hatasını verir.  Bu metot, Python/C API'sindeki
   Python nesneleri için tür yapısının "tp_iternext" yuvasına karşılık
   gelir.

Python, genel ve özel dizi türleri, sözlükler ve diğer daha özel
formlar üzerinde yinelemeyi desteklemek için birkaç yineleyici nesnesi
tanımlar.  Belirli türler, yineleyici protokolünün uygulanmasının
ötesinde önemli değildir.

Bir yineleyicinin "__next__()" metodu "StopIteration" hatasını
verdiğinde, sonraki çağrılarda bunu yapmaya devam etmelidir. Bu
özelliğe uymayan uygulamalar bozuk sayılır.


Oluşturucu Tipleri
------------------

Python'un *generator*s, yineleyici protokolünü uygulamak için uygun
bir yol sağlar.  Bir container nesnesinin "__iter__()" metodu bir
oluşturucu olarak uygulanırsa, otomatik olarak "__iter__()" ve
"__next__()" metotlarını sağlayan bir yineleyici nesne (teknik olarak
bir oluşturucu nesnesi) döndürür. Oluşturucular hakkında daha fazla
bilgi the documentation for the yield expression adresinde
bulunabilir.


Dizi Tipleri --- "list", "tuple", "range"
=========================================

Üç temel dizi türü vardır: listeler, demetler ve aralık nesneleri.
binary data ve text strings 'in işlenmesi için uyarlanmış ek dizi
türleri, özel bölümlerde açıklanmıştır.


Yaygın Dizi İşlemleri
---------------------

Aşağıdaki tablodaki işlemler, hem değiştirilebilir hem de
değiştirilemez olan çoğu dizi türü tarafından desteklenir.
"collections.abc.Sequence" ABC, bu işlemleri özel dize türlerinde
doğru şekilde uygulamayı kolaylaştırmak için sağlanmıştır.

Bu tablo artan önceliğe göre sıralanmış dizi işlemlerini listeler.
Tabloda *s* ve *t* aynı türden dizilerdir, *n*, *i*, *j* ve *k* tam
sayılardır ve *x*, *s* tarafından dayatılan her tür ve değer
kısıtlamasını karşılayan isteğe bağlı bir nesnedir.

"in" ve "not in" işlemleri, karşılaştırma işlemleriyle aynı
önceliklere sahiptir. "+" (birleştirme) ve "*" (yineleme) işlemleri,
karşılık gelen sayısal işlemlerle aynı önceliğe sahiptir. [3]

+----------------------------+----------------------------------+------------+
| İşlem                      | Sonuç                            | Notlar     |
|============================|==================================|============|
| "x in s"                   | *s* 'nin bir öğesi *x* 'e eşitse | (1)        |
|                            | "True", aksi takdirde "False"    |            |
+----------------------------+----------------------------------+------------+
| "x not in s"               | *s* 'nin bir öğesi *x* 'e eşitse | (1)        |
|                            | "False", aksi taktirde "True"    |            |
+----------------------------+----------------------------------+------------+
| "s + t"                    | *s* ve *t* 'nin birleşimi        | (6)(7)     |
+----------------------------+----------------------------------+------------+
| "s * n" veya "n * s"       | *s* 'yi kendisine *n* kez        | (2)(7)     |
|                            | eklemeye eş değer                |            |
+----------------------------+----------------------------------+------------+
| "s[i]"                     | *s* 'nin *i*'inci öğesi, orijin  | (3)        |
|                            | 0                                |            |
+----------------------------+----------------------------------+------------+
| "s[i:j]"                   | *s* 'nin *i* 'den *j* 'ye kadar  | (3)(4)     |
|                            | olan dilimi                      |            |
+----------------------------+----------------------------------+------------+
| "s[i:j:k]"                 | *s* 'nin *i* 'den *j* 'ye kadar  | (3)(5)     |
|                            | olan dilimi, *k* 'lik adımlarla  |            |
|                            | (örneğin *k* = 2 ise, ikişer     |            |
|                            | ikişer)                          |            |
+----------------------------+----------------------------------+------------+
| "len(s)"                   | *s* 'nin uzunluğu                |            |
+----------------------------+----------------------------------+------------+
| "min(s)"                   | *s* 'nin en küçük öğesi          |            |
+----------------------------+----------------------------------+------------+
| "max(s)"                   | *s* 'nin en büyük öğesi          |            |
+----------------------------+----------------------------------+------------+
| "s.index(x[, i[, j]])"     | *x* 'in *s* içindeki ilk         | (8)        |
|                            | görüldüğü dizini (*i* dizininde  |            |
|                            | veya sonrasında ve *j*           |            |
|                            | dizininden önce)                 |            |
+----------------------------+----------------------------------+------------+
| "s.count(x)"               | *s* 'de *x*'in toplam görülme    |            |
|                            | sayısı                           |            |
+----------------------------+----------------------------------+------------+

Aynı türden diziler de karşılaştırmaları destekler. Özellikle,
demetler ve listeler, karşılık gelen öğeler ile sözlükbilimsel olarak
karşılaştırılır. Bu, eşit karşılaştırma yapılabilmesi için her öğenin
eşit olarak karşılaştırması gerektiği ve iki dizinin aynı türde ve
aynı uzunlukta olması gerektiği anlamına gelir. (Tüm ayrıntılar için
dil referansındaki Comparisons bölümüne bakın.)

Forward and reversed iterators over mutable sequences access values
using an index.  That index will continue to march forward (or
backward) even if the underlying sequence is mutated.  The iterator
terminates only when an "IndexError" or a "StopIteration" is
encountered (or when the index drops below zero).

Notlar:

1. "in" ve "not in" işlemleri, genel durumda yalnızca basit sınırlama
   testi için kullanılırken, bazı özel diziler (örneğin: "str",
   "bytes" ve "bytearray") bunları sonraki dizi testi için de
   kullanır:

      >>> "gg" in "eggs"
      True

2. *n* 'nin "`0" 'dan küçük değerleri "0" olarak değerlendirilir (bu,
   *s* ile aynı türde boş bir dizi verir). *s* dizisindeki öğeler
   kopyalanmaz, birden çok kez referans gösterilir (kullanılır).  Bu,
   çoğunlukla yeni Python programcılarına musallat olur; şunu düşünün:

      >>> lists = [[]] * 3
      >>> lists
      [[], [], []]
      >>> lists[0].append(3)
      >>> lists
      [[3], [3], [3]]

   Olan şu ki, "[[]]" boş bir liste içeren tek elemanlı bir listedir,
   dolayısıyla "[[]] * 3" 'ün üç elemanı da bu boş listeye
   referanstır.  "lists" öğelerinin herhangi birinin değiştirilmesi bu
   listeyi değiştirir. Bu şekilde farklı listelerin bir listesini
   oluşturabilirsiniz:

      >>> lists = [[] for i in range(3)]
      >>> lists[0].append(3)
      >>> lists[1].append(5)
      >>> lists[2].append(7)
      >>> lists
      [[3], [5], [7]]

   Daha fazla açıklama SSS gönderisinde mevcuttur: How do I create a
   multidimensional list?.

3. *i* veya *j* negatifse, dizin *s*: dizisinin sonuna göredir:
   "len(s) + i" veya "len(s) + j" değiştirilir.  Ancak "-0" 'ın hala
   "0" olduğuna dikkat edin.

4. *s* 'nin *i* ile *j* arasındaki dilimi, "`i <= k < j" olacak
   şekilde *k* indeksine sahip öğelerin dizisi olarak tanımlanır.  *i*
   veya *j* "len(s)" 'den büyükse,``len(s)`` kullanın.  *i* atlanırsa
   veya "None" ise, "0" kullanın.  *j* atlanırsa veya "None" ise,
   "len(s)" kullanın. *i*, *j* 'den büyük veya ona eşitse, dilim
   boştur.

5. The slice of *s* from *i* to *j* with step *k* is defined as the
   sequence of items with index  "x = i + n*k" such that "0 <= n <
   (j-i)/k".  In other words, the indices are "i", "i+k", "i+2*k",
   "i+3*k" and so on, stopping when *j* is reached (but never
   including *j*).  When *k* is positive, *i* and *j* are reduced to
   "len(s)" if they are greater. When *k* is negative, *i* and *j* are
   reduced to "len(s) - 1" if they are greater.  If *i* or *j* are
   omitted or "None", they become "end" values (which end depends on
   the sign of *k*).  Note, *k* cannot be zero. If *k* is "None", it
   is treated like "1".

6. Değiştirilemez dizileri birleştirmek her zaman yeni bir nesneyle
   sonuçlanır.  Bu, tekrarlanan birleştirme ile bir dizi oluşturmanın,
   toplam dizi uzunluğunda ikinci dereceden bir çalışma zamanı
   maliyetine sahip olacağı anlamına gelir.  Doğrusal bir çalışma
   zamanı maliyeti elde etmek için aşağıdaki alternatiflerden birine
   geçmelisiniz:

   * "str" nesnelerini birleştiriyorsanız, bir liste oluşturabilir ve
     sonunda "str.join()" kullanabilir veya bir "io.StringIO" örneğine
     yazabilir ve tamamlandığında değerini alabilirsiniz

   * "bytes" nesnelerini birleştiriyorsanız, benzer şekilde
     "bytes.join()" veya "io.BytesIO" kullanabilir veya bir
     "bytearray" nesnesiyle yerinde birleştirme yapabilirsiniz.
     "bytearray" nesneleri değiştirilebilirdir ve verimli bir aşırı
     tahsis mekanizmasına sahiptir

   * "tuple" nesneleri birleştiriyorsanız, bunun yerine bir "list"
     öğesini genişletin

   * diğer türler için ilgili sınıf dokümantasyonunu inceleyin

7. Bazı dizi türleri (örneğin "range") yalnızca belirli kalıpları
   takip eden öğe dizilerini destekler ve bu nedenle dizi
   birleştirmeyi veya tekrarlamayı desteklemez.

8. *s* içinde *x* bulunmadığında "index" "ValueError" hatasını verir.
   Tüm uygulamalar *i* ve *j* ek argümanlarının iletilmesini
   desteklemez. Bu argümanlar, dizinin alt bölümlerinin verimli bir
   şekilde aranmasını sağlar. Fazladan argümanları iletmek kabaca
   "s[i:j].index(x)" kullanmaya eş değerdir, yalnızca herhangi bir
   veri kopyalamadan ve döndürülen index dilimin başlangıcından ziyade
   dizinin başlangıcına göredir.


Değiştirilemez Dizi Tipleri
---------------------------

Değiştirilemez dizi türlerinin genellikle uyguladığı ve aynı zamanda
değişken dizi türleri tarafından uygulanmayan tek işlem, gömülü
"hash()" desteğidir.

Bu destek, "tuple" örnekleri gibi değiştirilemez dizilerin "dict"
anahtarları olarak kullanılmasına, "set" ve "frozenset" örneklerinde
saklanmasına izin verir.

Attempting to hash an immutable sequence that contains unhashable
values will result in "TypeError".


Değiştirilebilir Dizi Tipleri
-----------------------------

Aşağıdaki tabloda yer alan işlemler değiştirilebilir dizi tiplerinde
tanımlanmıştır. "collections.abc.MutableSequence" ABC, bu işlemleri
özel dizi türlerinde doğru şekilde uygulamayı kolaylaştırmak için
sağlanmıştır.

Tabloda *s* değiştirilebilir bir dizi türünün bir örneğidir, *t*
yinelenebilir herhangi bir nesnedir ve *x*, *s* tarafından dayatılan
herhangi bir tür ve değer kısıtlamasını karşılayan rastgele bir
nesnedir (örneğin, "bytearray" yalnızca "0 <= x <= 255" değer
kısıtlamasını karşılayan tam sayıları kabul eder).

+--------------------------------+----------------------------------+-----------------------+
| İşlem                          | Sonuç                            | Notlar                |
|================================|==================================|=======================|
| "s[i] = x"                     | *s* 'nin *i* öğesi *x* ile       |                       |
|                                | değiştirilir                     |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s[i:j] = t"                   | *s* 'nin *i* ile *j* arasındaki  |                       |
|                                | dilimi, yinelenebilir *t*        |                       |
|                                | içeriğiyle değiştirilir          |                       |
+--------------------------------+----------------------------------+-----------------------+
| "del s[i:j]"                   | "s[i:j] = []" ile eş değerdir    |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s[i:j:k] = t"                 | "s[i:j:k]" 'nin öğelerinin       | (1)                   |
|                                | yerini *t* öğelerininkiler alır  |                       |
+--------------------------------+----------------------------------+-----------------------+
| "del s[i:j:k]"                 | "s[i:j:k]" 'nin öğelerini        |                       |
|                                | listeden kaldırır                |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.append(x)"                  | dizinin sonuna *x* ekler         |                       |
|                                | ("s[len(s):len(s)] = [x]" ile eş |                       |
|                                | değerdir)                        |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.clear()"                    | *s* içindeki tüm öğeleri         | (5)                   |
|                                | kaldırır ("del s[:]" ile eş      |                       |
|                                | değerdir)                        |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.copy()"                     | *s*'nin sığ bir kopyasını        | (5)                   |
|                                | oluşturur ("s[:]" ile eş         |                       |
|                                | değerdir)                        |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.extend(t)" veya "s += t"    | *s* 'yi *t* 'nin içeriğiyle      |                       |
|                                | genişletir (çoğunlukla           |                       |
|                                | "s[len(s):len(s)] = t" ile eş    |                       |
|                                | değerdir)                        |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s *= n"                       | *n* kez tekrarlanan içeriğiyle   | (6)                   |
|                                | *s* 'yi günceller                |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.insert(i, x)"               | *i* tarafından verilen dizinde   |                       |
|                                | *s* 'nin içine *x* ekler         |                       |
|                                | ("s[i:i] = [x]" ile eş değerdir) |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.pop()" veya "s.pop(i)"      | *i* noktasındaki öğeyi alır ve   | (2)                   |
|                                | *s* öğesinden kaldırır           |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.remove(x)"                  | remove the first item from *s*   | (3)                   |
|                                | where "s[i]" is equal to *x*     |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s.reverse()"                  | *s* 'nin öğelerini yerinde       | (4)                   |
|                                | tersine çevirir                  |                       |
+--------------------------------+----------------------------------+-----------------------+

Notlar:

1. *t*, değiştirdiği dilimle aynı uzunlukta olmalıdır.

2. İsteğe bağlı *i* argümanı varsayılan olarak "-1" şeklindedir,
   böylece varsayılan olarak son öğe kaldırılır ve döndürülür.

3. *s* 'nin içinde *x* bulunmadığında "remove()" işlemi "ValueError"
   hatasını verir.

4. "reverse()" metodu, büyük bir diziyi tersine çevirirken yerden
   tasarruf sağlamak için diziyi yerinde değiştirir. Kullanıcılara yan
   etki ile çalıştığını hatırlatmak için ters diziyi döndürmez.

5. "clear()" and "copy()" are included for consistency with the
   interfaces of mutable containers that don't support slicing
   operations (such as "dict" and "set"). "copy()" is not part of the
   "collections.abc.MutableSequence" ABC, but most concrete mutable
   sequence classes provide it.

   3.3 sürümünde geldi: "clear()" ve "copy()" metotları.

6. *n* değeri bir tam sayıdır veya "__index__()" uygulayan bir
   nesnedir.  *n* 'nin sıfır ve negatif değerleri diziyi temizler.
   Dizideki öğeler kopyalanmaz; Yaygın Dizi İşlemleri altında "`s * n"
   için açıklandığı gibi, bunlara birden çok kez başvurulur.


Listeler
--------

Listeler, tipik olarak (kesin benzerlik derecesinin uygulamaya göre
değişeceği) homojen öğelerin koleksiyonlarını depolamak için
kullanılan değiştirilebilir dizilerdir.

class list([iterable])

   Listeler birkaç şekilde oluşturulabilir:

   * Boş listeyi belirtmek için bir çift köşeli parantez kullanma:
     "[]"

   * Köşeli parantez kullanarak, öğeleri virgülle ayırarak: "[a]",
     "[a, b, c]"

   * Liste kavrayışını kullanma: "[x for x in iterable]"

   * Tür oluşturucuyu kullanma: "list()" veya "list(iterable)"

   Yapıcı, öğeleri *iterable* 'ın öğeleriyle aynı ve aynı sırada olan
   bir liste oluşturur.  *iterable*; bir dizi, yinelemeyi destekleyen
   bir container veya yineleyici nesne olabilir.  *iterable* zaten bir
   listeyse, "iterable[:]" 'e benzer şekilde bir kopya oluşturulur ve
   döndürülür. Örneğin, "list('abc')", "['a', 'b', 'c']" değerini
   döndürür ve "list( (1, 2, 3) )", "[ 1, 2, 3]". Argüman verilmezse,
   yapıcı "[]" yeni bir boş liste oluşturur.

   Gömülü "sorted()" dahil olmak üzere diğer birçok işlem de listeler
   üretir.

   Listeler, tüm common ve mutable dizi işlemlerini uygular. Listeler
   ayrıca aşağıdaki ek metodu da sağlar:

   sort(*, key=None, reverse=False)

      Bu metot, öğeler arasında yalnızca "<" karşılaştırmalarını
      kullanarak listeyi yerinde sıralar. Hatalar bastırılmaz -
      herhangi bir karşılaştırma işlemi başarısız olursa, tüm sıralama
      işlemi başarısız olur (ve liste büyük olasılıkla kısmen
      değiştirilmiş durumda kalır).

      "sort()" yalnızca anahtar kelime tarafından iletilebilen iki
      argümanı kabul eder (keyword-only arguments):

      *key*, her liste öğesinden bir karşılaştırma anahtarı çıkarmak
      için kullanılan bir argümanın işlevini belirtir (örneğin,
      "key=str.lower"). Listedeki her bir öğeye karşılık gelen anahtar
      bir kez hesaplanır ve ardından tüm sıralama işlemi için
      kullanılır. Varsayılan değer olan "None", liste öğelerinin ayrı
      bir anahtar değeri hesaplamadan doğrudan sıralandığı anlamına
      gelir.

      "functools.cmp_to_key()" yardımcı programı, 2.x stili *cmp*
      işlevini bir *key* işlevine dönüştürmek için kullanılabilir.

      *reverse* bir boolean değeridir. "True" olarak ayarlanırsa,
      liste öğeleri, her karşılaştırma tersine çevrilmiş gibi
      sıralanır.

      Bu yöntem, büyük bir diziyi sıralarken yerden tasarruf sağlamak
      için diziyi yerinde değiştirir. Kullanıcılara yan etki ile
      çalıştığını hatırlatmak için, sıralanan diziyi döndürmez (açıkça
      yeni bir sıralanmış liste örneği istemek için "sorted()"
      kullanın).

      "sort()" metodunun kararlı olduğu garanti edilir.  Bir sıralama,
      eşit olarak karşılaştırılan öğelerin göreli sırasını
      değiştirmemeyi garanti ediyorsa kararlıdır --- bu, birden çok
      geçişte sıralama için yararlıdır (örneğin, departmana göre
      sıralama, ardından maaş derecesine göre).

      Sıralama örnekleri ve kısa bir sıralama eğitimi için bkz.
      Sorting HOW TO.

      **CPython uygulama ayrıntısı:** Bir liste sıralanırken, listeyi
      değiştirmeye ve hatta incelemeye çalışmanın etkisi tanımsızdır.
      Python'un C uygulaması, listenin süre boyunca boş görünmesini
      sağlar ve bir sıralama sırasında listenin mutasyona uğradığını
      algılayabilirse "ValueError" hatasını verir.


Demetler
--------

Tuple'lar, tipik olarak heterojen veri koleksiyonlarını depolamak için
kullanılan değiştirilemez dizilerdir (örneğin, gömülü "enumerate()"
tarafından üretilen 2 tuple). Tuple'lar, değiştirilemez bir homojen
veri dizisinin gerekli olduğu durumlarda da kullanılır (bir "set" veya
"dict" örneğinde depolamaya izin vermek gibi).

class tuple([iterable])

   Tuple'lar çeşitli şekillerde oluşturulabilir:

   * Boş demeti belirtmek için bir çift parantez kullanma: "()"

   * Tekli bir tuple için sonunda virgül kullanma: "a," veya "(a,)"

   * Öğeleri virgülle ayırma: "a, b, c" veya "(a, b, c)"

   * Gömülü "tuple()" kullanmak: "tuple()" veya "tuple(iterable)"

   Yapıcı, öğeleri *iterable* öğeleriyle aynı ve aynı sırada olan bir
   demet oluşturur.  *iterable* bir dizi, yinelemeyi destekleyen bir
   container veya yineleyici nesne olabilir.  *iterable* zaten bir
   tuple ise, değiştirilmeden döndürülür. Örneğin, "tuple('abc')",
   "('a', 'b', 'c')" 'yi ve "tuple( [1, 2, 3] )", "(1, 2, 3)" 'yi
   döndürür. Herhangi bir argüman verilmezse, yapıcı yeni bir boş
   demet oluşturur "()".

   Bir demeti oluşturanın aslında parantez değil virgül olduğuna
   dikkat edin. Boş demet durumunda veya söz dizimsel belirsizliği
   önlemek için gerektiğinde parantezler isteğe bağlıdır. Örneğin,
   "f(a, b, c)" üç argümanlı bir fonksiyon çağrısı iken "f((a, b,
   c))", tek argüman olarak 3'lü bir tuple içeren bir fonksiyon
   çağrısıdır.

   Tuple'lar, tüm common dizi işlemlerini uygular.

Ada göre erişimin dizine göre erişimden daha net olduğu heterojen veri
koleksiyonları için, "collections.namedtuple()" basit bir tuple
nesnesinden daha uygun bir seçim olabilir.


Aralıklar
---------

"range" türü, değiştirilemez bir sayı dizisini temsil eder ve
genellikle "for" döngülerinde belirli sayıda döngü yapmak için
kullanılır.

class range(stop)
class range(start, stop[, step])

   Aralık oluşturucunun argümanları tamsayı olmalıdır (gömülü "int"
   veya "__index__()" özel metodunu uygulayan herhangi bir nesne).
   *step* argümanı atlanırsa, varsayılan olarak "1" olur. *start*
   argümanı atlanırsa, varsayılan olarak "0" olur. *step* sıfırsa,
   "ValueError" hatası ortaya çıkar.

   Pozitif *step* için, "r" aralığının içeriği, "i >= 0" ve "r[i] <
   stop" olmak üzere "r[i] = start + step*i" formülüyle belirlenir.

   Negatif bir *step* için, aralığın içeriği hala "r[i] = start +
   step*i" formülüyle belirlenir, ancak kısıtlamalar "i >= 0" ve "r[i]
   > stop" 'dir.

   Bir aralık nesnesi "r[0]" değer kısıtlamasını karşılamıyorsa, boş
   olacaktır. Aralıklar negatif indeksleri destekler, ancak bunlar
   pozitif indeksler tarafından belirlenen dizinin sonundan indeksleme
   olarak yorumlanır.

   "sys.maxsize" 'dan büyük mutlak değerler içeren aralıklara izin
   verilir, ancak bazı özellikler ("len()" gibi), "OverflowError"
   hatasınının ortaya çıkmasını sağlayabilir.

   Aralık örnekleri:

      >>> list(range(10))
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      >>> list(range(1, 11))
      [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
      >>> list(range(0, 30, 5))
      [0, 5, 10, 15, 20, 25]
      >>> list(range(0, 10, 3))
      [0, 3, 6, 9]
      >>> list(range(0, -10, -1))
      [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
      >>> list(range(0))
      []
      >>> list(range(1, 0))
      []

   Aralıklar, birleştirme ve tekrar dışında tüm common dizi
   işlemlerini uygular (aralık nesnelerinin yalnızca katı bir kalıp
   izleyen dizileri temsil edebilmesi ve tekrarlama ve birleştirmenin
   genellikle bu kalıbı ihlal etmesi nedeniyle).

   start

      *start* parametresinin değeri (veya parametre sağlanmadıysa "0")

   stop

      *stop* parametresinin değeri

   step

      *step* parametresinin değeri (veya parametre sağlanmadıysa "1")

"range" türünün normal bir "list" veya "tuple" üzerindeki avantajı,
bir "range" nesnesinin temsil ettiği aralığın boyutu ne olursa olsun
her zaman aynı (küçük) miktarda bellek almasıdır (yalnızca "start",
"stop" ve "step" değerlerini sakladığı için, tek tek öğeleri ve alt
aralıkları gerektiği gibi hesaplar).

Aralık (range) nesneleri "collections.abc.Sequence" ABC'sini uygular
ve sınırlama testleri, eleman indeksi araması, dilimleme ve negatif
indeksler için destek gibi özellikler sağlar (bkz. Dizi Tipleri ---
list, tuple, range):

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

Aralık nesnelerini "==" ve "!=" ile eşitlik açısından test etmek,
bunları diziler olarak karşılaştırır. Yani, aynı değer dizisini temsil
ediyorlarsa, iki aralık nesnesi eşit kabul edilir.  (Eşit
karşılaştıran iki aralık nesnesinin farklı "start", "stop" ve "step"
niteliklerine sahip olabileceğini unutmayın, örneğin "range(0) ==
range(2, 1, 3)" veya "range(0, 3, 2) == range(0, 4, 2)".)

3.2 sürümünde değişti: Dizi ABC'sini uygular, Dilimleme ve negatif
indekslemeyi destekler, Tüm öğeleri yinelemek yerine sabit zamanda
üyelik için "int" nesnelerini test eder.

3.3 sürümünde değişti: Aralık nesnelerini tanımladıkları değer
sırasına göre karşılaştırmak için '==' ve '!=' tanımlayın (nesne
kimliğine göre karşılaştırmak yerine).

3.3 sürümünde geldi: "start", "stop" ve "step" özellikleri.

Ayrıca bakınız:

  * The linspace recipe shows how to implement a lazy version of range
    suitable for floating point applications.


Metin Sırası Türü --- "str"
===========================

Python'da metinsel veriler "str" nesneleri veya *strings* ile işlenir.
Dizeler, Unicode kod noktalarının değişmez dizgeleridir. Dize
değişmezleri çeşitli şekillerde yazılır:

* Tek tırnak: "'katıştırılmış "çift" tırnaklara izin verir'"

* Double quotes: ""allows embedded 'single' quotes""

* Üçlü tırnak: "'''Üç tek tırnak'''", """"Üç çift tırnak""""

Üçlü tırnak içine alınmış dizeler birden çok satıra yayılabilir -
ilişkili tüm boşluklar dize değişmezine dahil edilecektir.

Tek bir ifadenin parçası olan ve aralarında yalnızca boşluk bulunan
dize değişmezleri, örtük olarak tek bir dize değişmezine dönüştürülür.
Yani, "("spam" "yumurtalar") == "spam yumurtalar"".

Desteklenen kaçış dizileri ve çoğu kaçış dizisi işlemeyi devre dışı
bırakan "r" ("raw", Türkçesiyle "ham") ön eki dahil olmak üzere dize
değişmezinin çeşitli biçimleri hakkında daha fazla bilgi için bkz.
String and Bytes literals.

Dizeler, "str" yapıcısı kullanılarak diğer nesnelerden de
oluşturulabilir.

Ayrı bir "karakter" türü olmadığından, bir dizenin indekslenmesi 1
uzunluğunda dizeler üretir. Yani, boş olmayan bir *s* dizesi için
"s[0] == s[0:1]".

Değiştirilebilir bir dize türü de yoktur, ancak "str.join()" veya
"io.StringIO" birden çok parçadan dizeleri verimli bir şekilde
oluşturmak için kullanılabilir.

3.3 sürümünde değişti: Python 2 serisiyle geriye dönük uyumluluk için,
dize değişmezlerinde "u" ön ekine izin verilir. Bunun dize
değişmezlerinin anlamı üzerinde hiçbir etkisi yoktur ve "r" ön ekiyle
birleştirilemez.

class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')

   Return a string version of *object*.  If *object* is not provided,
   returns the empty string.  Otherwise, the behavior of "str()"
   depends on whether *encoding* or *errors* is given, as follows.

   If neither *encoding* nor *errors* is given, "str(object)" returns
   "type(object).__str__(object)", which is the "informal" or nicely
   printable string representation of *object*.  For string objects,
   this is the string itself.  If *object* does not have a "__str__()"
   method, then "str()" falls back to returning "repr(object)".

   *kodlama* veya *hatalar* 'dan en az biri verilirse, *nesne* bir
   *bytes-like object* olmalıdır (ör. "bytes" veya "bytearray").  Bu
   durumda, *nesne* bir "bytes" (veya "bytearray") nesnesiyse
   "str(bytes, *kodlama*, *hatalar*)", "bytes.decode(*kodlama*,
   *hatalar*)" 'a eşdeğerdir.  Aksi takdirde, arabellek nesnesinin
   altında yatan bayt nesnesi, "bytes.decode()" çağrılmadan önce elde
   edilir.  Arabellek nesneleri hakkında bilgi için bkz. Binary
   Sequence Types --- bytes, bytearray, memoryview ve Buffer Protocol.

   Bir "bytes" nesnesini *kodlama* veya *hatalar* argümanları olmadan
   "str()" 'ye iletmek, gayriresmi dize temsilini döndürmenin ilk
   durumuna girer (ayrıca bkz. Python için "-b" komut satırı
   seçeneği).  Örneğin:

      >>> str(b'Zoot!')
      "b'Zoot!'"

   "str" sınıfı ve metotları hakkında daha fazla bilgi için aşağıdaki
   Metin Sırası Türü --- str ve String (Dize) Metotları bölümüne
   bakın.  Biçimlendirilmiş dizelerin çıktısını almak için Formatted
   string literals ve Format String Syntax bölümlerine bakın.  Ayrıca,
   Text Processing Services bölümüne de bakın.


String (Dize) Metotları
-----------------------

Dizeler, aşağıda açıklanan ek yöntemlerle birlikte tüm ortak dizi
işlemlerini uygular.

Strings also support two styles of string formatting, one providing a
large degree of flexibility and customization (see "str.format()",
Format String Syntax and Custom String Formatting) and the other based
on C "printf" style formatting that handles a narrower range of types
and is slightly harder to use correctly, but is often faster for the
cases it can handle (printf-style String Formatting).

Standart kütüphanenin Text Processing Services bölümü, metinle ilgili
çeşitli yardımcı programlar sağlayan bir dizi başka modülü kapsar
("re" modülündeki normal ifade desteği dahil).

str.capitalize()

   İlk karakteri büyük ve geri kalanı küçük harf ile, dizenin bir
   kopyasını döndürür.

   3.8 sürümünde değişti: The first character is now put into
   titlecase rather than uppercase. This means that characters like
   digraphs will only have their first letter capitalized, instead of
   the full character.

str.casefold()

   Dizenin küçük harfe katlanmış bir kopyasını döndürür. Küçük harfe
   katlanmış dizeler, büyük/küçük harfsiz eşleştirme için
   kullanılabilir.

   Büyük harf katlama, harf küçültmeye (lowercasing) benzer ancak daha
   agresiftir, çünkü bir dizedeki tüm büyük/küçük harf ayrımlarını
   kaldırmayı amaçlar. Örneğin, Almanca küçük harf "'ß'", ""ss"" ile
   eşdeğerdir. Zaten küçük harf olduğundan, "lower()" "'ß'" için
   hiçbir şey yapmaz; "casefold()" onu ""ss"" biçimine dönüştürür.

   Casefolding algoritması, Unicode Standardının 3.13 bölümünde
   açıklanmıştır.

   3.3 sürümünde geldi.

str.center(width[, fillchar])

   *width* uzunluğundaki bir dizede ortalanmış olarak döndürür.
   Doldurma, belirtilen *fillchar* kullanılarak yapılır (varsayılanı
   bir ASCII boşluğudur). *width*, "len(s)" değerinden küçük veya ona
   eşitse orijinal dize döndürülür.

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

   [*start*, *end*] aralığında *sub* alt dizesinin örtüşmeyen
   oluşumlarının sayısını döndürür. İsteğe bağlı bağımsız değişkenler
   *start* ve *end*, dilim notasyonunda olduğu gibi yorumlanır.

   If *sub* is empty, returns the number of empty strings between
   characters which is the length of the string plus one.

str.encode(encoding='utf-8', errors='strict')

   Return the string encoded to "bytes".

   *encoding* defaults to "'utf-8'"; see Standard Encodings for
   possible values.

   *errors* controls how encoding errors are handled. If "'strict'"
   (the default), a "UnicodeError" exception is raised. Other possible
   values are "'ignore'", "'replace'", "'xmlcharrefreplace'",
   "'backslashreplace'" and any other name registered via
   "codecs.register_error()". See Error Handlers for details.

   For performance reasons, the value of *errors* is not checked for
   validity unless an encoding error actually occurs, Python
   Development Mode is enabled or a debug build is used.

   3.1 sürümünde değişti: Added support for keyword arguments.

   3.9 sürümünde değişti: The value of the *errors* argument is now
   checked in Python Development Mode and in debug mode.

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

   Dize belirtilen *suffix* ile bitiyorsa "True", aksi takdirde
   "`False" döndürün. *suffix* ayrıca aranacak bir son ek grubu da
   olabilir. İsteğe bağlı *start* ile, o konumdan başlayarak test
   edin. İsteğe bağlı *end* ile, o konumda karşılaştırmayı bırakın.

str.expandtabs(tabsize=8)

   Geçerli sütuna ve verilen tab boyutuna bağlı olarak, tüm tab
   karakterlerinin bir veya daha fazla boşlukla değiştirildiği dizenin
   bir kopyasını döndürün.  Tab konumları her *tab boyutu*
   karakterinde oluşur (varsayılan 8'dir, 0, 8, 16 ve benzeri
   sütunlarda tab konumları verilir).  Dizeyi genişletmek için mevcut
   sütun sıfıra ayarlanır ve dize karakter karakter incelenir.
   Karakter bir tab ise ("\t"), geçerli sütun sonraki tab konumuna
   eşit olana kadar sonuca bir veya daha fazla boşluk karakteri
   eklenir. (Tab karakterinin kendisi kopyalanmaz.)  Karakter yeni
   satırsa ("\n") veya dönüşse ("\r"), kopyalanır ve mevcut sütun
   sıfırlanır.  Diğer herhangi bir karakter değiştirilmeden kopyalanır
   ve mevcut sütun, karakterin yazdırıldığında nasıl temsil edildiğine
   bakılmaksızın bir artırılır.

   >>> '01\t012\t0123\t01234'.expandtabs()
   '01      012     0123    01234'
   >>> '01\t012\t0123\t01234'.expandtabs(4)
   '01  012 0123    01234'

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

   *sub* alt dizesinin "s[start:end]" diliminde bulunduğu dizedeki en
   düşük dizini döndür.  İsteğe bağlı argümanlar *start* ve *end*,
   dilim notasyonunda olduğu gibi yorumlanır. *sub* bulunamazsa "-1"
   döndürür.

   Not:

     "find()" metodu yalnızca *sub* öğesinin konumunu bilmeniz
     gerekiyorsa kullanılmalıdır.  *sub* 'ın bir alt dize olup
     olmadığını kontrol etmek için "in" operatörünü kullanın:

        >>> 'Py' in 'Python'
        True

str.format(*args, **kwargs)

   Bir dize biçimlendirme işlemi gerçekleştirin. Bu yöntemin
   çağrıldığı dize, parantez "{}" ile sınırlandırılmış metin veya
   değiştirme alanları içerebilir.  Her değiştirme alanı, ya bir
   konumsal (sırası önemli) argümanın sayısal dizinini ya da bir
   anahtar sözcük argmünanının adını içerir. Her değiştirme alanının,
   karşılık gelen argümanın dize değeriyle değiştirildiği dizenin bir
   kopyasını döndürür.

   >>> "The sum of 1 + 2 is {0}".format(1+2)
   'The sum of 1 + 2 is 3'

   Biçim dizelerinde (f string) belirtilebilecek çeşitli biçimlendirme
   seçeneklerinin açıklaması için bkz. Format String Syntax.

   Not:

     When formatting a number ("int", "float", "complex",
     "decimal.Decimal" and subclasses) with the "n" type (ex:
     "'{:n}'.format(1234)"), the function temporarily sets the
     "LC_CTYPE" locale to the "LC_NUMERIC" locale to decode
     "decimal_point" and "thousands_sep" fields of "localeconv()" if
     they are non-ASCII or longer than 1 byte, and the "LC_NUMERIC"
     locale is different than the "LC_CTYPE" locale.  This temporary
     change affects other threads.

   3.7 sürümünde değişti: Bir sayıyı "n" türüyle biçimlendirirken,
   fonksiyon bazı durumlarda "LC_CTYPE" yerel ayarını geçici olarak
   "LC_NUMERIC" yerel ayarına ayarlar.

str.format_map(mapping)

   "str.format(**mapping)" ile benzerdir, ancak "mapping" doğrudan
   kullanılır ve bir "dict" 'e kopyalanmaz.  Örneğin, "mapping" bir
   dict alt sınıfı ise bu kullanışlıdır:

   >>> class Default(dict):
   ...     def __missing__(self, key):
   ...         return key
   ...
   >>> '{name} was born in {country}'.format_map(Default(name='Guido'))
   'Guido was born in country'

   3.2 sürümünde geldi.

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

   "find()" gibi, ancak alt dize bulunamadığında "ValueError"
   yükseltir.

str.isalnum()

   Dizedeki tüm karakterler alfanümerikse ve en az bir karakter varsa
   "True", aksi takdirde "False" döndürür.  Bir "c" karakteri,
   aşağıdakilerden biri "True" döndürüyorsa alfasayısaldır:
   "c.isalpha()", "c.isdecimal()", "c.isdigit()" veya "c.isnumeric()".

str.isalpha()

   Dizedeki tüm karakterler alfabetikse ve en az bir karakter varsa
   "True", aksi takdirde "False" döndürür.  Alfabetik karakterler,
   Unicode karakter veritabanında "Harf" olarak tanımlanan
   karakterlerdir, yani genel kategori özelliği "Lm", "Lt", "Lu", "Ll"
   veya "Lo "dan biri olan karakterlerdir.  Bunun Unicode Standardında
   tanımlanan "Alfabetik" özelliğinden farklı olduğunu unutmayın.

str.isascii()

   Dize boşsa veya dizedeki tüm karakterler ASCII ise "True", aksi
   takdirde "False" döndürür. ASCII karakterleri U+0000-U+007F
   aralığında kod noktalarına sahiptir.

   3.7 sürümünde geldi.

str.isdecimal()

   Dizedeki tüm karakterler ondalık karakter ise ve en az bir karakter
   varsa "True", aksi takdirde "False" döndürür. Ondalık karakterler
   10 tabanında sayılar oluşturmak için kullanılabilen karakterlerdir,
   örneğin U+0660, ARAPÇA-HİNTÇE RAKAM SIFIR.  Resmi olarak bir
   ondalık karakter Unicode Genel Kategorisi "Nd" içerisindeki bir
   karakterdir.

str.isdigit()

   Dizedeki tüm karakterler rakamsa ve en az bir karakter varsa
   "True", aksi takdirde "False" döndürür.  Rakamlar ondalık
   karakterleri ve özel işlem gerektiren rakamları (uyumluluk üst
   simge rakamları gibi) içerir. Bu, Kharosthi sayıları gibi 10
   tabanında sayı oluşturmak için kullanılamayan rakamları kapsar.
   Resmi olarak rakam, Numeric_Type=Digit veya Numeric_Type=Decimal
   özellik değerine sahip bir karakterdir.

str.isidentifier()

   Identifiers and keywords bölümüne göre dizge dil tanımına göre
   geçerli bir tanımlayıcı ise "True" döndürür.

   "keyword.iskeyword()" çağrısı yaparak "s" dizesinin "def" ve
   "class" gibi ayrılmış bir tanımlayıcı olup olmadığını test eder.

   Örnek:

      >>> from keyword import iskeyword

      >>> 'hello'.isidentifier(), iskeyword('hello')
      (True, False)
      >>> 'def'.isidentifier(), iskeyword('def')
      (True, True)

str.islower()

   Dizedeki tüm büyük harfli karakterler [4] küçük harfli ise ve en az
   bir büyük harfli karakter varsa "True", aksi takdirde "False"
   döndürür.

str.isnumeric()

   Dizedeki tüm karakterler sayısal karakterlerse ve en az bir
   karakter varsa "True", aksi takdirde "False" döndürür. Sayısal
   karakterler rakam karakterlerini ve Unicode sayısal değer
   özelliğine sahip tüm karakterleri içerir, örneğin U+2155, VULGAR
   FRAKSİYONU BEŞİNCİ.  Resmi olarak, sayısal karakterler
   Numeric_Type=Digit, Numeric_Type=Decimal veya Numeric_Type=Numeric
   özellik değerine sahip karakterlerdir.

str.isprintable()

   Dizedeki tüm karakterler yazdırılabilirse veya dize boşsa "True",
   aksi takdirde "False" döndürür.  Yazdırılamayan karakterler,
   yazdırılabilir olarak kabul edilen ASCII boşluğu (0x20) dışında,
   Unicode karakter veritabanında "Diğer" veya "Ayırıcı" olarak
   tanımlanan karakterlerdir.  (Bu bağlamda, yazdırılabilir
   karakterlerin "repr()" bir dize üzerinde çağrıldığında kaçılmaması
   gereken karakterler olduğunu unutmayın.  Bunun "sys.stdout" veya
   "sys.stderr" dosyalarına yazılan dizelerin işlenmesiyle bir ilgisi
   yoktur)

str.isspace()

   Dizede yalnızca boşluk karakterleri varsa ve en az bir karakter
   varsa "True", aksi takdirde "False" döndürür.

   Bir karakter, genel kategorisi "Zs" (“Ayırıcı, boşluk”) ya da çift
   yönlü sınıfı "WS", "B" veya "S"’den biri ise Unicode karakter
   veritabanında (bkz. "unicodedata") *beyaz boşluk karakteri*’dir.

str.istitle()

   Eğer dizenin yalnızca ilk harfi büyük ise ve en az bir karakter
   varsa "True" döndürür. Örneğin, büyük harfli karakterler sadece
   küçük harfli karakterleri ve küçük harfli karakterler sadece büyük
   harfli karakterleri takip edebilir.  Aksi takdirde "False"
   döndürür.

str.isupper()

   Dizedeki tüm karakterler [4] büyük harfli ise ve en az bir büyük
   harfli karakter varsa "True", aksi takdirde "False" döndürür.

   >>> 'BANANA'.isupper()
   True
   >>> 'banana'.isupper()
   False
   >>> 'baNana'.isupper()
   False
   >>> ' '.isupper()
   False

str.join(iterable)

   *iterable* içindeki dizgelerin birleşiminden oluşan bir dizge
   döndürür. Eğer *iterable* içinde "bytes" nesneleri de dahil olmak
   üzere string olmayan değerler varsa bir "TypeError" oluşacaktır.
   Öğeler arasındaki ayırıcı, bu yöntemi sağlayan dizedir.

str.ljust(width[, fillchar])

   *width* uzunluğundaki bir dizeyi sola hizalanmış olarak döndürür.
   Doldurma, belirtilen *fillchar* kullanılarak yapılır (varsayılanı
   bir ASCII boşluğudur). *width*, "len(s)" değerinden küçük veya ona
   eşitse orijinal dize döndürülür.

str.lower()

   Dizenin tüm büyük harfli karakterlerini [4] küçük harfe
   dönüştürerek bir kopyasını döndürür.

   Harf küçültme algoritması, Unicode Standardının 3.13 bölümünde
   açıklanmıştır.

str.lstrip([chars])

   Dizenin baştaki karakterleri çıkarılmış bir kopyasını döndürür.
   *chars* bağımsız değişkeni, kaldırılacak karakter kümesini belirten
   bir dizedir.  Atlanırsa veya "None" olursa, *chars* bağımsız
   değişkeni varsayılan olarak boşlukları kaldırır.  *chars* bağımsız
   değişkeni bir ön ek değildir; bunun yerine, değerlerinin tüm
   kombinasyonları çıkarılır:

      >>> '   spacious   '.lstrip()
      'spacious   '
      >>> 'www.example.com'.lstrip('cmowz.')
      'example.com'

   Bir karakter kümesinin tüm ön ekleri yerine tek bir ön ek dizesini
   kaldıracak bir yöntem için "str.removeprefix()" bölümüne bakın.
   Örneğin:

      >>> 'Arthur: three!'.lstrip('Arthur: ')
      'ee!'
      >>> 'Arthur: three!'.removeprefix('Arthur: ')
      'three!'

static str.maketrans(x[, y[, z]])

   Bu statik yöntem "str.translate()" için kullanılabilecek bir çeviri
   tablosu döndürür.

   Yalnızca bir bağımsız değişken varsa, Unicode sıradanlarını
   (tamsayılar) veya karakterlerini (1 uzunluğundaki dizeler) Unicode
   sıradanlarına, dizelere (isteğe bağlı uzunluklarda) veya "None"
   değerine eşleyen bir sözlük olmalıdır.  Karakter anahtarları daha
   sonra sıradanlara dönüştürülecektir.

   İki bağımsız değişken varsa, bunlar eşit uzunlukta dizgeler
   olmalıdır. Sözlüğün son halinde x'teki her karakter y'de aynı
   konumdaki karakterle eşlenecektir. Üçüncü bir bağımsız değişken
   varsa, karakterleri sonuçta "None" ile eşlenecek bir dizge
   olmalıdır.

str.partition(sep)

   Dizeyi *sep* öğesinin ilk geçtiği yerden böler ve ayırıcıdan önceki
   kısmı, ayırıcının kendisini ve ayırıcıdan sonraki kısmı içeren bir
   3'lü döndürür.  Ayırıcı bulunamazsa, dizenin kendisini ve ardından
   iki boş dizeyi içeren bir 3'lü döndürür.

str.removeprefix(prefix, /)

   Eğer dize *prefix* dizesi ile başlıyorsa, "dize[len(prefix):]"
   döndürür. Aksi takdirde, orijinal dizgenin bir kopyasını döndürür:

      >>> 'TestHook'.removeprefix('Test')
      'Hook'
      >>> 'BaseTestCase'.removeprefix('Test')
      'BaseTestCase'

   3.9 sürümünde geldi.

str.removesuffix(suffix, /)

   Dize *suffix* (son ek) dizesiyle bitiyorsa ve bu *suffix* boş
   değilse, "dize[:-len(suffix)]" döndürür. Aksi takdirde, orijinal
   dizenin bir kopyasını döndürür:

      >>> 'MiscTests'.removesuffix('Tests')
      'Misc'
      >>> 'TmpDirMixin'.removesuffix('Tests')
      'TmpDirMixin'

   3.9 sürümünde geldi.

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

   Dizenin, *eski* alt dizesinin tüm oluşumları *yeni* ile
   değiştirilmiş bir kopyasını döndürür.  İsteğe bağlı olarak *count*
   bağımsız değişkeni verilirse, yalnızca ilk *count* oluşumu
   değiştirilir.

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

   Dizede *sub* alt dizesinin bulunduğu en yüksek dizini döndürür,
   öyle ki *sub* "s[start:end]" içinde yer alır.  İsteğe bağlı
   argümanlar *start* ve *end* dilim gösterimindeki gibi yorumlanır.
   Başarısızlık durumunda "-1" döndürür.

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

   "rfind()" gibi, ancak *sub* alt dizesi bulunamadığında "ValueError"
   yükseltir.

str.rjust(width[, fillchar])

   *width* uzunluğundaki bir dizeyi sağa hizalanmış olarak döndürür.
   Doldurma, belirtilen *fillchar* kullanılarak yapılır (varsayılanı
   bir ASCII boşluğudur). *width*, "len(s)" değerinden küçük veya ona
   eşitse orijinal dize döndürülür.

str.rpartition(sep)

   Dizeyi *sep* öğesinin ilk geçtiği yerden böler ve ayırıcıdan önceki
   kısmı, ayırıcının kendisini ve ayırıcıdan sonraki kısmı içeren bir
   3'lü döndürür.  Ayırıcı bulunamazsa, dizenin kendisini ve ardından
   iki boş dizeyi içeren bir 3'lü döndürür.

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

   Ayırıcı dizge olarak *sep* kullanarak dizgedeki sözcüklerin bir
   listesini döndürür. Eğer *maxsplit* belirtilmişse, *rightmost*
   olmak üzere en fazla *maxsplit* bölme yapılır.  Eğer *sep*
   belirtilmemişse veya "None" ise, herhangi bir boşluk dizesi
   ayırıcıdır.  Sağdan bölme dışında, "rsplit()" aşağıda ayrıntılı
   olarak açıklanan "split()" gibi davranır.

str.rstrip([chars])

   Dizenin en sondaki karakterleri çıkarılmış bir kopyasını döndürür.
   *chars* bağımsız değişkeni, kaldırılacak karakter kümesini belirten
   bir dizedir.  Atlanırsa veya "None" olursa, *chars* bağımsız
   değişkeni varsayılan olarak boşlukları kaldırır.  *chars* bağımsız
   değişkeni bir ön ek değildir; bunun yerine, değerlerinin tüm
   kombinasyonları çıkarılır:

      >>> '   spacious   '.rstrip()
      '   spacious'
      >>> 'mississippi'.rstrip('ipz')
      'mississ'

   Bir karakter kümesinin tüm son ekleri yerine tek bir son ek
   dizesini kaldıracak bir yöntem için "str.removeprefix()" bölümüne
   bakın.  Örneğin:

      >>> 'Monty Python'.rstrip(' Python')
      'M'
      >>> 'Monty Python'.removesuffix(' Python')
      'Monty'

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

   Ayırıcı dizge olarak *sep* kullanarak dizgedeki sözcüklerin bir
   listesini döndürür.  Eğer *maxsplit* belirtilmişse, en fazla
   *maxsplit* bölme işlemi yapılır (dolayısıyla, liste en fazla
   "maxsplit+1" elemana sahip olur).  Eğer *maxsplit* belirtilmemişse
   veya "-1" ise, bölme sayısında bir sınırlama yoktur (tüm olası
   bölmeler yapılır).

   *sep* verilirse, ardışık sınırlayıcılar birlikte gruplanmaz ve boş
   dizeleri sınırladıkları kabul edilir (örneğin, "'1,,2'.split(',')",
   "['1', '', '2']" döndürür). *sep* bağımsız değişkeni birden çok
   karakterden oluşabilir (örneğin, "'1<>2<>3'.split('<>')", "['1',
   '2', '3']" döndürür). Boş bir dizeyi belirtilen bir ayırıcıyla
   bölmek "['']" döndürür.

   Örneğin:

      >>> '1,2,3'.split(',')
      ['1', '2', '3']
      >>> '1,2,3'.split(',', maxsplit=1)
      ['1', '2,3']
      >>> '1,2,,3,'.split(',')
      ['1', '2', '', '3', '']

   Eğer *sep* belirtilmemişse veya "None" ise, farklı bir bölme
   algoritması uygulanır: ardışık boşluk dizileri tek bir ayırıcı
   olarak kabul edilir ve dizgenin başında veya sonunda boşluk varsa,
   sonucun başında veya sonunda boş dizeler olmaz. Dolayısıyla, boş
   bir dizeyi veya sadece beyaz boşluktan oluşan bir dizeyi "None"
   ayırıcısıyla bölmek "[]" döndürür.

   Örneğin:

      >>> '1 2 3'.split()
      ['1', '2', '3']
      >>> '1 2 3'.split(maxsplit=1)
      ['1', '2 3']
      >>> '   1   2   3   '.split()
      ['1', '2', '3']

str.splitlines(keepends=False)

   Satır sınırlarında keserek dizedeki satırların bir listesini
   döndürür.  Satır sonları için *keepends* belirtilmediği ve true
   değerinde olmadığı sürece, satır sonları sonuç listesine dahil
   edilmez.

   Bu yöntem aşağıdaki satır sınırlarında bölme yapar.  Spesifik
   olarak, sınırlar *universal newlines* 'ın bir üst kümesidir.

   +-------------------------+-------------------------------+
   | Temsil                  | Açıklama                      |
   |=========================|===============================|
   | "\n"                    | Satır Atlama                  |
   +-------------------------+-------------------------------+
   | "\r"                    | Satır Başına Alma             |
   +-------------------------+-------------------------------+
   | "\r\n"                  | Satır Başına Alma + Satır     |
   |                         | Atlama                        |
   +-------------------------+-------------------------------+
   | "\v" or "\x0b"          | Satır Tablolama               |
   +-------------------------+-------------------------------+
   | "\f" or "\x0c"          | Form Besleme                  |
   +-------------------------+-------------------------------+
   | "\x1c"                  | Dosya Ayırıcı                 |
   +-------------------------+-------------------------------+
   | "\x1d"                  | Grup Ayırıcı                  |
   +-------------------------+-------------------------------+
   | "\x1e"                  | Kayıt Ayırıcı                 |
   +-------------------------+-------------------------------+
   | "\x85"                  | Yeni Satır (C1 Denetim Kodu)  |
   +-------------------------+-------------------------------+
   | "\u2028"                | Satır Ayrıcı                  |
   +-------------------------+-------------------------------+
   | "\u2029"                | Paragraf Ayırıcı              |
   +-------------------------+-------------------------------+

   3.2 sürümünde değişti: "\v" ve "\f" satır sınırlarına eklenir.

   Örneğin:

      >>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
      ['ab c', '', 'de fg', 'kl']
      >>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
      ['ab c\n', '\n', 'de fg\r', 'kl\r\n']

   Bir sınırlayıcı dize *sep* verildiğinde "split()" yönteminden
   farklı olarak, bu yöntem boş dize için boş bir liste döndürür ve
   bir terminal satır sonu fazladan bir satır ile sonuçlanmaz:

      >>> "".splitlines()
      []
      >>> "One line\n".splitlines()
      ['One line']

   Kıyaslayacak olursak "split(‘\n’)" şu değeri verir:

      >>> ''.split('\n')
      ['']
      >>> 'Two lines\n'.split('\n')
      ['Two lines', '']

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

   Dize *önek* ile başlıyorsa "True" döndürür, aksi takdirde "False"
   döndürür. *prefix* ayrıca aranacak ön eklerin bir tuple'ı da
   olabilir.  İsteğe bağlı *start* ile, o konumdan başlayan dizeyi
   sınar.  İsteğe bağlı *end* ile, dizeyi o konumda karşılaştırmayı
   durdurur.

str.strip([chars])

   Dizenin baştaki ve sondaki karakterleri çıkarılmış bir kopyasını
   döndürür. *chars* bağımsız değişkeni, kaldırılacak karakter
   kümesini belirten bir dizedir. Atlanırsa veya "None" olursa,
   *chars* bağımsız değişkeni varsayılan olarak boşlukları kaldırır.
   *chars* bağımsız değişkeni bir ön ek veya son ek değildir; bunun
   yerine, değerlerinin tüm kombinasyonları çıkarılır:

      >>> '   spacious   '.strip()
      'spacious'
      >>> 'www.example.com'.strip('cmowz.')
      'example'

   En dıştaki ön ve son*chars* bağımsız değişken değerleri dizeden
   çıkarılır. Karakterler, *chars* içindeki karakter kümesinde
   bulunmayan bir dize karakterine ulaşılana kadar önde gelen uçtan
   çıkarılır. Benzer bir işlem son uçta da gerçekleşir. Örneğin:

      >>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
      >>> comment_string.strip('.#! ')
      'Section 3.2.1 Issue #32'

str.swapcase()

   Büyük harf karakterleri küçük harfe dönüştürülmüş veya tam tersi
   yapılmış dizenin bir kopyasını döndürür. "s.swapcase().swapcase()
   == s" ifadesinin mutlaka doğru olması gerekmediğine dikkat edin.

str.title()

   Sözcüklerin büyük harfle başladığı ve kalan karakterlerin küçük
   harf olduğu dizenin başlıklandırılmış bir sürümünü döndürür.

   Örneğin:

      >>> 'Hello world'.title()
      'Hello World'

   Algoritma, bir kelimenin ardışık harf grupları olarak dilden
   bağımsız basit bir tanımını kullanır.  Bu tanım birçok bağlamda işe
   yarar, ancak bu, kısaltmalar ve iyeliklerdeki kesme işaretlerinin
   kelime sınırları oluşturduğu anlamına gelir ve bu istenen sonuç
   olmayabilir:

      >>> "they're bill's friends from the UK".title()
      "They'Re Bill'S Friends From The Uk"

   The "string.capwords()" function does not have this problem, as it
   splits words on spaces only.

   Alternatively, a workaround for apostrophes can be constructed
   using regular expressions:

      >>> import re
      >>> def titlecase(s):
      ...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
      ...                   lambda mo: mo.group(0).capitalize(),
      ...                   s)
      ...
      >>> titlecase("they're bill's friends.")
      "They're Bill's Friends."

str.translate(table)

   Her karakterin verilen çeviri tablosu aracılığıyla eşlendiği
   dizgenin bir kopyasını döndürür.  Tablo, "__getitem__()"
   aracılığıyla indeksleme uygulayan bir nesne, tipik olarak bir
   *mapping* veya *sequence* olmalıdır.  Bir Unicode sıra numarası
   (bir tamsayı) ile indekslendiğinde, tablo nesnesi aşağıdakilerden
   herhangi birini yapabilir: karakteri bir veya daha fazla başka
   karakterle eşlemek için bir Unicode sıra numarası veya bir dize
   döndürmek; karakteri dönüş dizesinden silmek için "None" döndürmek;
   veya karakteri kendisiyle eşlemek için bir "LookupError" istisnası
   oluşturmak.

   You can use "str.maketrans()" to create a translation map from
   character-to-character mappings in different formats.

   See also the "codecs" module for a more flexible approach to custom
   character mappings.

str.upper()

   Return a copy of the string with all the cased characters [4]
   converted to uppercase.  Note that "s.upper().isupper()" might be
   "False" if "s" contains uncased characters or if the Unicode
   category of the resulting character(s) is not "Lu" (Letter,
   uppercase), but e.g. "Lt" (Letter, titlecase).

   Harf büyütme algoritması, Unicode Standardının 3.13 bölümünde
   açıklanmıştır.

str.zfill(width)

   Return a copy of the string left filled with ASCII "'0'" digits to
   make a string of length *width*. A leading sign prefix
   ("'+'"/"'-'") is handled by inserting the padding *after* the sign
   character rather than before. The original string is returned if
   *width* is less than or equal to "len(s)".

   Örneğin:

      >>> "42".zfill(5)
      '00042'
      >>> "-42".zfill(5)
      '-0042'


"printf"-style String Formatting
--------------------------------

Not:

  The formatting operations described here exhibit a variety of quirks
  that lead to a number of common errors (such as failing to display
  tuples and dictionaries correctly).  Using the newer formatted
  string literals, the "str.format()" interface, or template strings
  may help avoid these errors.  Each of these alternatives provides
  their own trade-offs and benefits of simplicity, flexibility, and/or
  extensibility.

String objects have one unique built-in operation: the "%" operator
(modulo). This is also known as the string *formatting* or
*interpolation* operator. Given "format % values" (where *format* is a
string), "%" conversion specifications in *format* are replaced with
zero or more elements of *values*. The effect is similar to using the
"sprintf()" in the C language.

If *format* requires a single argument, *values* may be a single non-
tuple object. [5]  Otherwise, *values* must be a tuple with exactly
the number of items specified by the format string, or a single
mapping object (for example, a dictionary).

A conversion specifier contains two or more characters and has the
following components, which must occur in this order:

1. The "'%'" character, which marks the start of the specifier.

2. Mapping key (optional), consisting of a parenthesised sequence of
   characters (for example, "(somename)").

3. Conversion flags (optional), which affect the result of some
   conversion types.

4. Minimum field width (optional).  If specified as an "'*'"
   (asterisk), the actual width is read from the next element of the
   tuple in *values*, and the object to convert comes after the
   minimum field width and optional precision.

5. Precision (optional), given as a "'.'" (dot) followed by the
   precision.  If specified as "'*'" (an asterisk), the actual
   precision is read from the next element of the tuple in *values*,
   and the value to convert comes after the precision.

6. Length modifier (optional).

7. Conversion type.

When the right argument is a dictionary (or other mapping type), then
the formats in the string *must* include a parenthesised mapping key
into that dictionary inserted immediately after the "'%'" character.
The mapping key selects the value to be formatted from the mapping.
For example:

>>> print('%(language)s has %(number)03d quote types.' %
...       {'language': "Python", "number": 2})
Python has 002 quote types.

In this case no "*" specifiers may occur in a format (since they
require a sequential parameter list).

The conversion flag characters are:

+-----------+-----------------------------------------------------------------------+
| Flag      | Anlamı                                                                |
|===========|=======================================================================|
| "'#'"     | The value conversion will use the "alternate form" (where defined     |
|           | below).                                                               |
+-----------+-----------------------------------------------------------------------+
| "'0'"     | The conversion will be zero padded for numeric values.                |
+-----------+-----------------------------------------------------------------------+
| "'-'"     | The converted value is left adjusted (overrides the "'0'" conversion  |
|           | if both are given).                                                   |
+-----------+-----------------------------------------------------------------------+
| "' '"     | (a space) A blank should be left before a positive number (or empty   |
|           | string) produced by a signed conversion.                              |
+-----------+-----------------------------------------------------------------------+
| "'+'"     | A sign character ("'+'" or "'-'") will precede the conversion         |
|           | (overrides a "space" flag).                                           |
+-----------+-----------------------------------------------------------------------+

A length modifier ("h", "l", or "L") may be present, but is ignored as
it is not necessary for Python -- so e.g. "%ld" is identical to "%d".

The conversion types are:

+--------------+-------------------------------------------------------+---------+
| Conversion   | Anlamı                                                | Notlar  |
|==============|=======================================================|=========|
| "'d'"        | Signed integer decimal.                               |         |
+--------------+-------------------------------------------------------+---------+
| "'i'"        | Signed integer decimal.                               |         |
+--------------+-------------------------------------------------------+---------+
| "'o'"        | Signed octal value.                                   | (1)     |
+--------------+-------------------------------------------------------+---------+
| "'u'"        | Obsolete type -- it is identical to "'d'".            | (6)     |
+--------------+-------------------------------------------------------+---------+
| "'x'"        | Signed hexadecimal (lowercase).                       | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'X'"        | Signed hexadecimal (uppercase).                       | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'e'"        | Floating point exponential format (lowercase).        | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'E'"        | Floating point exponential format (uppercase).        | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'f'"        | Floating point decimal format.                        | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'F'"        | Floating point decimal format.                        | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'g'"        | Floating point format. Uses lowercase exponential     | (4)     |
|              | format if exponent is less than -4 or not less than   |         |
|              | precision, decimal format otherwise.                  |         |
+--------------+-------------------------------------------------------+---------+
| "'G'"        | Floating point format. Uses uppercase exponential     | (4)     |
|              | format if exponent is less than -4 or not less than   |         |
|              | precision, decimal format otherwise.                  |         |
+--------------+-------------------------------------------------------+---------+
| "'c'"        | Single character (accepts integer or single character |         |
|              | string).                                              |         |
+--------------+-------------------------------------------------------+---------+
| "'r'"        | String (converts any Python object using "repr()").   | (5)     |
+--------------+-------------------------------------------------------+---------+
| "'s'"        | String (converts any Python object using "str()").    | (5)     |
+--------------+-------------------------------------------------------+---------+
| "'a'"        | String (converts any Python object using "ascii()").  | (5)     |
+--------------+-------------------------------------------------------+---------+
| "'%'"        | No argument is converted, results in a "'%'"          |         |
|              | character in the result.                              |         |
+--------------+-------------------------------------------------------+---------+

Notlar:

1. The alternate form causes a leading octal specifier ("'0o'") to be
   inserted before the first digit.

2. The alternate form causes a leading "'0x'" or "'0X'" (depending on
   whether the "'x'" or "'X'" format was used) to be inserted before
   the first digit.

3. The alternate form causes the result to always contain a decimal
   point, even if no digits follow it.

   The precision determines the number of digits after the decimal
   point and defaults to 6.

4. The alternate form causes the result to always contain a decimal
   point, and trailing zeroes are not removed as they would otherwise
   be.

   The precision determines the number of significant digits before
   and after the decimal point and defaults to 6.

5. If precision is "N", the output is truncated to "N" characters.

6. See **PEP 237**.

Since Python strings have an explicit length, "%s" conversions do not
assume that "'\0'" is the end of the string.

3.1 sürümünde değişti: "%f" conversions for numbers whose absolute
value is over 1e50 are no longer replaced by "%g" conversions.


Binary Sequence Types --- "bytes", "bytearray", "memoryview"
============================================================

The core built-in types for manipulating binary data are "bytes" and
"bytearray". They are supported by "memoryview" which uses the buffer
protocol to access the memory of other binary objects without needing
to make a copy.

The "array" module supports efficient storage of basic data types like
32-bit integers and IEEE754 double-precision floating values.


Bytes Objects
-------------

Bytes objects are immutable sequences of single bytes. Since many
major binary protocols are based on the ASCII text encoding, bytes
objects offer several methods that are only valid when working with
ASCII compatible data and are closely related to string objects in a
variety of other ways.

class bytes([source[, encoding[, errors]]])

   Firstly, the syntax for bytes literals is largely the same as that
   for string literals, except that a "b" prefix is added:

   * Single quotes: "b'still allows embedded "double" quotes'"

   * Double quotes: "b"still allows embedded 'single' quotes""

   * Triple quoted: "b'''3 single quotes'''", "b"""3 double quotes""""

   Only ASCII characters are permitted in bytes literals (regardless
   of the declared source code encoding). Any binary values over 127
   must be entered into bytes literals using the appropriate escape
   sequence.

   As with string literals, bytes literals may also use a "r" prefix
   to disable processing of escape sequences. See String and Bytes
   literals for more about the various forms of bytes literal,
   including supported escape sequences.

   While bytes literals and representations are based on ASCII text,
   bytes objects actually behave like immutable sequences of integers,
   with each value in the sequence restricted such that "0 <= x < 256"
   (attempts to violate this restriction will trigger "ValueError").
   This is done deliberately to emphasise that while many binary
   formats include ASCII based elements and can be usefully
   manipulated with some text-oriented algorithms, this is not
   generally the case for arbitrary binary data (blindly applying text
   processing algorithms to binary data formats that are not ASCII
   compatible will usually lead to data corruption).

   In addition to the literal forms, bytes objects can be created in a
   number of other ways:

   * A zero-filled bytes object of a specified length: "bytes(10)"

   * From an iterable of integers: "bytes(range(20))"

   * Copying existing binary data via the buffer protocol:
     "bytes(obj)"

   Also see the bytes built-in.

   Since 2 hexadecimal digits correspond precisely to a single byte,
   hexadecimal numbers are a commonly used format for describing
   binary data. Accordingly, the bytes type has an additional class
   method to read data in that format:

   classmethod fromhex(string)

      This "bytes" class method returns a bytes object, decoding the
      given string object.  The string must contain two hexadecimal
      digits per byte, with ASCII whitespace being ignored.

      >>> bytes.fromhex('2Ef0 F1f2  ')
      b'.\xf0\xf1\xf2'

      3.7 sürümünde değişti: "bytes.fromhex()" now skips all ASCII
      whitespace in the string, not just spaces.

   A reverse conversion function exists to transform a bytes object
   into its hexadecimal representation.

   hex([sep[, bytes_per_sep]])

      Return a string object containing two hexadecimal digits for
      each byte in the instance.

      >>> b'\xf0\xf1\xf2'.hex()
      'f0f1f2'

      If you want to make the hex string easier to read, you can
      specify a single character separator *sep* parameter to include
      in the output. By default, this separator will be included
      between each byte. A second optional *bytes_per_sep* parameter
      controls the spacing. Positive values calculate the separator
      position from the right, negative values from the left.

      >>> value = b'\xf0\xf1\xf2'
      >>> value.hex('-')
      'f0-f1-f2'
      >>> value.hex('_', 2)
      'f0_f1f2'
      >>> b'UUDDLRLRAB'.hex(' ', -4)
      '55554444 4c524c52 4142'

      3.5 sürümünde geldi.

      3.8 sürümünde değişti: "bytes.hex()" now supports optional *sep*
      and *bytes_per_sep* parameters to insert separators between
      bytes in the hex output.

Since bytes objects are sequences of integers (akin to a tuple), for a
bytes object *b*, "b[0]" will be an integer, while "b[0:1]" will be a
bytes object of length 1.  (This contrasts with text strings, where
both indexing and slicing will produce a string of length 1)

The representation of bytes objects uses the literal format ("b'...'")
since it is often more useful than e.g. "bytes([46, 46, 46])".  You
can always convert a bytes object into a list of integers using
"list(b)".


Bytearray Objects
-----------------

"bytearray" objects are a mutable counterpart to "bytes" objects.

class bytearray([source[, encoding[, errors]]])

   There is no dedicated literal syntax for bytearray objects, instead
   they are always created by calling the constructor:

   * Creating an empty instance: "bytearray()"

   * Creating a zero-filled instance with a given length:
     "bytearray(10)"

   * From an iterable of integers: "bytearray(range(20))"

   * Copying existing binary data via the buffer protocol:
     "bytearray(b'Hi!')"

   As bytearray objects are mutable, they support the mutable sequence
   operations in addition to the common bytes and bytearray operations
   described in Bytes and Bytearray Operations.

   Also see the bytearray built-in.

   Since 2 hexadecimal digits correspond precisely to a single byte,
   hexadecimal numbers are a commonly used format for describing
   binary data. Accordingly, the bytearray type has an additional
   class method to read data in that format:

   classmethod fromhex(string)

      This "bytearray" class method returns bytearray object, decoding
      the given string object.  The string must contain two
      hexadecimal digits per byte, with ASCII whitespace being
      ignored.

      >>> bytearray.fromhex('2Ef0 F1f2  ')
      bytearray(b'.\xf0\xf1\xf2')

      3.7 sürümünde değişti: "bytearray.fromhex()" now skips all ASCII
      whitespace in the string, not just spaces.

   A reverse conversion function exists to transform a bytearray
   object into its hexadecimal representation.

   hex([sep[, bytes_per_sep]])

      Return a string object containing two hexadecimal digits for
      each byte in the instance.

      >>> bytearray(b'\xf0\xf1\xf2').hex()
      'f0f1f2'

      3.5 sürümünde geldi.

      3.8 sürümünde değişti: Similar to "bytes.hex()",
      "bytearray.hex()" now supports optional *sep* and
      *bytes_per_sep* parameters to insert separators between bytes in
      the hex output.

Since bytearray objects are sequences of integers (akin to a list),
for a bytearray object *b*, "b[0]" will be an integer, while "b[0:1]"
will be a bytearray object of length 1.  (This contrasts with text
strings, where both indexing and slicing will produce a string of
length 1)

The representation of bytearray objects uses the bytes literal format
("bytearray(b'...')") since it is often more useful than e.g.
"bytearray([46, 46, 46])".  You can always convert a bytearray object
into a list of integers using "list(b)".


Bytes and Bytearray Operations
------------------------------

Both bytes and bytearray objects support the common sequence
operations. They interoperate not just with operands of the same type,
but with any *bytes-like object*. Due to this flexibility, they can be
freely mixed in operations without causing errors. However, the return
type of the result may depend on the order of operands.

Not:

  The methods on bytes and bytearray objects don't accept strings as
  their arguments, just as the methods on strings don't accept bytes
  as their arguments.  For example, you have to write:

     a = "abc"
     b = a.replace("a", "f")

  and:

     a = b"abc"
     b = a.replace(b"a", b"f")

Some bytes and bytearray operations assume the use of ASCII compatible
binary formats, and hence should be avoided when working with
arbitrary binary data. These restrictions are covered below.

Not:

  Using these ASCII based operations to manipulate binary data that is
  not stored in an ASCII based format may lead to data corruption.

The following methods on bytes and bytearray objects can be used with
arbitrary binary data.

bytes.count(sub[, start[, end]])
bytearray.count(sub[, start[, end]])

   Return the number of non-overlapping occurrences of subsequence
   *sub* in the range [*start*, *end*].  Optional arguments *start*
   and *end* are interpreted as in slice notation.

   The subsequence to search for may be any *bytes-like object* or an
   integer in the range 0 to 255.

   If *sub* is empty, returns the number of empty slices between
   characters which is the length of the bytes object plus one.

   3.3 sürümünde değişti: Also accept an integer in the range 0 to 255
   as the subsequence.

bytes.removeprefix(prefix, /)
bytearray.removeprefix(prefix, /)

   If the binary data starts with the *prefix* string, return
   "bytes[len(prefix):]". Otherwise, return a copy of the original
   binary data:

      >>> b'TestHook'.removeprefix(b'Test')
      b'Hook'
      >>> b'BaseTestCase'.removeprefix(b'Test')
      b'BaseTestCase'

   The *prefix* may be any *bytes-like object*.

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

   3.9 sürümünde geldi.

bytes.removesuffix(suffix, /)
bytearray.removesuffix(suffix, /)

   If the binary data ends with the *suffix* string and that *suffix*
   is not empty, return "bytes[:-len(suffix)]".  Otherwise, return a
   copy of the original binary data:

      >>> b'MiscTests'.removesuffix(b'Tests')
      b'Misc'
      >>> b'TmpDirMixin'.removesuffix(b'Tests')
      b'TmpDirMixin'

   The *suffix* may be any *bytes-like object*.

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

   3.9 sürümünde geldi.

bytes.decode(encoding='utf-8', errors='strict')
bytearray.decode(encoding='utf-8', errors='strict')

   Return the bytes decoded to a "str".

   *encoding* defaults to "'utf-8'"; see Standard Encodings for
   possible values.

   *errors* controls how decoding errors are handled. If "'strict'"
   (the default), a "UnicodeError" exception is raised. Other possible
   values are "'ignore'", "'replace'", and any other name registered
   via "codecs.register_error()". See Error Handlers for details.

   For performance reasons, the value of *errors* is not checked for
   validity unless a decoding error actually occurs, Python
   Development Mode is enabled or a debug build is used.

   Not:

     Passing the *encoding* argument to "str" allows decoding any
     *bytes-like object* directly, without needing to make a temporary
     "bytes" or "bytearray" object.

   3.1 sürümünde değişti: Added support for keyword arguments.

   3.9 sürümünde değişti: The value of the *errors* argument is now
   checked in Python Development Mode and in debug mode.

bytes.endswith(suffix[, start[, end]])
bytearray.endswith(suffix[, start[, end]])

   Return "True" if the binary data ends with the specified *suffix*,
   otherwise return "False".  *suffix* can also be a tuple of suffixes
   to look for.  With optional *start*, test beginning at that
   position.  With optional *end*, stop comparing at that position.

   The suffix(es) to search for may be any *bytes-like object*.

bytes.find(sub[, start[, end]])
bytearray.find(sub[, start[, end]])

   Return the lowest index in the data where the subsequence *sub* is
   found, such that *sub* is contained in the slice "s[start:end]".
   Optional arguments *start* and *end* are interpreted as in slice
   notation.  Return "-1" if *sub* is not found.

   The subsequence to search for may be any *bytes-like object* or an
   integer in the range 0 to 255.

   Not:

     The "find()" method should be used only if you need to know the
     position of *sub*.  To check if *sub* is a substring or not, use
     the "in" operator:

        >>> b'Py' in b'Python'
        True

   3.3 sürümünde değişti: Also accept an integer in the range 0 to 255
   as the subsequence.

bytes.index(sub[, start[, end]])
bytearray.index(sub[, start[, end]])

   Like "find()", but raise "ValueError" when the subsequence is not
   found.

   The subsequence to search for may be any *bytes-like object* or an
   integer in the range 0 to 255.

   3.3 sürümünde değişti: Also accept an integer in the range 0 to 255
   as the subsequence.

bytes.join(iterable)
bytearray.join(iterable)

   Return a bytes or bytearray object which is the concatenation of
   the binary data sequences in *iterable*.  A "TypeError" will be
   raised if there are any values in *iterable* that are not *bytes-
   like objects*, including "str" objects.  The separator between
   elements is the contents of the bytes or bytearray object providing
   this method.

static bytes.maketrans(from, to)
static bytearray.maketrans(from, to)

   This static method returns a translation table usable for
   "bytes.translate()" that will map each character in *from* into the
   character at the same position in *to*; *from* and *to* must both
   be *bytes-like objects* and have the same length.

   3.1 sürümünde geldi.

bytes.partition(sep)
bytearray.partition(sep)

   Split the sequence at the first occurrence of *sep*, and return a
   3-tuple containing the part before the separator, the separator
   itself or its bytearray copy, and the part after the separator. If
   the separator is not found, return a 3-tuple containing a copy of
   the original sequence, followed by two empty bytes or bytearray
   objects.

   The separator to search for may be any *bytes-like object*.

bytes.replace(old, new[, count])
bytearray.replace(old, new[, count])

   Return a copy of the sequence with all occurrences of subsequence
   *old* replaced by *new*.  If the optional argument *count* is
   given, only the first *count* occurrences are replaced.

   The subsequence to search for and its replacement may be any
   *bytes-like object*.

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

bytes.rfind(sub[, start[, end]])
bytearray.rfind(sub[, start[, end]])

   Return the highest index in the sequence where the subsequence
   *sub* is found, such that *sub* is contained within "s[start:end]".
   Optional arguments *start* and *end* are interpreted as in slice
   notation. Return "-1" on failure.

   The subsequence to search for may be any *bytes-like object* or an
   integer in the range 0 to 255.

   3.3 sürümünde değişti: Also accept an integer in the range 0 to 255
   as the subsequence.

bytes.rindex(sub[, start[, end]])
bytearray.rindex(sub[, start[, end]])

   Like "rfind()" but raises "ValueError" when the subsequence *sub*
   is not found.

   The subsequence to search for may be any *bytes-like object* or an
   integer in the range 0 to 255.

   3.3 sürümünde değişti: Also accept an integer in the range 0 to 255
   as the subsequence.

bytes.rpartition(sep)
bytearray.rpartition(sep)

   Split the sequence at the last occurrence of *sep*, and return a
   3-tuple containing the part before the separator, the separator
   itself or its bytearray copy, and the part after the separator. If
   the separator is not found, return a 3-tuple containing two empty
   bytes or bytearray objects, followed by a copy of the original
   sequence.

   The separator to search for may be any *bytes-like object*.

bytes.startswith(prefix[, start[, end]])
bytearray.startswith(prefix[, start[, end]])

   Return "True" if the binary data starts with the specified
   *prefix*, otherwise return "False".  *prefix* can also be a tuple
   of prefixes to look for.  With optional *start*, test beginning at
   that position.  With optional *end*, stop comparing at that
   position.

   The prefix(es) to search for may be any *bytes-like object*.

bytes.translate(table, /, delete=b'')
bytearray.translate(table, /, delete=b'')

   Return a copy of the bytes or bytearray object where all bytes
   occurring in the optional argument *delete* are removed, and the
   remaining bytes have been mapped through the given translation
   table, which must be a bytes object of length 256.

   You can use the "bytes.maketrans()" method to create a translation
   table.

   Set the *table* argument to "None" for translations that only
   delete characters:

      >>> b'read this short text'.translate(None, b'aeiou')
      b'rd ths shrt txt'

   3.6 sürümünde değişti: *delete* is now supported as a keyword
   argument.

The following methods on bytes and bytearray objects have default
behaviours that assume the use of ASCII compatible binary formats, but
can still be used with arbitrary binary data by passing appropriate
arguments. Note that all of the bytearray methods in this section do
*not* operate in place, and instead produce new objects.

bytes.center(width[, fillbyte])
bytearray.center(width[, fillbyte])

   Return a copy of the object centered in a sequence of length
   *width*. Padding is done using the specified *fillbyte* (default is
   an ASCII space). For "bytes" objects, the original sequence is
   returned if *width* is less than or equal to "len(s)".

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

bytes.ljust(width[, fillbyte])
bytearray.ljust(width[, fillbyte])

   Return a copy of the object left justified in a sequence of length
   *width*. Padding is done using the specified *fillbyte* (default is
   an ASCII space). For "bytes" objects, the original sequence is
   returned if *width* is less than or equal to "len(s)".

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

bytes.lstrip([chars])
bytearray.lstrip([chars])

   Return a copy of the sequence with specified leading bytes removed.
   The *chars* argument is a binary sequence specifying the set of
   byte values to be removed - the name refers to the fact this method
   is usually used with ASCII characters.  If omitted or "None", the
   *chars* argument defaults to removing ASCII whitespace.  The
   *chars* argument is not a prefix; rather, all combinations of its
   values are stripped:

      >>> b'   spacious   '.lstrip()
      b'spacious   '
      >>> b'www.example.com'.lstrip(b'cmowz.')
      b'example.com'

   The binary sequence of byte values to remove may be any *bytes-like
   object*. See "removeprefix()" for a method that will remove a
   single prefix string rather than all of a set of characters.  For
   example:

      >>> b'Arthur: three!'.lstrip(b'Arthur: ')
      b'ee!'
      >>> b'Arthur: three!'.removeprefix(b'Arthur: ')
      b'three!'

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

bytes.rjust(width[, fillbyte])
bytearray.rjust(width[, fillbyte])

   Return a copy of the object right justified in a sequence of length
   *width*. Padding is done using the specified *fillbyte* (default is
   an ASCII space). For "bytes" objects, the original sequence is
   returned if *width* is less than or equal to "len(s)".

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

bytes.rsplit(sep=None, maxsplit=- 1)
bytearray.rsplit(sep=None, maxsplit=- 1)

   Split the binary sequence into subsequences of the same type, using
   *sep* as the delimiter string. If *maxsplit* is given, at most
   *maxsplit* splits are done, the *rightmost* ones.  If *sep* is not
   specified or "None", any subsequence consisting solely of ASCII
   whitespace is a separator. Except for splitting from the right,
   "rsplit()" behaves like "split()" which is described in detail
   below.

bytes.rstrip([chars])
bytearray.rstrip([chars])

   Return a copy of the sequence with specified trailing bytes
   removed.  The *chars* argument is a binary sequence specifying the
   set of byte values to be removed - the name refers to the fact this
   method is usually used with ASCII characters.  If omitted or
   "None", the *chars* argument defaults to removing ASCII whitespace.
   The *chars* argument is not a suffix; rather, all combinations of
   its values are stripped:

      >>> b'   spacious   '.rstrip()
      b'   spacious'
      >>> b'mississippi'.rstrip(b'ipz')
      b'mississ'

   The binary sequence of byte values to remove may be any *bytes-like
   object*. See "removesuffix()" for a method that will remove a
   single suffix string rather than all of a set of characters.  For
   example:

      >>> b'Monty Python'.rstrip(b' Python')
      b'M'
      >>> b'Monty Python'.removesuffix(b' Python')
      b'Monty'

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

bytes.split(sep=None, maxsplit=- 1)
bytearray.split(sep=None, maxsplit=- 1)

   Split the binary sequence into subsequences of the same type, using
   *sep* as the delimiter string. If *maxsplit* is given and non-
   negative, at most *maxsplit* splits are done (thus, the list will
   have at most "maxsplit+1" elements).  If *maxsplit* is not
   specified or is "-1", then there is no limit on the number of
   splits (all possible splits are made).

   If *sep* is given, consecutive delimiters are not grouped together
   and are deemed to delimit empty subsequences (for example,
   "b'1,,2'.split(b',')" returns "[b'1', b'', b'2']").  The *sep*
   argument may consist of a multibyte sequence (for example,
   "b'1<>2<>3'.split(b'<>')" returns "[b'1', b'2', b'3']"). Splitting
   an empty sequence with a specified separator returns "[b'']" or
   "[bytearray(b'')]" depending on the type of object being split.
   The *sep* argument may be any *bytes-like object*.

   Örneğin:

      >>> b'1,2,3'.split(b',')
      [b'1', b'2', b'3']
      >>> b'1,2,3'.split(b',', maxsplit=1)
      [b'1', b'2,3']
      >>> b'1,2,,3,'.split(b',')
      [b'1', b'2', b'', b'3', b'']

   If *sep* is not specified or is "None", a different splitting
   algorithm is applied: runs of consecutive ASCII whitespace are
   regarded as a single separator, and the result will contain no
   empty strings at the start or end if the sequence has leading or
   trailing whitespace.  Consequently, splitting an empty sequence or
   a sequence consisting solely of ASCII whitespace without a
   specified separator returns "[]".

   Örneğin:

      >>> b'1 2 3'.split()
      [b'1', b'2', b'3']
      >>> b'1 2 3'.split(maxsplit=1)
      [b'1', b'2 3']
      >>> b'   1   2   3   '.split()
      [b'1', b'2', b'3']

bytes.strip([chars])
bytearray.strip([chars])

   Return a copy of the sequence with specified leading and trailing
   bytes removed. The *chars* argument is a binary sequence specifying
   the set of byte values to be removed - the name refers to the fact
   this method is usually used with ASCII characters.  If omitted or
   "None", the *chars* argument defaults to removing ASCII whitespace.
   The *chars* argument is not a prefix or suffix; rather, all
   combinations of its values are stripped:

      >>> b'   spacious   '.strip()
      b'spacious'
      >>> b'www.example.com'.strip(b'cmowz.')
      b'example'

   The binary sequence of byte values to remove may be any *bytes-like
   object*.

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

The following methods on bytes and bytearray objects assume the use of
ASCII compatible binary formats and should not be applied to arbitrary
binary data. Note that all of the bytearray methods in this section do
*not* operate in place, and instead produce new objects.

bytes.capitalize()
bytearray.capitalize()

   Return a copy of the sequence with each byte interpreted as an
   ASCII character, and the first byte capitalized and the rest
   lowercased. Non-ASCII byte values are passed through unchanged.

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

bytes.expandtabs(tabsize=8)
bytearray.expandtabs(tabsize=8)

   Return a copy of the sequence where all ASCII tab characters are
   replaced by one or more ASCII spaces, depending on the current
   column and the given tab size.  Tab positions occur every *tabsize*
   bytes (default is 8, giving tab positions at columns 0, 8, 16 and
   so on).  To expand the sequence, the current column is set to zero
   and the sequence is examined byte by byte.  If the byte is an ASCII
   tab character ("b'\t'"), one or more space characters are inserted
   in the result until the current column is equal to the next tab
   position. (The tab character itself is not copied.)  If the current
   byte is an ASCII newline ("b'\n'") or carriage return ("b'\r'"), it
   is copied and the current column is reset to zero.  Any other byte
   value is copied unchanged and the current column is incremented by
   one regardless of how the byte value is represented when printed:

      >>> b'01\t012\t0123\t01234'.expandtabs()
      b'01      012     0123    01234'
      >>> b'01\t012\t0123\t01234'.expandtabs(4)
      b'01  012 0123    01234'

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

bytes.isalnum()
bytearray.isalnum()

   Return "True" if all bytes in the sequence are alphabetical ASCII
   characters or ASCII decimal digits and the sequence is not empty,
   "False" otherwise. Alphabetic ASCII characters are those byte
   values in the sequence
   "b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'". ASCII
   decimal digits are those byte values in the sequence
   "b'0123456789'".

   Örneğin:

      >>> b'ABCabc1'.isalnum()
      True
      >>> b'ABC abc1'.isalnum()
      False

bytes.isalpha()
bytearray.isalpha()

   Return "True" if all bytes in the sequence are alphabetic ASCII
   characters and the sequence is not empty, "False" otherwise.
   Alphabetic ASCII characters are those byte values in the sequence
   "b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'".

   Örneğin:

      >>> b'ABCabc'.isalpha()
      True
      >>> b'ABCabc1'.isalpha()
      False

bytes.isascii()
bytearray.isascii()

   Return "True" if the sequence is empty or all bytes in the sequence
   are ASCII, "False" otherwise. ASCII bytes are in the range 0-0x7F.

   3.7 sürümünde geldi.

bytes.isdigit()
bytearray.isdigit()

   Return "True" if all bytes in the sequence are ASCII decimal digits
   and the sequence is not empty, "False" otherwise. ASCII decimal
   digits are those byte values in the sequence "b'0123456789'".

   Örneğin:

      >>> b'1234'.isdigit()
      True
      >>> b'1.23'.isdigit()
      False

bytes.islower()
bytearray.islower()

   Return "True" if there is at least one lowercase ASCII character in
   the sequence and no uppercase ASCII characters, "False" otherwise.

   Örneğin:

      >>> b'hello world'.islower()
      True
      >>> b'Hello world'.islower()
      False

   Lowercase ASCII characters are those byte values in the sequence
   "b'abcdefghijklmnopqrstuvwxyz'". Uppercase ASCII characters are
   those byte values in the sequence "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

bytes.isspace()
bytearray.isspace()

   Return "True" if all bytes in the sequence are ASCII whitespace and
   the sequence is not empty, "False" otherwise.  ASCII whitespace
   characters are those byte values in the sequence "b' \t\n\r\x0b\f'"
   (space, tab, newline, carriage return, vertical tab, form feed).

bytes.istitle()
bytearray.istitle()

   Return "True" if the sequence is ASCII titlecase and the sequence
   is not empty, "False" otherwise. See "bytes.title()" for more
   details on the definition of "titlecase".

   Örneğin:

      >>> b'Hello World'.istitle()
      True
      >>> b'Hello world'.istitle()
      False

bytes.isupper()
bytearray.isupper()

   Return "True" if there is at least one uppercase alphabetic ASCII
   character in the sequence and no lowercase ASCII characters,
   "False" otherwise.

   Örneğin:

      >>> b'HELLO WORLD'.isupper()
      True
      >>> b'Hello world'.isupper()
      False

   Lowercase ASCII characters are those byte values in the sequence
   "b'abcdefghijklmnopqrstuvwxyz'". Uppercase ASCII characters are
   those byte values in the sequence "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

bytes.lower()
bytearray.lower()

   Return a copy of the sequence with all the uppercase ASCII
   characters converted to their corresponding lowercase counterpart.

   Örneğin:

      >>> b'Hello World'.lower()
      b'hello world'

   Lowercase ASCII characters are those byte values in the sequence
   "b'abcdefghijklmnopqrstuvwxyz'". Uppercase ASCII characters are
   those byte values in the sequence "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

bytes.splitlines(keepends=False)
bytearray.splitlines(keepends=False)

   Return a list of the lines in the binary sequence, breaking at
   ASCII line boundaries. This method uses the *universal newlines*
   approach to splitting lines. Line breaks are not included in the
   resulting list unless *keepends* is given and true.

   Örneğin:

      >>> b'ab c\n\nde fg\rkl\r\n'.splitlines()
      [b'ab c', b'', b'de fg', b'kl']
      >>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
      [b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']

   Unlike "split()" when a delimiter string *sep* is given, this
   method returns an empty list for the empty string, and a terminal
   line break does not result in an extra line:

      >>> b"".split(b'\n'), b"Two lines\n".split(b'\n')
      ([b''], [b'Two lines', b''])
      >>> b"".splitlines(), b"One line\n".splitlines()
      ([], [b'One line'])

bytes.swapcase()
bytearray.swapcase()

   Return a copy of the sequence with all the lowercase ASCII
   characters converted to their corresponding uppercase counterpart
   and vice-versa.

   Örneğin:

      >>> b'Hello World'.swapcase()
      b'hELLO wORLD'

   Lowercase ASCII characters are those byte values in the sequence
   "b'abcdefghijklmnopqrstuvwxyz'". Uppercase ASCII characters are
   those byte values in the sequence "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

   Unlike "str.swapcase()", it is always the case that
   "bin.swapcase().swapcase() == bin" for the binary versions. Case
   conversions are symmetrical in ASCII, even though that is not
   generally true for arbitrary Unicode code points.

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

bytes.title()
bytearray.title()

   Return a titlecased version of the binary sequence where words
   start with an uppercase ASCII character and the remaining
   characters are lowercase. Uncased byte values are left unmodified.

   Örneğin:

      >>> b'Hello world'.title()
      b'Hello World'

   Lowercase ASCII characters are those byte values in the sequence
   "b'abcdefghijklmnopqrstuvwxyz'". Uppercase ASCII characters are
   those byte values in the sequence "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".
   All other byte values are uncased.

   Algoritma, bir kelimenin ardışık harf grupları olarak dilden
   bağımsız basit bir tanımını kullanır.  Bu tanım birçok bağlamda işe
   yarar, ancak bu, kısaltmalar ve iyeliklerdeki kesme işaretlerinin
   kelime sınırları oluşturduğu anlamına gelir ve bu istenen sonuç
   olmayabilir:

      >>> b"they're bill's friends from the UK".title()
      b"They'Re Bill'S Friends From The Uk"

   Kesme işaretleri için geçici bir çözüm düzenli ifadeler
   kullanılarak oluşturulabilir:

      >>> import re
      >>> def titlecase(s):
      ...     return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?",
      ...                   lambda mo: mo.group(0)[0:1].upper() +
      ...                              mo.group(0)[1:].lower(),
      ...                   s)
      ...
      >>> titlecase(b"they're bill's friends.")
      b"They're Bill's Friends."

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

bytes.upper()
bytearray.upper()

   Return a copy of the sequence with all the lowercase ASCII
   characters converted to their corresponding uppercase counterpart.

   Örneğin:

      >>> b'Hello World'.upper()
      b'HELLO WORLD'

   Lowercase ASCII characters are those byte values in the sequence
   "b'abcdefghijklmnopqrstuvwxyz'". Uppercase ASCII characters are
   those byte values in the sequence "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.

bytes.zfill(width)
bytearray.zfill(width)

   Return a copy of the sequence left filled with ASCII "b'0'" digits
   to make a sequence of length *width*. A leading sign prefix
   ("b'+'"/ "b'-'") is handled by inserting the padding *after* the
   sign character rather than before. For "bytes" objects, the
   original sequence is returned if *width* is less than or equal to
   "len(seq)".

   Örneğin:

      >>> b"42".zfill(5)
      b'00042'
      >>> b"-42".zfill(5)
      b'-0042'

   Not:

     The bytearray version of this method does *not* operate in place
     - it always produces a new object, even if no changes were made.


"printf"-style Bytes Formatting
-------------------------------

Not:

  The formatting operations described here exhibit a variety of quirks
  that lead to a number of common errors (such as failing to display
  tuples and dictionaries correctly).  If the value being printed may
  be a tuple or dictionary, wrap it in a tuple.

Bytes objects ("bytes"/"bytearray") have one unique built-in
operation: the "%" operator (modulo). This is also known as the bytes
*formatting* or *interpolation* operator. Given "format % values"
(where *format* is a bytes object), "%" conversion specifications in
*format* are replaced with zero or more elements of *values*. The
effect is similar to using the "sprintf()" in the C language.

If *format* requires a single argument, *values* may be a single non-
tuple object. [5]  Otherwise, *values* must be a tuple with exactly
the number of items specified by the format bytes object, or a single
mapping object (for example, a dictionary).

A conversion specifier contains two or more characters and has the
following components, which must occur in this order:

1. The "'%'" character, which marks the start of the specifier.

2. Mapping key (optional), consisting of a parenthesised sequence of
   characters (for example, "(somename)").

3. Conversion flags (optional), which affect the result of some
   conversion types.

4. Minimum field width (optional).  If specified as an "'*'"
   (asterisk), the actual width is read from the next element of the
   tuple in *values*, and the object to convert comes after the
   minimum field width and optional precision.

5. Precision (optional), given as a "'.'" (dot) followed by the
   precision.  If specified as "'*'" (an asterisk), the actual
   precision is read from the next element of the tuple in *values*,
   and the value to convert comes after the precision.

6. Length modifier (optional).

7. Conversion type.

When the right argument is a dictionary (or other mapping type), then
the formats in the bytes object *must* include a parenthesised mapping
key into that dictionary inserted immediately after the "'%'"
character. The mapping key selects the value to be formatted from the
mapping.  For example:

>>> print(b'%(language)s has %(number)03d quote types.' %
...       {b'language': b"Python", b"number": 2})
b'Python has 002 quote types.'

In this case no "*" specifiers may occur in a format (since they
require a sequential parameter list).

The conversion flag characters are:

+-----------+-----------------------------------------------------------------------+
| Flag      | Anlamı                                                                |
|===========|=======================================================================|
| "'#'"     | The value conversion will use the "alternate form" (where defined     |
|           | below).                                                               |
+-----------+-----------------------------------------------------------------------+
| "'0'"     | The conversion will be zero padded for numeric values.                |
+-----------+-----------------------------------------------------------------------+
| "'-'"     | The converted value is left adjusted (overrides the "'0'" conversion  |
|           | if both are given).                                                   |
+-----------+-----------------------------------------------------------------------+
| "' '"     | (a space) A blank should be left before a positive number (or empty   |
|           | string) produced by a signed conversion.                              |
+-----------+-----------------------------------------------------------------------+
| "'+'"     | A sign character ("'+'" or "'-'") will precede the conversion         |
|           | (overrides a "space" flag).                                           |
+-----------+-----------------------------------------------------------------------+

A length modifier ("h", "l", or "L") may be present, but is ignored as
it is not necessary for Python -- so e.g. "%ld" is identical to "%d".

The conversion types are:

+--------------+-------------------------------------------------------+---------+
| Conversion   | Anlamı                                                | Notlar  |
|==============|=======================================================|=========|
| "'d'"        | Signed integer decimal.                               |         |
+--------------+-------------------------------------------------------+---------+
| "'i'"        | Signed integer decimal.                               |         |
+--------------+-------------------------------------------------------+---------+
| "'o'"        | Signed octal value.                                   | (1)     |
+--------------+-------------------------------------------------------+---------+
| "'u'"        | Obsolete type -- it is identical to "'d'".            | (8)     |
+--------------+-------------------------------------------------------+---------+
| "'x'"        | Signed hexadecimal (lowercase).                       | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'X'"        | Signed hexadecimal (uppercase).                       | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'e'"        | Floating point exponential format (lowercase).        | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'E'"        | Floating point exponential format (uppercase).        | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'f'"        | Floating point decimal format.                        | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'F'"        | Floating point decimal format.                        | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'g'"        | Floating point format. Uses lowercase exponential     | (4)     |
|              | format if exponent is less than -4 or not less than   |         |
|              | precision, decimal format otherwise.                  |         |
+--------------+-------------------------------------------------------+---------+
| "'G'"        | Floating point format. Uses uppercase exponential     | (4)     |
|              | format if exponent is less than -4 or not less than   |         |
|              | precision, decimal format otherwise.                  |         |
+--------------+-------------------------------------------------------+---------+
| "'c'"        | Single byte (accepts integer or single byte objects). |         |
+--------------+-------------------------------------------------------+---------+
| "'b'"        | Bytes (any object that follows the buffer protocol or | (5)     |
|              | has "__bytes__()").                                   |         |
+--------------+-------------------------------------------------------+---------+
| "'s'"        | "'s'" is an alias for "'b'" and should only be used   | (6)     |
|              | for Python2/3 code bases.                             |         |
+--------------+-------------------------------------------------------+---------+
| "'a'"        | Bytes (converts any Python object using               | (5)     |
|              | "repr(obj).encode('ascii', 'backslashreplace')").     |         |
+--------------+-------------------------------------------------------+---------+
| "'r'"        | "'r'" is an alias for "'a'" and should only be used   | (7)     |
|              | for Python2/3 code bases.                             |         |
+--------------+-------------------------------------------------------+---------+
| "'%'"        | No argument is converted, results in a "'%'"          |         |
|              | character in the result.                              |         |
+--------------+-------------------------------------------------------+---------+

Notlar:

1. The alternate form causes a leading octal specifier ("'0o'") to be
   inserted before the first digit.

2. The alternate form causes a leading "'0x'" or "'0X'" (depending on
   whether the "'x'" or "'X'" format was used) to be inserted before
   the first digit.

3. The alternate form causes the result to always contain a decimal
   point, even if no digits follow it.

   The precision determines the number of digits after the decimal
   point and defaults to 6.

4. The alternate form causes the result to always contain a decimal
   point, and trailing zeroes are not removed as they would otherwise
   be.

   The precision determines the number of significant digits before
   and after the decimal point and defaults to 6.

5. If precision is "N", the output is truncated to "N" characters.

6. "b'%s'" is deprecated, but will not be removed during the 3.x
   series.

7. "b'%r'" is deprecated, but will not be removed during the 3.x
   series.

8. See **PEP 237**.

Not:

  The bytearray version of this method does *not* operate in place -
  it always produces a new object, even if no changes were made.

Ayrıca bakınız:

  **PEP 461** - Adding % formatting to bytes and bytearray

3.5 sürümünde geldi.


Memory Views
------------

"memoryview" objects allow Python code to access the internal data of
an object that supports the buffer protocol without copying.

class memoryview(object)

   Create a "memoryview" that references *object*.  *object* must
   support the buffer protocol.  Built-in objects that support the
   buffer protocol include "bytes" and "bytearray".

   A "memoryview" has the notion of an *element*, which is the atomic
   memory unit handled by the originating *object*.  For many simple
   types such as "bytes" and "bytearray", an element is a single byte,
   but other types such as "array.array" may have bigger elements.

   "len(view)" is equal to the length of "tolist". If "view.ndim = 0",
   the length is 1. If "view.ndim = 1", the length is equal to the
   number of elements in the view. For higher dimensions, the length
   is equal to the length of the nested list representation of the
   view. The "itemsize" attribute will give you the number of bytes in
   a single element.

   A "memoryview" supports slicing and indexing to expose its data.
   One-dimensional slicing will result in a subview:

      >>> v = memoryview(b'abcefg')
      >>> v[1]
      98
      >>> v[-1]
      103
      >>> v[1:4]
      <memory at 0x7f3ddc9f4350>
      >>> bytes(v[1:4])
      b'bce'

   If "format" is one of the native format specifiers from the
   "struct" module, indexing with an integer or a tuple of integers is
   also supported and returns a single *element* with the correct
   type.  One-dimensional memoryviews can be indexed with an integer
   or a one-integer tuple.  Multi-dimensional memoryviews can be
   indexed with tuples of exactly *ndim* integers where *ndim* is the
   number of dimensions.  Zero-dimensional memoryviews can be indexed
   with the empty tuple.

   Here is an example with a non-byte format:

      >>> import array
      >>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
      >>> m = memoryview(a)
      >>> m[0]
      -11111111
      >>> m[-1]
      44444444
      >>> m[::2].tolist()
      [-11111111, -33333333]

   If the underlying object is writable, the memoryview supports one-
   dimensional slice assignment. Resizing is not allowed:

      >>> data = bytearray(b'abcefg')
      >>> v = memoryview(data)
      >>> v.readonly
      False
      >>> v[0] = ord(b'z')
      >>> data
      bytearray(b'zbcefg')
      >>> v[1:4] = b'123'
      >>> data
      bytearray(b'z123fg')
      >>> v[2:3] = b'spam'
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      ValueError: memoryview assignment: lvalue and rvalue have different structures
      >>> v[2:6] = b'spam'
      >>> data
      bytearray(b'z1spam')

   One-dimensional memoryviews of *hashable* (read-only) types with
   formats 'B', 'b' or 'c' are also hashable. The hash is defined as
   "hash(m) == hash(m.tobytes())":

      >>> v = memoryview(b'abcefg')
      >>> hash(v) == hash(b'abcefg')
      True
      >>> hash(v[2:4]) == hash(b'ce')
      True
      >>> hash(v[::-2]) == hash(b'abcefg'[::-2])
      True

   3.3 sürümünde değişti: One-dimensional memoryviews can now be
   sliced. One-dimensional memoryviews with formats 'B', 'b' or 'c'
   are now *hashable*.

   3.4 sürümünde değişti: memoryview is now registered automatically
   with "collections.abc.Sequence"

   3.5 sürümünde değişti: memoryviews can now be indexed with tuple of
   integers.

   "memoryview" has several methods:

   __eq__(exporter)

      A memoryview and a **PEP 3118** exporter are equal if their
      shapes are equivalent and if all corresponding values are equal
      when the operands' respective format codes are interpreted using
      "struct" syntax.

      For the subset of "struct" format strings currently supported by
      "tolist()", "v" and "w" are equal if "v.tolist() == w.tolist()":

         >>> import array
         >>> a = array.array('I', [1, 2, 3, 4, 5])
         >>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])
         >>> c = array.array('b', [5, 3, 1])
         >>> x = memoryview(a)
         >>> y = memoryview(b)
         >>> x == a == y == b
         True
         >>> x.tolist() == a.tolist() == y.tolist() == b.tolist()
         True
         >>> z = y[::-2]
         >>> z == c
         True
         >>> z.tolist() == c.tolist()
         True

      If either format string is not supported by the "struct" module,
      then the objects will always compare as unequal (even if the
      format strings and buffer contents are identical):

         >>> from ctypes import BigEndianStructure, c_long
         >>> class BEPoint(BigEndianStructure):
         ...     _fields_ = [("x", c_long), ("y", c_long)]
         ...
         >>> point = BEPoint(100, 200)
         >>> a = memoryview(point)
         >>> b = memoryview(point)
         >>> a == point
         False
         >>> a == b
         False

      Note that, as with floating point numbers, "v is w" does *not*
      imply "v == w" for memoryview objects.

      3.3 sürümünde değişti: Previous versions compared the raw memory
      disregarding the item format and the logical array structure.

   tobytes(order=None)

      Return the data in the buffer as a bytestring.  This is
      equivalent to calling the "bytes" constructor on the memoryview.

         >>> m = memoryview(b"abc")
         >>> m.tobytes()
         b'abc'
         >>> bytes(m)
         b'abc'

      For non-contiguous arrays the result is equal to the flattened
      list representation with all elements converted to bytes.
      "tobytes()" supports all format strings, including those that
      are not in "struct" module syntax.

      3.8 sürümünde geldi: *order* can be {'C', 'F', 'A'}.  When
      *order* is 'C' or 'F', the data of the original array is
      converted to C or Fortran order. For contiguous views, 'A'
      returns an exact copy of the physical memory. In particular, in-
      memory Fortran order is preserved. For non-contiguous views, the
      data is converted to C first. *order=None* is the same as
      *order='C'*.

   hex([sep[, bytes_per_sep]])

      Return a string object containing two hexadecimal digits for
      each byte in the buffer.

         >>> m = memoryview(b"abc")
         >>> m.hex()
         '616263'

      3.5 sürümünde geldi.

      3.8 sürümünde değişti: Similar to "bytes.hex()",
      "memoryview.hex()" now supports optional *sep* and
      *bytes_per_sep* parameters to insert separators between bytes in
      the hex output.

   tolist()

      Return the data in the buffer as a list of elements.

         >>> memoryview(b'abc').tolist()
         [97, 98, 99]
         >>> import array
         >>> a = array.array('d', [1.1, 2.2, 3.3])
         >>> m = memoryview(a)
         >>> m.tolist()
         [1.1, 2.2, 3.3]

      3.3 sürümünde değişti: "tolist()" now supports all single
      character native formats in "struct" module syntax as well as
      multi-dimensional representations.

   toreadonly()

      Return a readonly version of the memoryview object.  The
      original memoryview object is unchanged.

         >>> m = memoryview(bytearray(b'abc'))
         >>> mm = m.toreadonly()
         >>> mm.tolist()
         [89, 98, 99]
         >>> mm[0] = 42
         Traceback (most recent call last):
           File "<stdin>", line 1, in <module>
         TypeError: cannot modify read-only memory
         >>> m[0] = 43
         >>> mm.tolist()
         [43, 98, 99]

      3.8 sürümünde geldi.

   release()

      Release the underlying buffer exposed by the memoryview object.
      Many objects take special actions when a view is held on them
      (for example, a "bytearray" would temporarily forbid resizing);
      therefore, calling release() is handy to remove these
      restrictions (and free any dangling resources) as soon as
      possible.

      After this method has been called, any further operation on the
      view raises a "ValueError" (except "release()" itself which can
      be called multiple times):

         >>> m = memoryview(b'abc')
         >>> m.release()
         >>> m[0]
         Traceback (most recent call last):
           File "<stdin>", line 1, in <module>
         ValueError: operation forbidden on released memoryview object

      The context management protocol can be used for a similar
      effect, using the "with" statement:

         >>> with memoryview(b'abc') as m:
         ...     m[0]
         ...
         97
         >>> m[0]
         Traceback (most recent call last):
           File "<stdin>", line 1, in <module>
         ValueError: operation forbidden on released memoryview object

      3.2 sürümünde geldi.

   cast(format[, shape])

      Cast a memoryview to a new format or shape. *shape* defaults to
      "[byte_length//new_itemsize]", which means that the result view
      will be one-dimensional. The return value is a new memoryview,
      but the buffer itself is not copied. Supported casts are 1D ->
      C-*contiguous* and C-contiguous -> 1D.

      The destination format is restricted to a single element native
      format in "struct" syntax. One of the formats must be a byte
      format ('B', 'b' or 'c'). The byte length of the result must be
      the same as the original length.

      Cast 1D/long to 1D/unsigned bytes:

         >>> import array
         >>> a = array.array('l', [1,2,3])
         >>> x = memoryview(a)
         >>> x.format
         'l'
         >>> x.itemsize
         8
         >>> len(x)
         3
         >>> x.nbytes
         24
         >>> y = x.cast('B')
         >>> y.format
         'B'
         >>> y.itemsize
         1
         >>> len(y)
         24
         >>> y.nbytes
         24

      Cast 1D/unsigned bytes to 1D/char:

         >>> b = bytearray(b'zyz')
         >>> x = memoryview(b)
         >>> x[0] = b'a'
         Traceback (most recent call last):
           File "<stdin>", line 1, in <module>
         ValueError: memoryview: invalid value for format "B"
         >>> y = x.cast('c')
         >>> y[0] = b'a'
         >>> b
         bytearray(b'ayz')

      Cast 1D/bytes to 3D/ints to 1D/signed char:

         >>> import struct
         >>> buf = struct.pack("i"*12, *list(range(12)))
         >>> x = memoryview(buf)
         >>> y = x.cast('i', shape=[2,2,3])
         >>> y.tolist()
         [[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
         >>> y.format
         'i'
         >>> y.itemsize
         4
         >>> len(y)
         2
         >>> y.nbytes
         48
         >>> z = y.cast('b')
         >>> z.format
         'b'
         >>> z.itemsize
         1
         >>> len(z)
         48
         >>> z.nbytes
         48

      Cast 1D/unsigned long to 2D/unsigned long:

         >>> buf = struct.pack("L"*6, *list(range(6)))
         >>> x = memoryview(buf)
         >>> y = x.cast('L', shape=[2,3])
         >>> len(y)
         2
         >>> y.nbytes
         48
         >>> y.tolist()
         [[0, 1, 2], [3, 4, 5]]

      3.3 sürümünde geldi.

      3.5 sürümünde değişti: The source format is no longer restricted
      when casting to a byte view.

   There are also several readonly attributes available:

   obj

      The underlying object of the memoryview:

         >>> b  = bytearray(b'xyz')
         >>> m = memoryview(b)
         >>> m.obj is b
         True

      3.3 sürümünde geldi.

   nbytes

      "nbytes == product(shape) * itemsize == len(m.tobytes())". This
      is the amount of space in bytes that the array would use in a
      contiguous representation. It is not necessarily equal to
      "len(m)":

         >>> import array
         >>> a = array.array('i', [1,2,3,4,5])
         >>> m = memoryview(a)
         >>> len(m)
         5
         >>> m.nbytes
         20
         >>> y = m[::2]
         >>> len(y)
         3
         >>> y.nbytes
         12
         >>> len(y.tobytes())
         12

      Multi-dimensional arrays:

         >>> import struct
         >>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])
         >>> x = memoryview(buf)
         >>> y = x.cast('d', shape=[3,4])
         >>> y.tolist()
         [[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]
         >>> len(y)
         3
         >>> y.nbytes
         96

      3.3 sürümünde geldi.

   readonly

      A bool indicating whether the memory is read only.

   format

      A string containing the format (in "struct" module style) for
      each element in the view. A memoryview can be created from
      exporters with arbitrary format strings, but some methods (e.g.
      "tolist()") are restricted to native single element formats.

      3.3 sürümünde değişti: format "'B'" is now handled according to
      the struct module syntax. This means that "memoryview(b'abc')[0]
      == b'abc'[0] == 97".

   itemsize

      The size in bytes of each element of the memoryview:

         >>> import array, struct
         >>> m = memoryview(array.array('H', [32000, 32001, 32002]))
         >>> m.itemsize
         2
         >>> m[0]
         32000
         >>> struct.calcsize('H') == m.itemsize
         True

   ndim

      An integer indicating how many dimensions of a multi-dimensional
      array the memory represents.

   shape

      A tuple of integers the length of "ndim" giving the shape of the
      memory as an N-dimensional array.

      3.3 sürümünde değişti: An empty tuple instead of "None" when
      ndim = 0.

   strides

      A tuple of integers the length of "ndim" giving the size in
      bytes to access each element for each dimension of the array.

      3.3 sürümünde değişti: An empty tuple instead of "None" when
      ndim = 0.

   suboffsets

      Used internally for PIL-style arrays. The value is informational
      only.

   c_contiguous

      Belleğin C-*contiguous* olup olmadığını gösteren bir bool.

      3.3 sürümünde geldi.

   f_contiguous

      Belleğin Fortran *contiguous* olup olmadığını gösteren bir bool.

      3.3 sürümünde geldi.

   contiguous

      Belleğin *contiguous* olup olmadığını gösteren bir bool.

      3.3 sürümünde geldi.


Set Türleri --- "set", "frozenset"
==================================

Bir *set* nesnesi, farklı *hashable* nesnelerinin sıralanmamış bir
koleksiyonudur. Yaygın kullanımları arasında üyelik sınaması, bir
diziden yinelenenlerin kaldırılması ve kesişim, birleşim, fark ve
simetrik fark gibi matematiksel işlemlerin hesaplanması yer alır.
(Diğer kapsayıcılar için yerleşik "dict", "list" ve "tuple"
sınıflarına ve "collections" modülüne bakın)

Diğer koleksiyonlar gibi, kümeler de "x in set", "len(set)", ve "for x
in set" özelliklerini destekler.  Sırasız bir koleksiyon olan kümeler,
eleman konumunu veya ekleme sırasını kaydetmez.  Buna göre, kümeler
dizinleme, dilimleme veya sıra benzeri davranışları desteklemez.

Şu anda iki yerleşik set türü vardır, "set" ve "frozenset". "set" türü
değişkendir --- içeriği "add()" ve "remove()" gibi yöntemler
kullanılarak değiştirilebilir.  Değiştirilebilir olduğu için hash
değeri yoktur ve bir sözlük anahtarı ya da başka bir kümenin elemanı
olarak kullanılamaz. "frozenset" türü değişmezdir ve *hashable* ---
içeriği oluşturulduktan sonra değiştirilemez; bu nedenle bir sözlük
anahtarı veya başka bir kümenin öğesi olarak kullanılabilir.

Boş olmayan kümeler (frozensetler değil), "set" yapıcısına ek olarak
parantez içine virgülle ayrılmış bir öğe listesi yerleştirilerek
oluşturulabilir, örneğin: "{'jack', 'sjoerd'}".

Her iki sınıfın kurucuları aynı şekilde çalışır:

class set([iterable])
class frozenset([iterable])

   Elemanları *iterable* öğesinden alınan yeni bir küme veya frozenset
   nesnesi döndürür.  Bir kümenin elemanları *hashable* olmalıdır.
   Kümelerin kümelerini temsil etmek için, iç kümeler "frozenset"
   nesneleri olmalıdır.  Eğer *iterable* belirtilmemişse, yeni bir boş
   küme döndürülür.

   Setler çeşitli yollarla oluşturulabilir:

   * Parantez içinde virgülle ayrılmış bir öğe listesi kullanın:
     "{'jack', 'sjoerd'}"

   * Bir küme kavrayışı kullanın: "{c for c in 'abracadabra' if c not
     in 'abc'}"

   * Tür kurucusunu kullanın: "set()", "set('foobar')", "set(['a',
     'b', 'foo'])"

   "set" ve "frozenset" örnekleri aşağıdaki işlemleri sağlar:

   len(s)

      *s* kümesindeki eleman sayısını döndürür (*s*'nin
      kardinalitesi).

   x in s

      *x*'i *s* üyeliği için test edin.

   x not in s

      *x*'in *s*'ye üye olup olmadığını test edin.

   isdisjoint(other)

      Kümenin *other* kümelerle ortak hiçbir elemanı yoksa "True"
      döndürür.  Kümeler, ancak ve ancak kesişimleri boş küme ise
      ayrıktır.

   issubset(other)
   set <= other

      Kümedeki her elemanın *other* içinde olup olmadığını test edin.

   set < other

      Kümenin *other* kümenin uygun bir alt kümesi olup olmadığını,
      yani "set <= other and set != other" olup olmadığını test eder.

   issuperset(other)
   set >= other

      Kümedeki her elemanın *other* içinde olup olmadığını test edin.

   set > other

      Kümenin *other* kümenin uygun bir üst kümesi olup olmadığını,
      yani "set >= other and set != other" olup olmadığını test edin.

   union(*others)
   set | other | ...

      Kümedeki ve diğer tüm kümelerdeki elemanları içeren yeni bir
      küme döndürür.

   intersection(*others)
   set & other & ...

      Küme ve diğer tüm kümeler için ortak öğeler içeren yeni bir küme
      döndürür.

   difference(*others)
   set - other - ...

      Küme içinde diğerlerinde olmayan elemanlar içeren yeni bir küme
      döndürür.

   symmetric_difference(other)
   set ^ other

      Elemanları ya kümede ya da *diğer* kümede olan ancak her
      ikisinde de olmayan yeni bir küme döndürür.

   copy()

      Kümenin yüzeysel bir kopyasını döndürür.

   Not: "union()", "intersection()", "difference()",
   "symmetric_difference()", "issubset()" ve "issuperset()"
   metotlarının operatörsüz versiyonları herhangi bir yinelenebiliri
   argüman olarak kabul edecektir.  Buna karşılık, operatör tabanlı
   benzerleri argümanlarının küme olmasını gerektirir.  Bu, daha
   okunabilir "set('abc').intersection('cbs')" yerine "set('abc') &
   'cbs'" gibi hataya açık yapıları engeller.

   Hem "set" hem de "frozenset" kümeden kümeye karşılaştırmaları
   destekler. İki küme, ancak ve ancak her kümenin her elemanı
   diğerinin içinde bulunuyorsa (her biri diğerinin alt kümesi ise)
   eşittir. Bir küme başka bir kümeden ancak ve ancak birinci küme
   ikinci kümenin uygun bir alt kümesi ise (bir alt kümedir, ancak
   eşit değildir) küçüktür. Bir küme, ancak ve ancak birinci küme
   ikinci kümenin uygun bir üst kümesi ise (bir üst kümedir, ancak
   eşit değildir) başka bir kümeden büyüktür.

   "set" örnekleri, üyelerine göre "frozenset" örnekleriyle
   karşılaştırılır.  Örneğin, "set('abc') == frozenset('abc')" "True"
   döndürür ve "set('abc') in set([frozenset('abc')])" de öyle.

   Alt küme ve eşitlik karşılaştırmaları toplam sıralama fonksiyonuna
   genelleştirilemez.  Örneğin, boş olmayan herhangi iki ayrık küme
   eşit değildir ve birbirinin alt kümesi değildir, bu nedenle
   aşağıdakilerin *all* "Yanlış" döndürür: "a<b", "a==b" veya "a>b".

   Kümeler yalnızca kısmi sıralama (alt küme ilişkileri)
   tanımladığından, "list.sort()" yönteminin çıktısı küme listeleri
   için tanımsızdır.

   Sözlük anahtarları gibi küme öğeleri de *hashable* olmalıdır.

   "set" örneklerini "frozenset" ile karıştıran ikili işlemler ilk
   işlenenin türünü döndürür.  Örneğin: "frozenset('ab') | set('bc')"
   bir "frozenset" örneği döndürür.

   Aşağıdaki tabloda "set" için kullanılabilen ve "frozenset" 'in
   değişmez örneklerine uygulanmayan işlemler listelenmektedir:

   update(*others)
   set |= other | ...

      Diğer tüm öğeleri ekleyerek seti güncelleyin.

   intersection_update(*others)
   set &= other & ...

      Yalnızca içinde bulunan öğeleri ve diğerlerini koruyarak seti
      güncelleyin.

   difference_update(*others)
   set -= other | ...

      Diğerlerinde bulunan öğeleri kaldırarak kümeyi güncelleyin.

   symmetric_difference_update(other)
   set ^= other

      Kümeyi güncelleyin, yalnızca her iki kümede de bulunan öğeleri
      saklayın, ancak her ikisinde de bulunmayın.

   add(elem)

      Kümeye *elem* öğesini ekleyin.

   remove(elem)

      Kümeden *elem* elemanını kaldırır.  Eğer *elem* kümede
      bulunmuyorsa "KeyError" değerini yükseltir.

   discard(elem)

      Eğer varsa *elem* öğesini kümeden kaldırır.

   pop()

      Kümeden rastgele bir elemanı kaldırır ve döndürür.  Küme boşsa
      "KeyError" değerini yükseltir.

   clear()

      Kümeden tüm öğeleri kaldırın.

   Not: "update()", "intersection_update()", "difference_update()" ve
   "symmetric_difference_update()" metotlarının operatör olmayan
   versiyonları herhangi bir iterable'ı argüman olarak kabul
   edecektir.

   Not: "__contains__()", "remove()" ve "discard()" yöntemlerinin
   *elem* argümanı bir küme olabilir.  Eşdeğer bir frozenset aramayı
   desteklemek için, *elem*'den geçici bir tane oluşturulur.


Mapping Types --- "dict"
========================

Bir *mapping* nesnesi *hashable* değerlerini rastgele nesnelere eşler.
Eşlemeler değiştirilebilir nesnelerdir.  Şu anda sadece bir standart
eşleme türü vardır, *dictionary*.  (Diğer kapsayıcılar için yerleşik
"list", "set" ve "tuple" sınıflarına ve "collections" modülüne bakın).

A dictionary's keys are *almost* arbitrary values.  Values that are
not *hashable*, that is, values containing lists, dictionaries or
other mutable types (that are compared by value rather than by object
identity) may not be used as keys. Values that compare equal (such as
"1", "1.0", and "True") can be used interchangeably to index the same
dictionary entry.

class dict(**kwargs)
class dict(mapping, **kwargs)
class dict(iterable, **kwargs)

   İsteğe bağlı bir konumsal bağımsız değişken ve muhtemelen boş bir
   anahtar sözcük bağımsız değişken kümesinden başlatılan yeni bir
   sözlük döndürür.

   Sözlükler çeşitli yollarla oluşturulabilir:

   * Use a comma-separated list of "key: value" pairs within braces:
     "{'jack': 4098, 'sjoerd': 4127}" or "{4098: 'jack', 4127:
     'sjoerd'}"

   * Use a dict comprehension: "{}", "{x: x ** 2 for x in range(10)}"

   * Use the type constructor: "dict()", "dict([('foo', 100), ('bar',
     200)])", "dict(foo=100, bar=200)"

   If no positional argument is given, an empty dictionary is created.
   If a positional argument is given and it is a mapping object, a
   dictionary is created with the same key-value pairs as the mapping
   object.  Otherwise, the positional argument must be an *iterable*
   object.  Each item in the iterable must itself be an iterable with
   exactly two objects.  The first object of each item becomes a key
   in the new dictionary, and the second object the corresponding
   value.  If a key occurs more than once, the last value for that key
   becomes the corresponding value in the new dictionary.

   If keyword arguments are given, the keyword arguments and their
   values are added to the dictionary created from the positional
   argument.  If a key being added is already present, the value from
   the keyword argument replaces the value from the positional
   argument.

   To illustrate, the following examples all return a dictionary equal
   to "{"one": 1, "two": 2, "three": 3}":

      >>> a = dict(one=1, two=2, three=3)
      >>> b = {'one': 1, 'two': 2, 'three': 3}
      >>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
      >>> d = dict([('two', 2), ('one', 1), ('three', 3)])
      >>> e = dict({'three': 3, 'one': 1, 'two': 2})
      >>> f = dict({'one': 1, 'three': 3}, two=2)
      >>> a == b == c == d == e == f
      True

   Providing keyword arguments as in the first example only works for
   keys that are valid Python identifiers.  Otherwise, any valid keys
   can be used.

   These are the operations that dictionaries support (and therefore,
   custom mapping types should support too):

   list(d)

      Return a list of all the keys used in the dictionary *d*.

   len(d)

      Return the number of items in the dictionary *d*.

   d[key]

      Return the item of *d* with key *key*.  Raises a "KeyError" if
      *key* is not in the map.

      If a subclass of dict defines a method "__missing__()" and *key*
      is not present, the "d[key]" operation calls that method with
      the key *key* as argument.  The "d[key]" operation then returns
      or raises whatever is returned or raised by the
      "__missing__(key)" call. No other operations or methods invoke
      "__missing__()". If "__missing__()" is not defined, "KeyError"
      is raised. "__missing__()" must be a method; it cannot be an
      instance variable:

         >>> class Counter(dict):
         ...     def __missing__(self, key):
         ...         return 0
         >>> c = Counter()
         >>> c['red']
         0
         >>> c['red'] += 1
         >>> c['red']
         1

      The example above shows part of the implementation of
      "collections.Counter".  A different "__missing__" method is used
      by "collections.defaultdict".

   d[key] = value

      Set "d[key]" to *value*.

   del d[key]

      Remove "d[key]" from *d*.  Raises a "KeyError" if *key* is not
      in the map.

   key in d

      Return "True" if *d* has a key *key*, else "False".

   key not in d

      Equivalent to "not key in d".

   iter(d)

      Return an iterator over the keys of the dictionary.  This is a
      shortcut for "iter(d.keys())".

   clear()

      Remove all items from the dictionary.

   copy()

      Return a shallow copy of the dictionary.

   classmethod fromkeys(iterable[, value])

      Create a new dictionary with keys from *iterable* and values set
      to *value*.

      "fromkeys()" is a class method that returns a new dictionary.
      *value* defaults to "None".  All of the values refer to just a
      single instance, so it generally doesn't make sense for *value*
      to be a mutable object such as an empty list.  To get distinct
      values, use a dict comprehension instead.

   get(key[, default])

      Return the value for *key* if *key* is in the dictionary, else
      *default*. If *default* is not given, it defaults to "None", so
      that this method never raises a "KeyError".

   items()

      Return a new view of the dictionary's items ("(key, value)"
      pairs). See the documentation of view objects.

   keys()

      Return a new view of the dictionary's keys.  See the
      documentation of view objects.

   pop(key[, default])

      If *key* is in the dictionary, remove it and return its value,
      else return *default*.  If *default* is not given and *key* is
      not in the dictionary, a "KeyError" is raised.

   popitem()

      Remove and return a "(key, value)" pair from the dictionary.
      Pairs are returned in LIFO (last-in, first-out) order.

      "popitem()" is useful to destructively iterate over a
      dictionary, as often used in set algorithms.  If the dictionary
      is empty, calling "popitem()" raises a "KeyError".

      3.7 sürümünde değişti: LIFO order is now guaranteed. In prior
      versions, "popitem()" would return an arbitrary key/value pair.

   reversed(d)

      Return a reverse iterator over the keys of the dictionary. This
      is a shortcut for "reversed(d.keys())".

      3.8 sürümünde geldi.

   setdefault(key[, default])

      If *key* is in the dictionary, return its value.  If not, insert
      *key* with a value of *default* and return *default*.  *default*
      defaults to "None".

   update([other])

      Update the dictionary with the key/value pairs from *other*,
      overwriting existing keys.  Return "None".

      "update()" accepts either another dictionary object or an
      iterable of key/value pairs (as tuples or other iterables of
      length two).  If keyword arguments are specified, the dictionary
      is then updated with those key/value pairs: "d.update(red=1,
      blue=2)".

   values()

      Return a new view of the dictionary's values.  See the
      documentation of view objects.

      An equality comparison between one "dict.values()" view and
      another will always return "False". This also applies when
      comparing "dict.values()" to itself:

         >>> d = {'a': 1}
         >>> d.values() == d.values()
         False

   d | other

      Create a new dictionary with the merged keys and values of *d*
      and *other*, which must both be dictionaries. The values of
      *other* take priority when *d* and *other* share keys.

      3.9 sürümünde geldi.

   d |= other

      Update the dictionary *d* with keys and values from *other*,
      which may be either a *mapping* or an *iterable* of key/value
      pairs. The values of *other* take priority when *d* and *other*
      share keys.

      3.9 sürümünde geldi.

   Dictionaries compare equal if and only if they have the same "(key,
   value)" pairs (regardless of ordering). Order comparisons ('<',
   '<=', '>=', '>') raise "TypeError".

   Dictionaries preserve insertion order.  Note that updating a key
   does not affect the order.  Keys added after deletion are inserted
   at the end.

      >>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
      >>> d
      {'one': 1, 'two': 2, 'three': 3, 'four': 4}
      >>> list(d)
      ['one', 'two', 'three', 'four']
      >>> list(d.values())
      [1, 2, 3, 4]
      >>> d["one"] = 42
      >>> d
      {'one': 42, 'two': 2, 'three': 3, 'four': 4}
      >>> del d["two"]
      >>> d["two"] = None
      >>> d
      {'one': 42, 'three': 3, 'four': 4, 'two': None}

   3.7 sürümünde değişti: Dictionary order is guaranteed to be
   insertion order.  This behavior was an implementation detail of
   CPython from 3.6.

   Dictionaries and dictionary views are reversible.

      >>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
      >>> d
      {'one': 1, 'two': 2, 'three': 3, 'four': 4}
      >>> list(reversed(d))
      ['four', 'three', 'two', 'one']
      >>> list(reversed(d.values()))
      [4, 3, 2, 1]
      >>> list(reversed(d.items()))
      [('four', 4), ('three', 3), ('two', 2), ('one', 1)]

   3.8 sürümünde değişti: Dictionaries are now reversible.

Ayrıca bakınız:

  "types.MappingProxyType" can be used to create a read-only view of a
  "dict".


Dictionary view objects
-----------------------

The objects returned by "dict.keys()", "dict.values()" and
"dict.items()" are *view objects*.  They provide a dynamic view on the
dictionary's entries, which means that when the dictionary changes,
the view reflects these changes.

Dictionary views can be iterated over to yield their respective data,
and support membership tests:

len(dictview)

   Return the number of entries in the dictionary.

iter(dictview)

   Return an iterator over the keys, values or items (represented as
   tuples of "(key, value)") in the dictionary.

   Keys and values are iterated over in insertion order. This allows
   the creation of "(value, key)" pairs using "zip()": "pairs =
   zip(d.values(), d.keys())".  Another way to create the same list is
   "pairs = [(v, k) for (k, v) in d.items()]".

   Iterating views while adding or deleting entries in the dictionary
   may raise a "RuntimeError" or fail to iterate over all entries.

   3.7 sürümünde değişti: Dictionary order is guaranteed to be
   insertion order.

x in dictview

   Return "True" if *x* is in the underlying dictionary's keys, values
   or items (in the latter case, *x* should be a "(key, value)"
   tuple).

reversed(dictview)

   Return a reverse iterator over the keys, values or items of the
   dictionary. The view will be iterated in reverse order of the
   insertion.

   3.8 sürümünde değişti: Dictionary views are now reversible.

dictview.mapping

   Return a "types.MappingProxyType" that wraps the original
   dictionary to which the view refers.

   3.10 sürümünde geldi.

Keys views are set-like since their entries are unique and *hashable*.
If all values are hashable, so that "(key, value)" pairs are unique
and hashable, then the items view is also set-like.  (Values views are
not treated as set-like since the entries are generally not unique.)
For set-like views, all of the operations defined for the abstract
base class "collections.abc.Set" are available (for example, "==",
"<", or "^").

An example of dictionary view usage:

   >>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
   >>> keys = dishes.keys()
   >>> values = dishes.values()

   >>> # iteration
   >>> n = 0
   >>> for val in values:
   ...     n += val
   >>> print(n)
   504

   >>> # keys and values are iterated over in the same order (insertion order)
   >>> list(keys)
   ['eggs', 'sausage', 'bacon', 'spam']
   >>> list(values)
   [2, 1, 1, 500]

   >>> # view objects are dynamic and reflect dict changes
   >>> del dishes['eggs']
   >>> del dishes['sausage']
   >>> list(keys)
   ['bacon', 'spam']

   >>> # set operations
   >>> keys & {'eggs', 'bacon', 'salad'}
   {'bacon'}
   >>> keys ^ {'sausage', 'juice'}
   {'juice', 'sausage', 'bacon', 'spam'}

   >>> # get back a read-only proxy for the original dictionary
   >>> values.mapping
   mappingproxy({'bacon': 1, 'spam': 500})
   >>> values.mapping['spam']
   500


Bağlam Yöneticisi Türleri
=========================

Python's "with" statement supports the concept of a runtime context
defined by a context manager.  This is implemented using a pair of
methods that allow user-defined classes to define a runtime context
that is entered before the statement body is executed and exited when
the statement ends:

contextmanager.__enter__()

   Enter the runtime context and return either this object or another
   object related to the runtime context. The value returned by this
   method is bound to the identifier in the "as" clause of "with"
   statements using this context manager.

   An example of a context manager that returns itself is a *file
   object*. File objects return themselves from __enter__() to allow
   "open()" to be used as the context expression in a "with"
   statement.

   An example of a context manager that returns a related object is
   the one returned by "decimal.localcontext()". These managers set
   the active decimal context to a copy of the original decimal
   context and then return the copy. This allows changes to be made to
   the current decimal context in the body of the "with" statement
   without affecting code outside the "with" statement.

contextmanager.__exit__(exc_type, exc_val, exc_tb)

   Exit the runtime context and return a Boolean flag indicating if
   any exception that occurred should be suppressed. If an exception
   occurred while executing the body of the "with" statement, the
   arguments contain the exception type, value and traceback
   information. Otherwise, all three arguments are "None".

   Returning a true value from this method will cause the "with"
   statement to suppress the exception and continue execution with the
   statement immediately following the "with" statement. Otherwise the
   exception continues propagating after this method has finished
   executing. Exceptions that occur during execution of this method
   will replace any exception that occurred in the body of the "with"
   statement.

   The exception passed in should never be reraised explicitly -
   instead, this method should return a false value to indicate that
   the method completed successfully and does not want to suppress the
   raised exception. This allows context management code to easily
   detect whether or not an "__exit__()" method has actually failed.

Python defines several context managers to support easy thread
synchronisation, prompt closure of files or other objects, and simpler
manipulation of the active decimal arithmetic context. The specific
types are not treated specially beyond their implementation of the
context management protocol. See the "contextlib" module for some
examples.

Python's *generator*s and the "contextlib.contextmanager" decorator
provide a convenient way to implement these protocols.  If a generator
function is decorated with the "contextlib.contextmanager" decorator,
it will return a context manager implementing the necessary
"__enter__()" and "__exit__()" methods, rather than the iterator
produced by an undecorated generator function.

Note that there is no specific slot for any of these methods in the
type structure for Python objects in the Python/C API. Extension types
wanting to define these methods must provide them as a normal Python
accessible method. Compared to the overhead of setting up the runtime
context, the overhead of a single class dictionary lookup is
negligible.


Type Annotation Types --- Generic Alias, Union
==============================================

The core built-in types for *type annotations* are Generic Alias and
Union.


Genel Takma Ad Türü
-------------------

"GenericAlias" objects are generally created by subscripting a class.
They are most often used with container classes, such as "list" or
"dict". For example, "list[int]" is a "GenericAlias" object created by
subscripting the "list" class with the argument "int". "GenericAlias"
objects are intended primarily for use with *type annotations*.

Not:

  It is generally only possible to subscript a class if the class
  implements the special method "__class_getitem__()".

A "GenericAlias" object acts as a proxy for a *generic type*,
implementing *parameterized generics*.

For a container class, the argument(s) supplied to a subscription of
the class may indicate the type(s) of the elements an object contains.
For example, "set[bytes]" can be used in type annotations to signify a
"set" in which all the elements are of type "bytes".

For a class which defines "__class_getitem__()" but is not a
container, the argument(s) supplied to a subscription of the class
will often indicate the return type(s) of one or more methods defined
on an object. For example, "regular expressions" can be used on both
the "str" data type and the "bytes" data type:

* If "x = re.search('foo', 'foo')", "x" will be a re.Match object
  where the return values of "x.group(0)" and "x[0]" will both be of
  type "str". We can represent this kind of object in type annotations
  with the "GenericAlias" "re.Match[str]".

* If "y = re.search(b'bar', b'bar')", (note the "b" for "bytes"), "y"
  will also be an instance of "re.Match", but the return values of
  "y.group(0)" and "y[0]" will both be of type "bytes". In type
  annotations, we would represent this variety of re.Match objects
  with "re.Match[bytes]".

"GenericAlias" objects are instances of the class
"types.GenericAlias", which can also be used to create "GenericAlias"
objects directly.

T[X, Y, ...]

   Creates a "GenericAlias" representing a type "T" parameterized by
   types *X*, *Y*, and more depending on the "T" used. For example, a
   function expecting a "list" containing "float" elements:

      def average(values: list[float]) -> float:
          return sum(values) / len(values)

   Anahtar türünü ve değer türünü temsil eden iki tür parametresi
   bekleyen genel bir tür olan "dict" kullanarak *mapping* nesneleri
   için başka bir örnek.  Bu örnekte, fonksiyon "str" türünde
   anahtarları ve "int" türünde değerleri olan bir "dict" bekler:

      def send_post_request(url: str, body: dict[str, int]) -> None:
          ...

Yerleşik "isinstance()" ve "issubclass()" işlevleri ikinci argümanları
için "GenericAlias" türlerini kabul etmez:

   >>> isinstance([1, 2], list[str])
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: isinstance() argument 2 cannot be a parameterized generic

The Python runtime does not enforce *type annotations*. This extends
to generic types and their type parameters. When creating a container
object from a "GenericAlias", the elements in the container are not
checked against their type. For example, the following code is
discouraged, but will run without errors:

   >>> t = list[str]
   >>> t([1, 2, 3])
   [1, 2, 3]

Ayrıca, parametrelendirilmiş jenerikler nesne oluşturma sırasında tip
parametrelerini siler:

   >>> t = list[str]
   >>> type(t)
   <class 'types.GenericAlias'>

   >>> l = t()
   >>> type(l)
   <class 'list'>

Bir jenerik üzerinde "repr()" veya "str()" çağrısı
parametrelendirilmiş türü gösterir:

   >>> repr(list[int])
   'list[int]'

   >>> str(list[int])
   'list[int]'

The "__getitem__()" method of generic containers will raise an
exception to disallow mistakes like "dict[str][str]":

   >>> dict[str][str]
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: There are no type variables left in dict[str]

However, such expressions are valid when type variables are used.  The
index must have as many elements as there are type variable items in
the "GenericAlias" object's "__args__".

   >>> from typing import TypeVar
   >>> Y = TypeVar('Y')
   >>> dict[str, Y][int]
   dict[str, int]


Standard Generic Classes
~~~~~~~~~~~~~~~~~~~~~~~~

The following standard library classes support parameterized generics.
This list is non-exhaustive.

* "tuple"

* "list"

* "dict"

* "set"

* "frozenset"

* "type"

* "collections.deque"

* "collections.defaultdict"

* "collections.OrderedDict"

* "collections.Counter"

* "collections.ChainMap"

* "collections.abc.Awaitable"

* "collections.abc.Coroutine"

* "collections.abc.AsyncIterable"

* "collections.abc.AsyncIterator"

* "collections.abc.AsyncGenerator"

* "collections.abc.Iterable"

* "collections.abc.Iterator"

* "collections.abc.Generator"

* "collections.abc.Reversible"

* "collections.abc.Container"

* "collections.abc.Collection"

* "collections.abc.Callable"

* "collections.abc.Set"

* "collections.abc.MutableSet"

* "collections.abc.Mapping"

* "collections.abc.MutableMapping"

* "collections.abc.Sequence"

* "collections.abc.MutableSequence"

* "collections.abc.ByteString"

* "collections.abc.MappingView"

* "collections.abc.KeysView"

* "collections.abc.ItemsView"

* "collections.abc.ValuesView"

* "contextlib.AbstractContextManager"

* "contextlib.AbstractAsyncContextManager"

* "dataclasses.Field"

* "functools.cached_property"

* "functools.partialmethod"

* "os.PathLike"

* "queue.LifoQueue"

* "queue.Queue"

* "queue.PriorityQueue"

* "queue.SimpleQueue"

* re.Pattern

* re.Match

* "shelve.BsdDbShelf"

* "shelve.DbfilenameShelf"

* "shelve.Shelf"

* "types.MappingProxyType"

* "weakref.WeakKeyDictionary"

* "weakref.WeakMethod"

* "weakref.WeakSet"

* "weakref.WeakValueDictionary"


Special Attributes of "GenericAlias" objects
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Tüm parametreli jenerikler özel salt okunur öznitelikler uygular.

genericalias.__origin__

   Bu öznitelik, parametrelendirilmemiş genel sınıfa işaret eder:

      >>> list[int].__origin__
      <class 'list'>

genericalias.__args__

   This attribute is a "tuple" (possibly of length 1) of generic types
   passed to the original "__class_getitem__()" of the generic class:

      >>> dict[str, list[int]].__args__
      (<class 'str'>, list[int])

genericalias.__parameters__

   Bu öznitelik, ''__args__'' içinde bulunan benzersiz tür
   değişkenlerin tembel bir şekilde hesaplanmış bir demetidir
   (muhtemelen boş):

      >>> from typing import TypeVar

      >>> T = TypeVar('T')
      >>> list[T].__parameters__
      (~T,)

   Not:

     "GenericAlias" nesnesi ile "typing.ParamSpec" parametreleri
     değiştirildikten sonra doğru "__parameters__" olmayabilir çünkü
     "typing.ParamSpec" öncelikle statik tip kontrolü için
     tasarlanmıştır.

Ayrıca bakınız:

  **PEP 484** - Type Hints
     Introducing Python's framework for type annotations.

  **PEP 585** - Type Hinting Generics In Standard Collections
     Introducing the ability to natively parameterize standard-library
     classes, provided they implement the special class method
     "__class_getitem__()".

  Generics, user-defined generics and "typing.Generic"
     Documentation on how to implement generic classes that can be
     parameterized at runtime and understood by static type-checkers.

3.9 sürümünde geldi.


Sendika Türü
------------

Bir birleşim nesnesi, birden çok type objects üzerinde "|" (bitsel
veya) işleminin değerini tutar. Bu türler öncelikle aşağıdakiler için
tasarlanmıştır *type annotations*. Birleşim türü ifadesi,
aşağıdakilere kıyasla daha temiz tür ipucu sözdizimi sağlar
"typing.Union".

X | Y | ...

   *X*, *Y* vb. türleri tutan bir birleşim nesnesi tanımlar. "X | Y" X
   veya Y anlamına gelir.  Bu, "typing.Union[X, Y]" ile eşdeğerdir.
   Örneğin, aşağıdaki işlev "int" veya "float":

      def square(number: int | float) -> int | float:
          return number ** 2

union_object == other

   Birlik nesneleri, diğer birlik nesneleriyle eşitlik açısından test
   edilebilir.  Detaylar:

   * Birliklerin birlikleri düzleştirimiştir:

        (int | str) | float == int | str | float

   * Gereksiz türler kaldırılır:

        int | str | int == int | str

   * Birlikleri karşılaştırırken, sipariş göz ardı edilir:

        int | str == str | int

   * "typing.Union":: ile uyumludur:

        int | str == typing.Union[int, str]

   * İsteğe bağlı türler "None":: ile bir birlik olarak yazılabilir:

        str | None == typing.Optional[str]

isinstance(obj, union_object)

issubclass(obj, union_object)

   "isinstance()" ve "issubclass()" çağrıları da bir birlik nesnesiyle
   desteklenir:

      >>> isinstance("", int | str)
      True

   Ancak, Genel Takma Ad Türü içeren union nesneleri kullanılamaz:

      >>> isinstance(1, int | list[int])
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      TypeError: isinstance() argument 2 cannot contain a parameterized generic

Union nesnesinin kullanıcıya açık türüne "types.UnionType" adresinden
erişilebilir ve "isinstance()" kontrolleri için kullanılabilir.  Bir
nesne şu türden örneklenemez:

   >>> import types
   >>> isinstance(int | str, types.UnionType)
   True
   >>> types.UnionType()
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: cannot create 'types.UnionType' instances

Not:

  Tür nesneleri için "__or__()" yöntemi, "X | Y" sözdizimini
  desteklemek için eklendi.  Eğer bir metaclass "__or__()" metodunu
  uygularsa, Union bunu geçersiz kılabilir:

     >>> class M(type):
     ...     def __or__(self, other):
     ...         return "Hello"
     ...
     >>> class C(metaclass=M):
     ...     pass
     ...
     >>> C | int
     'Hello'
     >>> int | C
     int | __main__.C

Ayrıca bakınız:

  **PEP 604** -- "X | Y" sözdizimini ve Birlik türünü öneren PEP.

3.10 sürümünde geldi.


Diğer Yerleşik Tipler
=====================

Yorumlayıcı başka nesne türlerini de destekler. Bunların çoğu yalnızca
bir veya iki işlemi destekler.


Modüller
--------

Bir modül üzerindeki tek özel işlem öznitelik erişimidir: "m.name",
burada *m* bir modüldür ve *name*, *m*'nin sembol tablosunda
tanımlanan bir isme erişir. Modül nitelikleri atanabilir.  ("import"
deyiminin kesinlikle bir modül nesnesi üzerinde bir işlem olmadığına
dikkat edin; "import foo" *foo* adında bir modül nesnesinin var
olmasını gerektirmez, bunun yerine bir yerlerde *foo* adında bir modül
için (harici) bir *tanımlama* gerektirir)

Her modülün özel bir niteliği "__dict__" 'dir. Bu, modülün sembol
tablosunu içeren sözlüktür. Bu sözlüğü değiştirmek aslında modülün
sembol tablosunu değiştirecektir, ancak "__dict__" niteliğine doğrudan
atama yapmak mümkün değildir ("m.__dict__['a'] = 1" yazabilirsiniz, bu
"m.a" yı "1" olarak tanımlar, ancak "m.__dict__ = {}" yazamazsınız).
"__dict__" öğesinin doğrudan değiştirilmesi önerilmez.

Yorumlayıcıda yerleşik olarak bulunan modüller şu şekilde yazılır:
"<module 'sys' (built-in)>".  Eğer bir dosyadan yüklenmişlerse,
"<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>" şeklinde
yazılırlar.


Sınıflar ve Sınıf Örnekleri
---------------------------

Bunlar için Class definitions ve Objects, values and types  bakın.


Fonksiyonlar
------------

Fonksiyon nesneleri fonksiyon tanımları tarafından oluşturulur.  Bir
fonksiyon nesnesi üzerindeki tek işlem onu çağırmaktır: "func
(argument-list)".

Fonksiyon nesnelerinin gerçekten iki çeşidi vardır: yerleşik
fonksiyonlar ve kullanıcı tanımlı fonksiyonlar.  Her ikisi de aynı
işlemi destekler (işlevi çağırmak için), ancak uygulama farklıdır,
dolayısıyla farklı nesne türleri vardır.

Daha fazla bilgi için Function definitions bölümüne bakınız.


Yöntemler
---------

Yöntemler, nitelik gösterimi kullanılarak çağrılan işlevlerdir. İki
çeşidi vardır: yerleşik yöntemler (listelerde "append()" gibi) ve
sınıf örneği yöntemleri.  Yerleşik yöntemler, onları destekleyen
türlerle birlikte tanımlanır.

Bir yönteme (bir sınıf ad alanında tanımlanmış bir fonksiyon) bir
örnek üzerinden erişirseniz, özel bir nesne elde edersiniz: bir *bound
method* (ayrıca *instance method* olarak da adlandırılır) nesnesi.
Çağrıldığında, "self" argümanını argüman listesine ekleyecektir.
Bağlı metotların iki özel salt okunur niteliği vardır: "m.__self__"
metodun üzerinde çalıştığı nesne ve "m.__func__" metodu uygulayan
fonksiyondur.  "m(arg-1, arg-2, ..., arg-n)" çağrısı tamamen
"m.__func__(m.__self__, arg-1, arg-2, ..., arg-n)" çağrısına
eşdeğerdir.

Fonksiyon nesneleri gibi, bağlı metot nesneleri de keyfi nitelikler
almayı destekler.  Ancak, yöntem nitelikleri aslında temel işlev
nesnesinde ("meth.__func__") saklandığından, bağlı yöntemlerde yöntem
niteliklerinin ayarlanmasına izin verilmez.  Bir yöntem üzerinde bir
öznitelik ayarlamaya çalışmak "AttributeError" ile sonuçlanır.  Bir
yöntem özniteliğini ayarlamak için, bunu temel işlev nesnesi üzerinde
açıkça ayarlamanız gerekir:

   >>> class C:
   ...     def method(self):
   ...         pass
   ...
   >>> c = C()
   >>> c.method.whoami = 'my name is method'  # can't set on the method
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   AttributeError: 'method' object has no attribute 'whoami'
   >>> c.method.__func__.whoami = 'my name is method'
   >>> c.method.whoami
   'my name is method'

Daha fazla bilgi için The standard type hierarchy sayfasına bakın.


Kod Nesneleri
-------------

Kod nesneleri, uygulama tarafından bir fonksiyon gövdesi gibi "sözde
derlenmiş" çalıştırılabilir Python kodunu temsil etmek için
kullanılır. Fonksiyon nesnelerinden farklıdırlar çünkü global yürütme
ortamlarına bir referans içermezler.  Kod nesneleri yerleşik
"compile()" işlevi tarafından döndürülür ve  "__code__" niteliği
aracılığıyla işlev nesnelerinden çıkarılabilir. Ayrıca "code" modülüne
de bakınız.

"__code__" 'e erişmek,``obj`` ve ""__code__"" argümanlarıyla denetim
etkinliği "object.__getattr__" oluşturur.

Bir kod nesnesi (kaynak dize yerine) "exec()" veya "eval()" yerleşik
işlevlerine geçirilerek yürütülebilir veya değerlendirilebilir.

Daha fazla bilgi için The standard type hierarchy sayfasına bakın.


Type Objects
------------

Type nesneleri çeşitli nesne türlerini temsil eder.  Bir nesnenin
türüne yerleşik işlev "type()" tarafından erişilir.  Türler üzerinde
özel bir işlem yoktur.  Standart modül "types" tüm standart yerleşik
türler için isimleri tanımlar.

Türler şu şekilde yazılır: "<class 'int'>".


Null Nesne
----------

Bu nesne, açıkça bir değer döndürmeyen işlevler tarafından döndürülür.
Özel operasyonları desteklemez.  Tam olarak "None" (yerleşik bir ad)
adlı bir null nesne vardır.  "type(None)()" aynı singleton'u üretir.

''Yok'' olarak yazılmıştır.


Üç Nokta Nesnesi
----------------

Bu nesne genellikle dilimleme tarafından kullanılır (bkz. Slicings).
Özel operasyonları desteklemez.  Tam olarak "Ellipsis" (yerleşik bir
ad) adında bir elips nesnesi vardır.  "type(Ellipsis)()", "Ellipsis"
singletonunu üretir.

"Ellipsis" veya "..." olarak yazılmıştır.


NotImplemented Nesnesi
----------------------

Bu nesne, desteklemedikleri türlerde çalışmaları istendiğinde
karşılaştırmalardan ve ikili işlemlerden döndürülür. Daha fazla bilgi
için Comparisons sayfasına bakın.  Tam olarak bir "NotImplemented"
nesnesi vardır. "type(NotImplemented)()", singleton örneğini üretir.

''NotImplemented'' olarak yazılmıştır.


Boolean Değerleri
-----------------

Boolean değerleri, "Yanlış" ve "Doğru" olmak üzere iki sabit nesnedir.
Doğruluk değerlerini temsil etmek için kullanılırlar (diğer değerler
de yanlış veya doğru olarak kabul edilebilir).  Sayısal bağlamlarda
(örneğin, bir aritmetik işlecinin bağımsız değişkeni olarak
kullanıldığında), sırasıyla 0 ve 1 tamsayıları gibi davranırlar.
Yerleşik işlev "bool()", değer bir doğruluk değeri olarak
yorumlanabiliyorsa, herhangi bir değeri bir Boolean'a dönüştürmek için
kullanılabilir (yukarıdaki bölüm Doğruluk Değeri Testi a bakın).

Sırasıyla "Yanlış" ve "Doğru" olarak yazılırlar.


İç Nesneler
-----------

Bu bilgi için The standard type hierarchy sayfasına bakın.  Yığın
çerçeve nesnelerini, geri izleme nesnelerini ve dilim nesnelerini
açıklar.


Özel Özellikler
===============

Uygulama, ilgili oldukları çeşitli nesne türlerine birkaç özel salt
okunur öznitelik ekler.  Bunlardan bazıları "dir()" yerleşik işlevi
tarafından bildirilmez.

object.__dict__

   Bir nesnenin (yazılabilir) özniteliklerini depolamak için
   kullanılan sözlük veya başka bir eşleme nesnesi.

instance.__class__

   Bir sınıf örneğinin ait olduğu sınıf.

class.__bases__

   Bir sınıf elemanının temel sınıflarının kümesi.

definition.__name__

   Sınıf, fonksiyon, yöntem, tanımlayıcı veya üretici örneğinin adı.

definition.__qualname__

   Sınıf, fonksiyon, yöntem, tanımlayıcı veya üretici örneğinin
   *qualified name*.

   3.3 sürümünde geldi.

class.__mro__

   Bu öznitelik, yöntem çözümlemesi sırasında temel sınıfları ararken
   dikkate alınan bir sınıf kümesidir.

class.mro()

   Bu yöntem, örneklerinin yöntem çözümleme sırasını özelleştirmek
   için bir meta sınıf tarafından geçersiz kılınabilir.  Sınıf
   örneğinde çağrılır ve sonucu "__mro__" içinde depolanır.

class.__subclasses__()

   Her sınıf, kendi alt sınıflarına yapılan zayıf referansların bir
   listesini tutar.  Bu yöntem, hala var olan tüm bu başvuruların bir
   listesini döndürür.  Liste tanım sırasına göredir.  Örnek:

      >>> int.__subclasses__()
      [<class 'bool'>]


Integer string conversion length limitation
===========================================

CPython has a global limit for converting between "int" and "str" to
mitigate denial of service attacks. This limit *only* applies to
decimal or other non-power-of-two number bases. Hexadecimal, octal,
and binary conversions are unlimited. The limit can be configured.

The "int" type in CPython is an arbitrary length number stored in
binary form (commonly known as a "bignum"). There exists no algorithm
that can convert a string to a binary integer or a binary integer to a
string in linear time, *unless* the base is a power of 2. Even the
best known algorithms for base 10 have sub-quadratic complexity.
Converting a large value such as "int('1' * 500_000)" can take over a
second on a fast CPU.

Limiting conversion size offers a practical way to avoid
CVE-2020-10735.

The limit is applied to the number of digit characters in the input or
output string when a non-linear conversion algorithm would be
involved.  Underscores and the sign are not counted towards the limit.

When an operation would exceed the limit, a "ValueError" is raised:

   >>> import sys
   >>> sys.set_int_max_str_digits(4300)  # Illustrative, this is the default.
   >>> _ = int('2' * 5432)
   Traceback (most recent call last):
   ...
   ValueError: Exceeds the limit (4300) for integer string conversion: value has 5432 digits; use sys.set_int_max_str_digits() to increase the limit.
   >>> i = int('2' * 4300)
   >>> len(str(i))
   4300
   >>> i_squared = i*i
   >>> len(str(i_squared))
   Traceback (most recent call last):
   ...
   ValueError: Exceeds the limit (4300) for integer string conversion: value has 8599 digits; use sys.set_int_max_str_digits() to increase the limit.
   >>> len(hex(i_squared))
   7144
   >>> assert int(hex(i_squared), base=16) == i*i  # Hexadecimal is unlimited.

The default limit is 4300 digits as provided in
"sys.int_info.default_max_str_digits". The lowest limit that can be
configured is 640 digits as provided in
"sys.int_info.str_digits_check_threshold".

Verification:

   >>> import sys
   >>> assert sys.int_info.default_max_str_digits == 4300, sys.int_info
   >>> assert sys.int_info.str_digits_check_threshold == 640, sys.int_info
   >>> msg = int('578966293710682886880994035146873798396722250538762761564'
   ...           '9252925514383915483333812743580549779436104706260696366600'
   ...           '571186405732').to_bytes(53, 'big')
   ...

3.10.7 sürümünde geldi.


Affected APIs
-------------

The limitation only applies to potentially slow conversions between
"int" and "str" or "bytes":

* "int(string)" with default base 10.

* "int(string, base)" for all bases that are not a power of 2.

* "str(integer)".

* "repr(integer)".

* any other string conversion to base 10, for example "f"{integer}"",
  ""{}".format(integer)", or "b"%d" % integer".

The limitations do not apply to functions with a linear algorithm:

* "int(string, base)" with base 2, 4, 8, 16, or 32.

* "int.from_bytes()" and "int.to_bytes()".

* "hex()", "oct()", "bin()".

* Format Specification Mini-Language for hex, octal, and binary
  numbers.

* "str" to "float".

* "str" to "decimal.Decimal".


Configuring the limit
---------------------

Before Python starts up you can use an environment variable or an
interpreter command line flag to configure the limit:

* "PYTHONINTMAXSTRDIGITS", e.g. "PYTHONINTMAXSTRDIGITS=640 python3" to
  set the limit to 640 or "PYTHONINTMAXSTRDIGITS=0 python3" to disable
  the limitation.

* "-X int_max_str_digits", e.g. "python3 -X int_max_str_digits=640"

* "sys.flags.int_max_str_digits" contains the value of
  "PYTHONINTMAXSTRDIGITS" or "-X int_max_str_digits". If both the env
  var and the "-X" option are set, the "-X" option takes precedence. A
  value of *-1* indicates that both were unset, thus a value of
  "sys.int_info.default_max_str_digits" was used during
  initialization.

From code, you can inspect the current limit and set a new one using
these "sys" APIs:

* "sys.get_int_max_str_digits()" and "sys.set_int_max_str_digits()"
  are a getter and setter for the interpreter-wide limit.
  Subinterpreters have their own limit.

Information about the default and minimum can be found in
"sys.int_info":

* "sys.int_info.default_max_str_digits" is the compiled-in default
  limit.

* "sys.int_info.str_digits_check_threshold" is the lowest accepted
  value for the limit (other than 0 which disables it).

3.10.7 sürümünde geldi.

Uyarı:

  Setting a low limit *can* lead to problems. While rare, code exists
  that contains integer constants in decimal in their source that
  exceed the minimum threshold. A consequence of setting the limit is
  that Python source code containing decimal integer literals longer
  than the limit will encounter an error during parsing, usually at
  startup time or import time or even at installation time - anytime
  an up to date ".pyc" does not already exist for the code. A
  workaround for source that contains such large constants is to
  convert them to "0x" hexadecimal form as it has no limit.Test your
  application thoroughly if you use a low limit. Ensure your tests run
  with the limit set early via the environment or flag so that it
  applies during startup and even during any installation step that
  may invoke Python to precompile ".py" sources to ".pyc" files.


Recommended configuration
-------------------------

The default "sys.int_info.default_max_str_digits" is expected to be
reasonable for most applications. If your application requires a
different limit, set it from your main entry point using Python
version agnostic code as these APIs were added in security patch
releases in versions before 3.11.

Example:

   >>> import sys
   >>> if hasattr(sys, "set_int_max_str_digits"):
   ...     upper_bound = 68000
   ...     lower_bound = 4004
   ...     current_limit = sys.get_int_max_str_digits()
   ...     if current_limit == 0 or current_limit > upper_bound:
   ...         sys.set_int_max_str_digits(upper_bound)
   ...     elif current_limit < lower_bound:
   ...         sys.set_int_max_str_digits(lower_bound)

If you need to disable it entirely, set it to "0".

-[ Dipnotlar ]-

[1] Bu özel yöntemler hakkında daha fazla bilgi Python Referans El
    Kitabında (Basic customization) bulunabilir.

[2] Sonuç olarak, "[1, 2]" listesi "[1.0, 2.0]" ve benzer şekilde
    demetler için eşit kabul edilir.

[3] Ayrıştırıcı, işlenenlerin türünü söyleyemediğinden sahip olmaları
    gerekir.

[4] Harfli karakterler, genel kategori özelliği "Lu" (Harf, büyük),
    "Ll" (Harf, küçük harf) veya "Lt" (Harf, başlık) karakterlerinden
    biri olan karakterlerdir.

[5] Bu nedenle, yalnızca bir tuple(demet) biçimlendirmek için, tek
    öğesi biçimlendirilecek tuple(demet) olan tek bir tuple(demet)
    sağlamanız gerekir.
