Gömülü Fonksiyonlar
*******************

Python yorumlayıcısı, içinde gömülü olarak gelen ve her zaman
kullanılabilen bir dizi fonksiyon ve tür barındırır. Burada alfabetik
sıraya göre listelenmiştir.

+---------------------------+-------------------------+-------------------------+---------------------------+
| Gömülü Fonksiyonlar                                                                                       |
|===========================|=========================|=========================|===========================|
| **A** "abs()" "aiter()"   | **E** "enumerate()"     | **L** "len()" "list()"  | **R** "range()" "repr()"  |
| "all()" "anext()" "any()" | "eval()" "exec()"       | "locals()"  **M**       | "reversed()" "round()"    |
| "ascii()"  **B** "bin()"  | **F** "filter()"        | "map()" "max()"         | **S** "set()" "setattr()" |
| "bool()" "breakpoint()"   | "float()" "format()"    | "memoryview()" "min()"  | "slice()" "sorted()"      |
| "bytearray()" "bytes()"   | "frozenset()"  **G**    | **N** "next()"  **O**   | "staticmethod()" "str()"  |
| **C** "callable()"        | "getattr()" "globals()" | "object()" "oct()"      | "sum()" "super()"  **T**  |
| "chr()" "classmethod()"   | **H** "hasattr()"       | "open()" "ord()"  **P** | "tuple()" "type()"  **V** |
| "compile()" "complex()"   | "hash()" "help()"       | "pow()" "print()"       | "vars()"  **Z** "zip()"   |
| **D** "delattr()"         | "hex()"  **I** "id()"   | "property()"            | **_** "__import__()"      |
| "dict()" "dir()"          | "input()" "int()"       |                         |                           |
| "divmod()"                | "isinstance()"          |                         |                           |
|                           | "issubclass()" "iter()" |                         |                           |
+---------------------------+-------------------------+-------------------------+---------------------------+

abs(x)

   Return the absolute value of a number.  The argument may be an
   integer, a floating-point number, or an object implementing
   "__abs__()". If the argument is a complex number, its magnitude is
   returned.

aiter(async_iterable)

   Bir *asynchronous iterable* için bir *asynchronous iterator*
   döndürür. "x.__aiter__()" çağrısına eş değerdir.

   Not: "iter()" 'in aksine, "aiter()" 'in 2 argümanlı biçimi yoktur.

   Added in version 3.10.

all(iterable)

   Eğer *iterable* 'ın tüm elementleri doğruysa, "True" döndürür.
   Şuna eş değerdir:

      def all(iterable):
          for element in iterable:
              if not element:
                  return False
          return True

awaitable anext(async_iterator)
awaitable anext(async_iterator, default)

   Hazır olunduğunda, verilen *asynchronous iterator* 'dan sıradaki
   parçayı döndürür. Eğer yineleyici tükendiyse ve *default* değer
   verildiyse, *default* değeri döndürür.

   Bu, gömülü fonksiyonlardan olan "next()" 'in asenkron bir
   varyantıdır, benzer şekilde çalışır.

   Bu *async_iterator* 'ın "__anext__()" metodunu çağırır. Bir
   *awaitable* döndürür. Bunu beklemek yineleyicinin bir sonraki
   değerini döndürür. Eğer *default* değer verildiyse, yineleyici
   tükendiğinde o döndürülür. Aksi takdirde "StopAsyncIteration"
   hatası ortaya çıkar.

   Added in version 3.10.

any(iterable)

   Eğer *iterable* 'ın elementlerinden herhangi biri doğru ise "True"
   döndürür. Eğer *iterable* boş ise, "False" döndürür. Şuna eşittir:

      def any(iterable):
          for element in iterable:
              if element:
                  return True
          return False

ascii(object)

   "repr()" 'in bir nesnenin yazdırılabilir temsilini içeren bir dize
   döndürdüğü, ancak "repr()" tarafından döndürülen dizedeki ASCII
   olmayan karakterlerden "\x", "\u" veya "\U" gibi kaçış
   karakterlerini kullanarak kaçtığı gibi, bu da Python 2'deki
   "repr()" tarafından döndürülen değere benzeyen bir string üretir.

bin(x)

   Convert an integer number to a binary string prefixed with "0b".
   The result is a valid Python expression. If *x* is not a Python
   "int" object, it has to define an "__index__()" method that returns
   an integer. Some examples:

   >>> bin(3)
   '0b11'
   >>> bin(-10)
   '-0b1010'

   Eğer ön ek olarak "0b" isteniyorsa veya istenmiyorsa, aşağıdaki
   gibi iki şekilde de kullanabilirsiniz.

   >>> format(14, '#b'), format(14, 'b')
   ('0b1110', '1110')
   >>> f'{14:#b}', f'{14:b}'
   ('0b1110', '1110')

   Ayrıca daha fazla bilgi için "format()" 'a bakabilirsiniz.

class bool(object=False, /)

   Return a Boolean value, i.e. one of "True" or "False".  The
   argument is converted using the standard truth testing procedure.
   If the argument is false or omitted, this returns "False";
   otherwise, it returns "True".  The "bool" class is a subclass of
   "int" (see Sayısal Türler --- int, float, complex). It cannot be
   subclassed further.  Its only instances are "False" and "True" (see
   Boolean Type - bool).

   3.7 sürümünde değişti: The parameter is now positional-only.

breakpoint(*args, **kws)

   This function drops you into the debugger at the call site.
   Specifically, it calls "sys.breakpointhook()", passing "args" and
   "kws" straight through.  By default, "sys.breakpointhook()" calls
   "pdb.set_trace()" expecting no arguments.  In this case, it is
   purely a convenience function so you don't have to explicitly
   import "pdb" or type as much code to enter the debugger.  However,
   "sys.breakpointhook()" can be set to some other function and
   "breakpoint()" will automatically call that, allowing you to drop
   into the debugger of choice. If "sys.breakpointhook()" is not
   accessible, this function will raise "RuntimeError".

   By default, the behavior of "breakpoint()" can be changed with the
   "PYTHONBREAKPOINT" environment variable. See "sys.breakpointhook()"
   for usage details.

   Note that this is not guaranteed if "sys.breakpointhook()" has been
   replaced.

   Raises an auditing event "builtins.breakpoint" with argument
   "breakpointhook".

   Added in version 3.7.

class bytearray(source=b'')
class bytearray(source, encoding)
class bytearray(source, encoding, errors)

   Baytlardan oluşan yeni bir dizi döndürür. "bytearray" sınıfı 0 <= x
   < 256 aralığındaki tam sayılardan oluşan değişebilir bir dizedir.
   Değiştirilebilir Dizi Tipleri 'da tarif edildiği gibi değişebilir
   dizeler klasik metotlarının çoğuna sahiptir. "bytes" tipinin sahip
   olduğu metotlar için, Bytes and Bytearray Operations 'a bakınız.

   Opsiyonel *source* parametresi diziyi birkaç farklı şekilde
   başlatmak için kullanılabilir:

   * Eğer bir *string* ise, *encoding* (ve istenirse, *errors*)
     parametrelerini de vermelisiniz; sonrasında "bytearray()"
     "str.encode()" kullanarak dizeyi bayta çevirecektir.

   * Eğer bir *integer* ise, dizi bu boyuta göre null baytlar ile
     doldurulur.

   * Eğer arabellek arayüzü 'ne uyan bir objeyse, bayt dizisini
     başlatmak için bir salt okunur arabellek kullanılır.

   * Eğer *iterable* ise, 0 <= x < 256 aralığındaki dizinin başlangıç
     içeriği olan tam sayılardan oluşan bir yinelenebilir nesne
     olmalıdır.

   Argüman yoksa, boyutu 0 olan bir dizi oluşturulur.

   Binary Sequence Types --- bytes, bytearray, memoryview ve Bytearray
   Objects 'a bakınız.

class bytes(source=b'')
class bytes(source, encoding)
class bytes(source, encoding, errors)

   "0 <= x < 256" aralığındaki tam sayılardan oluşan değiştirilemez
   bir "bayt" objesi döndürür. "bytes", "bytearray" 'in değiştirilemez
   versiyonudur. Aynı objeyi değiştirmeyen metotlara, indeksleme ve
   dilimleme davranışına sahiptir.

   Buna göre, yapıcı argümanları "bytearray()" için yorumlanır.

   Bayt nesneleri değişmez değerler ile de oluşturulabilir, String and
   Bytes literals 'a bakınız.

   Ayrıca Binary Sequence Types --- bytes, bytearray, memoryview,
   Bytes Objects, ve Bytes and Bytearray Operations 'a bakınız.

callable(object)

   Return "True" if the *object* argument appears callable, "False" if
   not.  If this returns "True", it is still possible that a call
   fails, but if it is "False", calling *object* will never succeed.
   Note that classes are callable (calling a class returns a new
   instance); instances are callable if their class has a "__call__()"
   method.

   Added in version 3.2: Bu fonksiyon Python 3.0 versiyonunda
   kaldırılmıştı ama Python 3.2 versiyonunda geri getirildi.

chr(i)

   Unicode kod noktası *i* tamsayısı olan bir karakteri temsil eden
   dizeyi döndürür. Örneğin, "chr(97)" , "'a'" dizesini döndürürken,
   "chr(8364)" , "'€'" dizesini döndürür. Bu fonksiyon, "ord()" 'un
   tam tersidir.

   Argüman için geçerli değer 0 ile 1.114.111 arasındadır (16'lık sayı
   sisteminde 0x10FFFF). Eğer *i* aralığın dışında ise "ValueError"
   hatası ortaya çıkar.

@classmethod

   Bir metodu sınıf metoduna dönüştürür.

   Bir sınıf metodu, sınıfı örtük ilk argüman olarak alır, aynı
   sınıftan türeyen bir örneğin metodunun örneği aldığı gibi. Bir
   sınıf metodunu bu şekilde tanımlayabilirsiniz:

      class C:
          @classmethod
          def f(cls, arg1, arg2): ...

   "@classmethod" formu, bir *decorator* fonksiyonudur. -- detaylar
   için Function definitions 'a bakınız.

   Bir sınıf metodu sınıf ("C.f()" gibi) veya örnek ("C().f()" gibi)
   üzerinden çağırılabilir. Örnek, sınıfı dışında yoksayılır. Eğer bir
   sınıf metodu türetilmiş bir sınıf için çağrılırsa, türetilmiş sınıf
   nesnesi örtük ilk argüman olarak geçer.

   Sınıf metotları C++ ve Java static metotlarından farklıdır. Eğer
   bunları kullanmak isterseniz, bu bölümdeki "staticmethod()" kısmına
   bakınız. Sınıf metotları hakkında daha fazla bilgi için, The
   standard type hierarchy 'a bakınız.

   3.9 sürümünde değişti: Sınıf metotları artık "property()" gibi
   diğer *descriptors* 'ları sarmalayabilir.

   3.10 sürümünde değişti: Sınıf metotları artık ("__module__",
   "__name__", "__qualname__", "__doc__" and "__annotations__") metot
   özelliklerini miras alır ve yeni bir "__wrapped__" özelliğine
   sahiplerdir.

   Deprecated since version 3.11, removed in version 3.13: Sınıf
   metotları artık "property()" gibi diğer *descriptor* 'ları
   sarmalayamaz.

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

   *source* 'ı bir koda veya AST nesnesine derler. Kod nesneleri
   "exec()" veya "eval()" fonksiyonları kullanılarak çalıştırılabilir.
   *source* normal bir dize, bayt dizesi veya bir AST nesnesi
   olabilir. AST nesneleriyle nasıl çalışılacağını öğrenmek için "ast"
   modülüne bkz.

   *filename* argümanı kodun okunduğu dosyayı vermelidir; eğer bir
   dosyadan okunmuyorsa ayırtedilebilir bir değer verebilirsin
   (genellikle "'<string>'" kullanılır).

   *mode* argümanı hangi türden kodun derleneceğini belirtir; eğer
   *source* bir dizi ifadeden oluşuyorsa "'exec'" , eğer tek bir
   ifadeden oluşuyorsa "'eval'" , veya tek bir etkileşimli ifadeden
   oluşuyorsa "'single'" olabilir (ikinci durumda, "None" dışında bir
   değere sahip ifadeler yazdırılacaktır).

   *flags* ve *dont_inherit* opsiyonel argümanları hangi derleyici
   seçenekleri 'ın aktive edilmesi gerektiğini ve hangi gelecekteki
   özellikler 'e izin verileceğini kontrol eder. İkisi de verilmediyse
   (veya ikisi de sıfır ise) kod, "compile()" 'ı çağıran kodu
   etkileyen aynı bayraklarla derlenir. Eğer *flags* argümanı verilip
   *dont_inherit* verilmediyse (veya sıfırsa), derleyici seçenekleri
   ve gelecek ifadeleri *flags* argümanı tarafından belirtilirler, her
   türlükullanılacak olanlara ek olarak kullanılır. Eğer
   *dont_inherit* sıfırdan farklı bir tamsayıysa, *flags* argümanı da
   odur. -- çevreleyen koddaki bayraklar (gelecekteki özellikler ve
   derleyici seçenekleri) yoksayılır.

   Derleyici seçenekleri ve gelecek ifadeleri, birden fazla seçeneği
   belirlemek için bit düzeyinde VEYA'lanabilen bitler tarafından
   belirlenirler. Gelecekteki belirli bir özelliği belirtmek için
   gereken bit alanı, "__future__" modülündeki "_Feature" örneğinde
   "compiler_flag" niteliği olarak bulunabilir. Derleyici bayrakları ,
   "ast" modülünde "PyCF_" öneki ile bulunabilir.

   *optimize* argümanı derleyicinin optimizasyon seviyesini belirler;
   "-1" varsayılan değeri, "-O" seçenekleri tarafından verilen
   yorumlayıcının optimizasyon seviyesini seçer. Belli seviyeler: "0"
   (optimizasyon yok; "__debug__" doğru), "1" (iddialar kaldırılır,
   "__debug__" yanlış) veya "2" (Ekstradan doküman dizeleri de
   kaldırıldı).

   Bu fonksiyon derlenmiş kaynak geçerli değil ise "SyntaxError" ,
   null baytlar içeriyorsa "ValueError" hatalarını ortaya çıkarır.

   Python kodunu onun AST temsiline ayrıştırmak isterseniz,
   "ast.parse()" 'a bakınız.

   "source" ve "filename" argümanlarıyla denetleme olayı "compile"
   ortaya çıkartır. Bu durum, örtük derleme ile de ortaya
   çıkarılabilir.

   Not:

     "'single'" veya "'eval'" modunda çok satırlı bir dize
     derleneceğinde, giren veri en az bir yeni satır karakteri ile
     sonlandırılmalıdır. Bu "code" modülündeki tamamlanmış ve
     tamamlanmamış ifadelerin tespitini kolaylaştırmak içindir.

   Uyarı:

     Python'un AST derleyicisindeki yığın derinliği sınırlamaları
     nedeniyle yeterince büyük/karmaşık bir dizeyi bir AST nesnesine
     derlerken Python yorumlayıcısını çökertmek mümkündür.

   3.2 sürümünde değişti: Windows ve Mac yeni satırlarının kullanımına
   izin verildi. Ayrıca, bundan böyle "'exec'" modunda iken veri
   girişinin yeni satırda sonlanması gerekmiyor. *optimize*
   parametresi eklendi.

   3.5 sürümünde değişti: Önceden, *source* , null baytlar içeriyorsa
   "TypeError" hatası ortaya çıkardı.

   Added in version 3.8: "ast.PyCF_ALLOW_TOP_LEVEL_AWAIT" artık üst
   düze "await", "async for", ve "async with" desteğini etkinleştirmek
   için bayraklarla iletilebilir.

class complex(number=0, /)
class complex(string, /)
class complex(real=0, imag=0)

   Convert a single string or number to a complex number, or create a
   complex number from real and imaginary parts.

   Examples:

      >>> complex('+1.23')
      (1.23+0j)
      >>> complex('-4.5j')
      -4.5j
      >>> complex('-1.23+4.5j')
      (-1.23+4.5j)
      >>> complex('\t( -1.23+4.5J )\n')
      (-1.23+4.5j)
      >>> complex('-Infinity+NaNj')
      (-inf+nanj)
      >>> complex(1.23)
      (1.23+0j)
      >>> complex(imag=-4.5)
      -4.5j
      >>> complex(-1.23, 4.5)
      (-1.23+4.5j)

   If the argument is a string, it must contain either a real part (in
   the same format as for "float()") or an imaginary part (in the same
   format but with a "'j'" or "'J'" suffix), or both real and
   imaginary parts (the sign of the imaginary part is mandatory in
   this case). The string can optionally be surrounded by whitespaces
   and the round parentheses "'('" and "')'", which are ignored. The
   string must not contain whitespace between "'+'", "'-'", the "'j'"
   or "'J'" suffix, and the decimal number. For example,
   "complex('1+2j')" is fine, but "complex('1 + 2j')" raises
   "ValueError". More precisely, the input must conform to the
   "complexvalue" production rule in the following grammar, after
   parentheses and leading and trailing whitespace characters are
   removed:

      complexvalue ::= floatvalue |
                       floatvalue ("j" | "J") |
                       floatvalue sign absfloatvalue ("j" | "J")

   If the argument is a number, the constructor serves as a numeric
   conversion like "int" and "float". For a general Python object "x",
   "complex(x)" delegates to "x.__complex__()". If "__complex__()" is
   not defined then it falls back to "__float__()". If "__float__()"
   is not defined then it falls back to "__index__()".

   If two arguments are provided or keyword arguments are used, each
   argument may be any numeric type (including complex). If both
   arguments are real numbers, return a complex number with the real
   component *real* and the imaginary component *imag*. If both
   arguments are complex numbers, return a complex number with the
   real component "real.real-imag.imag" and the imaginary component
   "real.imag+imag.real". If one of arguments is a real number, only
   its real component is used in the above expressions.

   If all arguments are omitted, returns "0j".

   Karmaşık tür,  Sayısal Türler --- int, float, complex kısmında
   açıklanmıştır.

   3.6 sürümünde değişti: Rakamların, kod sabitlerinde olduğu gibi alt
   çizgi ile gruplandırılmasına izin verilir.

   3.8 sürümünde değişti: Falls back to "__index__()" if
   "__complex__()" and "__float__()" are not defined.

delattr(object, name)

   "setattr()" fonksiyonu ile ilişkilidir . Argümanlar bir nesne ve
   bir dizedir. Dize nesnenin özelliklerinden birinin adı olmak
   zorundadır. Fonksiyon nesnenin izin vermesi koşuluyla, dizede
   belirtilen bu özelliği siler. Örnek olarak, "delattr(x, 'foobar')"
   , "del x.foobar" 'a eş değerdir. *name* bir Python tanımlayıcısı
   olmak zorunda değildir ("setattr()" bkz.).

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

   Yeni bir sözlük yaratır. "dict" nesnesi bir sözlük sınıfıdır.  Bu
   sınıf hakkındaki dokümantasyon için "dict" ve Mapping Types ---
   dict 'e bakınız.

   Diğer konteynerler için dahili "list" , "set" , "tuple" sınıfları
   ve "collections" modülüne bakınız.

dir()
dir(object)

   Argüman yoksa, mevcut yerel kapsamdaki isimleri liste olarak
   döndürür. Argüman varsa, o nesne için geçerli özelliklerin bir
   listesini döndürmeye çalışır.

   If the object has a method named "__dir__()", this method will be
   called and must return the list of attributes. This allows objects
   that implement a custom "__getattr__()" or "__getattribute__()"
   function to customize the way "dir()" reports their attributes.

   If the object does not provide "__dir__()", the function tries its
   best to gather information from the object's "__dict__" attribute,
   if defined, and from its type object.  The resulting list is not
   necessarily complete and may be inaccurate when the object has a
   custom "__getattr__()".

   Varsayılan "dir()" mekanizması, eksiksiz bilgi yerine en alakalı
   bilgiyi üretmeye çalıştığı için farklı nesne türleriyle farklı
   çalışır:

   * Eğer nesne bir modül nesnesiyse, liste modülün özelliklerinin
     isimlerini içerir.

   * Eğer nesne bir tür veya sınıf nesnesiyse, liste onun
     özelliklerini ve yinelemeli olarak tabanlarının özelliklerini
     içerir.

   * Aksi takdirde, liste nesnenin özelliklerini, sınıfının
     özelliklerini ve yinelemeli olarak sınıfının temel sınıflarının
     özelliklerini içerir.

   Sonuç listesi alfabetik olarak sıralanmıştır. Örnek olarak:

   >>> import struct
   >>> dir()   # show the names in the module namespace  
   ['__builtins__', '__name__', 'struct']
   >>> dir(struct)   # show the names in the struct module 
   ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
    '__initializing__', '__loader__', '__name__', '__package__',
    '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
    'unpack', 'unpack_from']
   >>> class Shape:
   ...     def __dir__(self):
   ...         return ['area', 'perimeter', 'location']
   ...
   >>> s = Shape()
   >>> dir(s)
   ['area', 'location', 'perimeter']

   Not:

     Çünkü "dir()", öncelikle etkileşimli bir komut isteminde kullanım
     kolaylığı sunmak amacıyla sağlanır. Titizlikle ve tutarlı bir
     isim kümesi sağlamaktansa ilginç bir isim kümesi sağlar, Detaylı
     davranışlı sürümler arasında değişikliğe uğrayabilir. Örnek
     olarak, argüman sınıf ise metasınıf özellikleri sonuç listesinde
     yer almaz.

divmod(a, b)

   Take two (non-complex) numbers as arguments and return a pair of
   numbers consisting of their quotient and remainder when using
   integer division.  With mixed operand types, the rules for binary
   arithmetic operators apply.  For integers, the result is the same
   as "(a // b, a % b)". For floating-point numbers the result is "(q,
   a % b)", where *q* is usually "math.floor(a / b)" but may be 1 less
   than that.  In any case "q * b + a % b" is very close to *a*, if "a
   % b" is non-zero it has the same sign as *b*, and "0 <= abs(a % b)
   < abs(b)".

enumerate(iterable, start=0)

   Bir numaralandırma nesnesi döndürür. *iterable* bir dize,
   *iterator* veya tekrarlamayı destekleyen başka bir nesne olmalıdır.
   Yineleyicinin by "enumerate()" tarafından döndürülen "__next__()"
   metodu bir sayıyı (varsayılan olarak 0 olan *start* 'dan) ve
   *iterable* üzerinde yinelemeden elde edilen değerleri içeren bir
   demet döndürür.

   >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
   >>> list(enumerate(seasons))
   [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
   >>> list(enumerate(seasons, start=1))
   [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

   Şuna eşittir:

      def enumerate(iterable, start=0):
          n = start
          for elem in iterable:
              yield n, elem
              n += 1

eval(source, /, globals=None, locals=None)

   Parametreler:
      * **source** ("str" | code object) -- A Python expression.

      * **globals** ("dict" | "None") -- The global namespace
        (default: "None").

      * **locals** (*mapping* | "None") -- The local namespace
        (default: "None").

   Dönüşler:
      The result of the evaluated expression.

   Raises:
      Syntax errors are reported as exceptions.

   The *expression* argument is parsed and evaluated as a Python
   expression (technically speaking, a condition list) using the
   *globals* and *locals* mappings as global and local namespace.  If
   the *globals* dictionary is present and does not contain a value
   for the key "__builtins__", a reference to the dictionary of the
   built-in module "builtins" is inserted under that key before
   *expression* is parsed.  That way you can control what builtins are
   available to the executed code by inserting your own "__builtins__"
   dictionary into *globals* before passing it to "eval()".  If the
   *locals* mapping is omitted it defaults to the *globals*
   dictionary.  If both mappings are omitted, the expression is
   executed with the *globals* and *locals* in the environment where
   "eval()" is called.  Note, *eval()* will only have access to the
   *nested scopes* (non-locals) in the enclosing environment if they
   are already referenced in the scope that is calling "eval()" (e.g.
   via a "nonlocal" statement).

   Example:

   >>> x = 1
   >>> eval('x+1')
   2

   Bu fonksiyon keyfi kod nesnelerini ("compile()" tarafından
   oluşturulanlar gibi) çalıştırmak için de kullanılabilir. Bu
   durumda, dize yerine bir kod nesnesi iletin. Eğer kod nesnesi
   *mode* argümanı olarak "'exec'" ile derlendiyse, "eval()" 'in
   döndürdüğü değer "None" olacaktır.

   İpuçları: ifadelerin dinamik yürütmeleri "exec()" fonksiyonu
   tarafından desteklenir. "globals()" ve "locals()" fonksiyonları
   sırasıyla mevcut global ve yerel sözlüğü döndürür. "eval()" veya
   "exec()" tarafından kullanım için dolaşmak yararlı olabilir.

   Eğer verilen kaynak dize ise, baştaki ve sondaki boşluklar ve
   tab'lar çıkarılır.

   Sadece kalıp içeren ifadelerle dizeleri güvenli bir şekilde
   değerlendirebilen bir fonksiyon arıyorsanız, "ast.literal_eval()"
   'a bakınız.

   Argüman olarak kod nesnesi ile bir denetleme olayı "exec" hatası
   ortaya çıkartır. Kodun derlendiği sırada çıkan hatalar da
   yükseltilir.

   3.13 sürümünde değişti: The *globals* and *locals* arguments can
   now be passed as keywords.

   3.13 sürümünde değişti: The semantics of the default *locals*
   namespace have been adjusted as described for the "locals()"
   builtin.

exec(source, /, globals=None, locals=None, *, closure=None)

   This function supports dynamic execution of Python code. *source*
   must be either a string or a code object.  If it is a string, the
   string is parsed as a suite of Python statements which is then
   executed (unless a syntax error occurs). [1] If it is a code
   object, it is simply executed.  In all cases, the code that's
   executed is expected to be valid as file input (see the section
   File input in the Reference Manual). Be aware that the "nonlocal",
   "yield",  and "return" statements may not be used outside of
   function definitions even within the context of code passed to the
   "exec()" function. The return value is "None".

   In all cases, if the optional parts are omitted, the code is
   executed in the current scope.  If only *globals* is provided, it
   must be a dictionary (and not a subclass of dictionary), which will
   be used for both the global and the local variables.  If *globals*
   and *locals* are given, they are used for the global and local
   variables, respectively.  If provided, *locals* can be any mapping
   object.  Remember that at the module level, globals and locals are
   the same dictionary.

   Not:

     When "exec" gets two separate objects as *globals* and *locals*,
     the code will be executed as if it were embedded in a class
     definition. This means functions and classes defined in the
     executed code will not be able to access variables assigned at
     the top level (as the "top level" variables are treated as class
     variables in a class definition).

   Eğer *globals* sözlüğü "__builtins__" anahtarı için bir değer
   içermiyorsa, bu anahtarın altına bir referans yerleşik modül
   "builtins" 'in sözlüğüne eklenir. Bu şekilde, kendi "__builtins__"
   sözlüğünüzü "exec()" 'e geçirmeden önce *globals* içine ekleyerek
   yürütülen kod için hangi yerleşiklerin mevcut olduğunu kontrol
   edebilirsiniz.

   *closure* argümanı, bir hücre değişkenleri demeti olan bir
   kapatmayı belirtir. Yalnızca *nesne* serbest değişkenler içeren bir
   kod nesnesi olduğunda geçerlidir. Demetin uzunluğu, kod nesnesi
   tarafından başvurulan serbest değişkenlerin sayısıyla tam olarak
   eşleşmelidir.

   Argüman olarak kod nesnesi ile bir denetleme olayı "exec" hatası
   ortaya çıkartır. Kodun derlendiği sırada çıkan hatalar da
   yükseltilir.

   Not:

     The built-in functions "globals()" and "locals()" return the
     current global and local namespace, respectively, which may be
     useful to pass around for use as the second and third argument to
     "exec()".

   Not:

     The default *locals* act as described for function "locals()"
     below. Pass an explicit *locals* dictionary if you need to see
     effects of the code on *locals* after function "exec()" returns.

   3.11 sürümünde değişti: *closure* parametresi eklendi.

   3.13 sürümünde değişti: The *globals* and *locals* arguments can
   now be passed as keywords.

   3.13 sürümünde değişti: The semantics of the default *locals*
   namespace have been adjusted as described for the "locals()"
   builtin.

filter(function, iterable)

   *fonksiyon*'un doğru olduğu *iterable* öğelerinden bir yineleyici
   oluşturun. *iterable* bir dizi, yinelemeyi destekleyen bir
   kapsayıcı veya bir yineleyici olabilir. *fonksiyon* "None" ise,
   kimlik işlevi varsayılır, yani *iterable* öğesinin yanlış olan tüm
   öğeleri kaldırılır.

   Eğer fonksiyon "None" değilse ve "(item for item in iterable if
   item)" için fonksiyon "None" ise, "filter(function, iterable)" 'ın
   bir üretici ifadesine "(item for item in iterable if
   function(item))" eşit olduğunu unutmayın.

   *fonksiyon*'un yanlış olduğu *iterable* öğelerini döndüren
   tamamlayıcı fonksiyon için "itertools.filterfalse()" konusuna
   bakın.

class float(number=0.0, /)
class float(string, /)

   Return a floating-point number constructed from a number or a
   string.

   Examples:

      >>> float('+1.23')
      1.23
      >>> float('   -12345\n')
      -12345.0
      >>> float('1e-003')
      0.001
      >>> float('+1E6')
      1000000.0
      >>> float('-Infinity')
      -inf

   If the argument is a string, it should contain a decimal number,
   optionally preceded by a sign, and optionally embedded in
   whitespace.  The optional sign may be "'+'" or "'-'"; a "'+'" sign
   has no effect on the value produced.  The argument may also be a
   string representing a NaN (not-a-number), or positive or negative
   infinity. More precisely, the input must conform to the
   "floatvalue" production rule in the following grammar, after
   leading and trailing whitespace characters are removed:

      sign          ::= "+" | "-"
      infinity      ::= "Infinity" | "inf"
      nan           ::= "nan"
      digit         ::= <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
      digitpart     ::= digit (["_"] digit)*
      number        ::= [digitpart] "." digitpart | digitpart ["."]
      exponent      ::= ("e" | "E") [sign] digitpart
      floatnumber   ::= number [exponent]
      absfloatvalue ::= floatnumber | infinity | nan
      floatvalue    ::= [sign] absfloatvalue

   Case is not significant, so, for example, "inf", "Inf", "INFINITY",
   and "iNfINity" are all acceptable spellings for positive infinity.

   Otherwise, if the argument is an integer or a floating-point
   number, a floating-point number with the same value (within
   Python's floating-point precision) is returned.  If the argument is
   outside the range of a Python float, an "OverflowError" will be
   raised.

   For a general Python object "x", "float(x)" delegates to
   "x.__float__()".  If "__float__()" is not defined then it falls
   back to "__index__()".

   Argüman verilmediyse, "0.0" döndürülür.

   Float tipi Sayısal Türler --- int, float, complex kısmında
   açıklandı.

   3.6 sürümünde değişti: Rakamların, kod sabitlerinde olduğu gibi alt
   çizgi ile gruplandırılmasına izin verilir.

   3.7 sürümünde değişti: The parameter is now positional-only.

   3.8 sürümünde değişti: Falls back to "__index__()" if "__float__()"
   is not defined.

format(value, format_spec='')

   Bir *value* 'ı, *format_spec* tarafından kontrol edildiği gibi
   "biçimlendirilmiş" bir gösterime dönüştürür. *format_spec* 'in
   yorumlanması *value* argümanının tipine göre değişkendir; ama, çoğu
   yerleşik tiplerde kullanılan Format Specification Mini-Language
   adında bir standart biçimlendirme sözdizimi var.

   Varsayılan *format_spec*, "str(value)" fonksiyonunu çağırmakla aynı
   etkiyi gösteren boş bir dizedir.

   A call to "format(value, format_spec)" is translated to
   "type(value).__format__(value, format_spec)" which bypasses the
   instance dictionary when searching for the value's "__format__()"
   method. A "TypeError" exception is raised if the method search
   reaches "object" and the *format_spec* is non-empty, or if either
   the *format_spec* or the return value are not strings.

   3.4 sürümünde değişti: *format_spec* boş bir dize değilse,
   "object().__format__(format_spec)", "TypeError" hatasını ortaya
   çıkartır.

class frozenset(iterable=set())

   Opsiyonel olarak *iterable* öğesinden alınan öğelerle yeni bir
   "frozenset" nesnesi döndürür. "frozenset" yerleşik bir sınıftır. Bu
   sınıf hakkında dokümantasyona ulaşmak için "frozenset" ve Set
   Türleri --- set, frozenset 'e bakınız.

   Diğer konteynerler için, yerleşik "set", "list", "tuple", ve "dict"
   sınıflarına, ayrıca "collections" modülüne bakabilirsiniz.

getattr(object, name)
getattr(object, name, default)

   *object* 'in parametre olarak verilmiş isimli özelliğinin değerini
   döndürür. *name* bir dize olmalıdır. Eğer dize nesnenin
   özelliklerinden birinin ismi ise, sonuç bu özelliğin değeri olur.
   Örnek olarak, "getattr(x, 'foobar')", "x.foobar" 'a eşittir. Eğer
   isimlendirilmiş özellik objede bulunmuyorsa, *default* sağlanmışsa
   döndürülür, aksi takdirde "AttributeError" hatası ortaya çıkar.
   *name* bir Python tanımlayıcısı olmak zorunda değildir ("setattr()"
   bkz).

   Not:

     özel isim yönetimi derleme zamanında gerçekleştiğinden dolayı,
     "getattr()" ile almak için özel bir niteliğin (baştaki iki alt
     çizgili nitelikler) adını manuel olarak değiştirmek gerekir.

globals()

   Geçerli modül ad alanını uygulayan sözlüğü döndürür. Fonksiyonlar
   içeren kod için, bu fonksiyon tanımlandığında ayarlanır ve
   fonksiyonun çağrıldığı yerden bağımsız olarak aynı kalır.

hasattr(object, name)

   Argümanlar bir nesne ve dizedir. Eğer dize, nesnenin
   özelliklerinden birinin ismiyse "True", değilse "False" döndürür.
   (Bu "getattr(object, name)" 'i çağırarak uygulanır ve
   "AttributeError" hatası oluşup oluşmayacağı görülür.)

hash(object)

   Nesnenin karma değerini döndürür (eğer varsa). Karma değerler tam
   sayılardır. Sözlükleri incelerken hızlı bir şekilde anahtarları
   karşılaştırmak için kullanılırlar. Karşılaştırıldığında aynı olan
   nümerik değerler aynı karma değere sahiptir (1 ve 1.0 durumunda
   olduğu gibi farklı veri tiplerinde olsalar bile).

   Not:

     For objects with custom "__hash__()" methods, note that "hash()"
     truncates the return value based on the bit width of the host
     machine.

help()
help(request)

   Yerleşik yardım sistemini çağırın. (Bu fonksiyon interaktif
   kullanıma yöneliktir.) Eğer argüman verilmediyse, interaktif yardım
   sistemi yorumlayıcı konsolunda başlar. Eğer argüman bir dize ise,
   bir modül, fonksiyon, sınıf, metot, anahtar kelime veya
   dokümantasyon konusu için dizeye bakılır ve bir yardım sayfası
   konsola bastırılır. Eğer argüman başka tipte bir nesne ise, nesne
   üzerinde bir yardım sayfası oluşturulur.

   Eğer "help()" çağrılırken bir fonksiyonun parametre listesinde eğik
   çizgi(/) bulunuyorsa, bu, eğik çizgiden önceki parametrelerin
   yalnızca konumsal olduğu anlamına gelir. Daha fazla bilgi için
   yalnızca konumsalparametrelerle ilgili SSS girişi 'ne bakınız.

   Bu fonksiyon "site" modülü tarafından yerleşik ad alanına eklenir.

   3.4 sürümünde değişti: "pydoc" ve "inspect" 'e gelen değişiklikler,
   çağrılabilir nesneler için rapor edilen damgaların artık daha
   kapsamlı ve tutarlı olduğunu ifade eder.

hex(x)

   Convert an integer number to a lowercase hexadecimal string
   prefixed with "0x". If *x* is not a Python "int" object, it has to
   define an "__index__()" method that returns an integer. Some
   examples:

   >>> hex(255)
   '0xff'
   >>> hex(-42)
   '-0x2a'

   Eğer bir tam sayıyı büyük harf-küçük harf, önekli-öneksiz bir
   onaltılık sayıya dönüştürmek istiyorsanız, aşağıdaki yolları
   kullanabilirsiniz:

   >>> '%#x' % 255, '%x' % 255, '%X' % 255
   ('0xff', 'ff', 'FF')
   >>> format(255, '#x'), format(255, 'x'), format(255, 'X')
   ('0xff', 'ff', 'FF')
   >>> f'{255:#x}', f'{255:x}', f'{255:X}'
   ('0xff', 'ff', 'FF')

   Ayrıca daha fazla bilgi için "format()" 'a bakabilirsiniz.

   Ayrıca onaltılık bir dizgiyi 16 tabanını kullanarak bir tam sayıya
   dönüştürmek için "int()" 'e bakınız.

   Not:

     Bir gerçel sayıdan onaltılık bir dize gösterimi elde etmek için
     "float.hex()" metodunu kullanın.

id(object)

   Bir nesnenin "kimlik" 'ini döndürür. Bu nesnenin ömrü boyunca eşsiz
   ve sabit olduğu garanti edilen bir tam sayıdır. Ömürleri örtüşmeyen
   iki nesne aynı "id()" değerine sahip olabilir.

   **CPython uygulama ayrıntısı:** Bu, bellekteki nesnenin adresidir.

   Raises an auditing event "builtins.id" with argument "id".

input()
input(prompt)

   Eğer *prompt* argümanı bulunuyorsa, sonunda yeni bir satır olmadan
   standart çıktıya yazılır. Ardından fonksiyon veri girişinden bir
   satır okur ve bunu bir dizeye çevirip (sondaki yeni satırı
   çıkartır) döndürür. EOF okunduğunda, "EOFError" istisnası ortaya
   çıkar. Örnek:

      >>> s = input('--> ')  
      --> Monty Python's Flying Circus
      >>> s  
      "Monty Python's Flying Circus"

   Eğer "readline" modülü yüklendiyse, "input()" ayrıntılı satır
   düzenleme ve geçmiş özellikleri sağlamak için onu kullanacaktır.

   Girişi okumadan önce, "prompt" argümanıyla birlikte bir denetleme
   olayı "builtins.input" ortaya çıkartır

   Girişi başarıyla okuduktan sonra sonuçla birlikte bir auditing
   event "builtins.input/result" denetleme olayı ortaya çıkarır.

class int(number=0, /)
class int(string, /, base=10)

   Return an integer object constructed from a number or a string, or
   return "0" if no arguments are given.

   Examples:

      >>> int(123.45)
      123
      >>> int('123')
      123
      >>> int('   -12_345\n')
      -12345
      >>> int('FACE', 16)
      64206
      >>> int('0xface', 0)
      64206
      >>> int('01110011', base=2)
      115

   If the argument defines "__int__()", "int(x)" returns
   "x.__int__()".  If the argument defines "__index__()", it returns
   "x.__index__()".  If the argument defines "__trunc__()", it returns
   "x.__trunc__()". For floating-point numbers, this truncates towards
   zero.

   If the argument is not a number or if *base* is given, then it must
   be a string, "bytes", or "bytearray" instance representing an
   integer in radix *base*.  Optionally, the string can be preceded by
   "+" or "-" (with no space in between), have leading zeros, be
   surrounded by whitespace, and have single underscores interspersed
   between digits.

   Bir taban-n tamsayı dizesi, her biri 0 ile n-1 arasında bir değeri
   temsil eden rakamlar içerir. 0--9 değerleri herhangi bir Unicode
   ondalık basamağı ile temsil edilebilir. 10-35 değerleri "a" ila "z"
   (veya "A" ila "Z") ile temsil edilebilir. Varsayılan *taban*
   10'dur. İzin verilen tabanlar 0 ve 2--36'dır. Taban-2, -8 ve -16
   dizelerinin önüne isteğe bağlı olarak "0b"/"0B", "0o"/"0O" veya
   "0x"/"0X" eklenebilir, tıpkı koddaki tamsayı değişmezlerinde olduğu
   gibi.  Taban 0 için, dize koddaki tamsayı değişmezi 'ne benzer bir
   şekilde yorumlanır, gerçek taban önek tarafından belirlenen 2, 8,
   10 veya 16'dır. Taban 0 ayrıca baştaki sıfırlara da izin vermez:
   "int('010', 0)" yasal değilken, "int('010')" ve "int('010', 8)"
   yasaldır.

   Tam sayı tipi Sayısal Türler --- int, float, complex kısmında
   açıklandı.

   3.4 sürümünde değişti: Eğer *base* bir "int" örneği değilse ve
   *base* objesi "base.__index__" metoduna sahipse, bu metot, taban
   için bir tamsayı elde etmek için çağrılır. Önceki sürümler
   "base.__index__" yerine "base.__int__" 'i kullandı.

   3.6 sürümünde değişti: Rakamların, kod sabitlerinde olduğu gibi alt
   çizgi ile gruplandırılmasına izin verilir.

   3.7 sürümünde değişti: The first parameter is now positional-only.

   3.8 sürümünde değişti: Falls back to "__index__()" if "__int__()"
   is not defined.

   3.11 sürümünde değişti: The delegation to "__trunc__()" is
   deprecated.

   3.11 sürümünde değişti: "int" string inputs and string
   representations can be limited to help avoid denial of service
   attacks. A "ValueError" is raised when the limit is exceeded while
   converting a string to an "int" or when converting an "int" into a
   string would exceed the limit. See the integer string conversion
   length limitation documentation.

isinstance(object, classinfo)

   *object* argümanı, *classinfo* argümanının bir örneğiyse veya
   (doğrudan, dolaylı veya *sanal*) alt sınıfının bir örneğiyse "True"
   döndürür. Eğer *object* verilen tipte bir nesne değilse, fonksiyon
   mutlaka "False" döndürür. *classinfo*, tür nesnelerinden oluşan bir
   demet (veya yinelemeli olarak, bu tür diğer demetler) veya birden
   çok türden bir Sendika Türü ise, ayrıca *object* bu verilen
   türlerden herhangi birinin örneği ise "True" döndürür. Eğer
   *classinfo* bir tür veya türler içeren bir tuple değilse,
   "TypeError" hatası ortaya çıkar. Eğer önceden yapılmış bir kontrol
   başarılıysa "TypeError" geçersiz bir tip için ortaya çıkmayabilir.

   3.10 sürümünde değişti: *classinfo* bir Sendika Türü olabilir.

issubclass(class, classinfo)

   Eğer *class*, *classinfo* 'nun bir alt sınıfıysa (doğrudan,
   dolaylı, veya *sanal*), "True" döndürür. Bir sınıf kendisinin alt
   sınıfı olarak dikkate alınır. *classinfo* sınıf nesnelerinden
   oluşan bir demet (veya tekrarlı diğer benzer demetler) veya Sendika
   Türü olabilir, bu durumda eğer *class*, *classinfo* 'daki
   elemanlardan herhangi birinin alt sınıfıysa "True" döndürülür.
   Diğer her durumda, "TypeError" hatası ortaya çıkar.

   3.10 sürümünde değişti: *classinfo* bir Sendika Türü olabilir.

iter(object)
iter(object, sentinel)

   Return an *iterator* object.  The first argument is interpreted
   very differently depending on the presence of the second argument.
   Without a second argument, *object* must be a collection object
   which supports the *iterable* protocol (the "__iter__()" method),
   or it must support the sequence protocol (the "__getitem__()"
   method with integer arguments starting at "0").  If it does not
   support either of those protocols, "TypeError" is raised. If the
   second argument, *sentinel*, is given, then *object* must be a
   callable object.  The iterator created in this case will call
   *object* with no arguments for each call to its "__next__()"
   method; if the value returned is equal to *sentinel*,
   "StopIteration" will be raised, otherwise the value will be
   returned.

   Ayrıca Yineleyici Türleri bkz.

   "iter()" 'in ikinci formunun kullanışlı uygulamalarından biri bir
   blok okuyucu inşaa etmektir. Örnek olarak, dosyanın sonuna
   ulaşılana kadar ikili bir veritabanı dosyasından sabit genişlikte
   bloklar okunurken:

      from functools import partial
      with open('mydata.db', 'rb') as f:
          for block in iter(partial(f.read, 64), b''):
              process_block(block)

len(s)

   Bir objenin uzunluğunu (element sayısını) döndürür. Argüman bir
   dizi (örneğin dize, bytes, demet, liste veya aralık) veya bir
   koleksiyon (örneğin sözlük, küme veya dondurulmuş küme) olabilir.

   **CPython uygulama ayrıntısı:** "len", "range(2 ** 100)" gibi
   "sys.maxsize" 'dan daha geniş uzunluklar için "OverflowError"
   hatası ortaya çıkartır.

class list
class list(iterable)

   Bir fonksiyon görevi görmektense, Listeler ve Dizi Tipleri ---
   list, tuple, range de anlatıldığı gibi "list" bir değiştirebilir
   dizi çeşididir.

locals()

      Return a mapping object representing the current local symbol
      table, with variable names as the keys, and their currently
      bound references as the values.

      At module scope, as well as when using "exec()" or "eval()" with
      a single namespace, this function returns the same namespace as
      "globals()".

      At class scope, it returns the namespace that will be passed to
      the metaclass constructor.

      When using "exec()" or "eval()" with separate local and global
      arguments, it returns the local namespace passed in to the
      function call.

      In all of the above cases, each call to "locals()" in a given
      frame of execution will return the *same* mapping object.
      Changes made through the mapping object returned from "locals()"
      will be visible as assigned, reassigned, or deleted local
      variables, and assigning, reassigning, or deleting local
      variables will immediately affect the contents of the returned
      mapping object.

      In an *optimized scope* (including functions, generators, and
      coroutines), each call to "locals()" instead returns a fresh
      dictionary containing the current bindings of the function's
      local variables and any nonlocal cell references. In this case,
      name binding changes made via the returned dict are *not*
      written back to the corresponding local variables or nonlocal
      cell references, and assigning, reassigning, or deleting local
      variables and nonlocal cell references does *not* affect the
      contents of previously returned dictionaries.

      Calling "locals()" as part of a comprehension in a function,
      generator, or coroutine is equivalent to calling it in the
      containing scope, except that the comprehension's initialised
      iteration variables will be included. In other scopes, it
      behaves as if the comprehension were running as a nested
      function.

      Calling "locals()" as part of a generator expression is
      equivalent to calling it in a nested generator function.

   3.12 sürümünde değişti: The behaviour of "locals()" in a
   comprehension has been updated as described in **PEP 709**.

   3.13 sürümünde değişti: As part of **PEP 667**, the semantics of
   mutating the mapping objects returned from this function are now
   defined. The behavior in *optimized scopes* is now as described
   above. Aside from being defined, the behaviour in other scopes
   remains unchanged from previous versions.

map(function, iterable, *iterables)

   *iterable* 'in her elementini *function* 'a gönderen bir yineleyici
   döndürür ve sonuçları sunar. Eğer ek *iterables* parametreleri
   verildiyse, *function* o sayıda parametre almalı ve paralel bir
   şekilde tüm yinelenebilir nesnelerden tüm elementleri
   uygulamalıdır. Birden fazla yinelenebilir nesne ile, yineleyici en
   kısa yinelenebilir nesne tükendiğinde durur. Fonksiyon girdilerinin
   zaten demetler halinde verildiği durumlar için,
   "itertools.starmap()"'a bakın.

max(iterable, *, key=None)
max(iterable, *, default, key=None)
max(arg1, arg2, *args, key=None)

   Bir yineleyicinin veya birden fazla parametrenin en büyük
   elementini döndürür.

   Eğer bir konumsal parametre sağlandıysa, o bir  *iterable*
   olmalıdır. Yineleyicinin en büyük elementi döndürülür. Eğer iki
   veya daha fazla pozisyonel parametre sağlandıysa, pozisyonel
   parametrelerin en büyüğü döndürülür.

   İki tane opsiyonel anahtar kelime parametresi vardır. *key*
   parametresi, "list.sort()" için kullanıldığı gibi bir parametre
   talep etme fonksiyonunu belirtir. *varsayılan* parametre, sağlanan
   yineleyici boş ise döndürülecek nesneyi belirtir. Eğer yineleyici
   boş ve *varsayılan* verilmemiş ise, "ValueError" hatası ortaya
   çıkar.

   Eğer birden fazla element en büyük ise, fonksiyon ilk rastlananı
   döndürür. bu "sorted(iterable, key=keyfunc, reverse=True)[0]" ve
   "heapq.nlargest(1, iterable, key=keyfunc)" gibi sıralama
   kararlılığı muhafaza eden araçlar ile uygundur.

   3.4 sürümünde değişti: Added the *default* keyword-only parameter.

   3.8 sürümünde değişti: *key* "None" olabilir.

class memoryview(object)

   Verilen argümandan oluşturulan bir "memory view" objesi döndürür.
   Daha fazla bilgi için Memory Views bkz.

min(iterable, *, key=None)
min(iterable, *, default, key=None)
min(arg1, arg2, *args, key=None)

   Bir yineleyicideki en küçük elementi veya birden fazla argümandan
   en küçüğünü döndürür.

   Eğer bir argüman sağlandıysa, argüman bir *iterable* olmalıdır.
   Yineleyicinin en küçük elementi döndürülür. Eğer birden fazla
   argüman sağlandıysa, argümanların en küçüğü döndürülür.

   İki tane opsiyonel anahtar kelime parametresi vardır. *key*
   parametresi, "list.sort()" için kullanıldığı gibi bir parametre
   talep etme fonksiyonunu belirtir. *varsayılan* parametre, sağlanan
   yineleyici boş ise döndürülecek nesneyi belirtir. Eğer yineleyici
   boş ve *varsayılan* verilmemiş ise, "ValueError" hatası ortaya
   çıkar.

   Eğer birden fazla element minimum ise, ilk karşılaşılan döndürülür.
   Bu, "sorted(iterable, key=keyfunc)[0]" ve "heapq.nsmallest(1,
   iterable, key=keyfunc)" gibi diğer sıralama kararlılığını koruma
   araçlarıyla tutarlı çalışır.

   3.4 sürümünde değişti: Added the *default* keyword-only parameter.

   3.8 sürümünde değişti: *key* "None" olabilir.

next(iterator)
next(iterator, default)

   *iterator* 'ın "__next__()" metodunu çağırarak sıradaki elementi
   getirir. Eğer *default* verildiyse ve yineleyici tükenmiş ise
   *default* döndürülür, aksi takdirde "StopIteration" hatası ortaya
   çıkar.

class object

   Yeni bir niteliksiz nesne döndürür. "object" tüm sınıflar için
   temeldir. Tüm Python sınıflarında bulunan genel metotları içerir.
   Bu fonksiyon hiçbir argüman kabul etmez.

   Not:

     "object", "__dict__" özelliğine sahip *değildir*, yani bir
     "object" örneğine keyfi özellikler atayamazsınız.

oct(x)

   Convert an integer number to an octal string prefixed with "0o".
   The result is a valid Python expression. If *x* is not a Python
   "int" object, it has to define an "__index__()" method that returns
   an integer. For example:

   >>> oct(8)
   '0o10'
   >>> oct(-56)
   '-0o70'

   Eğer bir tamsayıyı "0o" ön ekiyle veya ön eksiz oktal bir dizeye
   dönüştürmek istiyorsanız, aşağıdaki yolları kullanabilirsiniz.

   >>> '%#o' % 10, '%o' % 10
   ('0o12', '12')
   >>> format(10, '#o'), format(10, 'o')
   ('0o12', '12')
   >>> f'{10:#o}', f'{10:o}'
   ('0o12', '12')

   Ayrıca daha fazla bilgi için "format()" 'a bakabilirsiniz.

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

   *file* 'ı açar ve buna karşılık gelen *file object* 'i döndürür.
   Eğer dosya açılamazsa, "OSError" hatası ortaya çıkar. Bu
   fonksiyonun nasıl kullanıldığına dair daha fazla örnek için
   Dosyaları Okuma ve Yazma bkz.

   *file*, açılan dosyanın açılması veya dosyanın bir tam sayı dosya
   tanımlayıcısının paketlenmesi için bir yol adını (mutlak veya
   geçerli çalışma dizinine göre) veren *path-like object* 'dir. (Eğer
   bir dosya açıklayıcısı veirldiyse, *closefd*, "False" 'a
   ayarlanmadığı sürece I/O nesnesi kapatıldığında kapatılır.

   *mode* is an optional string that specifies the mode in which the
   file is opened.  It defaults to "'r'" which means open for reading
   in text mode. Other common values are "'w'" for writing (truncating
   the file if it already exists), "'x'" for exclusive creation, and
   "'a'" for appending (which on *some* Unix systems, means that *all*
   writes append to the end of the file regardless of the current seek
   position).  In text mode, if *encoding* is not specified the
   encoding used is platform-dependent: "locale.getencoding()" is
   called to get the current locale encoding. (For reading and writing
   raw bytes use binary mode and leave *encoding* unspecified.)  The
   available modes are:

   +-----------+-----------------------------------------------------------------+
   | Karakter  | Anlam                                                           |
   |===========|=================================================================|
   | "'r'"     | okumaya açık (varsayılan)                                       |
   +-----------+-----------------------------------------------------------------+
   | "'w'"     | yazmaya açık, önce dosyayı keser                                |
   +-----------+-----------------------------------------------------------------+
   | "'x'"     | ayrıcalıklı oluşturma için açık, dosya varsa hata verir         |
   +-----------+-----------------------------------------------------------------+
   | "'a'"     | yazmaya açık, eğer dosya bulunuyorsa dosyaya ekleme yapar       |
   +-----------+-----------------------------------------------------------------+
   | "'b'"     | ikili mod                                                       |
   +-----------+-----------------------------------------------------------------+
   | "'t'"     | metin modu (varsayılan)                                         |
   +-----------+-----------------------------------------------------------------+
   | "'+'"     | güncellemeye açık (okuma ve yazma)                              |
   +-----------+-----------------------------------------------------------------+

   Varsayılan mod "'r'" (okumaya açık, "'rt'" 'nin eşanlamlısı.) 'dir.
   "'w+'" ve "'w+b'" modları dosyayı açar ve temizlerler. "'r+'" ve
   "'r+b'" modları dosyayı temizlemeden açarlar.

   Overview 'de bahsedildiği gibi, Python ikili ve metin I/O arasında
   ayrım yapar. İkili modda (*mode* parametresinde "'b'" 'yi içererek)
   açılan dosyalar, içerikleri "bytes" nesneleri halinde deşifre
   etmeden döndürür. Metin modunda (varsayılan, veya *mode*
   parametresinde "'t'" içerildiğinde), dosyanın içeriği "str" olarak
   döndürülür, baytlar platforma bağlı bir kodlayıcı veya belirtilen
   *encoding* 'i kullanarak deşifre edilir.

   Not:

     Python, temel alınan işletim sisteminin metin dosyaları kavramına
     bağlı değildir. Tüm işlemler Python'un kendisi tarafından yapılır
     ve bu yüzden de platformdan bağımsızdır.

   *buffering*, arabelleğe alma ilkesini ayarlamak için kullanılan
   isteğe bağlı bir tamsayıdır. Arabelleğe almayı kapatmak için 0
   (yalnızca ikili modda yazılırken izin verilir), satır arabelleğini
   seçmek için 1 (yalnızca metin modunda kullanılabilir) ve sabit
   boyutlu yığın arabelleğinin bayt cinsinden boyutunu belirtmek için
   birden büyük bir tam sayı iletin. Bir arabellek boyutunu bu şekilde
   belirtmenin ikili arabelleğe alınmış G/Ç için geçerli olduğunu
   unutmayın, ancak "TextIOWrapper" (yani, "mode='r+'" ile açılan
   dosyalar) başka bir arabelleğe alır. "TextIOWrapper" arabelleğe
   almayı devre dışı bırakmak için, "io.TextIOWrapper.reconfigure()"
   için "write_through" bayrağını kullanmayı düşünün. *arabelleğe
   alma* bağımsız değişkeni verilmediğinde, varsayılan arabelleğe alma
   ilkesi şu şekilde çalışır:

   * Binary files are buffered in fixed-size chunks; the size of the
     buffer is chosen using a heuristic trying to determine the
     underlying device's "block size" and falling back on
     "io.DEFAULT_BUFFER_SIZE".  On many systems, the buffer will
     typically be 4096 or 8192 bytes long.

   * "İnteraktif" metin dosyaları ("isatty()" 'nın "True" döndürdüğü
     dosyalar) satır arabelleğe almayı kullanır. Diğer metin dosyaları
     yukarıda ikili dosyalar için açıklanan poliçeyi kullanırlar.

   *encoding* dosyayı kodlamak veya deşifre etmek için kullanılan
   kodlayıcının ismidir. Bu sadece metin modunda kullanılmalıdır.
   Varsayılan kodlayıcı platforma bağımlıdır
   ("locale.getpreferredencoding()" ne döndürüyorsa), ama Python
   tarafından desteklenen herhangi bir *text encoding* kullanılabilir.
   Desteklenen kodlayıcıların listesi için "codecs" modülüne bkz.

   *errors* şifreleme ve deşifreleme hatalarının nasıl işleneceğini
   belirten opsiyonel bir dizedir—bu ikili modda kullanılamaz. Bazı
   standart hata işleyecileri mevcuttur (Error Handlers 'da
   listelendi), ayrıca "codecs.register_error()" ile kaydedilen
   herhangi bir hata işleyici ismi de geçerlidir. Standart isimler
   bunları içerir:

   * "'strict'", bir kodlama hatası varsa bir "ValueError" istisnasını
     yükseltmek için kullanılır. Varsayılan değer "None" ile aynı
     etkiyi gösterir.

   * "'ignore'" hataları görmezden gelir. Kodlayıcı hatalarını
     görmezden gelmenin veri kaybı ile sonuçlanabileceğini unutmayın.

   * "'replace'" hatalı biçimlendirilmiş veri olduğunda  bir yedek
     işaretleyici ("'?'" gibi) 'nin hatalı biçimlendirilmiş verinin
     yerine geçmesine neden olur.

   * "'surrogateescape'", hatalı baytları U+DC80'den U+DCFF'ye kadar
     değişen vekil kod birimleri olarak sunacaktır. Bu vekil kod
     birimleri sonradan "surrogateescape" hata işleyicisi veri yazmak
     için kullanıldığında aynı baytlara geri döndürülecektir. Bu
     dosyaları bilinmeyen bir kodlayıcıyla işlerken kullanışlıdır.

   * "'xmlcharrefreplace'" is only supported when writing to a file.
     Characters not supported by the encoding are replaced with the
     appropriate XML character reference "&#*nnn*;".

   * "'backslashreplace'" Python'un ters slash kaçış karakterleri
     yüzünden oluşan hatalı veriyi değiştirir.

   * "'namereplace'" (sadece yazarken desteklenir) desteklenmeyen
     karakterleri "\N{...}" kaçış karakterleriyle değiştirir.

   *newline* akıştan yeni satır karakterlerinin nasıl
   ayrıştırılacağını belirler. "None", "''", "'\n'", "'\r'" ve
   "'\r\n'" olabilir. Aşağıdaki gibi çalışır:

   * Akıştan veri okurken eğer *newline* "None" ise, evrensel
     *newlines* aktif hale getirilir. Girdideki satırlar "'\n'",
     "'\r'", veya "'\r\n'" ile bitebilirler ve bunlar çağrıcıya
     döndürülmeden önce "'\n'" 'e çevrilirler. Eğer "''" ise, evrensel
     *newlines* aktif hale getirilir ama satır sonları çağrıcıya
     çevrilmeden döndürülürler. Eğer başka bir geçerli değer
     verildiyse, girdi satırları sadece verilen dize ile sonlanır ve
     satır sonu çağrıcıya çevrilmeden döndürülür.

   * Çıktıyı akışa yazarkeni eğer *newline* "None" ise, tüm "'\n'"
     karakterleri sistemin varsayılan satır ayırıcısına, "os.linesep"
     'e dönüştürülür. Eğer *newline* "''" veya "'\n'" ise, bir
     dönüştürme yapılmaz. Eğer *newline* diğer uygun değerlerden biri
     ise, tüm "'\n'" karakterleri verilen dizeye dönüştürülür.

   Eğer *closefd*, "False" ise ve dosya adı yerine bir dosya
   tanımlayıcısı verildiyse, dosya kapatıldığında temel dosya
   tanımlayıcısı açık kalacaktır. Eğer bir dosya adı verildiyse,
   *closefd* "True" olmalıdır (varsayılan); aksi takdirde, bir hata
   ortaya çıkar.

   *opener* yerine bir çağrılabilir nesne verilerek özel bir açıcı
   kullanabilirsiniz. Dosya nesnesi için temel dosya tanımlayıcısı
   sonradan *opener* 'ı (*file*, *flags*) ile çağırarak elde edilir.
   *opener* bir açık dosya tanımlayıcısı döndürmelidir (*opener*
   yerine "os.open" göndermek fonksiyonel olarak "None" göndermek ile
   benzer sonuçlanır).

   Yeni oluşturulan dosya non-inheritable 'dir.

   Aşağıdaki örnek verilen bir dizine ait bir dosyayı açmak için
   "os.open()" fonksiyonunun dir_fd parametresini kullanır:

      >>> import os
      >>> dir_fd = os.open('somedir', os.O_RDONLY)
      >>> def opener(path, flags):
      ...     return os.open(path, flags, dir_fd=dir_fd)
      ...
      >>> with open('spamspam.txt', 'w', opener=opener) as f:
      ...     print('This will be written to somedir/spamspam.txt', file=f)
      ...
      >>> os.close(dir_fd)  # don't leak a file descriptor

   "open()" metodu tarafından döndürülen *file object* 'in tipi moda
   bağlıdır. "open()" bir dosyayı metin modunda ("'w'", "'r'", "'wt'",
   "'rt'" vb.) açmak için kullanıldığında, "io.TextIOBase" 'in bir alt
   sınıfını döndürür (özellikle "io.TextIOWrapper"). Bir dosyayı ikili
   modda arabellek ile açmak için kullanıldığında, döndürülen sınıf
   "io.BufferedIOBase" 'ın alt sınıfıdır. Kesin sınıf değişkendir:
   ikili okuma modunda, bir "io.BufferedReader" döndürür; ikili yazma
   ve ikili ekleme modunda, "io.BufferedWriter" döndürür, ve
   okuma/yazma modunda "io.BufferedRandom" döndürür. Arabelleğe alma
   devre dışı olduğunda, ham akış, "io.RawIOBase" 'in alt sınıfı,
   "io.FileIO" döndürülür.

   Ayrıca "fileinput", "io" ("open()" 'ın tanımlandığı yer), "os",
   "os.path", "tempfile", ve "shutil" gibi dosya işleme modüllerine de
   bkz.

   Raises an auditing event "open" with arguments "path", "mode",
   "flags".

   "mode" ve "flags" parametreleri orijinal çağrı tarafından modifiye
   edilmiş veya çıkartılmış olabilir.

   3.3 sürümünde değişti:

   * *opener* parametresi eklendi.

   * "'x'" modu eklendi.

   * Eskiden "IOError" hatası ortaya çıkardı, şimdi "OSError" 'un
     takma adıdır.

   * Artık eğer özel oluşturma modunda ("'x'") açılmış dosyalar zaten
     bulunuyorsa "FileExistsError" hatası ortaya çıkar.

   3.4 sürümünde değişti:

   * Dosya artık miras alınamaz.

   3.5 sürümünde değişti:

   * Eğer sistem çağrısı bölündüyse ve sinyal işleyicisi bir hata
     ortaya çıkartmazsa, artık fonksiyon "InterruptedError" hatası
     ortaya çıkartmak yerine sistem çağrısını yeniden dener (açıklama
     için **PEP 475** bkz).

   * "'namereplace'" hata işleyicisi eklendi.

   3.6 sürümünde değişti:

   * "os.PathLike" uygulayan nesneleri kabul etme desteği eklendi.

   * Windows'da, bir konsol arabelleğinin açılması "io.FileIO" dışında
     bir "io.RawIOBase" alt sınıfını döndürebilir.

   3.11 sürümünde değişti: "'U'" modu kaldırıldı.

ord(c)

   Bir Unicode karakterini temsil eden dize verilir ve o karakterin
   Unicode kod noktasını temsil eden bir tamsayı döndürür. Örneğin,
   "ord('a')" "97" tamsayısını döndürür ve "ord('€')" (Euro simgesi)
   "8364" tamsayısını döndürür. Bu "chr()" 'nin tersidir.

pow(base, exp, mod=None)

   *base* 'in *exp* kuvvetini döndürür; *mod* verildiyse, aynı sayı %
   *mod* sonucunu döndürür ("pow(base,exp) % mod" 'dan daha verimli
   işlenir). İki parametreli formu "pow(base, exp)", üs operatörü
   "base**exp" kullanmaya eş değerdir.

   The arguments must have numeric types.  With mixed operand types,
   the coercion rules for binary arithmetic operators apply.  For
   "int" operands, the result has the same type as the operands (after
   coercion) unless the second argument is negative; in that case, all
   arguments are converted to float and a float result is delivered.
   For example, "pow(10, 2)" returns "100", but "pow(10, -2)" returns
   "0.01".  For a negative base of type "int" or "float" and a non-
   integral exponent, a complex result is delivered.  For example,
   "pow(-9, 0.5)" returns a value close to "3j". Whereas, for a
   negative base of type "int" or "float" with an integral exponent, a
   float result is delivered. For example, "pow(-9, 2.0)" returns
   "81.0".

   "int" işlemleri için *mod* verilmişse, *base* ve *exp* bir tam sayı
   olmalıdır, aynı zamanda *mod* sıfır olamaz. Eğer *mod* verilmişse
   ve *exp* negatifse, *base*, *mod* için görece asal olmalıdır. Bu
   durumda, "pow(inv_base,-exp,mod)" döndürülüri *inv_base, *base* mod
   *mod* 'un tersidir.

   Burada "38" mod "97" 'nin tersini işlemek için bir örnek var:

      >>> pow(38, -1, mod=97)
      23
      >>> 23 * 38 % 97 == 1
      True

   3.8 sürümünde değişti: "int" işlenenleri için, "pow" 'un üç
   parametreli formu artık ikinci parametrenin negatif olmasına,
   modüler terslerin hesaplanmasına izin verir.

   3.8 sürümünde değişti: Anahtar kelime parametrelerine izin ver,
   önceden sadece pozisyonel parametreler desteklenirdi.

print(*objects, sep=' ', end='\n', file=None, flush=False)

   Metin akış *file* 'ına *sep* tarafından ayırılacak ve *end* ile
   bitirilecek şekilde  *objects* 'i yazdırır. *sep*, *end, *file*, ve
   *flush* sunulursa anahtar kelime parametreleri olarak verilmelidir.

   Tüm anahtar kelime olmayan parametler "str()" 'in yaptığı gibi
   dizeye çevirilir ve *sep* tarafından ayırılıp *end* ile bitecek
   şekilde akışa yazdırılır. *sep* ve *end* dize veya "None"
   olmalıdır. "None" olduğunda varsayılan değerler kullanılır. Eğer
   *objects* verilmediyse, "print()" sadece *end* 'i yazdırır.

   *file* parametresi "write(string)" metodu içeren bir obje
   olmalıdır; eğer sunulmamış veya "None" ise, "sys.stdout"
   kullanılacaktır. Yazdırılan argümanlar metin dizelerine
   çevrildiğinden, "print()" ikili dosya nesneleri ile kullanılamaz.
   Bunlar için, "file.write(...)" 'ı kullanın.

   Output buffering is usually determined by *file*. However, if
   *flush* is true, the stream is forcibly flushed.

   3.3 sürümünde değişti: *flush* anahtar kelimesi argümanı eklendi.

class property(fget=None, fset=None, fdel=None, doc=None)

   Bir özellik özelliği döndürür.

   *fget* bir özelliğin değerini almak için kullanılan bir
   fonksiyondur. *fset* bir özelliğin değerini ayarlamak için
   kullanılan bir fonksiyondur. *fdel* bir özelliğin değerini silmek
   için kullanılan bir fonksiyondur, ve *doc* özellik için bir belge
   dizisi oluşturur.

   Yönetilen bir "x" özelliği tanımlamak için tipik bir yöntem:

      class C:
          def __init__(self):
              self._x = None

          def getx(self):
              return self._x

          def setx(self, value):
              self._x = value

          def delx(self):
              del self._x

          x = property(getx, setx, delx, "I'm the 'x' property.")

   Eğer *c*, *C* 'nin bir örneğiyse, "c.x", alıcı fonksiyonu
   çağıracaktır. "c.x = value" ayarlayıcı fonksiyonu, "del c.x" ise
   siliciyi çağıracaktır.

   Eğer verildiyse, *doc* property özelliğinin doküman dizisi
   olacaktır. Aksi takdirde, property *fget* 'in (bulunuyorsa) doküman
   dizisini kopyalayacaktır. Bu "property()" 'i *decorator* olarak
   kullanarak kolayca salt-okunur özellikler oluşturmayı mümkün kılar:

      class Parrot:
          def __init__(self):
              self._voltage = 100000

          @property
          def voltage(self):
              """Get the current voltage."""
              return self._voltage

   The "@property" decorator turns the "voltage()" method into a
   "getter" for a read-only attribute with the same name, and it sets
   the docstring for *voltage* to "Get the current voltage."

   @getter

   @setter

   @deleter

      A property object has "getter", "setter", and "deleter" methods
      usable as decorators that create a copy of the property with the
      corresponding accessor function set to the decorated function.
      This is best explained with an example:

         class C:
             def __init__(self):
                 self._x = None

             @property
             def x(self):
                 """I'm the 'x' property."""
                 return self._x

             @x.setter
             def x(self, value):
                 self._x = value

             @x.deleter
             def x(self):
                 del self._x

      Bu kod birinci örneğin tamamen eş değeridir. Orijinal özellikte
      olduğu gibi ekstra fonksiyonlara aynı ismi verdiğinizden emin
      olun (bu durumda "x").

      Döndürülen property nesnesi yapıcı metotta verilen "fget",
      "fset", ve "fdel" özelliklerine sahiptir.

   3.5 sürümünde değişti: Property nesnelerinin doküman dizeleri artık
   yazılabilir.

   __name__

      Attribute holding the name of the property. The name of the
      property can be changed at runtime.

      Added in version 3.13.

class range(stop)
class range(start, stop, step=1)

   Bir metot olmaktansa, "range" aslında bir değiştirilemez dizi
   tipidir. Daha fazla bilgi için Aralıklar ve Dizi Tipleri --- list,
   tuple, range 'e bakınız.

repr(object)

   Return a string containing a printable representation of an object.
   For many types, this function makes an attempt to return a string
   that would yield an object with the same value when passed to
   "eval()"; otherwise, the representation is a string enclosed in
   angle brackets that contains the name of the type of the object
   together with additional information often including the name and
   address of the object.  A class can control what this function
   returns for its instances by defining a "__repr__()" method. If
   "sys.displayhook()" is not accessible, this function will raise
   "RuntimeError".

   This class has a custom representation that can be evaluated:

      class Person:
         def __init__(self, name, age):
            self.name = name
            self.age = age

         def __repr__(self):
            return f"Person('{self.name}', {self.age})"

reversed(seq)

   Return a reverse *iterator*.  *seq* must be an object which has a
   "__reversed__()" method or supports the sequence protocol (the
   "__len__()" method and the "__getitem__()" method with integer
   arguments starting at "0").

round(number, ndigits=None)

   Noktadan sonra *ndigits* basamak hassasiyetiyle *number* 'ı
   yuvarlar. Eğer *ndigits* verilmediyse veya "None" ise, *number* 'a
   en yakın tam sayı döndürülür.

   "round()" 'u destekleyen yerleşik yapılar için, değerler 10 üssü
   *ndigits* 'in en yakın katına yuvarlanır; eğer iki kat da eşitse,
   yuvarlama işlemi çift sayıya doğru yapılır (örneğin, "round(0.5)"
   ve "round(-0.5)" 'in değerleri "0" 'dır. ve "round(1.5)", "2"
   'dir). *ndigits* için herhangi bir tamsayı değeri (pozitif, sıfır
   veya negatif) uygundur. *ndigits* verilmediyse veya "None" ise
   döndürülen değer bir tam sayıdır. Aksi takdirde, döndürülen değerin
   tipi *number* 'ınkiyle aynıdır.

   Genel bir Python nesnesi için "number", "round" "number.__round__"
   'u temsil eder.

   Not:

     Gerçel sayılar için "round()" 'un davranışı şaşırtıcı olabilir:
     örneğin "round(2.675, 2)" beklenen gibi "2.68" yerine "2.67"
     sonucunu verir. Bu bir hata değil; çoğu ondalıklı kesir tamı
     tamına bir gerçel sayı olarak gösterilemeyeceğinden bu sonucu
     alıyoruz. Daha fazla bilgi için Floating-Point Arithmetic:
     Issues and Limitations 'e bkz.

class set
class set(iterable)

   Opsiyonel olarak *iterable* 'dan alınan elementlerle yeni bir "set"
   nesnesi döndürür. "set" yerleşik bir sınıftır. Bu sınıf hakkında
   dokümantasyon için "set" ve Set Türleri --- set, frozenset 'e
   bakınız.

   Diğer konteynerler için, yerleşik "frozenset", "list", "tuple" ve
   "dict" sınıflarını; aynı zamanda "collections"  modülüne bakınız.

setattr(object, name, value)

   Bu "getattr()" 'un karşılığıdır. Argümanlar bir nesne, dize ve
   opsiyonel değerdir. Dize halihazırda var olan veya yeni bir
   özelliğe isim verebilir. Fonksiyon, nesnenin izin vermesi
   koşuluyla, değeri özelliğe atar. Örneğin "setattr(x, 'foobar',
   123)" ve "x.foobar = 123" eş değerdir.

   *name*, nesne bunu zorunlu kılmayı seçmedikçe, örneğin özel bir
   "__getattribute__()" veya "__slots__" aracılığıyla, Identifiers and
   keywords içinde tanımlandığı gibi bir Python tanımlayıcısı olmak
   zorunda değildir. Adı tanımlayıcı olmayan bir özelliğe nokta
   kullanılarak erişilemez, ancak "getattr()" vb. aracılığıyla
   erişilebilir.

   Not:

     Özel isim karıştırma, derleme sürecinde olacağından, "setattr()"
     ile ayarlamak için özel bir niteliğin (iki alt çizgi ile başlayan
     nitelikler) adını manuel olarak değiştirmek gerekir.

class slice(stop)
class slice(start, stop, step=None)

   Return a *slice* object representing the set of indices specified
   by "range(start, stop, step)".  The *start* and *step* arguments
   default to "None".

   start

   stop

   step

      Slice objects have read-only data attributes "start", "stop",
      and "step" which merely return the argument values (or their
      default).  They have no other explicit functionality; however,
      they are used by NumPy and other third-party packages.

   Slice objects are also generated when extended indexing syntax is
   used.  For example: "a[start:stop:step]" or "a[start:stop, i]".
   See "itertools.islice()" for an alternate version that returns an
   *iterator*.

   3.12 sürümünde değişti: Slice objects are now *hashable* (provided
   "start", "stop", and "step" are hashable).

sorted(iterable, /, *, key=None, reverse=False)

   *iterable* 'ın içindeki elementlerden oluşan sıralı bir liste
   döndürür.

   İsimle belirtilmesi gereken 2 opsiyonel parametresi vardır.

   *key*, *iterable* 'ın her elementinden bir karşılaştırma anahtarı
   ayıklamak için kullanılan bir argümanın fonksiyonunu belirtir
   (örneğin, "key=str.lower"). Varsayılan değer "None" 'dır
   (elementleri direkt karşılaştırır).

   *reverse* bir boolean değerdir. Eğer "True" ise, liste elementleri
   tüm karşılaştırmalar tersine çevrilmiş şekilde sıralanır.

   Eski stil *cmp* fonksiyonunu bir *key* fonksiyonuna dönüştürmek
   için "functools.cmp_to_key()" 'yi kullanın.

   Yerleşik "sorted()" fonksiyonunun stabil çalışması
   garantilenmiştir. Bir sıralama eşit olan elementlerin ilgili
   sırasını değiştirmemeyi garantiliyorsa stabildir --- bu çoklu
   geçişlerle sıralama (örneğin önce departman, ardından maaş
   sıralama) için yardımcıdır.

   Sıralama algoritması elementler arasında sadece "<"
   karşılaştırmalarını kullanır. Bir "__lt__()" metodu tanımlamak
   sıralamak için yeterli olmasına rağmen, **PEP 8** tüm altı rich
   comparisons 'ların uygulanmasını öneriyor. Bu aynı veri ile "max()"
   gibi farklı bir temel metot ile çalışan farklı sıralama araçlarını
   kullanırken hataları önlemeyi kolaylaştıracaktır. Tüm
   karşılaştırmaları uygulamak ayrıca yansıtılan "__gt__()" metodunu
   çağırabilen karmaşık tür karşılaştırmaları için karışıklığı da
   önler.

   Sıralama örnekleri ve kısa sıralama öğreticisi için Sorting
   Techniques 'ya bakınız.

@staticmethod

   Bir metodu statik metoda dönüştürür.

   Statik bir metot üstü kapalı şekilde bir ilk argüman almaz. Statik
   metot tanımlamak için bu ifadeyi kullanabilirsiniz:

      class C:
          @staticmethod
          def f(arg1, arg2, argN): ...

   "@staticmethod" ifadesi bir *decorator* fonksiyonudur. -- detaylar
   için Function definitions bkz.

   A static method can be called either on the class (such as "C.f()")
   or on an instance (such as "C().f()"). Moreover, the static method
   *descriptor* is also callable, so it can be used in the class
   definition (such as "f()").

   Python'daki statik metotlar Java ve C++'takilerle benzerdir.
   Ayrıca, sınıf için alternatif bir yapıcı metot oluşturmak
   isterseniz "classmethod()" bkz.

   Tüm dekoratörler gibi, "staticmethod" 'u normal bir fonksiyon gibi
   çağırmak ve sonucu ile bir şeyler yapmak mümkündür. Bu, bir sınıfın
   fonksiyonuna referans vermeniz gerektiğinde ve örnek metoda
   otomatik dönüşümü engellemek istediğinizde işinize yarayabilir.
   Böyle durumlar için, bu ifadeyi kullanabilirsiniz:

      def regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

   Statik metotlar hakkında daha fazla bilgi için, The standard type
   hierarchy bkz.

   3.10 sürümünde değişti: Statik metotlar artık metot özelliklerini
   ("__module__", "__name__", "__qualname__", "__doc__" and
   "__annotations__") miras alır, yeni bir "__wrapped__" özellikleri
   var ve artık normal fonksiyonlar gibi çağırılabilirler.

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

   *object* 'in "str" versiyonunu döndürür. Detaylar için "str()" bkz.

   "str" yerleşik dize *class* 'ıdır. Dizeler hakkında genel bilgi
   için, Metin Sırası Türü --- str bkz.

sum(iterable, /, start=0)

   *start* ve *iterable* 'ın elemanlarını soldan sağa toplar ve
   toplamı döndürür. *iterable* 'ın elemanları normal olarak
   numaralardır ve başlangıç değeri bir dize olamaz.

   For some use cases, there are good alternatives to "sum()". The
   preferred, fast way to concatenate a sequence of strings is by
   calling "''.join(sequence)".  To add floating-point values with
   extended precision, see "math.fsum()".  To concatenate a series of
   iterables, consider using "itertools.chain()".

   3.8 sürümünde değişti: *start* parametresi bir anahtar kelime
   argümanı olarak belirtilebilir.

   3.12 sürümünde değişti: Summation of floats switched to an
   algorithm that gives higher accuracy and better commutativity on
   most builds.

class super
class super(type, object_or_type=None)

   *type* 'ın ebeveyn veya kardeş sınıfına yapılan metot çağrılarını
   temsil eden bir proxy objesi döndürür. Bu bir sınıfta üzerine
   yazılmış kalıtılan metotlara erişmek için kullanışlıdır.

   *object_or_type* aranacak *method resolution order* 'nı belirler.
   Arama *type* 'dan sonraki ilk sınıftan başlar.

   Örnek olarak, eğer *object_or_type* 'ın "__mro__" özelliği "D -> B
   -> C -> A -> object" ise ve *type* değeri "B" ise, "super()" "C ->
   A -> object" 'i arar.

   The "__mro__" attribute of the class corresponding to
   *object_or_type* lists the method resolution search order used by
   both "getattr()" and "super()".  The attribute is dynamic and can
   change whenever the inheritance hierarchy is updated.

   Eğer ikinci parametre atlanırsa, döndürülen süper objesi
   serbesttir. Eğer ikinci parametre bir objeyse, "isinstance(obj,
   type)" doğru olmak zorundadır. Eğer ikinci parametre bir tür ise,
   "issubclass(type2, type)" doğru olmak zorundadır (bu sınıf
   metotları için kullanışlıdır).

   When called directly within an ordinary method of a class, both
   arguments may be omitted ("zero-argument "super()""). In this case,
   *type* will be the enclosing class, and *obj* will be the first
   argument of the immediately enclosing function (typically "self").
   (This means that zero-argument "super()" will not work as expected
   within nested functions, including generator expressions, which
   implicitly create nested functions.)

   *super* için tipik iki kullanım şekli vardır. Tek kalıtımlı bir
   sınıf hiyerarşisinde *super* üst sınıfları açıkça adlandırmadan
   onlara başvurmak için kullanılabilir. böylece kodu daha
   sürdürülebilir hale getirir.

   İkinci kullanım şekli dinamik yürütme ortamında işbirlikli çoklu
   kalıtımı desteklemektir. Bu durum Python'a özgüdür ve statik
   derlenen diller veya tekli kalıtımı destekleyen dillerde bulunmaz.
   Bu çoklu temel sınıfların aynı metodu uyguladığı "diamond diagrams"
   sistemini uygulamayı mümkün kılar. İyi tasarım bu tür uygulamaların
   her durumda aynı çağrı imzasına sahip olduğunu (çünkü çağrıların
   sırası yürütme zamanında belirlenir, çünkü bu sıra sınıf
   hiyerarşisindeki değişikliklere uyarlanır ve çalışma zamanından
   önce bilinmeyen kardeş sınıfları içerebilir) dikte eder.

   İki kullanım durumu için de, tipik bir üst sınıf çağrısı bu
   şekildedir:

      class C(B):
          def method(self, arg):
              super().method(arg)    # This does the same thing as:
                                     # super(C, self).method(arg)

   Metot aramalarına ek olarak, "super()" özellik aramaları için de
   çalışır. Bunun kullanım şekli ebeveyn veya kardeş bir sınıfta
   *tanımlayıcılar* 'i çağırmaktır.

   Note that "super()" is implemented as part of the binding process
   for explicit dotted attribute lookups such as
   "super().__getitem__(name)". It does so by implementing its own
   "__getattribute__()" method for searching classes in a predictable
   order that supports cooperative multiple inheritance. Accordingly,
   "super()" is undefined for implicit lookups using statements or
   operators such as "super()[name]".

   Ayrıca, argümansız formunun yanı sıra, "süper()" iç metotları
   kullanmakla sınırlı değildir. İki parametreli form parametlerini
   tamı tamına belirler ve uygun karşılaştırmaları yapar. Argümansız
   form sadece bir sınıf tanımının içinde çalışır, derleyici
   tanımlanan sınıfı doğru şekilde almak ve sıradan yöntemlere geçerli
   örnekten erişmek için gerekli detayları doldurur.

   "super()" 'ı kullanarak kooperatif sınıflar tasarlamaya yönelik
   pratik öneriler için, guide to using super() bkz.

class tuple
class tuple(iterable)

   Bir fonksiyon olmaktansa, "tuple" Demetler ve Dizi Tipleri ---
   list, tuple, range 'de gösterildiği gibi düzenlenemez bir dizi
   türüdür.

class type(object)
class type(name, bases, dict, **kwds)

   Bir parametre ile, *object* 'in türünü döndürür. Döndürülen değer
   bir obje türüdür ve genellikle "object.__class__" tarafından
   döndürülen obje ile aynıdır.

   "isinstance()" yerleşik fonksiyonu bir objenin türünü test etmek
   için önerilir. Çünkü altsınıfları hesaba katar.

   Üç parametre ile, yeni nesne türü döndürür. Bu esasen "class"
   ifadesinin dinamik biçimidir. *name* dizesi sınıfın ismidir ve
   "__name__" özelliği yerine gelir. *bases* demeti temel sınıfları
   içerir ve "__bases__" özelliği yerine gelir; eğer boş ise,
   "object", tüm sınıfların nihai temeli eklenir. *dict* sözlüğü sınıf
   gövdesi için özellik ve metot tanımlamaları içerir; "__dict__"
   özelliği yerine geçmeden önce kopyalanabilir veya sarılabilir.
   Aşağıdaki iki ifade birebir aynı "type" nesneleri oluşturur:

   >>> class X:
   ...     a = 1
   ...
   >>> X = type('X', (), dict(a=1))

   Type Objects 'e de bkz.

   Üç değişkene sağlanan anahtar kelime argümanları, uygun metasınıf
   makinelerine (genellikle "__init_subclass__()") bir sınıf
   tanımındaki anahtar sözcüklerin (*metaclass* dışında) yapacağı
   şekilde iletilir.

   Customizing class creation 'a da bkz.

   3.6 sürümünde değişti: "type.__new__" 'in üzerine yazmayan "type"
   altsınıfları artık bir objenin türünü almak için tek argümanlı
   formu kullanamaz.

vars()
vars(object)

   Bir modül, sınıf, örnek veya "__dict__" özelliği bulunan herhangi
   bir obje için, "__dict__" özelliğini döndürür.

   Modüller ve örnekler gibi nesneler güncellenebilir bir "__dict__"
   özelliğine sahiptir; ama diğer nesnelerin kendilerinin "__dict__"
   özelliklerine yazma kısıtlaması olabilir (örnek olarak, sınıflar
   doğrudan sözlük güncellemelerini önlemek için
   "types.MappingProxyType" sınıfını kullanırlar).

   Without an argument, "vars()" acts like "locals()".

   Eğer bir obje belirtildiyse ama "__dict__" özelliği yoksa (örneğin,
   "__slots__" özelliğini tanımlayan bir sınıf ise), "TypeError"
   hatası ortaya çıkar.

   3.13 sürümünde değişti: The result of calling this function without
   an argument has been updated as described for the "locals()"
   builtin.

zip(*iterables, strict=False)

   Paralel olarak birkaç yinelenebilir nesneyi yineler ve hepsinden
   bir element alarak bir demet üretir.

   Örnek:

      >>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
      ...     print(item)
      ...
      (1, 'sugar')
      (2, 'spice')
      (3, 'everything nice')

   Daha resmice: "zip()" demetlerden oluşan ve *i* inci demetin her
   parametre yineleyicisinden *i* 'inci elementi içerdiği bir
   yineleyici döndürür.

   "zip()" 'i anlamanın başka bir yolu da, sütunları satırlara ve
   satırları sütunlara çevirmesidir. Bu transposing a matrix 'a
   benzer.

   "zip()" tembeldir: Yinelenebilir nesne, örneğin bir "for" döngüsü
   veya "list" tarafından sarılarak yinelenmediği sürece elementler
   işlenmez.

   Dikkate alınması gereken şeylerden biri de "zip()" 'e verilen
   yineleyiciler bazen tasarım gereği, bazen ise yineleyicileri
   hazırlayan kodda oluşan bir hatadan dolayı farklı uzunluklarda
   olabilirler. Python bununla başa çıkmak için üç farklı yaklaşım
   sunar:

   * Varsayılan olarak, "zip()" en kısa yinelenebilir nesne
     tükendiğinde durur. Daha uzun yinelebilirlerde kalan elementleri
     görmezden gelecektir ve sonucu en kısa yineleyicinin uzunluğuna
     eşitleyecektir:

        >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
        [(0, 'fee'), (1, 'fi'), (2, 'fo')]

   * "zip()" genellikle yineleyicilerin aynı uzunlukta olduğu
     varsayıldığında kullanılır. Bu gibi durumlarda, "strict=True"
     opsiyonunu kullanmak önerilir. Çıktısı sıradan "zip()" ile
     aynıdır:

        >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
        [('a', 1), ('b', 2), ('c', 3)]

     Varsayılan davranışın aksine, bir yinelenebilir diğerlerinden
     önce tükenirse bir "ValueError" ortaya çıkar:

     >>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):  
     ...     print(item)
     ...
     (0, 'fee')
     (1, 'fi')
     (2, 'fo')
     Traceback (most recent call last):
       ...
     ValueError: zip() argument 2 is longer than argument 1

     "strict=True" parametresi olmadan, farklı boyutlardaki
     nesnelerde sonuçlanan hatalar susturulacaktır. Mümkün olduğunca
     programın başka bir bölümünde bulunması zor bir hata olarak
     tezahür ediyor.

   * Daha kısa yinelenebilir nesneler, tüm yinelenebilir nesnelerin
     aynı uzunlukta olması için sabit bir değerle doldurulabilirler.
     Bu "itertools.zip_longest()" tarafından yapılır.

   Kenar durumları: Tek bir yinelenebilir nesne argümanı verilirse,
   "zip()" bir demetin yineleyicisini döndürür. Argüman verilmezse,
   boş bir yineleyici döndürür.

   İpucu ve hileler:

   * Yinelenebilir nesnelerin soldan sağa değerlendirme sırası garanti
     edilir. Bu, bir veri serisini "zip(*[iter(s)]*n, strict=True)"
     kullanarak n-uzunluklu gruplar halinde kümelemeyi mümkün kılar.
     Bu *aynı* yineleyiciyi "n" defa tekrar eder ve böylece tüm çıktı
     demetler yineleyiciye "n" sayıda çağrı yapmış olur. Bu, girdiyi
     n-uzunluklu parçalara bölme etkisine sahiptir.

   * "zip()", bir listeyi açmak için "*" operatörüyle birlikte
     kullanılabilir:

        >>> x = [1, 2, 3]
        >>> y = [4, 5, 6]
        >>> list(zip(x, y))
        [(1, 4), (2, 5), (3, 6)]
        >>> x2, y2 = zip(*zip(x, y))
        >>> x == list(x2) and y == list(y2)
        True

   3.10 sürümünde değişti: "strict" argümanı eklendi.

__import__(name, globals=None, locals=None, fromlist=(), level=0)

   Not:

     Bu "importlib.import_module()" 'un aksine günlük Python
     programlamasında genel olarak kullanılmayan gelişmiş bir
     fonksiyondur.

   Bu fonksiyon "import" ifadesi tarafından çağırılır. "import"
   ifadesinin anlamlarını değiştirmek için yenisiyle değiştirilebilir
   ("builtins" modülünü içe aktarıp "builtins.__import__" 'a
   devrederek), ama bunu yapmak aynı amaçlara ulaşmak için içe aktarma
   çengellerini kullanmak daha basit olduğundan ve içe aktarma
   çengellerinin kodda hatalara neden olmayacağından tavsiye
   **edilmez**. "__import__()" 'un doğrudan kullanımı da
   "importlib.import_module()" 'ın lehine tavsiye edilmez.

   Fonksiyon modül *adını* içe aktarır, potansiyel olarak bir paket
   bağlamındaki isimleri nasıl yorumlayacağını belirlemek için verien
   *globals* ve *locals* 'i kullanır. *fromlist*, *name* ismiyle içe
   aktarılması gereken modülün alt modüllerinin ve nesnelerinin
   isimlerini verir. Standart uygulama *locals* argümanını kullanmaya
   teşebbüs etmez ve *globals* 'i "import" ifadesinin paket bağlamını
   belirlemek için kullanır.

   *level* mutlak mı yoksa göreli içe aktarmaların mı kullanılacağını
   belirtir. "0" (varsayılan) sadece mutlak içe aktarmaların
   uygulanacağını belirtir. *level* için pozitif değerler,
   "__import__()" çağrısı yapan modülün dizinine göre aranacak üst
   dizinlerin sayısını gösterir (detaylar için **PEP 328** 'e
   bakınız).

   *name* değişkeni "package.module" biçiminde olduğunda, üst düzey
   paket ((ilk noktaya kadar olan isim) döndürülür, *name* isimli
   modül *değil*. Boş olmayan bir *fromlist* argümanı verildiğinde,
   *name* isimli modül döndürülür.

   Örnek olarak, "import spam" ifadesi aşağıdaki koda benzeyen bayt
   koduyla sonuçlanır:

      spam = __import__('spam', globals(), locals(), [], 0)

   "import spam.ham" ifadesi şu çağrıyla sonuçlanır:

      spam = __import__('spam.ham', globals(), locals(), [], 0)

   Burada "__import__()" öğesinin üst düzey modülü nasıl döndürdüğüne
   dikkat edin, çünkü bu, "import" ifadesiyle bir ada bağlanan
   nesnedir.

   Diğer yandan, "from spam.ham import eggs, sausage as saus" ifadesi
   şöyle sonuçlanır:

      _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
      eggs = _temp.eggs
      saus = _temp.sausage

   Burada, "spam.ham" modülü "__import__()" 'dan döndürülür. Bu
   objeden, içeri aktarılacak isimler alınır ve sırasıyla adlarına
   atanır.

   Eğer ismiyle bir modülü (potansiyel olarak bir paket içinde) içe
   aktarmak istiyorsanız, "importlib.import_module()" 'i kullanın.

   3.3 sürümünde değişti: *level* için negatif değerler artık
   desteklenmiyor (bu, varsayılan değeri 0 olarak da değiştirir).

   3.9 sürümünde değişti: Komut satırı opsiyonlarından "-E" veya "-I"
   kullanıldığında, ortam değişkeni "PYTHONCASEOK" görmezden gelinir.

-[ Dipnotlar ]-

[1] Ayrıştırıcının yalnızca Unix stili satır sonu kuralını kabul
    ettiğini unutmayın. Eğer bir dosyadan kod okuyorsanız, Windows
    veya Mac tarzı yeni satırları dönüştürmek için yeni satır
    dönüştürme modunu kullandığınızdan emin olun.
