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       |                    |                      |
|=====================|===================|====================|====================|======================|
| "abs()"             | "delattr()"       | "hash()"           | "memoryview()"     | "set()"              |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "all()"             | "dict()"          | "help()"           | "min()"            | "setattr()"          |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "any()"             | "dir()"           | "hex()"            | "next()"           | "slice()"            |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "ascii()"           | "divmod()"        | "id()"             | "object()"         | "sorted()"           |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "bin()"             | "enumerate()"     | "input()"          | "oct()"            | "staticmethod()"     |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "bool()"            | "eval()"          | "int()"            | "open()"           | "str()"              |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "breakpoint()"      | "exec()"          | "isinstance()"     | "ord()"            | "sum()"              |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "bytearray()"       | "filter()"        | "issubclass()"     | "pow()"            | "super()"            |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "bytes()"           | "float()"         | "iter()"           | "print()"          | "tuple()"            |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "callable()"        | "format()"        | "len()"            | "property()"       | "type()"             |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "chr()"             | "frozenset()"     | "list()"           | "range()"          | "vars()"             |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "classmethod()"     | "getattr()"       | "locals()"         | "repr()"           | "zip()"              |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "compile()"         | "globals()"       | "map()"            | "reversed()"       | "__import__()"       |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "complex()"         | "hasattr()"       | "max()"            | "round()"          |                      |
+---------------------+-------------------+--------------------+--------------------+----------------------+

abs(x)

   Return the absolute value of a number.  The argument may be an
   integer or a floating point number.  If the argument is a complex
   number, its magnitude is returned. If *x* defines "__abs__()",
   "abs(x)" returns "x.__abs__()".

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

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)

   As "repr()", return a string containing a printable representation
   of an object, but escape the non-ASCII characters in the string
   returned by "repr()" using "\x", "\u" or "\U" escapes.  This
   generates a string similar to that returned by "repr()" in Python
   2.

bin(x)

   Bir tam sayıyı, ön eki "0b" olan ikili bir dizeye dönüştürür. Sonuç
   geçerli bir Python ifadesidir. Eğer *x* bir Python "int" nesnesi
   değilse, tam sayı döndüren bir "__index__()" metodu tanımlaması
   gerekir. Bazı örnekler:

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

   If prefix "0b" is desired or not, you can use either of the
   following ways.

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

   Return a Boolean value, i.e. one of "True" or "False".  *x* is
   converted using the standard truth testing procedure.  If *x* 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 Değerleri).

   3.7 sürümünde değişti: *x* artık yalnızca konumsal bir
   parametredir.

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.

   "breakpointhook" parametresi ile denetleme olayı
   "builtins.breakpoint" ortaya çıkartır.

   3.7 sürümüyle geldi.

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[, encoding[, errors]]])

   Return a new "bytes" object, which is an immutable sequence of
   integers in the range "0 <= x < 256".  "bytes" is an immutable
   version of "bytearray" -- it has the same non-mutating methods and
   the same indexing and slicing behavior.

   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)

   Eğer *object* argümanı çağrılabilir ise, "True" , değilse "False"
   döndürür. Eğer "True" döndürür ise, bir çağrının başarısız olması
   hala mümkündür, "False" döndürdüğü takdirde, *object* çağrısı
   hiçbir zaman başarılı olamaz. Sınıfların ve örneklerin
   (Sınıflarında "__call__()"  metodu varsa) çağrılabilir olduğunu not
   edin. Bir sınıfı çağırmak sınıftan türeyen yeni bir örnek döndürür.

   3.2 sürümüyle geldi: 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.

   A class method receives the class as implicit first argument, just
   like an instance method receives the instance. To declare a class
   method, use this idiom:

      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.

   Class methods are different than C++ or Java static methods. If you
   want those, see "staticmethod()".

   For more information on class methods, see The standard type
   hierarchy.

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

   The optional arguments *flags* and *dont_inherit* control which
   future statements affect the compilation of *source*.  If neither
   is present (or both are zero) the code is compiled with those
   future statements that are in effect in the code that is calling
   "compile()".  If the *flags* argument is given and *dont_inherit*
   is not (or is zero) then the future statements specified by the
   *flags* argument are used in addition to those that would be used
   anyway. If *dont_inherit* is a non-zero integer then the *flags*
   argument is it -- the future statements in effect around the call
   to compile are ignored.

   Future statements are specified by bits which can be bitwise ORed
   together to specify multiple statements.  The bitfield required to
   specify a given feature can be found as the "compiler_flag"
   attribute on the "_Feature" instance in the "__future__" module.

   The optional argument *flags* also controls whether the compiled
   source is allowed to contain top-level "await", "async for" and
   "async with". When the bit "ast.PyCF_ALLOW_TOP_LEVEL_AWAIT" is set,
   the return code object has "CO_COROUTINE" set in "co_code", and can
   be interactively executed via "await eval(code_object)".

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

   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: Allowed use of Windows and Mac newlines.
   Also input in "'exec'" mode does not have to end in a newline
   anymore.  Added the *optimize* parameter.

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

   3.8 sürümüyle geldi: "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([real[, imag]])

   *real* + *imag**1j değeriyle bir karmaşık sayı döndürür veya dize
   veya sayıyı karmaşık sayıya dönüştürür. Eğer ilk parametre dize
   ise, karmaşık sayı olarak yorumlanır ve fonksiyon ikinci bir
   parametre olmadan çağrılmalıdır. İkinci parametre asla dize olamaz.
   Her argüman bir sayısal çeşit olabilir (karmaşık sayılar dahil).
   Eğer *imag* atlandıysa, varsayılan olarak sıfır alınır ve yapıcı
   metot "int" ve "float" gibi sayı dönüştürme işlevi görür. Eğer iki
   argüman da atlandıysa, "0j" döndürür.

   Genel bir python nesnesi "x" için, "complex(x)" , "x.__complex__()"
   'i temsil eder. Eğer "__complex__()" tanımlanmadıysa, "__float__()"
   'a geri döner. "__float__()" tanımlanmadıysa, "__index__()" 'e geri
   döner.

   Not:

     Bir dize dönüştürürken, dizenin, merkezi "+" veya "-"
     operatörünün etrafında boşluk içermemelidir. Örnek olarak,
     "complex('1+2j')" uygun, ama "complex('1 + 2j')" "ValueError"
     hatası ortaya çıkarır.

   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: Eğer "__complex__()" ve "__float__()"
   tanımlanmadıysa, "__index__()" 'e geri döner.

delattr(object, name)

   This is a relative of "setattr()".  The arguments are an object and
   a string.  The string must be the name of one of the object's
   attributes.  The function deletes the named attribute, provided the
   object allows it.  For example, "delattr(x, 'foobar')" is
   equivalent to "del x.foobar".

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 dökü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([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.

   Eğer nesne "__dir__()" adında bir metoda sahipse, bu metot çağrılır
   ve nesnenin özelliklerinin listesini döndürmelidir. Bu, özel bir
   "__getattr__()" veya "__getattribute__()" fonksiyonunu uygulayan
   nesnelerin, "dir()" 'in özellikleri bildirme şeklini
   özelleştirmesine izin verir.

   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(sequence, start=0):
          n = start
          for elem in sequence:
              yield n, elem
              n += 1

eval(expression[, globals[, locals]])

   Argümanlar bir dize veya opsiyonel global ve yerel değişkenler
   olabilir. Sağlanırsa, *globals* bir sözlük olmalıdır. Sağlanırsa,
   *locals* herhangi bir haritalama nesnesi olabilir.

   The *expression* argument is parsed and evaluated as a Python
   expression (technically speaking, a condition list) using the
   *globals* and *locals* dictionaries 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.  This means that *expression* normally has
   full access to the standard "builtins" module and restricted
   environments are propagated.  If the *locals* dictionary is omitted
   it defaults to the *globals* dictionary.  If both dictionaries are
   omitted, the expression is executed with the *globals* and *locals*
   in the environment where "eval()" is called.  Note, *eval()* does
   not have access to the *nested scopes* (non-locals) in the
   enclosing environment.

   Dönen değer değerlendirilmiş ifadenin sonucudur. Söz dizimi
   hataları, istisnalar olarak rapor edilir. Örnek:

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

   This function can also be used to execute arbitrary code objects
   (such as those created by "compile()").  In this case pass a code
   object instead of a string.  If the code object has been compiled
   with "'exec'" as the *mode* argument, "eval()"'s return value will
   be "None".

   Hints: dynamic execution of statements is supported by the "exec()"
   function.  The "globals()" and "locals()" functions returns the
   current global and local dictionary, respectively, which may be
   useful to pass around for use by "eval()" or "exec()".

   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.

   "code_object" argümanıyla bir denetleme olayı "exec" hatası ortaya
   çıkarır.

exec(object[, globals[, locals]])

   This function supports dynamic execution of Python code. *object*
   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 module level, globals and locals are the
   same dictionary. If exec gets two separate objects as *globals* and
   *locals*, the code will be executed as if it were embedded 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.

   "code_object" argümanıyla bir denetleme olayı "exec" hatası ortaya
   çıkarır.

   Not:

     Yerleşik "globals()" ve "locals()" fonksiyonları mevcut global ve
     yerel sözlüğü sırasıyla döndürür. Bu, "exec()" 'e ikinci ve
     üçüncü argüman olarak kullanılmak üzere geçirmek için yararlı
     olabilir.

   Not:

     Varsayılan *locals* davranışı aşağıda "locals()" fonksiyonu için
     açıklandığı gibi: varsayılan *locals* sözlüğünde değişiklik
     yapılmaya çalışılmamalıdır. "exec()" fonksiyonu değer
     döndürdükten sonra kodun *locals* üzerindeki etkilerini görmeniz
     gerekiyorsa, açık bir *local* sözlüğü geçirin.

filter(function, iterable)

   *function* 'ın doğru döndürdüğü *iterable* ögelerinden bir
   yineleyici oluşturun. *iterable* bir dizi, yinelemeyi destekleyen
   bir konteyner veya bir yineleyici olabilir. Eğer *function* "None"
   ise, fonksiyon gelen parametreler üzerinde bir değişiklik yapmaz.
   *iterable* 'ın tüm yanlış elementleri silinir.

   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.

   *function* 'ın yanlış döndürdüğü *iterable* öğelerini döndüren
   tamamlayıcı fonksiyon için "itertools.filterfalse()" 'a bakınız..

class float([x])

   Bir numara veya string *x* 'ten oluşturulan bir reel sayı döndürür.

   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 a positive or negative
   infinity.  More precisely, the input must conform to the following
   grammar after leading and trailing whitespace characters are
   removed:

      sign           ::= "+" | "-"
      infinity       ::= "Infinity" | "inf"
      nan            ::= "nan"
      numeric_value  ::= floatnumber | infinity | nan
      numeric_string ::= [sign] numeric_value

   Here "floatnumber" is the form of a Python floating-point literal,
   described in Floating point literals.  Case is not significant, so,
   for example, "inf", "Inf", "INFINITY" and "iNfINity" are all
   acceptable spellings for positive infinity.

   Aksi takdirde, argüman bir tam sayı veya reel sayıysa, aynı değerde
   reel sayı döndürülür. Eğer argüman Python reel sayı aralığının
   dışındaysa, "OverflowError" hatası ortaya çıkar.

   Genel bir Python nesnesi "x" için, "float(x)", "x.__float__()"
   fonksiyonuna delege eder. Eğer "__float__()" tanımlanmamışsa,
   "__index__()" 'e geri döner.

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

   Örnekler:

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

   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: *x* artık yalnızca konumsal bir
   parametredir.

   3.8 sürümünde değişti: "__float__()" tanımlanmadıysa, "__index__()"
   konumuna geri döner.

format(value[, format_spec])

   Convert a *value* to a "formatted" representation, as controlled by
   *format_spec*.  The interpretation of *format_spec* will depend on
   the type of the *value* argument, however there is a standard
   formatting syntax that is used by most built-in types: Format
   Specification Mini-Language.

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

   "format(value, format_spec)" çağrısı, değerin "__format__()"
   metodunu ararken örnek sözlüğü atlayan
   "type(value).__format__(value, format_spec)" biçimine çevrilir.
   Eğer metot araması "object" 'e ulaşırsa ve *format_spec* boş
   değilse, veya *format_spec* veya döndürülen değer dize değilse,
   "TypeError" hatası ortaya çıkar.

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

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

   Return the value of the named attribute of *object*.  *name* must
   be a string. If the string is the name of one of the object's
   attributes, the result is the value of that attribute.  For
   example, "getattr(x, 'foobar')" is equivalent to "x.foobar".  If
   the named attribute does not exist, *default* is returned if
   provided, otherwise "AttributeError" is raised.

globals()

   Return a dictionary representing the current global symbol table.
   This is always the dictionary of the current module (inside a
   function or method, this is the module where it is defined, not the
   module from which it is called).

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:

     "__hash__()" metodu olan nesneler için, "hash()" öğesinin ana
     makinenin bit genişliğine göre döndürdüğü değeri kestiğini
     unutmayın. Detaylar için "__hash__()" 'e bakınız.

help([object])

   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.

   Note that if a slash(/) appears in the parameter list of a
   function, when invoking "help()", it means that the parameters
   prior to the slash are positional-only. For more info, see the FAQ
   entry on positional-only parameters.

   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)

   Bir tam sayıyı küçük harflerden oluşan ve "0x" ile başlayan
   onaltılık bir dizeye dönüştürür. Eğer *x* Python "int" nesnesi
   değilse, tam sayı döndüren bir "__index__()" metoduna sahip
   olmalidir. Bazı örnekler:

   >>> 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 implementation detail:** This is the address of the
   object in memory.

   "id" argümanıyla beraber bir denetleme olayı "builtins.id" ortaya
   çıkartır.

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.

   "prompt" argümanıyla birlikte bir denetleme olayı "builtins.input"
   ortaya çıkartır.

   "result" argümanıyla birlikte bir denetleme olayı
   "builtins.input/result" ortaya çıkartır.

class int([x])
class int(x, base=10)

   Bir numara veya *x* dizesinden bir tam sayı oluşturur. Eğer argüman
   verilmediyse 0 döndürür. *x* "__int__()" 'i içeriyorsa, "int(x)"
   "x.__int__()" 'i döndürür. *x* "__index__()" 'i içeriyorsa,
   "x.__index__()" 'i döndürür. *x* "__trunc__()" 'ı içeriyorsa,
   "x.__trunc__()" 'ı döndürür. Gerçel sayılar için, sayı tam sayıya
   çevrilir.

   If *x* is not a number or if *base* is given, then *x* must be a
   string, "bytes", or "bytearray" instance representing an integer
   literal in radix *base*.  Optionally, the literal can be preceded
   by "+" or "-" (with no space in between) and surrounded by
   whitespace.  A base-n literal consists of the digits 0 to n-1, with
   "a" to "z" (or "A" to "Z") having values 10 to 35.  The default
   *base* is 10. The allowed values are 0 and 2--36. Base-2, -8, and
   -16 literals can be optionally prefixed with "0b"/"0B", "0o"/"0O",
   or "0x"/"0X", as with integer literals in code.  Base 0 means to
   interpret exactly as a code literal, so that the actual base is 2,
   8, 10, or 16, and so that "int('010', 0)" is not legal, while
   "int('010')" is, as well as "int('010', 8)".

   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: *x* artık yalnızca konumsal bir
   parametredir.

   3.8 sürümünde değişti: "__int__()" tanımlı değilse "__index__()"
   konumuna geri döner.

   3.8.14 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 *x* 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)

   Return "True" if the *object* argument is an instance of the
   *classinfo* argument, or of a (direct, indirect or *virtual*)
   subclass thereof.  If *object* is not an object of the given type,
   the function always returns "False". If *classinfo* is a tuple of
   type objects (or recursively, other such tuples), return "True" if
   *object* is an instance of any of the types. If *classinfo* is not
   a type or tuple of types and such tuples, a "TypeError" exception
   is raised.

issubclass(class, classinfo)

   Return "True" if *class* is a subclass (direct, indirect or
   *virtual*) of *classinfo*.  A class is considered a subclass of
   itself. *classinfo* may be a tuple of class objects, in which case
   every entry in *classinfo* will be checked. In any other case, a
   "TypeError" exception is raised.

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

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

   Anlık yerel sembol tablosunu temsil eden bir sözlüğü günceller ve
   döndürür. Serbest değişkenler "locals()" fonksiyon bloklarında
   çağırıldığında onun aracılığıyla döndürülür, aynısı sınıf
   bloklarında geçerli değildir. Unutmayın ki modül seviyesinde,
   "locals()" ve "globals()" aynı sözlüklerdir.

   Not:

     Bu sözlüğün içeriği modifiye edilmemelidir, değişiklikler
     yorumlayıcı tarafından kullanılan yerel ve serbest değişkenlerin
     değerlerini etkilemeyebilir.

map(function, iterable, ...)

   *iterable* 'in her elementini *fonksiyon* 'a gönderen bir
   yineleyici döndürür ve sonuçları sunar. Eğer ek *iterable*
   parametreleri verildiyse, *fonksiyon* 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, default])
max(arg1, arg2, *args[, key])

   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üyle geldi: *varsayılan* yalnızca anahtar kelime
   parametresi.

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

class memoryview(obj)

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

min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])

   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üyle geldi: *varsayılan* yalnızca anahtar kelime
   parametresi.

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

next(iterator[, default])

   Retrieve the next item from the *iterator* by calling its
   "__next__()" method.  If *default* is given, it is returned if the
   iterator is exhausted, otherwise "StopIteration" is raised.

class object

   Return a new featureless object.  "object" is a base for all
   classes. It has the methods that are common to all instances of
   Python classes.  This function does not accept any arguments.

   Not:

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

oct(x)

   Bir tamsayıyı "0o" ön ekiyle oktal bir dizeye çevirir. Sonuç
   geçerli bir Python ifadesidir. Eğer *x* bir Python "int" nesnesi
   değilse, tamsayı döndüren bir "__index__()" metoduna sahip
   olmalıdır. Örnek olarak:

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

   If you want to convert an integer number to octal string either
   with prefix "0o" or not, you can use either of the following ways.

   >>> '%#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* is a *path-like object* giving the pathname (absolute or
   relative to the current working directory) of the file to be opened
   or an integer file descriptor of the file to be wrapped.  (If a
   file descriptor is given, it is closed when the returned I/O object
   is closed, unless *closefd* is set to "False".)

   *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.getpreferredencoding(False)" 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'"     | open for writing, appending to the end of the file if it exists |
   +-----------+-----------------------------------------------------------------+
   | "'b'"     | ikili mod                                                       |
   +-----------+-----------------------------------------------------------------+
   | "'t'"     | metin modu (varsayılan)                                         |
   +-----------+-----------------------------------------------------------------+
   | "'+'"     | güncellemeye açık (okuma ve yazma)                              |
   +-----------+-----------------------------------------------------------------+

   The default mode is "'r'" (open for reading text, synonym of
   "'rt'"). Modes "'w+'" and "'w+b'" open and truncate the file.
   Modes "'r+'" and "'r+b'" open the file with no truncation.

   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.

   There is an additional mode character permitted, "'U'", which no
   longer has any effect, and is considered deprecated. It previously
   enabled *universal newlines* in text mode, which became the default
   behaviour in Python 3.0. Refer to the documentation of the newline
   parameter for further details.

   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* is an optional integer used to set the buffering
   policy.  Pass 0 to switch buffering off (only allowed in binary
   mode), 1 to select line buffering (only usable in text mode), and
   an integer > 1 to indicate the size in bytes of a fixed-size chunk
   buffer.  When no *buffering* argument is given, the default
   buffering policy works as follows:

   * İkili dosyalar sabit boyutlu yığınlarda arabelleğe alınır;
     arabelleğin boyutu temel cihazın "blok boyutu"'nu belirlemek için
     buluşsal bir deney kullanılarak seçilir ve
     "io.DEFAULT_BUFFER_SIZE" değerine düşer. Çoğu sistemde, arabellek
     4096 veya 8192 bayt uzunluğunda olacaktır.

   * "İ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'" will represent any incorrect bytes as code
     points in the Unicode Private Use Area ranging from U+DC80 to
     U+DCFF.  These private code points will then be turned back into
     the same bytes when the "surrogateescape" error handler is used
     when writing data.  This is useful for processing files in an
     unknown encoding.

   * "'xmlcharrefreplace'" sadece bir dosyaya veri yazarken
     desteklenir. Kodlayıcı tarafından desteklenmeyen karakterler
     uygun XML karakter örneği ile değiştirilir.

   * "'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* controls how *universal newlines* mode works (it only
   applies to text mode).  It can be "None", "''", "'\n'", "'\r'", and
   "'\r\n'".  It works as follows:

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

   If *closefd* is "False" and a file descriptor rather than a
   filename was given, the underlying file descriptor will be kept
   open when the file is closed.  If a filename is given *closefd*
   must be "True" (the default) otherwise an error will be raised.

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

   See also the file handling modules, such as, "fileinput", "io"
   (where "open()" is declared), "os", "os.path", "tempfile", and
   "shutil".

   "file", "mode", "flags" parametreleriyle bir audition event "open"
   ortaya çıkartır.

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

   Deprecated since version 3.4, will be removed in version 3.9: "'U'"
   modu.

      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.

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

   *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, "10**2" returns "100", but "10**-2" returns "0.01".

   "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=sys.stdout, flush=False)

   Print *objects* to the text stream *file*, separated by *sep* and
   followed by *end*.  *sep*, *end*, *file* and *flush*, if present,
   must be given as keyword arguments.

   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.

   Whether output is buffered is usually determined by *file*, but if
   the *flush* keyword argument 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.")

   If *c* is an instance of *C*, "c.x" will invoke the getter, "c.x =
   value" will invoke the setter and "del c.x" the deleter.

   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

   "@property" dekoratörü "voltage()" metodunu aynı isimli salt-okunur
   bir özellik için "getter" metoduna dönüştürür ve *voltage* için
   doküman dizisini "Get the current voltage." olarak ayarlar.

   Bir property nesnesi, dekore edilmiş metoda ayarlanan ilgili
   erişimci metoduyla özelliğin bir kopyasını oluşturmak için
   dekoratör olarak kullanılabilen "getter", "setter", ve "deleter"
   metotlarını içerir. Bu en iyi şekilde bir örnekle açıklanabilir:

      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.

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

   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.

reversed(seq)

   Ters bir *iterator* döndürür. *seq* "__reversed__()" metodunu
   içeren veya dizi protokolünü ("__len__()" metodu ve "0" ile
   başlayıp tam sayı argümanları alan bir "__getitem__()" metodu)
   destekleyen bir nesne olmalıdır.

round(number[, ndigits])

   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.

   For the built-in types supporting "round()", values are rounded to
   the closest multiple of 10 to the power minus *ndigits*; if two
   multiples are equally close, rounding is done toward the even
   choice (so, for example, both "round(0.5)" and "round(-0.5)" are
   "0", and "round(1.5)" is "2").  Any integer value is valid for
   *ndigits* (positive, zero, or negative).  The return value is an
   integer if *ndigits* is omitted or "None". Otherwise the return
   value has the same type as *number*.

   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 Kayan Nokta Aritmetiği: Sorunlar
     ve Sınırlamalar 'e bkz.

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)

   This is the counterpart of "getattr()".  The arguments are an
   object, a string and an arbitrary value.  The string may name an
   existing attribute or a new attribute.  The function assigns the
   value to the attribute, provided the object allows it.  For
   example, "setattr(x, 'foobar', 123)" is equivalent to "x.foobar =
   123".

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

   Return a *slice* object representing the set of indices specified
   by "range(start, stop, step)".  The *start* and *step* arguments
   default to "None".  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 Numerical Python and other third party
   extensions. 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.

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 örnekleri ve kısa sıralama öğreticisi için Sorting HOW TO
   '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, ...): ...

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

   Static methods in Python are similar to those found in Java or C++.
   Also see "classmethod()" for a variant that is useful for creating
   alternate class constructors.

   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:

      class C:
          builtin_open = staticmethod(open)

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

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.

   Bazı kullanım durumları için, "sum()" fonksiyonuna iyi
   alternatifler var. Dizelerden oluşan bir diziyi birleştirmek için
   tercih edilen hızlı yöntem "''.join(sequence)" fonksiyonudur.
   Gerçel değerleri hassas bir şekilde eklemek istiyorsanız,
   "math.fsum()"bkz. Yinelenebilir nesnelerden oluşan bir diziyi
   birleştirmek istiyorsanız, "itertools.chain()" fonksiyonunu
   kullanmayı göz önünde bulundurun.

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

super([type[, object-or-type]])

   *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 *yöntem çözümleme sırası* '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.

   *object-or-type* 'ın "__mro__" özelliği, hem "getattr()" hem de
   "super()" tarafından kullanılan yöntem çözümleme arama sırasını
   listeler. Özellik dinamiktir ve kalıtım hiyerarşisi her
   güncellendiğinde değişebilir.

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

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

   "super()" 'ın, "super().__getitem__(name)" gibi açık noktalı
   öznitelik aramaları için bağlayan işlemin bir parçası olarak
   uygulanır. Sınıfları işbirlikli çoklu kalıtımı destekleyen tahmin
   edilebilir bir sırada aramak için kendi "__getattribute__()"
   metodunu sağlar. Bu nedenle "super()", ifadeler veya
   "super()[name]" gibi operatörler kullanarak kesin aramalar için
   tanımsızdır.

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

   Parametre olmadan, "vars()" "locals()" gibi davranır. Yerel sözlük,
   ona yapılan güncellemeler görmezden gelindiğinden ötürü, sadece
   okuma işlemi için kullanışlıdır.

   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.

zip(*iterables)

   Make an iterator that aggregates elements from each of the
   iterables.

   Returns an iterator of tuples, where the *i*-th tuple contains the
   *i*-th element from each of the argument sequences or iterables.
   The iterator stops when the shortest input iterable is exhausted.
   With a single iterable argument, it returns an iterator of
   1-tuples.  With no arguments, it returns an empty iterator.
   Equivalent to:

      def zip(*iterables):
          # zip('ABCD', 'xy') --> Ax By
          sentinel = object()
          iterators = [iter(it) for it in iterables]
          while iterators:
              result = []
              for it in iterators:
                  elem = next(it, sentinel)
                  if elem is sentinel:
                      return
                  result.append(elem)
              yield tuple(result)

   The left-to-right evaluation order of the iterables is guaranteed.
   This makes possible an idiom for clustering a data series into
   n-length groups using "zip(*[iter(s)]*n)".  This repeats the *same*
   iterator "n" times so that each output tuple has the result of "n"
   calls to the iterator. This has the effect of dividing the input
   into n-length chunks.

   "zip()" should only be used with unequal length inputs when you
   don't care about trailing, unmatched values from the longer
   iterables.  If those values are important, use
   "itertools.zip_longest()" instead.

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

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

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

   The function imports the module *name*, potentially using the given
   *globals* and *locals* to determine how to interpret the name in a
   package context. The *fromlist* gives the names of objects or
   submodules that should be imported from the module given by *name*.
   The standard implementation does not use its *locals* argument at
   all, and uses its *globals* only to determine the package context
   of the "import" statement.

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

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