# 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()`
`all()`
`anext()`
`any()`
`ascii()`
B
`bin()`
`bool()`
`breakpoint()`
`bytearray()`
`bytes()`
C
`callable()`
`chr()`
`classmethod()`
`compile()`
`complex()`
D
`delattr()`
`dict()`
`dir()`
`divmod()`

E
`enumerate()`
`eval()`
`exec()`
F
`filter()`
`float()`
`format()`
`frozenset()`
G
`getattr()`
`globals()`
H
`hasattr()`
`hash()`
`help()`
`hex()`
I
`id()`
`input()`
`int()`
`isinstance()`
`issubclass()`
`iter()`

L
`len()`
`list()`
`locals()`
M
`map()`
`max()`
`memoryview()`
`min()`
N
`next()`
O
`object()`
`oct()`
`open()`
`ord()`
P
`pow()`
`print()`
`property()`

R
`range()`
`repr()`
`reversed()`
`round()`
S
`set()`
`setattr()`
`slice()`
`sorted()`
`staticmethod()`
`str()`
`sum()`
`super()`
T
`tuple()`
`type()`
V
`vars()`
Z
`zip()`
_
`__import__()`

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.

  3.10 sürümünde geldi.

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.

  3.10 sürümünde geldi.

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(x=False)

  `True` ya da `False` değeri döndürür. x, standart truth testing procedure kullanılarak boolean veri tipine dönüştürülür. x yanlışsa veya atlanırsa, bu `False` döndürür; aksi takdirde, `True` değerini döndürür. `bool` sınıfı `int` öğesinin bir alt sınıfıdır (bkz. Sayısal Türler — int, float, complex). Daha fazla alt sınıfa ayrılamaz. Bunun tek örnekleri `False` ve `True` ‘dur (bkz. Boolean Değerleri).

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

breakpoint(*args, **kws)

  Bu fonksiyon sizi çağrılma bölgesindeki hata ayıklayıcıya bırakır. Spesifik olarak, `sys.breakpointhook()` ‘u çağırır, `args` ve `kws` ‘yi doğrudan geçer. Varsayılan olarak, `sys.breakpointhook()` hiçbir parametre beklemeden `pdb.set_trace()` fonksiyonunu çağırır. Bu durumda, bu tamamen size kolaylık sağlamak içindir, bu nedenle hata ayıklayıcıya girmek için `pdb` ‘yi içe aktarmanız veya fazla kod yazmanız gerekmez. Buna rağmen, `sys.breakpointhook()` başka bir fonksiyona ayarlanabilir ve `breakpoint()` otomatik olarak bunu çağırır ve tercih ettiğiniz hata ayıklayıcıya girmenize izin verir. Eğer `sys.breakpointhook()` ulaşılabilir değilse, bu fonksiyon `RuntimeError` hatasını verecektir.

  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.

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

  3.7 sürümünde geldi.

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.

  3.2 sürümünde 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.

  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.

  3.11 sürümünde değişti: 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.

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

  3.8 sürümünde 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=0, imag=0)
class complex(string)

  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.

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

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

  Argüman olarak iki (karmaşık olmayan) sayı alır ve bölme işlemi yapılırken bu argümanların bölümleri ve kalanlarından oluşan bir sayı çifti döndürür. Karışık işlenen türlerinde, ikili aritmetik işleçler için geçerli olan kurallar geçerlidir. Sonuç tam sayılar için `(a // b, a % b)` , Gerçel sayılar için `(q, a % b)` (q genellikle `math.floor(a / b)` ‘ye eşit ama bundan 1 eksik olabilir). Her durumda `q * b + a % b` , a ‘ya çok yakındır. Eğer `a % b` sıfır değilse, b ile aynı işarete sahiptir ve `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(expression, globals=None, locals=None)

  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.

  expression bağımsız değişkeni, genel ve yerel ad alanı olarak globals ve locals sözlükleri kullanılarak Python ifadesi (teknik olarak bir koşul listesi) olarak ayrıştırılır ve değerlendirilir. globals sözlüğü varsa ve `__builtins__` anahtarı için bir değer içermiyorsa, expression ayrıştırılmadan önce bu anahtarın altına yerleşik modül `builtins` sözlüğüne bir referans eklenir. Bu şekilde, kendi `__builtins__` sözlüğünüzü `eval()` içine geçirmeden önce globals içine ekleyerek yürütülen kod için hangi yerleşiklerin kullanılabilir olduğunu kontrol edebilirsiniz. locals sözlüğü atlanırsa, varsayılan olarak globals sözlüğünü kullanır. Her iki sözlük de atlanırsa, ifade `eval()` olarak adlandırılan ortamda globals ve locals ile yürütülür. Not, eval() kapsama ortamında iç içe kapsamlar (yerel olmayan) erişimi yoktur.

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

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

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

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

  Bu fonksiyon Python kodunun dinamik çalıştırılmasını destekler. object bir kod objesi veya dize olmalıdır. Dize ise, dize daha sonra yürütülen bir Python ifadeleri paketi olarak ayrıştırılır (bir sözdizimi hatası olmadıkça). [1] eğer bir kod objesiyse, sadece çalıştırılır. Her durumda, çalıştırılacak kodun dosya girişi olarak geçerli olması beklenir (Referans Kılavuzundaki File input kısmına bakınız). `nonlocal`, `yield`, ve `return` ifadelerinin `exec()` fonksiyonuna geçirilen kod kaynağında bile fonksiyonlar dışında kullanılamayacağını unutmayınız. Döndürülen değer `None` ‘dır.

  Her durumda eğer opsiyonal kısımlar atlandıysa, kod mevcut kapsamda çalıştırılır. Eğer sadece globals sağlandıysa, global ve yerel değişkenler için kullanılacak bir sözlük olmalıdır (bir sözlüğün alt sınıfı değil). Eğer globals ve locals sağlandıysa, global ve yerel değişkenler için sırasıyla kullanılırlar. Eğer sağlandıysa, locals herhangi bir haritalama objesi olabilir. Modül seviyesinde global ve yerel değişkenlerin aynı sözlükte bulunduğunu unutmayın. Eğer exec globals ve locals olarak iki ayrı nesne alırsa, kod bir sınıf tanımına gömülmüş gibi çalıştırılacaktır.

  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.

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

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

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(x=0.0)

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

  Eğer argüman dize ise, bir ondalık sayı içermelidir, isteğe bağlı olarak önünde bir işaret bulunabilir veya boşluk içine gömülebilir. Opsiyonel işaret `'+'` veya `'-'` olabilir; `'+'` işareti üretilen değerde bir etkisi yoktur. Argüman ayrıca NaN (not-a-number), pozitif sonsuz veya negatif sonsuzu temsil eden bir dize olabilir. Daha açık olmak gerekirse, baştaki ve sondaki boşluk karakterleri kaldırıldıktan sonra veri girişi aşağıdaki dilbilgisindeki `floatvalue` üretim kuralına uygun olmalıdır:

      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") ["+" | "-"] digitpart
      floatnumber ::=  number [exponent]
      floatvalue  ::=  [sign] (floatnumber | infinity | nan)

  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.

  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.

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

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

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.

  `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=0)
class int(x, base=10)

  Return an integer object constructed from a number or string x, or return `0` if no arguments are given. If x defines `__int__()`, `int(x)` returns `x.__int__()`. If x defines `__index__()`, it returns `x.__index__()`. If x defines `__trunc__()`, it returns `x.__trunc__()`. For floating point numbers, this truncates towards zero.

  Eğer x bir sayı değilse veya base verilmişse, x base radiksinde bir tamsayıyı temsil eden bir string, `bytes` veya `bytearray` örneği olmalıdır. İsteğe bağlı olarak, dizeden önce `+` veya `-` (arada boşluk olmadan) gelebilir, önünde sıfırlar olabilir, boşluklarla çevrelenebilir ve rakamlar arasına serpiştirilmiş tek alt çizgilere sahip olabilir.

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

  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` dizi girişleri ve dizi gösterimleri, hizmet reddi saldırılarından (DOS) kaçınmaya yardımcı olmak için sınırlandırılabilir. `ValueError`, bir x dizgesini `int` ‘e dönüştürürken sınır aşıldığında veya `int` ‘i bir dizgeye dönüştürürken sınırı aştığında ortaya çıkar. tam sayı dönüştürme uzunluk sınırlaması dokümanına bakın.

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

  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, *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 dosyanın açılacağı modu belirten opsiyonel bir dizedir. Varsayılan olarak metin modunda okuma anlamına gelen `'r'` değerini alır. Diğer sıradan değerler yazmak için (dosya zaten varsa kesilir) `'w'`, ayrıcalıklı oluşturma için `'x'` ve dosyaya ekleme yapmak için (bazı Unix sistemlerinde, hepsi o anki imleç pozisyonundan bağımsız dosyanın sonuna ekleme anlamına gelir). Metin modunda, encoding belirtilmemiş ise kullanılan kodlayıcı platforma bağlıdır: `locale.getpreferredencoding(False)()` geçerli kodlayıcıyı getirmek için çağırılır. (İşlenmemiş baytlar okumak veya yazmak için ikili modu kullanın ve encoding ‘i boş bırakın. Geçerli modlar:

  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 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 when writing in text mode), and an integer > 1 to indicate the size in bytes of a fixed-size chunk buffer. Note that specifying a buffer size this way applies for binary buffered I/O, but `TextIOWrapper` (i.e., files opened with `mode='r+'`) would have another buffering. To disable buffering in `TextIOWrapper`, consider using the `write_through` flag for `io.TextIOWrapper.reconfigure()`. When no buffering argument is given, the default buffering policy works as follows:

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

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

  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.

  Parametreler nümerik olmak zorundadır. Karışık işlenen türleriyle, ikili aritmetik operatörler için baskı kuralları geçerlidir. `int` işlemleri için, ikinci parametre negatif olmadığı sürece sonuç işlenen ile aynı türe sahip olmalıdır (baskıdan sonra); bu durumda, tüm parametreler gerçel sayıya çevrilir ve bir gerçel sayı sonucu teslim edilir. Örneğin `pow(10, 2)`, `100` değerini döndürür, ama `pow(10, -2)`, `0.01` değerini döndürür. integral olmayan bir üs ile `int` veya `float` tipinin negatif tabanı için, karmaşık bir sayı çıktı verilir. Örneğin, `pow(-9, 0.5)`, `3j` ‘ye yakın bir değer döndürür.

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

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

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 Sıralama NASIL YAPILIR ‘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.

  Bir statik metot sınıf üzerinden (`C.f()` gibi) veya bir örnek üzerinden (`C().f()` gibi) çağırılabilir. Hatta normal fonksiyonlar gibi (`f()`) de çağırılabilirler.

  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.

  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.

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.

  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.

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

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