Sözlük
******

">>>"
   The default Python prompt of the interactive shell.  Often seen for
   code examples which can be executed interactively in the
   interpreter.

"..."
   Şunlara başvurabilir:

   * Girintili bir kod bloğu için kod girerken, eşleşen bir çift sol
     ve sağ sınırlayıcı (parantez, köşeli parantez, kaşlı ayraç veya
     üçlü tırnak) içindeyken veya bir dekoratör belirttikten sonra
     etkileşimli kabuğun varsayılan Python istemi.

   * "Elipsis" yerleşik sabiti.

2to3
   Kaynağı ayrıştırarak ve ayrıştırma ağacında gezinerek tespit
   edilebilecek uyumsuzlukların çoğunu işleyerek Python 2.x kodunu
   Python 3.x koduna dönüştürmeye çalışan bir araç.

   2to3, standart kitaplıkta "lib2to3'; bağımsız bir giriş noktası şu
   şekilde sağlanır:file:`Tools/scripts/2to3". Bakınız 2to3 ---
   Automated Python 2 to 3 code translation.

soyut temel sınıf
   Soyut temel sınıflar *duck-typing* 'i, "hasattr()" gibi diğer
   teknikler beceriksiz veya tamamen yanlış olduğunda arayüzleri
   tanımlamanın bir yolunu sağlayarak tamamlar (örneğin sihirli
   yöntemlerle).  ABC'ler, bir sınıftan miras almayan ancak yine de
   "isinstance()" ve "issubclass()" tarafından tanınan sınıflar olan
   sanal alt sınıfları tanıtır; "abc" modül belgelerine bakın.  Python
   comes with many built-in ABCs for data structures (in the
   "collections.abc" module), numbers (in the "numbers" module),
   streams (in the "io" module), import finders and loaders (in the
   "importlib.abc" module).  "abc" modülü ile kendi ABC'lerinizi
   oluşturabilirsiniz.

dipnot
   A label associated with a variable, a class attribute or a function
   parameter or return value, used by convention as a *type hint*.

   Yerel değişkenlerin açıklamalarına çalışma zamanında erişilemez,
   ancak global değişkenlerin, sınıf niteliklerinin ve işlevlerin
   açıklamaları, sırasıyla modüllerin, sınıfların ve işlevlerin
   "__annotations__" özel özelliğinde saklanır.

   Bu işlevi açıklayan *variable annotation*, *function annotation*,
   **PEP 484** ve **PEP 526**'e bakın. Ek açıklamalarla çalışmaya
   ilişkin en iyi uygulamalar için ayrıca bkz. Annotations Best
   Practices.

argüman
   A value passed to a *function* (or *method*) when calling the
   function.  There are two kinds of argument:

   * *keyword argument*: bir işlev çağrısında bir tanımlayıcının (ör.
     "ad=") önüne geçen veya bir sözlükte "**" ile başlayan bir değer
     olarak geçirilen bir argüman.  Örneğin, "3" ve "5", aşağıdaki
     "complex()": çağrılarında anahtar kelimenin argümanleridir:

        complex(real=3, imag=5)
        complex(**{'real': 3, 'imag': 5})

   * *positional argument*: anahtar kelime argümanı olmayan bir
     argüman. Konumsal argümanler, bir argüman listesinin başında
     görünebilir ve/veya "*" ile başlayan bir *iterable* öğesinin
     öğeleri olarak iletilebilir. Örneğin, "3" ve "5", aşağıdaki
     çağrılarda konumsal argümanlerdir:

        complex(3, 5)
        complex(*(3, 5))

   argümanler, bir işlev gövdesindeki adlandırılmış yerel değişkenlere
   atanır. Bu atamayı yöneten kurallar için Calls bölümüne bakın.
   Sözdizimsel olarak, bir argümanı temsil etmek için herhangi bir
   ifade kullanılabilir; değerlendirilen değer yerel değişkene atanır.

   See also the *parameter* glossary entry, the FAQ question on the
   difference between arguments and parameters, and **PEP 362**.

asenkron bağlam yöneticisi
   "async with" ifadesinde görülen ortamı "__aenter__()" ve
   "__aexit__()" yöntemlerini tanımlayarak kontrol eden bir nesne.
   **PEP 492** de anlatıldı.

asenkron jeneratör
   *asynchronous generator iterator* döndüren bir işlev.  Bir "async
   for" döngüsünde kullanılabilen bir dizi değer üretmek için "yield"
   ifadeleri içermesi dışında "async def" ile tanımlanmış bir eşyordam
   işlevine benziyor.

   Genellikle bir asenkron üreteç işlevine atıfta bulunur, ancak bazı
   bağlamlarda bir *asynchronous generator iterator* 'e karşılık
   gelebilir.  Amaçlanan anlamın net olmadığı durumlarda, tam
   terimlerin kullanılması belirsizliği önler.

   Bir asenkron üretici fonksiyonu, "await" ifadelerinin yanı sıra
   "async for" ve "async with" ifadeleri içerebilir.

asenkron jeneratör yineleyici
   Bir *asynchronous generator* işlevi tarafından oluşturulan bir
   nesne.

   Bu, "__anext__()" yöntemi kullanılarak çağrıldığında, bir sonraki
   "yield" ifadesine kadar asynchronous generator işlevinin gövdesini
   yürütecek, beklenebilir bir nesne döndüren bir *asynchronous
   iterator*.

   Her "yield", konum yürütme durumunu hatırlayarak (yerel değişkenler
   ve bekleyen try ifadeleri dahil) işlemeyi geçici olarak askıya
   alır. *asynchronous generator iterator*, "__anext__()" tarafından
   döndürülen başka birbeklenebilir ile etkili bir şekilde devam
   ettiğinde, kaldığı yerden devam eder. Bkz. **PEP 492** ve **PEP
   525**.

eşzamansız yinelenebilir
   Bir "async for" ifadesinde kullanılabilen bir nesne. "__aiter__()"
   yönteminden bir *asynchronous iterator* döndürmelidir.  **PEP 492**
   'de tanıtıldı.

asenkron yineleyici
   An object that implements the "__aiter__()" and "__anext__()"
   methods.  "__anext__" must return an *awaitable* object. "async
   for" resolves the awaitables returned by an asynchronous iterator's
   "__anext__()" method until it raises a "StopAsyncIteration"
   exception.  Introduced by **PEP 492**.

nitelik
   A value associated with an object which is usually referenced by
   name using dotted expressions. For example, if an object *o* has an
   attribute *a* it would be referenced as *o.a*.

   Bir nesneye, eğer nesne izin veriyorsa, örneğin "setattr()"
   kullanarak, adı Identifiers and keywords tarafından tanımlandığı
   gibi tanımlayıcı olmayan bir öznitelik vermek mümkündür. Böyle bir
   özniteliğe noktalı bir ifade kullanılarak erişilemez ve bunun
   yerine "getattr()" ile alınması gerekir.

beklenebilir
   "await" ifadesinde kullanılabilen bir nesne.  Bir *coroutine* veya
   "__await__()" yöntemine sahip bir nesne olabilir. Ayrıca bakınız
   **PEP 492**.

BDFL
   Benevolent Dictator For Life, namı diğer Guido van Rossum,
   Python'un yaratıcısı.

ikili dosya
   Bir *dosya nesnesi* *bayt benzeri nesneler* okuyabilir ve
   yazabilir. İkili dosya örnekleri, ikili modda açılan dosyalardır
   ("'rb'", "'wb'" veya "'rb+'"), "sys.stdin.buffer",
   "sys.stdout.buffer" ve "io.BytesIO" ve "gzip.GzipFile" örnekleri.

   Ayrıca "str" nesnelerini okuyabilen ve yazabilen bir dosya nesnesi
   için *text file* 'a bakın.

borrowed reference
   In Python's C API, a borrowed reference is a reference to an
   object, where the code using the object does not own the reference.
   It becomes a dangling pointer if the object is destroyed. For
   example, a garbage collection can remove the last *strong
   reference* to the object and so destroy it.

   *borrowed reference* üzerinde "Py_INCREF()" çağırmak, nesnenin
   ödünç alınanın son kullanımından önce yok edilemediği durumlar
   dışında, onu yerinde bir *strong reference* 'a dönüştürmek için
   tavsiye edilir. referans. "Py_NewRef()" işlevi, yeni bir *strong
   reference* oluşturmak için kullanılabilir.

bayt benzeri nesne
   Buffer Protocol 'i destekleyen ve bir C-*contiguous* arabelleğini
   dışa aktarabilen bir nesne. Bu, tüm "bytes", "bytearray" ve
   "array.array" nesnelerinin yanı sıra birçok yaygın "memoryview"
   nesnesini içerir.  Bayt benzeri nesneler, ikili verilerle çalışan
   çeşitli işlemler için kullanılabilir; bunlara sıkıştırma, ikili
   dosyaya kaydetme ve bir soket üzerinden gönderme dahildir.

   Bazı işlemler, değişken olması için ikili verilere ihtiyaç duyar.
   Belgeler genellikle bunlara "okuma-yazma bayt benzeri nesneler"
   olarak atıfta bulunur. Örnek değiştirilebilir arabellek nesneleri
   "bytearray" ve bir "bytearray" "memoryview" içerir. Diğer işlemler,
   ikili verilerin değişmez nesnelerde ("salt okunur bayt benzeri
   nesneler") depolanmasını gerektirir; bunların örnekleri arasında
   "bytes" ve bir "bytes" nesnesinin "memoryview" bulunur.

bayt kodu
   Python kaynak kodu, bir Python programının CPython
   yorumlayıcısındaki dahili temsili olan bayt kodunda derlenir.  Bayt
   kodu ayrıca ".pyc" dosyalarında önbelleğe alınır, böylece aynı
   dosyanın ikinci kez çalıştırılması daha hızlı olur (kaynaktan bayt
   koduna yeniden derleme önlenebilir).  Bu "ara dilin", her bir bayt
   koduna karşılık gelen makine kodunu yürüten bir *sanal makine*
   üzerinde çalıştığı söylenir. Bayt kodlarının farklı Python sanal
   makineleri arasında çalışması veya Python sürümleri arasında
   kararlı olması beklenmediğini unutmayın.

   Bayt kodu talimatlarının bir listesi Python Bytecode Instructions
   dokümanında bulunabilir.

callable
   Bir çağrılabilir, muhtemelen bir dizi argümanla (bkz. *argument*)
   ve aşağıdaki sözdizimiyle çağrılabilen bir nesnedir:

      callable(argument1, argument2, ...)

   Bir *fonksiyon* ve uzantısı olarak bir *metot* bir çağrılabilirdir.
   "__call__()" yöntemini uygulayan bir sınıf örneği de bir
   çağrılabilirdir.

geri çağırmak
   Gelecekte bir noktada yürütülecek bir argüman olarak iletilen bir
   alt program işlevi.

sınıf
   Kullanıcı tanımlı nesneler oluşturmak için bir şablon. Sınıf
   tanımları normalde sınıfın örnekleri üzerinde çalışan yöntem
   tanımlarını içerir.

sınıf değişkeni
   Bir sınıfta tanımlanmış ve yalnızca sınıf düzeyinde (yani sınıfın
   bir örneğinde değil) değiştirilmesi amaçlanan bir değişken.

zorlama
   Aynı türden iki argüman içeren bir işlem sırasında bir tür
   örneğinin diğerine örtük olarak dönüştürülmesi.  Örneğin,
   "int(3.15)", kayan noktalı sayıyı "3" tamsayısına dönüştürür, ancak
   "3+4.5" 'te her argüman farklı türdedir (bir int, bir kayan nokta),
   ve her ikisi de eklenmeden önce aynı türe dönüştürülmelidir, aksi
   takdirde bir "TypeError" yükseltir. Zorlama olmadan, uyumlu
   türlerin bile tüm argümanlarının programcı tarafından aynı değere
   normalleştirilmesi gerekir, örneğin: "3+4,5" yerine "float(3)+4,5".

karmaşık sayı
   Tüm sayıların bir reel kısım ve bir sanal kısım toplamı olarak
   ifade edildiği bilinen gerçek sayı sisteminin bir uzantısı.  Hayali
   sayılar, hayali birimin gerçek katlarıdır ("-1" 'in karekökü),
   genellikle matematikte "i" veya mühendislikte "j" ile yazılır.
   Python, bu son gösterimle yazılan karmaşık sayılar için yerleşik
   desteğe sahiptir; hayali kısım bir "j" son ekiyle yazılır, örneğin
   "3+1j".  "math" modülünün karmaşık eşdeğerlerine erişmek için
   "cmath" kullanın.  Karmaşık sayıların kullanımı oldukça gelişmiş
   bir matematiksel özelliktir. Onlara olan ihtiyacın farkında
   değilseniz, onları güvenle görmezden gelebileceğiniz neredeyse
   kesindir.

bağlam yöneticisi
   "with" ifadesinde görülen ortamı "__enter__()" ve "__exit__()"
   yöntemlerini tanımlayarak kontrol eden bir nesne. Bakınız **PEP
   343**.

bağlam değişkeni
   Bağlamına bağlı olarak farklı değerler alabilen bir değişken. Bu,
   her yürütme iş parçacığının bir değişken için farklı bir değere
   sahip olabileceği Thread-Local Storage'a benzer. Bununla birlikte,
   bağlam değişkenleriyle, bir yürütme iş parçacığında birkaç bağlam
   olabilir ve bağlam değişkenlerinin ana kullanımı, eşzamanlı zaman
   uyumsuz görevlerde değişkenleri izlemektir. Bakınız "contextvars".

bitişik
   Bir arabellek, *C-bitişik* veya *Fortran bitişik* ise tam olarak
   bitişik olarak kabul edilir.  Sıfır boyutlu arabellekler C ve
   Fortran bitişiktir.  Tek boyutlu dizilerde, öğeler sıfırdan
   başlayarak artan dizinler sırasına göre bellekte yan yana
   yerleştirilmelidir.  Çok boyutlu C-bitişik dizilerde, öğeleri
   bellek adresi sırasına göre ziyaret ederken son dizin en hızlı
   şekilde değişir.  Ancak, Fortran bitişik dizilerinde, ilk dizin en
   hızlı şekilde değişir.

eşyordam
   Eşyordamlar, altyordamların daha genelleştirilmiş bir biçimidir.
   Alt programlara bir noktada girilir ve başka bir noktada çıkılır.
   Eşyordamlar birçok farklı noktada girilebilir, çıkılabilir ve devam
   ettirilebilir.  "async def" ifadesi ile uygulanabilirler.  Ayrıca
   bakınız **PEP 492**.

eşyordam işlevi
   Bir *coroutine* nesnesi döndüren bir işlev.  Bir eşyordam işlevi
   "async def" ifadesiyle tanımlanabilir ve "await", "async for" ve
   "async with" anahtar kelimelerini içerebilir.  Bunlar **PEP 492**
   tarafından tanıtıldı.

CPython
   Python programlama dilinin python.org üzerinde dağıtıldığı şekliyle
   kurallı uygulaması.  "CPython" terimi, gerektiğinde bu uygulamayı
   Jython veya IronPython gibi diğerlerinden ayırmak için kullanılır.

dekoratör
   Genellikle "@wrapper" sözdizimi kullanılarak bir işlev dönüşümü
   olarak uygulanan, başka bir işlevi döndüren bir işlev.
   Dekoratörler için yaygın örnekler şunlardır: "classmethod()" ve
   "staticmethod()".

   Dekoratör sözdizimi yalnızca sözdizimsel şekerdir, aşağıdaki iki
   işlev tanımı anlamsal olarak eşdeğerdir:

      def f(arg):
          ...
      f = staticmethod(f)

      @staticmethod
      def f(arg):
          ...

   Aynı kavram sınıflar için de mevcuttur, ancak orada daha az
   kullanılır.  Dekoratörler hakkında daha fazla bilgi için function
   definitions ve class definitions belgelerine bakın.

tanımlayıcı
   "__get__()", "__set__()" veya "__delete__()" yöntemlerini
   tanımlayan herhangi bir nesne.  Bir sınıf özniteliği bir
   tanımlayıcı olduğunda, öznitelik araması üzerine özel bağlama
   davranışı tetiklenir.  Normalde, bir özniteliği almak, ayarlamak
   veya silmek için *a.b* kullanmak, *a* için sınıf sözlüğünde *b*
   adlı nesneyi arar, ancak *b* bir tanımlayıcı ise, ilgili
   tanımlayıcı yöntemi çağrılır.  Tanımlayıcıları anlamak, Python'u
   derinlemesine anlamanın anahtarıdır çünkü bunlar, işlevler,
   yöntemler, özellikler, sınıf yöntemleri, statik yöntemler ve süper
   sınıflara başvuru gibi birçok özelliğin temelidir.

   Tanımlayıcıların yöntemleri hakkında daha fazla bilgi için, bkz.
   Implementing Descriptors veya Descriptor How To Guide.

sözlük
   Rasgele anahtarların değerlerle eşlendiği ilişkisel bir dizi.
   Anahtarlar, "__hash__()" ve "__eq__()" yöntemleriyle herhangi bir
   nesne olabilir. Perl'de karma denir.

sözlük anlama
   Öğelerin tümünü veya bir kısmını yinelenebilir bir şekilde
   işlemenin ve sonuçları içeren bir sözlük döndürmenin kompakt bir
   yolu. "results = {n: n ** 2 for range(10)}", "n ** 2" değerine
   eşlenmiş "n" anahtarını içeren bir sözlük oluşturur. Bkz. Displays
   for lists, sets and dictionaries.

sözlük görünümü
   "dict.keys()", "dict.values()" ve "dict.items()" 'den döndürülen
   nesnelere sözlük görünümleri denir. Sözlüğün girişleri üzerinde
   dinamik bir görünüm sağlarlar; bu, sözlük değiştiğinde görünümün bu
   değişiklikleri yansıttığı anlamına gelir. Sözlük görünümünü tam
   liste olmaya zorlamak için "list(dictview)" kullanın.  Bakınız
   Dictionary view objects.

belge dizisi
   Bir sınıf, işlev veya modülde ilk ifade olarak görünen bir dize
   değişmezi.  Paket yürütüldüğünde yoksayılırken, derleyici
   tarafından tanınır ve çevreleyen sınıfın, işlevin veya modülün
   "__doc__" özniteliğine yerleştirilir.  İç gözlem yoluyla
   erişilebilir olduğundan, nesnenin belgelenmesi için kurallı yerdir.

duck-typing
   Doğru arayüze sahip olup olmadığını belirlemek için bir nesnenin
   türüne bakmayan bir programlama stili; bunun yerine, yöntem veya
   nitelik basitçe çağrılır veya kullanılır ("Ördek gibi görünüyorsa
   ve ördek gibi vaklıyorsa, ördek olmalıdır.")  İyi tasarlanmış kod,
   belirli türlerden ziyade arayüzleri vurgulayarak, polimorfik
   ikameye izin vererek esnekliğini artırır.  Ördek yazma, "type()"
   veya "isinstance()" kullanan testleri önler.  (Ancak, ördek
   yazmanın *abstract base class* ile tamamlanabileceğini unutmayın.)
   Bunun yerine, genellikle "hasattr()" testleri veya *EAFP*
   programlamasını kullanır.

EAFP
   Af dilemek izin almaktan daha kolaydır.  Bu yaygın Python kodlama
   stili, geçerli anahtarların veya niteliklerin varlığını varsayar ve
   varsayımın yanlış çıkması durumunda istisnaları yakalar.  Bu temiz
   ve hızlı stil, birçok "try" ve "except" ifadesinin varlığı ile
   karakterize edilir.  Teknik, C gibi diğer birçok dilde ortak olan
   *LBYL* stiliyle çelişir.

ifade (değer döndürür)
   Bir değere göre değerlendirilebilecek bir sözdizimi parçası.  Başka
   bir deyişle, bir ifade, tümü bir değer döndüren sabit değerler,
   adlar, öznitelik erişimi, işleçler veya işlev çağrıları gibi ifade
   öğelerinin bir toplamıdır.  Diğer birçok dilin aksine, tüm dil
   yapıları ifade değildir. Ayrıca "while" gibi kullanılamayan
   *ifadeler* de vardır.  Atamalar da değer döndürmeyen ifadelerdir
   (statement).

uzatma modülü
   Çekirdekle ve kullanıcı koduyla etkileşim kurmak için Python'un C
   API'sini kullanan, C veya C++ ile yazılmış bir modül.

f-string
   Ön eki "'f'" veya "'F'" olan dize değişmezleri genellikle
   "f-strings" olarak adlandırılır; bu, formatted string literals 'ın
   kısaltmasıdır.  Ayrıca bkz. **PEP 498**.

dosya nesnesi
   Dosya yönelimli bir API'yi ("read()" veya "write()" gibi
   yöntemlerle) temel alınan bir kaynağa gösteren bir nesne.
   Oluşturulma şekline bağlı olarak, bir dosya nesnesi gerçek bir disk
   üzerindeki dosyaya veya başka bir tür depolama veya iletişim
   aygıtına (örneğin standart giriş/çıkış, bellek içi arabellekler,
   yuvalar, borular vb.) erişime aracılık edebilir. .  Dosya nesneleri
   ayrıca *file-like objects* veya *streams* olarak da adlandırılır.

   Aslında üç dosya nesnesi kategorisi vardır: ham *binary files*,
   arabelleğe alınmış *binary files* ve *text files*. Arayüzleri "io"
   modülünde tanımlanmıştır.  Bir dosya nesnesi yaratmanın kurallı
   yolu "open()" işlevini kullanmaktır.

dosya benzeri nesne
   *dosya nesnesi* ile eşanlamlıdır.

dosya sistemi kodlaması ve hata işleyicisi
   Python tarafından işletim sistemindeki baytların kodunu çözmek ve
   Unicode'u işletim sistemine kodlamak için kullanılan kodlama ve
   hata işleyici.

   Dosya sistemi kodlaması, 128'in altındaki tüm baytların kodunu
   başarıyla çözmeyi garanti etmelidir. Dosya sistemi kodlaması bu
   garantiyi sağlayamazsa, API işlevleri "UnicodeError" değerini
   yükseltebilir.

   "sys.getfilesystemencoding()" ve "sys.getfilesystemencodeerrors()"
   işlevleri, dosya sistemi kodlamasını ve hata işleyicisini almak
   için kullanılabilir.

   *filesystem encoding and error handler* Python başlangıcında
   "PyConfig_Read()" işleviyle yapılandırılır: bkz.
   "filesystem_encoding" ve " filesystem_errors" üyeleri "PyConfig".

   Ayrıca bkz. *locale encoding*.

bulucu
   İçe aktarılmakta olan bir modül için *loader* 'ı bulmaya çalışan
   bir nesne.

   Python 3.3'ten beri, iki çeşit bulucu vardır: "sys.meta_path" ile
   kullanılmak üzere *meta yol bulucular*, ve "sys.path_hooks" ile
   kullanılmak üzere *yol girişi bulucular*.

   Daha fazla ayrıntı için **PEP 302**, **PEP 420** ve **PEP 451**
   bakın.

kat bölümü
   En yakın tam sayıya yuvarlayan matematiksel bölme.  Kat bölme
   operatörü "//" şeklindedir.  Örneğin, "11 // 4" ifadesi, gerçek
   yüzer bölme tarafından döndürülen "2.75" değerinin aksine "2"
   olarak değerlendirilir.  "(-11) // 4" 'ün "-3" olduğuna dikkat
   edin, çünkü bu "-2.75" yuvarlatılmış *aşağı*. Bakınız **PEP 238**.

fonksiyon
   Bir arayana bir değer döndüren bir dizi ifade. Ayrıca, gövdenin
   yürütülmesinde kullanılabilen sıfır veya daha fazla *argüman*
   iletilebilir. Ayrıca *parameter*, *method* ve Function definitions
   bölümüne bakın.

fonksiyon açıklaması
   Bir işlev parametresinin veya dönüş değerinin *ek açıklaması*.

   İşlev ek açıklamaları genellikle *type hints* için kullanılır:
   örneğin, bu fonksiyonun iki "int" argüman alması ve ayrıca bir
   "int" dönüş değerine sahip olması beklenir

      def sum_two_numbers(a: int, b: int) -> int:
         return a + b

   İşlev açıklama sözdizimi Function definitions bölümünde
   açıklanmaktadır.

   Bu işlevi açıklayan *variable annotation* ve **PEP 484** 'e bakın.
   Ek açıklamalarla çalışmaya ilişkin en iyi uygulamalar için ayrıca
   Annotations Best Practices konusuna bakın.

__future__
   Bir future ifadesi, "from __future__ import <feature>",
   derleyiciyi, Python'un gelecekteki bir sürümünde standart hale
   gelecek olan sözdizimini veya semantiği kullanarak mevcut modülü
   derlemeye yönlendirir. "__future__" modülü, *feature*'ın olası
   değerlerini belgeler.  Bu modülü içe aktararak ve değişkenlerini
   değerlendirerek, dile ilk kez yeni bir özelliğin ne zaman
   eklendiğini ve ne zaman varsayılan olacağını (ya da yaptığını)
   görebilirsiniz:

      >>> import __future__
      >>> __future__.division
      _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

çöp toplama
   Artık kullanılmadığında belleği boşaltma işlemi.  Python, referans
   sayımı ve referans döngülerini algılayıp kırabilen bir döngüsel çöp
   toplayıcı aracılığıyla çöp toplama gerçekleştirir.  Çöp toplayıcı
   "gc" modülü kullanılarak kontrol edilebilir.

jeneratör
   Bir *generator iterator* döndüren bir işlev.  Bir for döngüsünde
   kullanılabilen bir dizi değer üretmek için "yield" ifadeleri
   içermesi veya "next()" işleviyle birer birer alınabilmesi dışında
   normal bir işleve benziyor.

   Genellikle bir üretici işlevine atıfta bulunur, ancak bazı
   bağlamlarda bir *jeneratör yineleyicisine* atıfta bulunabilir.
   Amaçlanan anlamın net olmadığı durumlarda, tam terimlerin
   kullanılması belirsizliği önler.

jeneratör yineleyici
   Bir *generator* işlevi tarafından oluşturulan bir nesne.

   Her "yield", konum yürütme durumunu hatırlayarak (yerel değişkenler
   ve bekleyen try ifadeleri dahil) işlemeyi geçici olarak askıya
   alır.  *jeneratör yineleyici* devam ettiğinde, kaldığı yerden devam
   eder (her çağrıda yeniden başlayan işlevlerin aksine).

jeneratör ifadesi
   Yineleyici döndüren bir ifade.  Bir döngü değişkenini, aralığı ve
   isteğe bağlı bir "if" yan tümcesini tanımlayan bir "for" yan
   tümcesinin takip ettiği normal bir ifadeye benziyor.
   Birleştirilmiş ifade, bir çevreleyen için değerler üretir:

      >>> sum(i*i for i in range(10))         # sum of squares 0, 1, 4, ... 81
      285

genel işlev
   Farklı türler için aynı işlemi uygulayan birden çok işlevden oluşan
   bir işlev. Bir çağrı sırasında hangi uygulamanın kullanılması
   gerektiği, gönderme algoritması tarafından belirlenir.

   Ayrıca *single dispatch* sözlük girdisine,
   "functools.singledispatch()" dekoratörüne ve **PEP 443** 'e bakın.

genel tip
   Parametrelendirilebilen bir *type*; tipik olarak bir konteyner
   sınıfı, örneğin "list" veya "dict". *type hint* ve *annotation*
   için kullanılır.

   Daha fazla ayrıntı için generic allias types, **PEP 483**, **PEP
   484**, **PEP 585** ve "typing" modülüne bakın.

GIL
   Bakınız *global interpreter lock*.

genel tercüman kilidi
   *CPython* yorumlayıcısı tarafından aynı anda yalnızca bir iş
   parçacığının Python *bytecode* 'u yürütmesini sağlamak için
   kullanılan mekanizma. Bu, nesne modelini ("dict" gibi kritik
   yerleşik türler dahil) eşzamanlı erişime karşı örtük olarak güvenli
   hale getirerek CPython uygulamasını basitleştirir.  Tüm
   yorumlayıcıyı kilitlemek, çok işlemcili makinelerin sağladığı
   paralelliğin çoğu pahasına, yorumlayıcının çok iş parçacıklı
   olmasını kolaylaştırır.

   However, some extension modules, either standard or third-party,
   are designed so as to release the GIL when doing computationally
   intensive tasks such as compression or hashing.  Also, the GIL is
   always released when doing I/O.

   "Serbest iş parçacıklı" bir yorumlayıcı (paylaşılan verileri çok
   daha ince bir ayrıntı düzeyinde kilitleyen) oluşturma çabaları,
   ortak tek işlemcili durumda performans düştüğü için başarılı
   olmamıştır. Bu performans sorununun üstesinden gelinmesinin
   uygulamayı çok daha karmaşık hale getireceğine ve dolayısıyla
   bakımını daha maliyetli hale getireceğine inanılmaktadır.

karma tabanlı pyc
   Geçerliliğini belirlemek için ilgili kaynak dosyanın son
   değiştirilme zamanı yerine karma değerini kullanan bir bayt kodu
   önbellek dosyası. Bakınız Cached bytecode invalidation.

yıkanabilir
   Bir nesne, ömrü boyunca asla değişmeyen bir karma değere sahipse
   (bir "__hash__()" yöntemine ihtiyaç duyar) ve diğer nesnelerle
   karşılaştırılabilirse (bir "__eq__()" yöntemine ihtiyaç duyar)
   *hashable* olur. .  Eşit karşılaştıran Hashable nesneleri aynı
   karma değerine sahip olmalıdır.

   Hashability, bir nesneyi bir sözlük anahtarı ve bir set üyesi
   olarak kullanılabilir hale getirir, çünkü bu veri yapıları hash
   değerini dahili olarak kullanır.

   Python'un değişmez yerleşik nesnelerinin çoğu, yıkanabilir;
   değiştirilebilir kaplar (listeler veya sözlükler gibi) değildir;
   değişmez kaplar (tüpler ve donmuş kümeler gibi) yalnızca öğelerinin
   yıkanabilir olması durumunda yıkanabilirdir.  Kullanıcı tanımlı
   sınıfların örnekleri olan nesneler varsayılan olarak hash
   edilebilirdir.  Hepsi eşit olmayanı karşılaştırır (kendileriyle
   hariç) ve hash değerleri "id()" 'lerinden türetilir.

BOŞTA
   An Integrated Development and Learning Environment for Python. IDLE
   is a basic editor and interpreter environment which ships with the
   standard distribution of Python.

değişmez
   Sabit değeri olan bir nesne.  Değişmez nesneler arasında sayılar,
   dizeler ve demetler bulunur.  Böyle bir nesne değiştirilemez.
   Farklı bir değerin saklanması gerekiyorsa yeni bir nesne
   oluşturulmalıdır.  Örneğin bir sözlükte anahtar olarak, sabit bir
   karma değerinin gerekli olduğu yerlerde önemli bir rol oynarlar.

içe aktarım yolu
   İçe aktarılacak modüller için *path based finder* tarafından aranan
   konumların (veya *path entries*) listesi. İçe aktarma sırasında, bu
   konum listesi genellikle "sys.path" adresinden gelir, ancak alt
   paketler için üst paketin "__path__" özelliğinden de gelebilir.

içe aktarma
   Bir modüldeki Python kodunun başka bir modüldeki Python koduna
   sunulması süreci.

içe aktarıcı
   Bir modülü hem bulan hem de yükleyen bir nesne; hem bir *finder*
   hem de *loader* nesnesi.

etkileşimli
   Python'un etkileşimli bir yorumlayıcısı vardır; bu, yorumlayıcı
   isteminde ifadeler ve ifadeler girebileceğiniz, bunları hemen
   çalıştırabileceğiniz ve sonuçlarını görebileceğiniz anlamına gelir.
   Herhangi bir argüman olmadan "python" 'u başlatmanız yeterlidir
   (muhtemelen bilgisayarınızın ana menüsünden seçerek). Yeni
   fikirleri test etmenin veya modülleri ve paketleri incelemenin çok
   güçlü bir yoludur ("help(x)" 'i unutmayın).

yorumlanmış
   Python, derlenmiş bir dilin aksine yorumlanmış bir dildir, ancak
   bayt kodu derleyicisinin varlığı nedeniyle ayrım bulanık olabilir.
   Bu, kaynak dosyaların daha sonra çalıştırılacak bir yürütülebilir
   dosya oluşturmadan doğrudan çalıştırılabileceği anlamına gelir.
   Yorumlanan diller genellikle derlenmiş dillerden daha kısa bir
   geliştirme/hata ayıklama döngüsüne sahiptir, ancak programları
   genellikle daha yavaş çalışır.  Ayrıca bkz. *interactive*.

tercüman kapatma
   Kapatılması istendiğinde, Python yorumlayıcısı, modüller ve çeşitli
   kritik iç yapılar gibi tahsis edilen tüm kaynakları kademeli olarak
   serbest bıraktığı özel bir aşamaya girer.  Ayrıca *garbage
   collector* için birkaç çağrı yapar. Bu, kullanıcı tanımlı
   yıkıcılarda veya zayıf referans geri aramalarında kodun
   yürütülmesini tetikleyebilir. Kapatma aşamasında yürütülen kod,
   dayandığı kaynaklar artık çalışmayabileceğinden çeşitli
   istisnalarla karşılaşabilir (yaygın örnekler kitaplık modülleri
   veya uyarı makineleridir).

   Yorumlayıcının kapatılmasının ana nedeni, "__main__" modülünün veya
   çalıştırılan betiğin yürütmeyi bitirmiş olmasıdır.

yinelenebilir
   Üyelerini teker teker döndürebilen bir nesne. Yineleme örnekleri,
   tüm dizi türlerini ("list", "str", and "tuple" gibi) ve "dict",
   *dosya objeleri* gibi bazı dizi olmayan türleri ve bir "__iter__()"
   yöntemiyle veya *dizi* semantiğini uygulayan bir "__getitem__()"
   yöntemiyle tanımladığınız tüm sınıfların nesnelerini içerir.

   Yinelenebilirler bir "for" döngüsünde ve bir dizinin gerekli olduğu
   diğer birçok yerde kullanılabilir ("zip()", "map()", ...).
   Yerleşik "iter()" işlevine argüman olarak yinelenebilir bir nesne
   iletildiğinde, nesne için bir yineleyici döndürür.  Bu yineleyici,
   değerler kümesi üzerinden bir geçiş için iyidir.  Yinelenebilirleri
   kullanırken, genellikle "iter()" çağırmanız veya yineleyici
   nesnelerle kendiniz ilgilenmeniz gerekmez.  "for" ifadesi bunu
   sizin için otomatik olarak yapar ve yineleyiciyi döngü süresince
   tutmak için geçici bir adsız değişken oluşturur.  Ayrıca bkz.
   *iterator*, *sequence* ve *generator*.

yineleyici
   Bir veri akışını temsil eden bir nesne.  Yineleyicinin "__next__()"
   yöntemine (veya yerleşik "next()" işlevine iletilmesi) yinelenen
   çağrılar, akıştaki ardışık öğeleri döndürür.  Daha fazla veri
   bulunmadığında, bunun yerine bir "StopIteration" istisnası
   oluşturulur.  Bu noktada, yineleyici nesnesi tükenir ve
   "__next__()" yöntemine yapılan diğer çağrılar yalnızca
   "StopIteration" öğesini yeniden yükseltir.  Yineleyicilerin,
   yineleyici nesnesinin kendisini döndüren bir "__iter__()" yöntemine
   sahip olmaları gerekir, böylece her yineleyici de yinelenebilir ve
   diğer yinelenebilirlerin kabul edildiği çoğu yerde kullanılabilir.
   Dikkate değer bir istisna, birden çok yineleme geçişini deneyen
   koddur.  Bir kapsayıcı nesnesi (örneğin bir "list"), onu "iter()"
   işlevine her ilettiğinizde veya onu bir "for" döngüsünde
   kullandığınızda yeni bir yineleyici üretir.  Bunu bir yineleyiciyle
   denemek, önceki yineleme geçişinde kullanılan aynı tükenmiş
   yineleyici nesnesini döndürerek boş bir kap gibi görünmesini
   sağlar.

   Daha fazla bilgi Yineleyici Türleri içinde bulunabilir.

   **CPython uygulama ayrıntısı:** CPython, bir yineleyicinin
   "__iter__()" tanımlaması gereksinimini tutarlı bir şekilde
   uygulamaz.

anahtar işlev
   Anahtar işlevi veya harmanlama işlevi, sıralama veya sıralama için
   kullanılan bir değeri döndüren bir çağrılabilir.  Örneğin,
   "locale.strxfrm()", yerel ayara özgü sıralama kurallarının farkında
   olan bir sıralama anahtarı üretmek için kullanılır.

   Python'daki bir dizi araç, öğelerin nasıl sıralandığını veya
   gruplandırıldığını kontrol etmek için temel işlevleri kabul eder.
   Bunlar "min()", "max()", "sorted()", "list.sort()",
   "heapq.merge()", "heapq.nsmallest()", "heapq.nlargest()" ve
   "itertools.groupby()".

   Bir tuş işlevi oluşturmanın birkaç yolu vardır.  Örneğin.
   "str.lower()" yöntemi, büyük/küçük harfe duyarlı olmayan
   sıralamalar için bir anahtar işlev işlevi görebilir.  Alternatif
   olarak, "lambda r: (r[0], r[2])" gibi bir "lambda" ifadesinden bir
   anahtar işlevi oluşturulabilir.  Ayrıca, "operator" modülü üç temel
   işlev kurucusu sağlar: "attrgetter()", "itemgetter()" ve
   "methodcaller()".  Anahtar işlevlerin nasıl oluşturulacağı ve
   kullanılacağına ilişkin örnekler için Sorting HOW TO bölümüne
   bakın.

anahtar kelime argümanı
   Bakınız *argument*.

lambda
   İşlev çağrıldığında değerlendirilen tek bir *expression* 'dan
   oluşan anonim bir satır içi işlev.  Bir lambda işlevi oluşturmak
   için sözdizimi "lambda [parametreler]: ifade" şeklindedir

LBYL
   Zıplamadan önce Bak.  Bu kodlama stili, arama veya arama yapmadan
   önce ön koşulları açıkça test eder.  Bu stil, *EAFP* yaklaşımıyla
   çelişir ve birçok "if" ifadesinin varlığı ile karakterize edilir.

   Çok iş parçacıklı bir ortamda, LBYL yaklaşımı "bakan" ve "sıçrayan"
   arasında bir yarış koşulu getirme riskini taşıyabilir.  Örneğin,
   "if key in mapping: return mapping[key]" kodu, testten sonra, ancak
   aramadan önce başka bir iş parçacığı *eşlemeden* *key* kaldırırsa
   başarısız olabilir. Bu sorun, kilitlerle veya EAFP yaklaşımı
   kullanılarak çözülebilir.

yerel kodlama
   Unix'te, LC_CTYPE yerel ayarının kodlamasıdır.
   "locale.setlocale(locale.LC_CTYPE, new_locale)" ile ayarlanabilir.

   Windows'ta bu, ANSI kod sayfasıdır (ör. "cp1252").

   "locale.getpreferredencoding(False)" yerel ayar kodlamasını almak
   için kullanılabilir.

   Python, Unicode dosya adları ile bayt dosya adları arasında
   dönüştürme yapmak için *filesystem encoding and error handler*
   kullanır.

liste
   Yerleşik bir Python *dizi*.  Adına rağmen, öğelere erişim O(1)
   olduğundan, diğer dillerdeki bir diziye, bağlantılı bir listeden
   daha yakındır.

liste anlama
   Bir dizideki öğelerin tümünü veya bir kısmını işlemenin ve
   sonuçları içeren bir liste döndürmenin kompakt bir yolu.  "sonuç =
   ['{:#04x}'.format(x) for range(256) if x % 2 == 0]", dizinde çift
   onaltılık sayılar (0x..) içeren bir diziler listesi oluşturur. 0
   ile 255 arasındadır. "if" yan tümcesi isteğe bağlıdır.  Atlanırsa,
   "aralık(256)" içindeki tüm öğeler işlenir.

yükleyici
   Modül yükleyen bir nesne. "load_module()" adında bir yöntem
   tanımlamalıdır. Bir yükleyici genellikle bir *finder* ile
   döndürülür. Ayrıntılar için **PEP 302** ve bir *soyut temel sınıf*
   için "importlib.abc.Loader" bölümüne bakın.

sihirli yöntem
   *special method* için gayri resmi bir eşanlamlı.

haritalama
   Keyfi anahtar aramalarını destekleyen ve "Mapping" veya
   "MutableMapping" Collections Abstract Base Classes içinde
   belirtilen yöntemleri uygulayan bir kapsayıcı nesnesi temel
   sınıflar.  Örnekler arasında "dict", "collections.defaultdict",
   "collections.OrderedDict" ve "collections.Counter" sayılabilir.

meta yol bulucu
   Bir *finder*, "sys.meta_path" aramasıyla döndürülür.  Meta yol
   bulucular, *yol girişi bulucuları* ile ilişkilidir, ancak onlardan
   farklıdır.

   Meta yol bulucuların uyguladığı yöntemler için
   "importlib.abc.MetaPathFinder" bölümüne bakın.

metasınıf
   Bir sınıfın sınıfı.  Sınıf tanımları, bir sınıf adı, bir sınıf
   sözlüğü ve temel sınıfların bir listesini oluşturur.  Metasınıf, bu
   üç argümanı almaktan ve sınıfı oluşturmaktan sorumludur. Çoğu nesne
   yönelimli programlama dili, varsayılan bir uygulama sağlar.
   Python'u özel yapan şey, özel metasınıflar oluşturmanın mümkün
   olmasıdır. Çoğu kullanıcı bu araca hiçbir zaman ihtiyaç duymaz,
   ancak ihtiyaç duyulduğunda, metasınıflar güçlü ve zarif çözümler
   sağlayabilir.  Nitelik erişimini günlüğe kaydetmek, iş parçacığı
   güvenliği eklemek, nesne oluşturmayı izlemek, tekilleri uygulamak
   ve diğer birçok görev için kullanılmışlardır.

   Daha fazla bilgi Metaclasses içinde bulunabilir.

metot
   Bir sınıf gövdesi içinde tanımlanan bir işlev. Bu sınıfın bir
   örneğinin özniteliği olarak çağrılırsa, yöntem örnek nesnesini ilk
   *argument* (genellikle "self" olarak adlandırılır) olarak alır.
   Bkz. *function* ve *nested scope*.

metot kalite sıralaması
   Metot Çözüm Sırası, arama sırasında bir üye için temel sınıfların
   arandığı sıradır. 2.3 sürümünden bu yana Python yorumlayıcısı
   tarafından kullanılan algoritmanın ayrıntıları için bkz. The Python
   2.3 Method Resolution Order

modül
   Python kodunun kuruluş birimi olarak hizmet eden bir nesne.
   Modüller, rastgele Python nesneleri içeren bir ad alanına sahiptir.
   Modüller, *importing* işlemiyle Python'a yüklenir.

   Ayrıca bakınız *package*.

modül özelliği
   Bir modülü yüklemek için kullanılan içe aktarmayla ilgili bilgileri
   içeren bir ad alanı. Bir "importlib.machinery.ModuleSpec" örneği.

MRO
   Bakınız *metot çözüm sırası*.

değiştirilebilir
   Değiştirilebilir (mutable) nesneler değerlerini değiştirebilir
   ancak "idlerini" koruyabilirler. Ayrıca bkz. *immutable*.

adlandırılmış demet
   "named tuple" terimi, demetten miras alan ve dizinlenebilir
   öğelerine de adlandırılmış nitelikler kullanılarak erişilebilen
   herhangi bir tür veya sınıf için geçerlidir. Tür veya sınıfın başka
   özellikleri de olabilir.

   Çeşitli yerleşik türler, "time.localtime()" ve "os.stat()"
   tarafından döndürülen değerler de dahil olmak üzere, tanımlama
   grupları olarak adlandırılır. Başka bir örnek "sys.float_info":

      >>> sys.float_info[1]                   # indexed access
      1024
      >>> sys.float_info.max_exp              # named field access
      1024
      >>> isinstance(sys.float_info, tuple)   # kind of tuple
      True

   Bazı adlandırılmış demetler yerleşik türlerdir (yukarıdaki örnekler
   gibi). Alternatif olarak, "tuple" öğesinden miras alan ve
   adlandırılmış alanları tanımlayan normal bir sınıf tanımından
   adlandırılmış bir tanımlama grubu oluşturulabilir. Böyle bir sınıf
   elle yazılabilir veya fabrika işlevi "collections.namedtuple()" ile
   oluşturulabilir. İkinci teknik ayrıca elle yazılmış veya yerleşik
   adlandırılmış demetlerde bulunmayan bazı ekstra yöntemler ekler.

ad alanı
   Değişkenin saklandığı yer. Ad alanları sözlükler olarak uygulanır.
   Nesnelerde (yöntemlerde) yerel, genel ve yerleşik ad alanlarının
   yanı sıra iç içe ad alanları vardır. Ad alanları, adlandırma
   çakışmalarını önleyerek modülerliği destekler. Örneğin,
   "builtins.open" ve "os.open()" işlevleri ad alanlarıyla ayırt
   edilir. Ad alanları, hangi modülün bir işlevi uyguladığını açıkça
   belirterek okunabilirliğe ve sürdürülebilirliğe de yardımcı olur.
   Örneğin, "random.seed()" veya "itertools.islice()" yazmak, bu
   işlevlerin sırasıyla "random" ve "itertools" modülleri tarafından
   uygulandığını açıkça gösterir.

ad alanı paketi
   A **PEP 420** *package*, yalnızca alt paketler için bir kap olarak
   hizmet eder. Ad alanı paketlerinin hiçbir fiziksel temsili
   olmayabilir ve "__init__.py" dosyası olmadığından özellikle
   *regular package* gibi değildirler.

   Ayrıca bkz. *module*.

iç içe kapsam
   Kapsamlı bir tanımdaki bir değişkene atıfta bulunma yeteneği.
   Örneğin, başka bir fonksiyonun içinde tanımlanan bir fonksiyon, dış
   fonksiyondaki değişkenlere atıfta bulunabilir. İç içe kapsamların
   varsayılan olarak yalnızca başvuru için çalıştığını ve atama için
   çalışmadığını unutmayın. Yerel değişkenler en içteki kapsamda hem
   okur hem de yazar. Benzer şekilde, global değişkenler global ad
   alanını okur ve yazar. "nonlocal", dış kapsamlara yazmaya izin
   verir.

yeni stil sınıf
   Artık tüm sınıf nesneleri için kullanılan sınıfların lezzetinin
   eski adı. Önceki Python sürümlerinde, yalnızca yeni stil sınıfları
   Python'un "__slots__", tanımlayıcılar, özellikler,
   "__getattribute__()", sınıf yöntemleri ve statik yöntemler gibi
   daha yeni, çok yönlü özelliklerini kullanabilirdi.

obje
   Durum (öznitelikler veya değer) ve tanımlanmış davranış (yöntemler)
   içeren herhangi bir veri. Ayrıca herhangi bir *yeni tarz sınıfın*
   nihai temel sınıfı.

paket
   A Python *module* which can contain submodules or recursively,
   subpackages.  Technically, a package is a Python module with a
   "__path__" attribute.

   Ayrıca bkz. *regular package* ve *namespace package*.

parametre
   Bir *function* (veya yöntem) tanımında, işlevin kabul edebileceği
   bir *argument* (veya bazı durumlarda, argümanlar) belirten
   adlandırılmış bir varlık.  Beş çeşit parametre vardır:

   * *positional-or-keyword*: *pozisyonel* veya bir *keyword argümanı*
     olarak iletilebilen bir argüman belirtir. Bu, varsayılan
     parametre türüdür, örneğin aşağıdakilerde *foo* ve *bar*:

        def func(foo, bar=None): ...

   * *positional-only*: yalnızca konuma göre sağlanabilen bir argüman
     belirtir. Yalnızca konumsal parametreler, onlardan sonra
     fonksiyon tanımının parametre listesine bir "/" karakteri
     eklenerek tanımlanabilir, örneğin aşağıdakilerde *posonly1* ve
     *posonly2*:

        def func(posonly1, posonly2, /, positional_or_keyword): ...

   * *keyword-only*: sadece anahtar kelime ile sağlanabilen bir
     argüman belirtir. Yalnızca anahtar kelime (keyword-only)
     parametreleri, onlardan önceki fonksiyon tanımının parametre
     listesine tek bir değişken konumlu parametre veya çıplak "*"
     dahil edilerek tanımlanabilir, örneğin aşağıdakilerde *kw_only1*
     ve *kw_only2*:

        def func(arg, *, kw_only1, kw_only2): ...

   * *var-positional*: keyfi bir pozisyonel argüman dizisinin
     sağlanabileceğini belirtir (diğer parametreler tarafından zaten
     kabul edilmiş herhangi bir konumsal argümana ek olarak). Böyle
     bir parametre, parametre adının başına "*" eklenerek
     tanımlanabilir, örneğin aşağıdakilerde *args*:

        def func(*args, **kwargs): ...

   * *var-keyword*: keyfi olarak birçok anahtar kelime argümanının
     sağlanabileceğini belirtir (diğer parametreler tarafından zaten
     kabul edilen herhangi bir anahtar kelime argümanına ek olarak).
     Böyle bir parametre, parametre adının başına "**", örneğin
     yukarıdaki örnekte *kwargs* eklenerek tanımlanabilir.

   Parametreler, hem isteğe bağlı hem de gerekli argümanleri ve ayrıca
   bazı isteğe bağlı bağımsız değişkenler için varsayılan değerleri
   belirtebilir.

   Ayrıca bkz. *argüman*, argümanlar ve parametreler arasındaki fark,
   "inspect.Parameter", Function definitions ve **PEP 362**.

yol girişi
   *path based finder* içe aktarma modüllerini bulmak için başvurduğu
   *import path* üzerindeki tek bir konum.

yol girişi bulucu
   Bir *finder* "sys.path_hooks" (yani bir *yol giriş kancası*)
   üzerinde bir çağrılabilir tarafından döndürülür ve *path entry*
   verilen modüllerin nasıl bulunacağını bilir.

   Yol girişi bulucularının uyguladığı yöntemler için
   "importlib.abc.PathEntryFinder" bölümüne bakın.

yol giriş kancası
   "sys.path_hook" listesinde, belirli bir *yol girişindeki* modülleri
   nasıl bulacağını biliyorsa, bir *yol girişi bulucu* döndüren bir
   çağrılabilir.

yol tabanlı bulucu
   Modüller için bir *import path* arayan varsayılan *meta yol
   buluculardan* biri.

yol benzeri nesne
   Bir dosya sistemi yolunu temsil eden bir nesne. Yol benzeri bir
   nesne, bir yolu temsil eden bir "str" veya "bytes" nesnesi veya
   "os.PathLike" protokolünü uygulayan bir nesnedir. "os.PathLike"
   protokolünü destekleyen bir nesne, "os.fspath()" işlevi çağrılarak
   bir "str" veya "bytes" dosya sistemi yoluna dönüştürülebilir;
   "os.fsdecode()" ve "os.fsencode()", bunun yerine sırasıyla "str"
   veya "bytes" sonucunu garanti etmek için kullanılabilir. **PEP
   519** tarafından tanıtıldı.

PEP
   Python Geliştirme Önerisi. PEP, Python topluluğuna bilgi sağlayan
   veya Python veya süreçleri ya da ortamı için yeni bir özelliği
   açıklayan bir tasarım belgesidir. PEP'ler, önerilen özellikler için
   özlü bir teknik şartname ve bir gerekçe sağlamalıdır.

   PEP'lerin, önemli yeni özellikler önermek, bir sorun hakkında
   topluluk girdisi toplamak ve Python'a giren tasarım kararlarını
   belgelemek için birincil mekanizmalar olması amaçlanmıştır. PEP
   yazarı, topluluk içinde fikir birliği oluşturmaktan ve muhalif
   görüşleri belgelemekten sorumludur.

   Bakınız **PEP 1**.

kısım
   **PEP 420** içinde tanımlandığı gibi, bir ad alanı paketine katkıda
   bulunan tek bir dizindeki (muhtemelen bir zip dosyasında depolanan)
   bir dizi dosya.

konumsal argüman
   Bakınız *argument*.

geçici API
   Geçici bir API, standart kitaplığın geriye dönük uyumluluk
   garantilerinden kasıtlı olarak hariç tutulan bir API'dir. Bu tür
   arayüzlerde büyük değişiklikler beklenmese de, geçici olarak
   işaretlendikleri sürece, çekirdek geliştiriciler tarafından gerekli
   görüldüğü takdirde geriye dönük uyumsuz değişiklikler (arayüzün
   kaldırılmasına kadar ve buna kadar) meydana gelebilir. Bu tür
   değişiklikler karşılıksız yapılmayacaktır - bunlar yalnızca API'nin
   eklenmesinden önce gözden kaçan ciddi temel kusurlar ortaya çıkarsa
   gerçekleşecektir.

   Geçici API'ler için bile, geriye dönük uyumsuz değişiklikler "son
   çare çözümü" olarak görülür - tanımlanan herhangi bir soruna geriye
   dönük uyumlu bir çözüm bulmak için her türlü girişimde
   bulunulacaktır.

   Bu süreç, standart kitaplığın, uzun süreler boyunca sorunlu tasarım
   hatalarına kilitlenmeden zaman içinde gelişmeye devam etmesini
   sağlar. Daha fazla ayrıntı için bkz. **PEP 411**.

geçici paket
   Bakınız *provisional API*.

Python 3000
   Python 3.x sürüm satırının takma adı (uzun zaman önce sürüm 3'ün
   piyasaya sürülmesi uzak bir gelecekte olduğu zaman ortaya çıktı.)
   Bu aynı zamanda "Py3k" olarak da kısaltılır.

Pythonic
   Diğer dillerde ortak kavramları kullanarak kod uygulamak yerine
   Python dilinin en yaygın deyimlerini yakından takip eden bir fikir
   veya kod parçası. Örneğin, Python'da yaygın bir deyim, bir "for"
   ifadesi kullanarak yinelenebilir bir öğenin tüm öğeleri üzerinde
   döngü oluşturmaktır. Diğer birçok dilde bu tür bir yapı yoktur, bu
   nedenle Python'a aşina olmayan kişiler bazen bunun yerine sayısal
   bir sayaç kullanır:

      for i in range(len(food)):
          print(food[i])

   Temizleyicinin aksine, Pythonic yöntemi:

      for piece in food:
          print(piece)

nitelikli isim
   **PEP 3155** içinde tanımlandığı gibi, bir modülün genel
   kapsamından o modülde tanımlanan bir sınıfa, işleve veya yönteme
   giden "yolu" gösteren noktalı ad. Üst düzey işlevler ve sınıflar
   için nitelikli ad, nesnenin adıyla aynıdır:

      >>> class C:
      ...     class D:
      ...         def meth(self):
      ...             pass
      ...
      >>> C.__qualname__
      'C'
      >>> C.D.__qualname__
      'C.D'
      >>> C.D.meth.__qualname__
      'C.D.meth'

   Modüllere atıfta bulunmak için kullanıldığında, *tam nitelenmiş
   ad*, herhangi bir üst paket de dahil olmak üzere, modüle giden tüm
   noktalı yol anlamına gelir, örn. "email.mime.text":

      >>> import email.mime.text
      >>> email.mime.text.__name__
      'email.mime.text'

referans sayısı
   Bir nesneye yapılan başvuruların sayısı. Bir nesnenin referans
   sayısı sıfıra düştüğünde, yerinden çıkarılır. Referans sayımı
   genellikle Python kodunda görülmez, ancak *CPython* uygulamasının
   önemli bir öğesidir. "sys" modülü, programcıların belirli bir nesne
   için referans sayısını döndürmek üzere çağırabilecekleri bir
   "getrefcount()" işlevini tanımlar.

sürekli paketleme
   "__init__.py" dosyası içeren bir dizin gibi geleneksel bir
   *package*.

   Ayrıca bkz. *ad alanı paketi*.

__slots__
   Örnek öznitelikleri için önceden yer bildirerek ve örnek
   sözlüklerini ortadan kaldırarak bellekten tasarruf sağlayan bir
   sınıf içindeki bildirim. Popüler olmasına rağmen, tekniğin doğru
   olması biraz zor ve en iyi, bellek açısından kritik bir uygulamada
   çok sayıda örneğin bulunduğu nadir durumlar için ayrılmıştır.

dizi
   "__getitem__()" özel yöntemi aracılığıyla tamsayı dizinlerini
   kullanarak verimli öğe erişimini destekleyen ve dizinin uzunluğunu
   döndüren bir "__len__()" yöntemini tanımlayan bir *iterable*. Bazı
   yerleşik dizi türleri şunlardır: "list", "str", "tuple" ve "bytes".
   "dict" ayrıca "__getitem__()" ve "__len__()" 'i de desteklediğine
   dikkat edin, ancak aramalar tamsayılar yerine rastgele *immutable*
   anahtarları kullandığından bir diziden ziyade bir eşleme olarak
   kabul edilir.

   "collections.abc.Sequence" soyut temel sınıfı;, "count()",
   "index()", "__contains__()", ve "__reversed__()" ekleyerek sadece
   "__getitem__()" ve "__len__()" 'in ötesine geçen çok daha zengin
   bir arayüzü tanımlar. Bu genişletilmiş arabirimi uygulayan türler,
   "register()" kullanılarak açıkça kaydedilebilir.

anlamak
   Öğelerin tümünü veya bir kısmını yinelenebilir bir şekilde
   işlemenin ve sonuçlarla birlikte bir küme döndürmenin kompakt bir
   yolu. "results = {c for c in 'abracadabra' if c not in 'abc'}",
   "{'r', 'd'}" dizelerini oluşturur. Bakınız Displays for lists, sets
   and dictionaries.

tek sevk
   Uygulamanın tek bir argüman türüne göre seçildiği bir *generic
   function* gönderimi biçimi.

parçalamak
   Genellikle bir *sequence* 'nin bir bölümünü içeren bir nesne. Bir
   dilim, örneğin "variable_name[1:3:5]" 'de olduğu gibi, birkaç tane
   verildiğinde, sayılar arasında iki nokta üst üste koyarak, "[]" alt
   simge gösterimi kullanılarak oluşturulur. Köşeli ayraç (alt simge)
   gösterimi, dahili olarak "slice" nesnelerini kullanır.

özel metod
   Toplama gibi bir tür üzerinde belirli bir işlemi yürütmek için
   Python tarafından örtük olarak çağrılan bir yöntem. Bu tür
   yöntemlerin çift alt çizgi ile başlayan ve biten adları vardır.
   Özel yöntemler Special method names içinde belgelenmiştir.

ifade (değer döndürmez)
   Bir ifade, bir paketin parçasıdır (kod "bloğu"). Bir ifade, bir
   *expression* veya "if", "while" veya "for" gibi bir anahtar
   kelimeye sahip birkaç yapıdan biridir.

güçlü referans
   In Python's C API, a strong reference is a reference to an object
   which is owned by the code holding the reference.  The strong
   reference is taken by calling "Py_INCREF()" when the reference is
   created and released with "Py_DECREF()" when the reference is
   deleted.

   "Py_NewRef()" fonksiyonu, bir nesneye güçlü bir başvuru oluşturmak
   için kullanılabilir. Genellikle "Py_DECREF()" fonksiyonu, bir
   referansın sızmasını önlemek için güçlü referans kapsamından
   çıkmadan önce güçlü referansta çağrılmalıdır.

   Ayrıca bkz. *ödünç alınan referans*.

yazı çözümleme
   Python'da bir dize, bir Unicode kod noktaları dizisidir
   ("U+0000"--"U+10FFFF" aralığında). Bir dizeyi depolamak veya
   aktarmak için, bir bayt dizisi olarak seri hale getirilmesi
   gerekir.

   Bir dizeyi bir bayt dizisi halinde seri hale getirmek "kodlama
   (encoding)" olarak bilinir ve dizeyi bayt dizisinden yeniden
   oluşturmak "kod çözme (decoding)" olarak bilinir.

   Toplu olarak "metin kodlamaları" olarak adlandırılan çeşitli farklı
   metin serileştirme kodekleri vardır.

yazı dosyası
   A *file object* "str" nesnelerini okuyabilir ve yazabilir. Çoğu
   zaman, bir metin dosyası aslında bir bayt yönelimli veri akışına
   erişir ve otomatik olarak *text encoding* işler. Metin dosyalarına
   örnek olarak metin modunda açılan dosyalar ("'r'" veya "'w'"),
   "sys.stdin", "sys.stdout" ve "io.StringIO" örnekleri verilebilir.

   Ayrıca *ikili dosyaları* okuyabilen ve yazabilen bir dosya nesnesi
   için *bayt benzeri nesnelere* bakın.

üç tırnaklı dize
   Üç tırnak işareti (") veya kesme işareti (') ile sınırlanan bir
   dize. Tek tırnaklı dizelerde bulunmayan herhangi bir işlevsellik
   sağlamasalar da, birkaç nedenden dolayı faydalıdırlar. bir dizeye
   çıkışsız tek ve çift tırnak eklemeniz gerekir ve bunlar, devam
   karakterini kullanmadan birden çok satıra yayılabilir, bu da onları
   özellikle belge dizileri yazarken kullanışlı hale getirir.

tip
   Bir Python nesnesinin türü, onun ne tür bir nesne olduğunu
   belirler; her nesnenin bir türü vardır. Bir nesnenin tipine
   "__class__" niteliği ile erişilebilir veya "type(obj)" ile
   alınabilir.

tip takma adı
   Bir tanımlayıcıya tür atanarak oluşturulan, bir tür için eş
   anlamlı.

   Tür takma adları, *tür ipuçlarını* basitleştirmek için
   kullanışlıdır. Örneğin:

      def remove_gray_shades(
              colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:
          pass

   bu şekilde daha okunaklı hale getirilebilir:

      Color = tuple[int, int, int]

      def remove_gray_shades(colors: list[Color]) -> list[Color]:
          pass

   Bu işlevi açıklayan "typing" ve **PEP 484** bölümlerine bakın.

tür ipucu
   Bir değişken, bir sınıf niteliği veya bir işlev parametresi veya
   dönüş değeri için beklenen türü belirten bir *ek açıklama*.

   Tür ipuçları isteğe bağlıdır ve Python tarafından uygulanmaz, ancak
   bunlar statik tip analiz araçları için faydalıdır ve kod tamamlama
   ve yeniden düzenleme ile IDE'lere yardımcı olur.

   Genel değişkenlerin, sınıf özniteliklerinin ve işlevlerin tür
   ipuçlarına, yerel değişkenlere değil, "typing.get_type_hints()"
   kullanılarak erişilebilir.

   Bu işlevi açıklayan "typing" ve **PEP 484** bölümlerine bakın.

evrensel yeni satırlar
   Aşağıdakilerin tümünün bir satırın bitişi olarak kabul edildiği
   metin akışlarını yorumlamanın bir yolu: Unix satır sonu kuralı
   "\n'", Windows kuralı "`\r\n'", ve eski Macintosh kuralı "'\r'". Ek
   bir kullanım için **PEP 278** ve **PEP 3116** ve ayrıca
   "bytes.splitlines()" bakın.

değişken açıklama
   Bir değişkenin veya bir sınıf özniteliğinin *ek açıklaması*.

   Bir değişkene veya sınıf niteliğine açıklama eklerken atama isteğe
   bağlıdır:

      class C:
          field: 'annotation'

   Değişken açıklamaları genellikle *tür ipuçları* için kullanılır:
   örneğin, bu değişkenin "int" değerlerini alması beklenir:

      count: int = 0

   Değişken açıklama sözdizimi Annotated assignment statements
   bölümünde açıklanmıştır.

   Bu işlevi açıklayan; *function annotation*, **PEP 484** ve **PEP
   526** bölümlerine bakın. Ek açıklamalarla çalışmaya ilişkin en iyi
   uygulamalar için ayrıca bkz. Annotations Best Practices.

sanal ortam
   Python kullanıcılarının ve uygulamalarının, aynı sistem üzerinde
   çalışan diğer Python uygulamalarının davranışına müdahale etmeden
   Python dağıtım paketlerini kurmasına ve yükseltmesine olanak
   tanıyan, işbirliği içinde yalıtılmış bir çalışma zamanı ortamı.

   Ayrıca bakınız "venv".

sanal makine
   Tamamen yazılımla tanımlanmış bir bilgisayar. Python'un sanal
   makinesi, bayt kodu derleyicisi tarafından yayınlanan *bytecode* 'u
   çalıştırır.

Python'un Zen'i
   Dili anlamaya ve kullanmaya yardımcı olan Python tasarım ilkeleri
   ve felsefelerinin listesi. Liste, etkileşimli komut isteminde
   ""import this"" yazarak bulunabilir.
