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.

By default, an object is considered true unless its class defines
either a "__bool__()" method that returns "False" or a "__len__()"
method that returns zero, when called with the object. [1]  Here are
most of the built-in objects considered false:

* constants defined to be false: "None" and "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"      | *x* doğruysa, *x*, aksi halde *y* | (1)     |
+---------------+-----------------------------------+---------+
| "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     |
+--------------+---------------------------+

Unless stated otherwise, objects of different types never compare
equal. The "==" operator is always defined but for some object types
(for example, class objects) is equivalent to "is". The "<", "<=", ">"
and ">=" operators are only defined where they make sense; for
example, they raise a "TypeError" exception when one of the arguments
is a complex number.

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.

Two more operations with the same syntactic priority, "in" and "not
in", are supported by types that are *iterable* or implement the
"__contains__()" method.


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.)

Numbers are created by numeric literals or as the result of built-in
functions and operators.  Unadorned integer literals (including hex,
octal and binary numbers) yield integers.  Numeric literals containing
a decimal point or an exponent sign yield floating-point numbers.
Appending "'j'" or "'J'" to a numeric literal yields an imaginary
number (a complex number with a zero real part) which you can add to
an integer or float to get a complex number with real and imaginary
parts.

Python karma aritmetiği tam olarak destekler: herhangi bir ikili
aritmetik operatörü farklı sayısal türlerde işlenenlere sahip
olduğunda, "dar" türe sahip işlenen, tam sayı karmaşık sayıdan daha
dar olan gerçel sayıdan daha dar olduğu diğerininkine genişletilir.
Farklı türlerdeki sayıların karşılaştırılması, bu sayıların tam
değerleri karşılaştırılıyormuş gibi davranır. [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)(2)    |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "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. Also referred to as integer division.  For operands of type "int",
   the result has type "int".  For operands of type "float", the
   result has type "float".  In general, the result is a whole
   integer, though the result's type is not necessarily "int".  The
   result is always rounded towards minus infinity: "1//2" is "0",
   "(-1)//2" is "-1", "1//(-2)" is "-1", and "(-1)//(-2)" is "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 ayrıca "nan" ve "inf" dizelerini, Sayı Değil ( Not a Number
   -> NaN) ve pozitif veya negatif sonsuzluk için isteğe bağlı bir "+"
   veya "-" ön ekiyle kabul eder.

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.

   See the Unicode Standard for a complete list of code points with
   the "Nd" property.

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

   Daha doğrusu, "x" sıfırdan farklıysa, "x.bit_length()", "2**(k-1)
   <= abs(x) < 2**k" olacak şekilde benzersiz "k" pozitif tam
   sayısıdır. Aynı şekilde, "abs(x)" doğru olarak yuvarlatılmış bir
   logaritmaya sahip olacak kadar küçük olduğunda, "k = 1 +
   int(log(abs(x), 2))" olur. "x" sıfır ise, "x.bit_length()", "0"
   döndürür.

   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

   Added in version 3.1.

int.bit_count()

   Tam sayının mutlak değerinin ikili gösterimindeki birlerin sayısını
   döndürür. 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")

   Added in version 3.10.

int.to_bytes(length=1, byteorder='big', *, 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 ve varsayılan
   olarak birdir.  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 ve varsayılan olarak ""big"" 'dir.  *byteorder*
   ""big"" ise, en önemli bayt, bayt dizisinin başındadır. *byteorder*
   ""little"" ise, en önemli bayt, bayt dizisinin sonundadır.

   *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.

   The default values can be used to conveniently turn an integer into
   a single byte object:

      >>> (65).to_bytes()
      b'A'

   However, when using the default arguments, don't try to convert a
   value greater than 255 or you'll get an "OverflowError".

   Eşittir:

      def to_bytes(n, length=1, byteorder='big', signed=False):
          if byteorder == 'little':
              order = range(length)
          elif byteorder == 'big':
              order = reversed(range(length))
          else:
              raise ValueError("byteorder must be either 'little' or 'big'")

          return bytes((n >> i*8) & 0xff for i in order)

   Added in version 3.2.

   3.11 sürümünde değişti: Added default argument values for "length"
   and "byteorder".

classmethod int.from_bytes(bytes, byteorder='big', *, 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.

   The *byteorder* argument determines the byte order used to
   represent the integer, and defaults to ""big"".  If *byteorder* is
   ""big"", the most significant byte is at the beginning of the byte
   array.  If *byteorder* is ""little"", the most significant byte is
   at the end of the byte array.  To request the native byte order of
   the host system, use "sys.byteorder" as the byte order value.

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

   Eşittir:

      def from_bytes(bytes, byteorder='big', signed=False):
          if byteorder == 'little':
              little_ordered = list(bytes)
          elif byteorder == 'big':
              little_ordered = list(reversed(bytes))
          else:
              raise ValueError("byteorder must be either 'little' or 'big'")

          n = sum(b << i*8 for i, b in enumerate(little_ordered))
          if signed and little_ordered and (little_ordered[-1] & 0x80):
              n -= 1 << 8*len(little_ordered)

          return n

   Added in version 3.2.

   3.11 sürümünde değişti: Added default argument value for
   "byteorder".

int.as_integer_ratio()

   Return a pair of integers whose ratio is equal to the original
   integer and has a positive denominator.  The integer ratio of
   integers (whole numbers) is always the integer as the numerator and
   "1" as the denominator.

   Added in version 3.8.

int.is_integer()

   Returns "True". Exists for duck type compatibility with
   "float.is_integer()".

   Added in version 3.12.


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()

   Return a pair of integers whose ratio is exactly equal to the
   original float. The ratio is in lowest terms and has a positive
   denominator.  Raises "OverflowError" on infinities and a
   "ValueError" on NaNs.

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
---------------------------

For numbers "x" and "y", possibly of different types, it's a
requirement that "hash(x) == hash(y)" whenever "x == y" (see the
"__hash__()" method documentation for more details).  For ease of
implementation and efficiency across a variety of numeric types
(including "int", "float", "decimal.Decimal" and "fractions.Fraction")
Python's hash for numeric types is based on a single mathematical
function that's defined for any rational number, and hence applies to
all instances of "int" and "fractions.Fraction", and all finite
instances of "float" and "decimal.Decimal".  Essentially, this
function is given by reduction modulo "P" for a fixed prime "P".  The
value of "P" is made available to Python as the "modulus" attribute of
"sys.hash_info".

Ş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


Boolean Type - "bool"
=====================

Booleans represent truth values. The "bool" type has exactly two
constant instances: "True" and "False".

The built-in function "bool()"  converts any value to a boolean, if
the value can be interpreted as a truth value (see section Doğruluk
Değeri Testi above).

For logical operations, use the boolean operators "and", "or" and
"not". When applying the bitwise operators "&", "|", "^" to two
booleans, they return a bool equivalent to the logical operations
"and", "or", "xor". However, the logical operators "and", "or" and
"!=" should be preferred over "&", "|" and "^".

3.12 sürümünden beri kullanım dışı: The use of the bitwise inversion
operator "~" is deprecated and will raise an error in Python 3.16.

"bool" is a subclass of "int" (see Sayısal Türler --- int, float,
complex). In many numeric contexts, "False" and "True" behave like the
integers 0 and 1, respectively. However, relying on this is
discouraged; explicitly convert using "int()" instead.


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's *generator*s provide a convenient way to implement the
iterator protocol.  If a container object's "__iter__()" method is
implemented as a generator, it will automatically return an iterator
object (technically, a generator object) supplying the "__iter__()"
and "__next__()" methods. More information about generators can be
found in the documentation for the yield expression.


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)(8)     |
|                            | 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          |            |
+----------------------------+----------------------------------+------------+

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. An "IndexError" is raised if *i* is outside the sequence range.

-[ Sequence Methods ]-

Sequence types also support the following methods:

sequence.count(value, /)

   Return the total number of occurrences of *value* in *sequence*.

sequence.index(value[, start[, stop])

   Return the index of the first occurrence of *value* in *sequence*.

   Raises "ValueError" if *value* is not found in *sequence*.

   The *start* or *stop* arguments allow for efficient searching of
   subsections of the sequence, beginning at *start* and ending at
   *stop*. This is roughly equivalent to "start +
   sequence[start:stop].index(value)", only without copying any data.

   Uyarı:

     Not all sequence types support passing the *start* and *stop*
     arguments.


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                     |                       |
+--------------------------------+----------------------------------+-----------------------+
| "del s[i]"                     | removes item *i* of *s*          |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s[i:j] = t"                   | *s* 'nin *i* ile *j* arasındaki  |                       |
|                                | dilimi, yinelenebilir *t*        |                       |
|                                | içeriğiyle değiştirilir          |                       |
+--------------------------------+----------------------------------+-----------------------+
| "del s[i:j]"                   | removes the elements of "s[i:j]" |                       |
|                                | from the list (same as "s[i:j] = |                       |
|                                | []")                             |                       |
+--------------------------------+----------------------------------+-----------------------+
| "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 += 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   | (2)                   |
|                                | *s* 'yi günceller                |                       |
+--------------------------------+----------------------------------+-----------------------+

Notlar:

1. If *k* is not equal to "1", *t* must have the same length as the
   slice it is replacing.

2. *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.

-[ Mutable Sequence Methods ]-

Mutable sequence types also support the following methods:

sequence.append(value, /)

   Append *value* to the end of the sequence This is equivalent to
   writing "seq[len(seq):len(seq)] = [value]".

sequence.clear()

   Added in version 3.3.

   Remove all items from *sequence*. This is equivalent to writing
   "del sequence[:]".

sequence.copy()

   Added in version 3.3.

   Create a shallow copy of *sequence*. This is equivalent to writing
   "sequence[:]".

   İpucu:

     The "copy()" method is not part of the "MutableSequence" "ABC",
     but most concrete mutable sequence types provide it.

sequence.extend(iterable, /)

   Extend *sequence* with the contents of *iterable*. For the most
   part, this is the same as writing "seq[len(seq):len(seq)] =
   iterable".

sequence.insert(index, value, /)

   Insert *value* into *sequence* at the given *index*. This is
   equivalent to writing "sequence[index:index] = [value]".

sequence.pop(index=-1, /)

   Retrieve the item at *index* and also removes it from *sequence*.
   By default, the last item in *sequence* is removed and returned.

sequence.remove(value, /)

   Remove the first item from *sequence* where "sequence[i] == value".

   Raises "ValueError" if *value* is not found in *sequence*.

sequence.reverse()

   Reverse the items of *sequence* in place. This method maintains
   economy of space when reversing a large sequence. To remind users
   that it operates by side-effect, it returns "None".


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 Techniques.

      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=1, /)

   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).Added the "start", "stop" and
"step" attributes.

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'"

* Çift tırnak: ""katıştırılmış 'tek' tırnaklara izin verir""

* Üç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"".

See String and Bytes literals for more about the various forms of
string literal, including supported escape sequences, and the "r"
("raw") prefix that disables most escape sequence processing.

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(*, encoding='utf-8', errors='strict')
class str(object)
class str(object, encoding, errors='strict')
class str(object, *, errors)

   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 f-strings
   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.

   The casefolding algorithm is described in section 3.13 'Default
   Case Folding' of the Unicode Standard.

   Added in version 3.3.

str.center(width, fillchar=' ', /)

   Return centered in a string of length *width*. Padding is done
   using the specified *fillchar* (default is an ASCII space). The
   original string is returned if *width* is less than or equal to
   "len(s)".  For example:

      >>> 'Python'.center(10)
      '  Python  '
      >>> 'Python'.center(10, '-')
      '--Python--'
      >>> 'Python'.center(4)
      'Python'

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. For example:

      >>> 'spam, spam, spam'.count('spam')
      3
      >>> 'spam, spam, spam'.count('spam', 5)
      2
      >>> 'spam, spam, spam'.count('spam', 5, 10)
      1
      >>> 'spam, spam, spam'.count('eggs')
      0
      >>> 'spam, spam, spam'.count('')
      17

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* kodlama hatalarının nasıl ele alınacağını kontrol eder.
   Eğer "'strict'" (varsayılan) ise, bir "UnicodeError" istisnası
   oluşturulur. Diğer olası değerler "'ignore'", "'replace'",
   "'xmlcharrefreplace'", "'backslashreplace'" ve
   "codecs.register_error()" ile kaydedilen diğer isimlerdir.
   Ayrıntılar için Error Handlers bölümüne bakınız.

   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. For example:

      >>> encoded_str_to_bytes = 'Python'.encode()
      >>> type(encoded_str_to_bytes)
      <class 'bytes'>
      >>> encoded_str_to_bytes
      b'Python'

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

   3.9 sürümünde değişti: *errors* şimdi Python Development Mode ve
   hata ayıklama modunda kontrol edilir.

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

   Return "True" if the string 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.
   Using *start* and *end* is equivalent to
   "str[start:end].endswith(suffix)". For example:

      >>> 'Python'.endswith('on')
      True
      >>> 'a tuple of suffixes'.endswith(('at', 'in'))
      False
      >>> 'a tuple of suffixes'.endswith(('at', 'es'))
      True
      >>> 'Python is amazing'.endswith('is', 0, 9)
      True

   See also "startswith()" and "removesuffix()".

str.expandtabs(tabsize=8)

   Return a copy of the string where all tab characters are replaced
   by one or more spaces, depending on the current column and the
   given tab size.  Tab positions occur every *tabsize* characters
   (default is 8, giving tab positions at columns 0, 8, 16 and so on).
   To expand the string, the current column is set to zero and the
   string is examined character by character.  If the character is a
   tab ("\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 character is a newline
   ("\n") or return ("\r"), it is copied and the current column is
   reset to zero.  Any other character is copied unchanged and the
   current column is incremented by one regardless of how the
   character is represented when printed. For example:

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

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

   Return the lowest index in the string where substring *sub* is
   found within the slice "s[start:end]".  Optional arguments *start*
   and *end* are interpreted as in slice notation.  Return "-1" if
   *sub* is not found. For example:

      >>> 'spam, spam, spam'.find('sp')
      0
      >>> 'spam, spam, spam'.find('sp', 5)
      6

   See also "rfind()" and "index()".

   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)

   Perform a string formatting operation.  The string on which this
   method is called can contain literal text or replacement fields
   delimited by braces "{}".  Each replacement field contains either
   the numeric index of a positional argument, or the name of a
   keyword argument.  Returns a copy of the string where each
   replacement field is replaced with the string value of the
   corresponding argument. For example:

      >>> "The sum of 1 + 2 is {0}".format(1+2)
      'The sum of 1 + 2 is 3'
      >>> "The sum of {a} + {b} is {answer}".format(answer=1+2, a=1, b=2)
      'The sum of 1 + 2 is 3'
      >>> "{1} expects the {0} Inquisition!".format("Spanish", "Nobody")
      'Nobody expects the Spanish Inquisition!'

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

   Not:

     Bir sayıyı ("int", "float", "complex", "decimal.Decimal" ve alt
     sınıfları) "n" türüyle biçimlendirirken (örn: "'{:n}'.
     format(1234)"), işlev "localeconv()" öğesinin "decimal_point" ve
     "thousands_sep" alanlarını ASCII değilse veya 1 bayttan uzunsa ve
     "LC_NUMERIC" yerel ayarı "LC_CTYPE" yerel ayarından farklıysa kod
     çözmek için "LC_CTYPE" yerel ayarını geçici olarak "LC_NUMERIC"
     yerel ayarına ayarlar.  Bu geçici değişiklik diğer iş
     parçacıklarını etkiler.

   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'

   Added in version 3.2.

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()

   Return "True" if all characters in the string are alphabetic and
   there is at least one character, "False" otherwise.  Alphabetic
   characters are those characters defined in the Unicode character
   database as "Letter", i.e., those with general category property
   being one of "Lm", "Lt", "Lu", "Ll", or "Lo".  Note that this is
   different from the Alphabetic property defined in the section 4.10
   'Letters, Alphabetic, and Ideographic' of the Unicode Standard. For
   example:

      >>> 'Letters and spaces'.isalpha()
      False
      >>> 'LettersOnly'.isalpha()
      True
      >>> 'µ'.isalpha()  # non-ASCII characters can be considered alphabetical too
      True

   See Unicode Properties.

str.isascii()

   Return "True" if the string is empty or all characters in the
   string are ASCII, "False" otherwise. ASCII characters have code
   points in the range U+0000-U+007F. For example:

      >>> 'ASCII characters'.isascii()
      True
      >>> 'µ'.isascii()
      False

   Added in version 3.7.

str.isdecimal()

   Return "True" if all characters in the string are decimal
   characters and there is at least one character, "False" otherwise.
   Decimal characters are those that can be used to form numbers in
   base 10, such as U+0660, ARABIC-INDIC DIGIT ZERO.  Formally a
   decimal character is a character in the Unicode General Category
   "Nd". For example:

      >>> '0123456789'.isdecimal()
      True
      >>> '٠١٢٣٤٥٦٧٨٩'.isdecimal()  # Arabic-Indic digits zero to nine
      True
      >>> 'alphabetic'.isdecimal()
      False

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()" can be used to test whether string "s" is a
   reserved identifier, such as "def" and "class".

   Ö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()

   Return "True" if all characters in the string are numeric
   characters, and there is at least one character, "False" otherwise.
   Numeric characters include digit characters, and all characters
   that have the Unicode numeric value property, e.g. U+2155, VULGAR
   FRACTION ONE FIFTH.  Formally, numeric characters are those with
   the property value Numeric_Type=Digit, Numeric_Type=Decimal or
   Numeric_Type=Numeric. For example:

      >>> '0123456789'.isnumeric()
      True
      >>> '٠١٢٣٤٥٦٧٨٩'.isnumeric()  # Arabic-indic digit zero to nine
      True
      >>> '⅕'.isnumeric()  # Vulgar fraction one fifth
      True
      >>> '²'.isdecimal(), '²'.isdigit(),  '²'.isnumeric()
      (False, True, True)

   See also "isdecimal()" and "isdigit()". Numeric characters are a
   superset of decimal numbers.

str.isprintable()

   Return "True" if all characters in the string are printable,
   "False" if it contains at least one non-printable character.

   Here "printable" means the character is suitable for "repr()" to
   use in its output; "non-printable" means that "repr()" on built-in
   types will hex-escape the character.  It has no bearing on the
   handling of strings written to "sys.stdout" or "sys.stderr".

   The printable characters are those which in the Unicode character
   database (see "unicodedata") have a general category in group
   Letter, Mark, Number, Punctuation, or Symbol (L, M, N, P, or S);
   plus the ASCII space 0x20. Nonprintable characters are those in
   group Separator or Other (Z or C), except the ASCII space.

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.

   For example:

      >>> 'Spam, Spam, Spam'.istitle()
      True
      >>> 'spam, spam, spam'.istitle()
      False
      >>> 'SPAM, SPAM, SPAM'.istitle()
      False

   See also "title()".

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, /)

   Return a string which is the concatenation of the strings in
   *iterable*. A "TypeError" will be raised if there are any non-
   string values in *iterable*, including "bytes" objects.  The
   separator between elements is the string providing this method. For
   example:

      >>> ', '.join(['spam', 'spam', 'spam'])
      'spam, spam, spam'
      >>> '-'.join('Python')
      'P-y-t-h-o-n'

   See also "split()".

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.

   For example:

      >>> 'Python'.ljust(10)
      'Python    '
      >>> 'Python'.ljust(10, '.')
      'Python....'
      >>> 'Monty Python'.ljust(10, '.')
      'Monty Python'

   See also "rjust()".

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.

   The lowercasing algorithm used is described in section 3.13
   'Default Case Folding' of the Unicode Standard.

str.lstrip(chars=None, /)

   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(dict, /)
static str.maketrans(from, to, remove='', /)

   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.

   If there are two arguments, they must be strings of equal length,
   and in the resulting dictionary, each character in *from* will be
   mapped to the character at the same position in *to*.  If there is
   a third argument, it must be a string, whose characters will be
   mapped to "None" in the result.

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'

   Added in version 3.9.

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'

   Added in version 3.9.

str.replace(old, new, /, count=-1)

   Return a copy of the string with all occurrences of substring *old*
   replaced by *new*.  If *count* is given, only the first *count*
   occurrences are replaced. If *count* is not specified or "-1", then
   all occurrences are replaced.

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

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=None, /)

   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).

   If *sep* is given, consecutive delimiters are not grouped together
   and are deemed to delimit empty strings (for example,
   "'1,,2'.split(',')" returns "['1', '', '2']").  The *sep* argument
   may consist of multiple characters as a single delimiter (to split
   with multiple delimiters, use "re.split()"). Splitting an empty
   string with a specified separator returns "['']".

   Ö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', '']
      >>> '1<>2<>3<4'.split('<>')
      ['1', '2', '3<4']

   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']

   If *sep* is not specified or is "None" and  *maxsplit* is "0", only
   leading runs of consecutive whitespace are considered.

   Örneğin:

      >>> "".split(None, 0)
      []
      >>> "   ".split(None, 0)
      []
      >>> "   foo   ".split(maxsplit=0)
      ['foo   ']

   See also "join()".

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=None, /)

   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."

   See also "istitle()".

str.translate(table, /)

   Return a copy of the string in which each character has been mapped
   through the given translation table.  The table must be an object
   that implements indexing via "__getitem__()", typically a *mapping*
   or *sequence*.  When indexed by a Unicode ordinal (an integer), the
   table object can do any of the following: return a Unicode ordinal
   or a string, to map the character to one or more other characters;
   return "None", to delete the character from the return string; or
   raise a "LookupError" exception, to map the character to itself.

   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).

   The uppercasing algorithm used is described in section 3.13
   'Default Case Folding' of the Unicode Standard.

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'


Formatted String Literals (f-strings)
-------------------------------------

Added in version 3.6.

3.7 sürümünde değişti: The "await" and "async for" can be used in
expressions within f-strings.

3.8 sürümünde değişti: Added the debugging operator ("=")

3.12 sürümünde değişti: Many restrictions on expressions within
f-strings have been removed. Notably, nested strings, comments, and
backslashes are now permitted.

An *f-string* (formally a *formatted string literal*) is a string
literal that is prefixed with "f" or "F". This type of string literal
allows embedding arbitrary Python expressions within *replacement
fields*, which are delimited by curly brackets ("{}"). These
expressions are evaluated at runtime, similarly to "str.format()", and
are converted into regular "str" objects. For example:

   >>> who = 'nobody'
   >>> nationality = 'Spanish'
   >>> f'{who.title()} expects the {nationality} Inquisition!'
   'Nobody expects the Spanish Inquisition!'

It is also possible to use a multi line f-string:

   >>> f'''This is a string
   ... on two lines'''
   'This is a string\non two lines'

A single opening curly bracket, "'{'", marks a *replacement field*
that can contain any Python expression:

   >>> nationality = 'Spanish'
   >>> f'The {nationality} Inquisition!'
   'The Spanish Inquisition!'

To include a literal "{" or "}", use a double bracket:

   >>> x = 42
   >>> f'{{x}} is {x}'
   '{x} is 42'

Functions can also be used, and format specifiers:

   >>> from math import sqrt
   >>> f'√2 \N{ALMOST EQUAL TO} {sqrt(2):.5f}'
   '√2 ≈ 1.41421'

Any non-string expression is converted using "str()", by default:

   >>> from fractions import Fraction
   >>> f'{Fraction(1, 3)}'
   '1/3'

To use an explicit conversion, use the "!" (exclamation mark)
operator, followed by any of the valid formats, which are:

+------------+----------------+
| Conversion | Anlamı         |
|============|================|
| "!a"       | "ascii()"      |
+------------+----------------+
| "!r"       | "repr()"       |
+------------+----------------+
| "!s"       | "str()"        |
+------------+----------------+

For example:

   >>> from fractions import Fraction
   >>> f'{Fraction(1, 3)!s}'
   '1/3'
   >>> f'{Fraction(1, 3)!r}'
   'Fraction(1, 3)'
   >>> question = '¿Dónde está el Presidente?'
   >>> print(f'{question!a}')
   '\xbfD\xf3nde est\xe1 el Presidente?'

While debugging it may be helpful to see both the expression and its
value, by using the equals sign ("=") after the expression. This
preserves spaces within the brackets, and can be used with a
converter. By default, the debugging operator uses the "repr()" ("!r")
conversion. For example:

   >>> from fractions import Fraction
   >>> calculation = Fraction(1, 3)
   >>> f'{calculation=}'
   'calculation=Fraction(1, 3)'
   >>> f'{calculation = }'
   'calculation = Fraction(1, 3)'
   >>> f'{calculation = !s}'
   'calculation = 1/3'

Once the output has been evaluated, it can be formatted using a format
specifier following a colon ("':'"). After the expression has been
evaluated, and possibly converted to a string, the "__format__()"
method of the result is called with the format specifier, or the empty
string if no format specifier is given. The formatted result is then
used as the final value for the replacement field. For example:

   >>> from fractions import Fraction
   >>> f'{Fraction(1, 7):.6f}'
   '0.142857'
   >>> f'{Fraction(1, 7):_^+10}'
   '___+1/7___'


"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()" function in the C language. For example:

   >>> print('%s has %d quote types.' % ('Python', 2))
   Python has 2 quote types.

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=b'')
class bytes(source, encoding, errors='strict')

   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(*, bytes_per_sep=1)
   hex(sep, bytes_per_sep=1)

      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'

      Added in version 3.5.

      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=b'')
class bytearray(source, encoding, errors='strict')

   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(*, bytes_per_sep=1)
   hex(sep, bytes_per_sep=1)

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

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

      Added in version 3.5.

      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.

   Added in version 3.9.

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.

   Added in version 3.9.

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: *errors* şimdi Python Development Mode ve
   hata ayıklama modunda kontrol edilir.

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.

   Added in version 3.1.

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=-1, /)
bytearray.replace(old, new, count=-1, /)

   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=b' ', /)
bytearray.center(width, fillbyte=b' ', /)

   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=b' ', /)
bytearray.ljust(width, fillbyte=b' ', /)

   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(bytes=None, /)
bytearray.lstrip(bytes=None, /)

   Return a copy of the sequence with specified leading bytes removed.
   The *bytes* argument is a binary sequence specifying the set of
   byte values to be removed.  If omitted or "None", the *bytes*
   argument defaults to removing ASCII whitespace.  The *bytes*
   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=b' ', /)
bytearray.rjust(width, fillbyte=b' ', /)

   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(bytes=None, /)
bytearray.rstrip(bytes=None, /)

   Return a copy of the sequence with specified trailing bytes
   removed.  The *bytes* argument is a binary sequence specifying the
   set of byte values to be removed.  If omitted or "None", the
   *bytes* argument defaults to removing ASCII whitespace.  The
   *bytes* 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 as a single delimiter.
   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'']
      >>> b'1<>2<>3<4'.split(b'<>')
      [b'1', b'2', b'3<4']

   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(bytes=None, /)
bytearray.strip(bytes=None, /)

   Return a copy of the sequence with specified leading and trailing
   bytes removed. The *bytes* argument is a binary sequence specifying
   the set of byte values to be removed.  If omitted or "None", the
   *bytes* argument defaults to removing ASCII whitespace. The *bytes*
   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.

   Added in version 3.7.

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

Added in version 3.5.


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", which is the nested
   list representation of the view. If "view.ndim = 1", this is equal
   to the number of elements in the view.

   3.12 sürümünde değişti: If "view.ndim == 0", "len(view)" now raises
   "TypeError" instead of returning 1.

   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='C')

      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.

      Added in version 3.8: *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(*, bytes_per_sep=1)
   hex(sep, bytes_per_sep=1)

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

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

      Added in version 3.5.

      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()
         [97, 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]

      Added in version 3.8.

   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

      Added in version 3.2.

   cast(format, /)
   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. Note that all byte lengths may
      depend on the operating system.

      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):
           ...
         TypeError: memoryview: invalid type 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]]

      Added in version 3.3.

      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

      Added in version 3.3.

   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

      Added in version 3.3.

   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.

      Added in version 3.3.

   f_contiguous

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

      Added in version 3.3.

   contiguous

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

      Added in version 3.3.


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.

frozenset.isdisjoint(other, /)
set.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.

frozenset.issubset(other, /)
set.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.

frozenset.issuperset(other, /)
set.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.

frozenset.union(*others)
set.union(*others)

set | other | ...

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

frozenset.intersection(*others)
set.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.

frozenset.difference(*others)
set.difference(*others)

set - other - ...

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

frozenset.symmetric_difference(other, /)
set.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.

frozenset.copy()
set.copy()

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

Note, the non-operator versions of "union()", "intersection()",
"difference()", "symmetric_difference()", "issubset()", and
"issuperset()" methods will accept any iterable as an argument.  In
contrast, their operator based counterparts require their arguments to
be sets.  This precludes error-prone constructions like "set('abc') &
'cbs'" in favor of the more readable "set('abc').intersection('cbs')".

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:

set.update(*others)

set |= other | ...

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

set.intersection_update(*others)

set &= other & ...

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

set.difference_update(*others)

set -= other | ...

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

set.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.

set.add(elem, /)

   Kümeye *elem* öğesini ekleyin.

set.remove(elem, /)

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

set.discard(elem, /)

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

set.pop()

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

set.clear()

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

Note, the non-operator versions of the "update()",
"intersection_update()", "difference_update()", and
"symmetric_difference_update()" methods will accept any iterable as an
argument.

Note, the *elem* argument to the "__contains__()", "remove()", and
"discard()" methods may be a set.  To support searching for an
equivalent frozenset, a temporary one is created from *elem*.


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).

Bir sözlüğün anahtarları *neredeyse* rastgele değerlerdir. *hashable*
olmayan değerler, yani listeler, sözlükler veya diğer değişken türleri
içeren değerler (nesne kimliği yerine değere göre karşılaştırılan)
anahtar olarak kullanılamaz. Eşit karşılaştırılan değerler ("1", "1.0"
ve "True" gibi) aynı sözlük girdisini indekslemek için birbirinin
yerine kullanılabilir.

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 defines a "keys()" method,
   a dictionary is created by calling "__getitem__()" on the argument
   with each returned key from the method.  Otherwise, the positional
   argument must be an *iterable* object.  Each item in the iterable
   must itself be an iterable with exactly two elements.  The first
   element of each item becomes a key in the new dictionary, and the
   second element 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.

   Dictionaries compare equal if and only if they have the same "(key,
   value)" pairs (regardless of ordering). Order comparisons ('<',
   '<=', '>=', '>') raise "TypeError".  To illustrate dictionary
   creation and equality, 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.

   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.

   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=None, /)

      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=None, /)

      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, /)
   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())".

      Added in version 3.8.

   setdefault(key, default=None, /)

      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(**kwargs)
   update(mapping, /, **kwargs)
   update(iterable, /, **kwargs)

      Update the dictionary with the key/value pairs from *mapping* or
      *iterable* and *kwargs*, overwriting existing keys.  Return
      "None".

      "update()" accepts either another object with a "keys()" method
      (in which case "__getitem__()" is called with every key returned
      from the method) 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.

      Added in version 3.9.

   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.

      Added in version 3.9.

   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.

   Added in version 3.10.

Keys views are set-like since their entries are unique and *hashable*.
Items views also have set-like operations since the (key, value) pairs
are unique and the keys are hashable. If all values in an items view
are hashable as well, then the items view can interoperate with other
sets. (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 "^").  While using set
operators, set-like views accept any iterable as the other operand,
unlike sets which only accept sets as the input.

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'}
   True
   >>> keys | ['juice', 'juice', 'juice'] == {'bacon', 'spam', 'juice'}
   True

   >>> # 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.

   If this method raises an exception while handling an earlier
   exception from the "with" block, the new exception is raised, and
   the original exception is stored in its "__context__" attribute.

   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__()".

Bir "GenericAlias" nesnesi, *generic type* için bir vekil olarak
hareket eder ve *parameterized generics* uygular.

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" nesneleri, doğrudan "GenericAlias" nesneleri oluşturmak
için de kullanılabilen "types.GenericAlias" sınıfının örnekleridir.

T[X, Y, ...]

   Kullanılan "T" türüne bağlı olarak *X*, *Y* ve daha fazla tür
   tarafından parametrelenen bir "T" türünü temsil eden bir
   "GenericAlias" oluşturur. Örneğin, "float" elemanları içeren bir
   "list" bekleyen bir fonksiyon:

      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

Python çalışma zamanı *tip anotasyonları* 'nı zorlamaz. Bu, genel
türleri ve bunların tür parametrelerini de kapsar. Bir "GenericAlias"
türünden bir konteyner nesnesi oluştururken, konteynerdeki elemanlar
türlerine göre kontrol edilmez. Örneğin, aşağıdaki kod tavsiye
edilmez, ancak hatasız çalışacaktır:

   >>> 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]'

Genel kapsayıcıların "__getitem__()" metodu, "dict[str][str]" gibi
hatalara izin vermemek için bir istisna oluşturacaktır:

   >>> dict[str][str]
   Traceback (most recent call last):
     ...
   TypeError: dict[str] is not a generic class

Ancak, bu tür ifadeler type variables kullanıldığında geçerlidir.
Dizin, "GenericAlias" nesnesinin "__args__" öğesindeki tür değişkeni
öğeleri kadar öğeye sahip olmalıdır:

   >>> from typing import TypeVar
   >>> Y = TypeVar('Y')
   >>> dict[str, Y][int]
   dict[str, int]


Standart Jenerik Sınıflar
~~~~~~~~~~~~~~~~~~~~~~~~~

Bu standart kütüphane sınıfları parametrelendirilmiş jenerikleri
destekler. Bu liste kapsamlı değildir.

* "tuple"

* "list"

* "dict"

* "set"

* "frozenset"

* "type"

* "asyncio.Future"

* "asyncio.Task"

* "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"

* "tuple"

* re.Pattern

* re.Match

* "shelve.BsdDbShelf"

* "shelve.DbfilenameShelf"

* "shelve.Shelf"

* "types.MappingProxyType"

* "weakref.WeakKeyDictionary"

* "weakref.WeakMethod"

* "weakref.WeakSet"

* "weakref.WeakValueDictionary"


"GenericAlias" objesinin Özel Öznitelikleri
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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__

   Bu öznitelik, jenerik sınıfın orijinal "__class_getitem__()"
   öğesine iletilen jenerik tiplerinden bir "tuple" 'dır (muhtemelen 1
   uzunluğunda):

      >>> 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.

genericalias.__unpacked__

   A boolean that is true if the alias has been unpacked using the "*"
   operator (see "TypeVarTuple").

   Added in version 3.11.

Ayrıca bakınız:

  **PEP 484** - Type Hints
     Introducing Python's framework for type annotations.

  **PEP 585** - Standart Koleksiyonlarda Tip İma Etme (Type Hinting)
  Jenerikleri
     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.

Added in version 3.9.


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

   Not:

     The "|" operand cannot be used at runtime to define unions where
     one or more members is a forward reference. For example, "int |
     "Foo"", where ""Foo"" is a reference to a class not yet defined,
     will fail at runtime. For unions which include forward
     references, present the whole expression as a string, e.g. ""int
     | Foo"".

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

   However, parameterized generics in union objects cannot be checked:

      >>> isinstance(1, int | list[int])  # short-circuit evaluation
      True
      >>> isinstance([1], int | list[int])
      Traceback (most recent call last):
        ...
      TypeError: isinstance() argument 2 cannot be 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:

  The "__or__()" method for type objects was added to support the
  syntax "X | Y".  If a metaclass implements "__or__()", the Union may
  override it:

     >>> class M(type):
     ...     def __or__(self, other):
     ...         return "Hello"
     ...
     >>> class C(metaclass=M):
     ...     pass
     ...
     >>> C | int
     'Hello'
     >>> int | C
     int | C

Ayrıca bakınız:

  **PEP 604** -- "X | Y" sözdizimini ve Birlik türünü öneren PEP.

Added in version 3.10.


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
---------

Methods are functions that are called using the attribute notation.
There are two flavors: built-in methods (such as "append()" on lists)
and class instance method. Built-in methods are described with the
types that support them.

If you access a method (a function defined in a class namespace)
through an instance, you get a special object: a *bound method* (also
called instance method) object. When called, it will add the "self"
argument to the argument list.  Bound methods have two special read-
only attributes: "m.__self__" is the object on which the method
operates, and "m.__func__" is the function implementing the method.
Calling "m(arg-1, arg-2, ..., arg-n)" is completely equivalent to
calling "m.__func__(m.__self__, arg-1, arg-2, ..., arg-n)".

Like function objects, bound method objects support getting arbitrary
attributes.  However, since method attributes are actually stored on
the underlying function object ("method.__func__"), setting method
attributes on bound methods is disallowed.  Attempting to set an
attribute on a method results in an "AttributeError" being raised.  In
order to set a method attribute, you need to explicitly set it on the
underlying function object:

   >>> 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'

See Instance methods for more information.


Kod Nesneleri
-------------

Code objects are used by the implementation to represent "pseudo-
compiled" executable Python code such as a function body. They differ
from function objects because they don't contain a reference to their
global execution environment.  Code objects are returned by the built-
in "compile()" function and can be extracted from function objects
through their "__code__" attribute. See also the "code" module.

Accessing "__code__" raises an auditing event "object.__getattr__"
with arguments "obj" and ""__code__"".

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
----------------

This object is commonly used to indicate that something is omitted. It
supports no special operations.  There is exactly one ellipsis object,
named "Ellipsis" (a built-in name).  "type(Ellipsis)()" produces the
"Ellipsis" singleton.

"Ellipsis" veya "..." olarak yazılmıştır.

In typical use, "..." as the "Ellipsis" object appears in a few
different places, for instance:

* In type annotations, such as callable arguments or tuple elements.

* As the body of a function instead of a pass statement.

* In third-party libraries, such as Numpy's slicing and striding.

Python also uses three dots in ways that are not "Ellipsis" objects,
for instance:

* Doctest's "ELLIPSIS", as a pattern for missing content.

* The default Python prompt of the *interactive* shell when partial
  input is incomplete.

Lastly, the Python documentation often uses three dots in conventional
English usage to mean omitted content, even in code examples that also
use them as the "Ellipsis".


NotImplemented Nesnesi
----------------------

This object is returned from comparisons and binary operations when
they are asked to operate on types they don't support. See Comparisons
for more information.  There is exactly one "NotImplemented" object.
"type(NotImplemented)()" produces the singleton instance.

It is written as "NotImplemented".


İç Nesneler
-----------

See The standard type hierarchy for this information.  It describes
stack frame objects, traceback objects, and slice objects.


Ö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.

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*.

   Added in version 3.3.

definition.__module__

   The name of the module in which a class or function was defined.

definition.__doc__

   The documentation string of a class or function, or "None" if
   undefined.

definition.__type_params__

   The type parameters of generic classes, functions, and type
   aliases. For classes and functions that are not generic, this will
   be an empty tuple.

   Added in version 3.12.


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 digits) 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 digits) for integer string conversion; 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".

Doğrulama

   >>> 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')
   ...

Added in version 3.11.


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).

Added in version 3.11.

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.12.

Örnek:

   >>> 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.
