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:

   * The default Python prompt of the *interactive* shell when
     entering the code for an indented code block, when within a pair
     of matching left and right delimiters (parentheses, square
     brackets, curly braces or triple quotes), or after specifying a
     decorator.

   * The three dots form of the Ellipsis object.

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.

annotate function
   A callable that can be called to retrieve the *annotations* of an
   object. Annotate functions are usually *functions*, automatically
   generated as the "__annotate__" attribute of functions, classes,
   and modules. Annotate functions are a subset of *evaluate
   functions*.

dipnot
   Bir değişkenle, bir sınıf niteliğiyle veya bir fonksiyon
   parametresiyle veya bir dönüş değeriyle ilişkilendirilen, gelenek
   olarak *type hint* biçiminde kullanılan bir etiket.

   Annotations of local variables cannot be accessed at runtime, but
   annotations of global variables, class attributes, and functions
   can be retrieved by calling "annotationlib.get_annotations()" on
   modules, classes, and functions, respectively.

   See *variable annotation*, *function annotation*, **PEP 484**,
   **PEP 526**, and **PEP 649**, which describe this functionality.
   Also see Annotations Best Practices for best practices on working
   with annotations.

argüman
   Fonksiyon çağrılırken bir *function* 'a (veya *method*) geçirilen
   bir değer. İki tür argüman vardır:

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

   Ayrıca *parameter* sözlüğü girişine, the difference between
   arguments and parameters hakkındaki SSS sorusuna ve **PEP 362** 'ye
   bakın.

asenkron bağlam yöneticisi
   An object which controls the environment seen in an "async with"
   statement by defining "__aenter__()" and "__aexit__()" methods.
   Introduced by **PEP 492**.

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
   An object created by an *asynchronous generator* function.

   This is an *asynchronous iterator* which when called using the
   "__anext__()" method returns an awaitable object which will execute
   the body of the asynchronous generator function until the next
   "yield" expression.

   Each "yield" temporarily suspends processing, remembering the
   execution state (including local variables and pending try-
   statements).  When the *asynchronous generator iterator*
   effectively resumes with another awaitable returned by
   "__anext__()", it picks up where it left off.  See **PEP 492** and
   **PEP 525**.

eşzamansız yinelenebilir
   An object, that can be used in an "async for" statement. Must
   return an *asynchronous iterator* from its "__aiter__()" method.
   Introduced by **PEP 492**.

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

atomic operation
   An operation that appears to execute as a single, indivisible step:
   no other thread can observe it half-done, and its effects become
   visible all at once.  Python does not guarantee that high-level
   statements are atomic (for example, "x += 1" performs multiple
   bytecode operations and is not atomic).  Atomicity is only
   guaranteed where explicitly documented.  See also *race condition*
   and *data race*.

attached thread state
   A *thread state* that is active for the current OS thread.

   When a *thread state* is attached, the OS thread has access to the
   full Python C API and can safely invoke the bytecode interpreter.

   Unless a function explicitly notes otherwise, attempting to call
   the C API without an attached thread state will result in a fatal
   error or undefined behavior.  A thread state can be attached and
   detached explicitly by the user through the C API, or implicitly by
   the runtime, including during blocking C calls and by the bytecode
   interpreter in between calls.

   On most builds of Python, having an attached thread state implies
   that the caller holds the *GIL* for the current interpreter, so
   only one OS thread can have an attached thread state at a given
   moment. In *free-threaded builds* of Python, threads can
   concurrently hold an attached thread state, allowing for true
   parallelism of the bytecode interpreter.

nitelik
   Noktalı ifadeler kullanılarak adıyla başvurulan bir nesneyle
   ilişkili değer.  Örneğin, *o* nesnesinin *a* özniteliği varsa, bu
   nesneye *o.a* olarak başvurulur.

   Bir nesneye, eğer nesne izin veriyorsa, örneğin "setattr()"
   kullanarak, adı Names (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
   An object that can be used in an "await" expression.  Can be a
   *coroutine* or an object with an "__await__()" method. See also
   **PEP 492**.

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

ikili dosya
   A *file object* able to read and write *bytes-like objects*.
   Examples of binary files are files opened in binary mode ("'rb'",
   "'wb'" or "'rb+'"), "sys.stdin.buffer", "sys.stdout.buffer", and
   instances of "io.BytesIO" and "gzip.GzipFile".

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

ödünç alınan referans
   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.

çağırılabilir
   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, argumentN)

   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.

closure variable
   A *free variable* referenced from a *nested scope* that is defined
   in an outer scope rather than being resolved at runtime from the
   globals or builtin namespaces. May be explicitly defined with the
   "nonlocal" keyword to allow write access, or implicitly defined if
   the variable is only being read.

   For example, in the "inner" function in the following code, both
   "x" and "print" are *free variables*, but only "x" is a *closure
   variable*:

      def outer():
          x = 0
          def inner():
              nonlocal x
              x += 1
              print(x)
          return inner

   Due to the "codeobject.co_freevars" attribute (which, despite its
   name, only includes the names of closure variables rather than
   listing all referenced free variables), the more general *free
   variable* term is sometimes used even when the intended meaning is
   to refer specifically to closure variables.

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.

concurrency
   The ability of a computer program to perform multiple tasks at the
   same time.  Python provides libraries for writing programs that
   make use of different forms of concurrency.  "asyncio" is a library
   for dealing with asynchronous tasks and coroutines.  "threading"
   provides access to operating system threads and "multiprocessing"
   to operating system processes. Multi-core processors can execute
   threads and processes on different CPU cores at the same time (see
   *parallelism*).

concurrent modification
   When multiple threads modify shared data at the same time.
   Concurrent modification without proper synchronization can cause
   *race conditions*, and might also trigger a *data race*, data
   corruption, or both.

context
   This term has different meanings depending on where and how it is
   used. Some common meanings:

   * The temporary state or environment established by a *context
     manager* via a "with" statement.

   * The collection of key­value bindings associated with a particular
     "contextvars.Context" object and accessed via "ContextVar"
     objects.  Also see *context variable*.

   * A "contextvars.Context" object.  Also see *current context*.

context management protocol
   The "__enter__()" and "__exit__()" methods called by the "with"
   statement.  See **PEP 343**.

bağlam yöneticisi
   An object which implements the *context management protocol* and
   controls the environment seen in a "with" statement.  See **PEP
   343**.

bağlam değişkeni
   A variable whose value depends on which context is the *current
   context*.  Values are accessed via "contextvars.ContextVar"
   objects.  Context variables are primarily used to isolate state
   between concurrent asynchronous tasks.

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.

current context
   The *context* ("contextvars.Context" object) that is currently used
   by "ContextVar" objects to access (get or set) the values of
   *context variables*.  Each thread has its own current context.
   Frameworks for executing asynchronous tasks (see "asyncio")
   associate each task with a context which becomes the current
   context whenever the task starts or resumes execution.

cyclic isolate
   A subgroup of one or more objects that reference each other in a
   reference cycle, but are not referenced by objects outside the
   group.  The goal of the *cyclic garbage collector* is to identify
   these groups and break the reference cycles so that the memory can
   be reclaimed.

data race
   A situation where multiple threads access the same memory location
   concurrently, at least one of the accesses is a write, and the
   threads do not use any synchronization to control their access.
   Data races lead to *non-deterministic* behavior and can cause data
   corruption. Proper use of *locks* and other *synchronization
   primitives* prevents data races.  Note that data races can only
   happen in native code, but that *native code* might be exposed in a
   Python API.  See also *race condition* and *thread-safe*.

deadlock
   A situation in which two or more tasks (threads, processes, or
   coroutines) wait indefinitely for each other to release resources
   or complete actions, preventing any from making progress.  For
   example, if thread A holds lock 1 and waits for lock 2, while
   thread B holds lock 2 and waits for lock 1, both threads will wait
   indefinitely.  In Python this often arises from acquiring multiple
   locks in conflicting orders or from circular join/await
   dependencies.  Deadlocks can be avoided by always acquiring
   multiple *locks* in a consistent order.  See also *lock* and
   *reentrant*.

dekoratör
   A function returning another function, usually applied as a
   function transformation using the "@wrapper" syntax.  Common
   examples for decorators are "@classmethod" and "@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ı
   Any object which defines the methods "__get__()", "__set__()", or
   "__delete__()". When a class attribute is a descriptor, its special
   binding behavior is triggered upon attribute lookup.  Normally,
   using *a.b* to get, set or delete an attribute looks up the object
   named *b* in the class dictionary for *a*, but if *b* is a
   descriptor, the respective descriptor method gets called.
   Understanding descriptors is a key to a deep understanding of
   Python because they are the basis for many features including
   functions, methods, properties, class methods, static methods, and
   reference to super classes.

   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
   An associative array, where arbitrary keys are mapped to values.
   The keys can be any object with "__hash__()" and "__eq__()"
   methods. Called a hash in Perl.

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

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
   A string literal which appears as the first expression in a class,
   function or module.  While ignored when the suite is executed, it
   is recognized by the compiler and put into the "__doc__" attribute
   of the enclosing class, function or module.  Since it is available
   via introspection, it is the canonical place for documentation of
   the object.

ördek yazma
   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.

dunder
   An informal short-hand for "double underscore", used when talking
   about a *special method*. For example, "__init__" is often
   pronounced "dunder init".

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.

evaluate function
   A function that can be called to evaluate a lazily evaluated
   attribute of an object, such as the value of type aliases created
   with the "type" statement.

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
f-strings
   String literals prefixed with "f" or "F" are commonly called
   "f-strings" which is short for formatted string literals.  See also
   **PEP 498**.

dosya nesnesi
   An object exposing a file-oriented API (with methods such as
   "read()" or "write()") to an underlying resource.  Depending on the
   way it was created, a file object can mediate access to a real on-
   disk file or to another type of storage or communication device
   (for example standard input/output, in-memory buffers, sockets,
   pipes, etc.).  File objects are also called *file-like objects* or
   *streams*.

   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.

   There are two types of finder: *meta path finders* for use with
   "sys.meta_path", and *path entry finders* for use with
   "sys.path_hooks".

   See Finders and loaders and "importlib" for much more detail.

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

free threading
   A threading model where multiple threads can run Python bytecode
   simultaneously within the same interpreter.  This is in contrast to
   the *global interpreter lock* which allows only one thread to
   execute Python bytecode at a time.  See **PEP 703**.

free-threaded build
   A build of *CPython* that supports *free threading*, configured
   using the "--disable-gil" option before compilation.

   See Python support for free threading.

free variable
   Formally, as defined in the language execution model, a free
   variable is any variable used in a namespace which is not a local
   variable in that namespace. See *closure variable* for an example.
   Pragmatically, due to the name of the "codeobject.co_freevars"
   attribute, the term is also sometimes used as a synonym for
   *closure variable*.

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.

   Each "yield" temporarily suspends processing, remembering the
   execution state (including local variables and pending try-
   statements).  When the *generator iterator* resumes, it picks up
   where it left off (in contrast to functions which start fresh on
   every invocation).

jeneratör ifadesi
   An *expression* that returns an *iterator*.  It looks like a normal
   expression followed by a "for" clause defining a loop variable,
   range, and an optional "if" clause.  The combined expression
   generates values for an enclosing function:

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

   See also the *single dispatch* glossary entry, the
   "@functools.singledispatch" decorator, and **PEP 443**.

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.

   Bununla birlikte, standart veya üçüncü taraf bazı genişletme
   modülleri, sıkıştırma veya karma gibi hesaplama açısından yoğun
   görevler yaparken GIL'yi serbest bırakacak şekilde tasarlanmıştır.
   Ayrıca, GIL, G/Ç yaparken her zaman serbest bırakılır.

   As of Python 3.13, the GIL can be disabled using the "--disable-
   gil" build configuration. After building Python with this option,
   code must be run with "-X gil=0" or after setting the
   "PYTHON_GIL=0" environment variable. This feature enables improved
   performance for multi-threaded applications and makes it easier to
   use multi-core CPUs efficiently. For more details, see **PEP 703**.

   In prior versions of Python's C API, a function might declare that
   it requires the GIL to be held in order to use it. This refers to
   having an *attached thread state*.

global state
   Data that is accessible throughout a program, such as module-level
   variables, class variables, or C static variables in *extension
   modules*.  In multi-threaded programs, global state shared between
   threads typically requires synchronization to avoid *race
   conditions* and *data races*.

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
   An object is *hashable* if it has a hash value which never changes
   during its lifetime (it needs a "__hash__()" method), and can be
   compared to other objects (it needs an "__eq__()" method). Hashable
   objects which compare equal must have the same hash value.

   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
   Python için Entegre Geliştirme Ortamı. IDLE --- Python editor and
   shell, Python'un standart dağıtımıyla birlikte gelen temel bir
   düzenleyici ve yorumlayıcı ortamıdır.

immortal
   *Immortal objects* are a CPython implementation detail introduced
   in **PEP 683**.

   If an object is immortal, its *reference count* is never modified,
   and therefore it is never deallocated while the interpreter is
   running. For example, "True" and "None" are immortal in CPython.

   Immortal objects can be identified via "sys._is_immortal()", or via
   "PyUnstable_IsImmortal()" in the C API.

değişmez
   An object with a fixed value.  Immutable objects include numbers,
   strings and tuples.  Such an object cannot be altered.  A new
   object has to be created if a different value has to be stored.
   They play an important role in places where a constant hash value
   is needed, for example as a key in a dictionary.  Immutable objects
   are inherently *thread-safe* because their state cannot be modified
   after creation, eliminating concerns about improperly synchronized
   *concurrent modification*.

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.

index
   A numeric value that represents the position of an element in a
   *sequence*.

   In Python, indexing starts at zero. For example, "things[0]" names
   the *first* element of "things"; "things[1]" names the second one.

   In some contexts, Python allows negative indexes for counting from
   the end of a sequence, and indexing using *slices*.

   See also *subscript*.

etkileşimli
   Python has an interactive interpreter which means you can enter
   statements and expressions at the interpreter prompt, immediately
   execute them and see their results.  Just launch "python" with no
   arguments (possibly by selecting it from your computer's main
   menu). It is a very powerful way to test out new ideas or inspect
   modules and packages (remember "help(x)"). For more on interactive
   mode, see Etkileşimli Mod.

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 kütüphane 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
   An object capable of returning its members one at a time. Examples
   of iterables include all sequence types (such as "list", "str", and
   "tuple") and some non-sequence types like "dict", *file objects*,
   and objects of any classes you define with an "__iter__()" method
   or with a "__getitem__()" method that implements *sequence*
   semantics.

   Iterables can be used in a "for" loop and in many other places
   where a sequence is needed ("zip()", "map()", ...).  When an
   iterable object is passed as an argument to the built-in function
   "iter()", it returns an iterator for the object.  This iterator is
   good for one pass over the set of values.  When using iterables, it
   is usually not necessary to call "iter()" or deal with iterator
   objects yourself.  The "for" statement does that automatically for
   you, creating a temporary unnamed variable to hold the iterator for
   the duration of the loop.  See also *iterator*, *sequence*, and
   *generator*.

yineleyici
   An object representing a stream of data.  Repeated calls to the
   iterator's "__next__()" method (or passing it to the built-in
   function "next()") return successive items in the stream.  When no
   more data are available a "StopIteration" exception is raised
   instead.  At this point, the iterator object is exhausted and any
   further calls to its "__next__()" method just raise "StopIteration"
   again.  Iterators are required to have an "__iter__()" method that
   returns the iterator object itself so every iterator is also
   iterable and may be used in most places where other iterables are
   accepted.  One notable exception is code which attempts multiple
   iteration passes.  A container object (such as a "list") produces a
   fresh new iterator each time you pass it to the "iter()" function
   or use it in a "for" loop.  Attempting this with an iterator will
   just return the same exhausted iterator object used in the previous
   iteration pass, making it appear like an empty container.

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

   **CPython uygulama ayrıntısı:** CPython does not consistently apply
   the requirement that an iterator define "__iter__()". And also
   please note that *free-threaded* CPython does not guarantee
   *thread-safe* behavior of iterator operations.

key
   A value that identifies an entry in a *mapping*. See also
   *subscript*.

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

   There are several ways to create a key function.  For example. the
   "str.casefold()" method can serve as a key function for case
   insensitive sorts.  Alternatively, a key function can be built from
   a "lambda" expression such as "lambda r: (r[0], r[2])".  Also,
   "operator.attrgetter()", "operator.itemgetter()", and
   "operator.methodcaller()" are three key function constructors.  See
   the Sorting HOW TO for examples of how to create and use key
   functions.

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.

   In a multi-threaded environment, the LBYL approach can risk
   introducing a *race condition* between "the looking" and "the
   leaping".  For example, the code, "if key in mapping: return
   mapping[key]" can fail if another thread removes *key* from
   *mapping* after the test, but before the lookup. This issue can be
   solved with *locks* or by using the *EAFP* approach.  See also
   *thread-safe*.

lexical analyzer
   Formal name for the *tokenizer*; see *token*.

liste
   A built-in Python *sequence*.  Despite its name it is more akin to
   an array in other languages than to a linked list since access to
   elements is *O*(1).

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.

lock
   A *synchronization primitive* that allows only one thread at a time
   to access a shared resource.  A thread must acquire a lock before
   accessing the protected resource and release it afterward.  If a
   thread attempts to acquire a lock that is already held by another
   thread, it will block until the lock becomes available.  Python's
   "threading" module provides "Lock" (a basic lock) and "RLock" (a
   *reentrant* lock).  Locks are used to prevent *race conditions* and
   ensure *thread-safe* access to shared data.  Alternative design
   patterns to locks exist such as queues, producer/consumer patterns,
   and thread-local state. See also *deadlock*, and *reentrant*.

lock-free
   An operation that does not acquire any *lock* and uses atomic CPU
   instructions to ensure correctness. Lock-free operations can
   execute concurrently without blocking each other and cannot be
   blocked by operations that hold locks. In *free-threaded* Python,
   built-in types like "dict" and "list" provide lock-free read
   operations, which means other threads may observe intermediate
   states during multi-step modifications even when those
   modifications hold the *per-object lock*.

yükleyici
   An object that loads a module. It must define the "exec_module()"
   and "create_module()" methods to implement the "Loader" interface.
   A loader is typically returned by a *finder*. See also:

   * Finders and loaders

   * "importlib.abc.Loader"

   * **PEP 302**

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

   Android ve VxWorks'te Python, yerel kodlama olarak ""utf-8""
   kullanır.

   "locale.getencoding()" can be used to get the locale encoding.

   Ayrıca *filesystem encoding and error handler* '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. Ö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ı
   Method Resolution Order is the order in which base classes are
   searched for a member during lookup. See The Python 2.3 Method
   Resolution Order for details of the algorithm used by the Python
   interpreter since the 2.3 release.

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.

   See also Module specs.

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

değiştirilebilir
   An *object* with state that is allowed to change during the course
   of the program.  In multi-threaded programs, mutable objects that
   are shared between threads require careful synchronization to avoid
   *race conditions*.  See also *immutable*, *thread-safe*, and
   *concurrent modification*.

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

   Some named tuples are built-in types (such as the above examples).
   Alternatively, a named tuple can be created from a regular class
   definition that inherits from "tuple" and that defines named
   fields.  Such a class can be written by hand, or it can be created
   by inheriting "typing.NamedTuple", or with the factory function
   "collections.namedtuple()".  The latter techniques also add some
   extra methods that may not be found in hand-written or built-in
   named tuples.

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 *package* which serves only as a container for subpackages.
   Namespace packages may have no physical representation, and
   specifically are not like a *regular package* because they have no
   "__init__.py" file.

   Namespace packages allow several individually installable packages
   to have a common parent package. Otherwise, it is recommended to
   use a *regular package*.

   For more information, see **PEP 420** and Namespace packages.

   Ayrıca bkz. *module*.

native code
   Code that is compiled to machine instructions and runs directly on
   the processor, as opposed to code that is interpreted or runs in a
   virtual machine.  In the context of Python, native code typically
   refers to C, C++, Rust or Fortran code in *extension modules* that
   can be called from Python.  See also *extension 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
   Old name for the flavor of classes now used for all class objects.
   In earlier Python versions, only new-style classes could use
   Python's newer, versatile features like "__slots__", descriptors,
   properties, "__getattribute__()", class methods, and static
   methods.

non-deterministic
   Behavior where the outcome of a program can vary between executions
   with the same inputs.  In multi-threaded programs, non-
   deterministic behavior often results from *race conditions* where
   the relative timing or interleaving of threads affects the result.
   Proper synchronization using *locks* and other *synchronization
   primitives* helps ensure deterministic behavior.

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

optimized scope
   A scope where target local variable names are reliably known to the
   compiler when the code is compiled, allowing optimization of read
   and write access to these names. The local namespaces for
   functions, generators, coroutines, comprehensions, and generator
   expressions are optimized in this fashion. Note: most interpreter
   optimizations are applied to all scopes, only those relying on a
   known set of local and nonlocal variable names are restricted to
   optimized scopes.

optional module
   An *extension module* that is part of the *standard library*, but
   may be absent in some builds of *CPython*, usually due to missing
   third-party libraries or because the module is not available for a
   given platform.

   See Requirements for optional modules for a list of optional
   modules that require third-party libraries.

paket
   Alt modüller veya yinelemeli olarak alt paketler içerebilen bir
   Python *module*. Teknik olarak bir paket, "__path__" özniteliğine
   sahip bir Python modülüdür.

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

parallelism
   Executing multiple operations at the same time (e.g. on multiple
   CPU cores).  In Python builds with the *global interpreter lock
   (GIL)*, only one thread runs Python bytecode at a time, so taking
   advantage of multiple CPU cores typically involves multiple
   processes (e.g. "multiprocessing") or native extensions that
   release the GIL. In *free-threaded* Python, multiple Python threads
   can run Python code simultaneously on different cores.

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

per-object lock
   A *lock* associated with an individual object instance rather than
   a global lock shared across all objects. In *free-threaded* Python,
   built-in types like "dict" and "list" use per-object locks to allow
   concurrent operations on different objects while serializing
   operations on the same object. Operations that hold the per-object
   lock prevent other locking operations on the same object from
   proceeding, but do not block *lock-free* operations.

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ı
   A callable on the "sys.path_hooks" list which returns a *path entry
   finder* if it knows how to find modules on a specific *path entry*.

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'

race condition
   A condition of a program where the behavior depends on the relative
   timing or ordering of events, particularly in multi-threaded
   programs.  Race conditions can lead to *non-deterministic* behavior
   and bugs that are difficult to reproduce.  A *data race* is a
   specific type of race condition involving unsynchronized access to
   shared memory.  The *LBYL* coding style is particularly susceptible
   to race conditions in multi-threaded code.  Using *locks* and other
   *synchronization primitives* helps prevent race conditions.

referans sayısı
   The number of references to an object.  When the reference count of
   an object drops to zero, it is deallocated.  Some objects are
   *immortal* and have reference counts that are never modified, and
   therefore the objects are never deallocated.  Reference counting is
   generally not visible to Python code, but it is a key element of
   the *CPython* implementation.  Programmers can call the
   "sys.getrefcount()" function to return the reference count for a
   particular object.

   In *CPython*, reference counts are not considered to be stable or
   well-defined values; the number of references to an object, and how
   that number is affected by Python code, may be different between
   versions.

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

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

reentrant
   A property of a function or *lock* that allows it to be called or
   acquired multiple times by the same thread without causing errors
   or a *deadlock*.

   For functions, reentrancy means the function can be safely called
   again before a previous invocation has completed, which is
   important when functions may be called recursively or from signal
   handlers. Thread-unsafe functions may be *non-deterministic* if
   they're called reentrantly in a multithreaded program.

   For locks, Python's "threading.RLock" (reentrant lock) is
   reentrant, meaning a thread that already holds the lock can acquire
   it again without blocking.  In contrast, "threading.Lock" is not
   reentrant - attempting to acquire it twice from the same thread
   will cause a deadlock.

   See also *lock* and *deadlock*.

REPL
   An acronym for the "read–eval–print loop", another name for the
   *interactive* interpreter shell.

__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
   An *iterable* which supports efficient element access using integer
   indices via the "__getitem__()" special method and defines a
   "__len__()" method that returns the length of the sequence. Some
   built-in sequence types are "list", "str", "tuple", and "bytes".
   Note that "dict" also supports "__getitem__()" and "__len__()", but
   is considered a mapping rather than a sequence because the lookups
   use arbitrary *hashable* keys rather than integers.

   The "collections.abc.Sequence" abstract base class defines a much
   richer interface that goes beyond just "__getitem__()" and
   "__len__()", adding "count()", "index()", "__contains__()", and
   "__reversed__()". Types that implement this expanded interface can
   be registered explicitly using "register()". For more documentation
   on sequence methods generally, see Common Sequence Operations.

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

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
   An object of type "slice", used to describe a portion of a
   *sequence*. A slice object is created when using the slicing form
   of subscript notation, with colons inside square brackets, such as
   in "variable_name[1:3:5]".

soft deprecated
   A soft deprecated API should not be used in new code, but it is
   safe for already existing code to use it. The API remains
   documented and tested, but will not be enhanced further.

   Soft deprecation, unlike normal deprecation, does not plan on
   removing the API and will not emit warnings.

   See PEP 387: Soft Deprecation.

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

standard library
   The collection of *packages*, *modules* and *extension modules*
   distributed as a part of the official Python interpreter package.
   The exact membership of the collection may vary based on platform,
   available system libraries, or other criteria.  Documentation can
   be found at Python Standart Kütüphanesi.

   See also "sys.stdlib_module_names" for a list of all possible
   standard library module names.

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.

static type checker
   An external tool that reads Python code and analyzes it, looking
   for issues such as incorrect types. See also *type hints* and the
   "typing" module.

stdlib
   An abbreviation of *standard library*.

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

subscript
   The expression in square brackets of a subscription expression, for
   example, the "3" in "items[3]". Usually used to select an element
   of a container. Also called a *key* when subscripting a *mapping*,
   or an *index* when subscripting a *sequence*.

synchronization primitive
   A basic building block for coordinating (synchronizing) the
   execution of multiple threads to ensure *thread-safe* access to
   shared resources. Python's "threading" module provides several
   synchronization primitives including "Lock", "RLock", "Semaphore",
   "Condition", "Event", and "Barrier".  Additionally, the "queue"
   module provides multi-producer, multi-consumer queues that are
   especially useful in multithreaded programs. These primitives help
   prevent *race conditions* and coordinate thread execution.  See
   also *lock*.

t-string
t-strings
   String literals prefixed with "t" or "T" are commonly called
   "t-strings" which is short for template string literals.

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.

thread state
   The information used by the *CPython* runtime to run in an OS
   thread. For example, this includes the current exception, if any,
   and the state of the bytecode interpreter.

   Each thread state is bound to a single OS thread, but threads may
   have many thread states available.  At most, one of them may be
   *attached* at once.

   An *attached thread state* is required to call most of Python's C
   API, unless a function explicitly documents otherwise. The bytecode
   interpreter only runs under an attached thread state.

   Each thread state belongs to a single interpreter, but each
   interpreter may have many thread states, including multiple for the
   same OS thread. Thread states from multiple interpreters may be
   bound to the same thread, but only one can be *attached* in that
   thread at any given moment.

   See Thread State and the Global Interpreter Lock for more
   information.

thread-safe
   A module, function, or class that behaves correctly when used by
   multiple threads concurrently.  Thread-safe code uses appropriate
   *synchronization primitives* like *locks* to protect shared mutable
   state, or is designed to avoid shared mutable state entirely.  In
   the *free-threaded* build, built-in types like "dict", "list", and
   "set" use internal locking to make many operations thread-safe,
   although thread safety is not necessarily guaranteed.  Code that is
   not thread-safe may experience *race conditions* and *data races*
   when used in multi-threaded programs.

token
   A small unit of source code, generated by the lexical analyzer
   (also called the *tokenizer*). Names, numbers, strings, operators,
   newlines and similar are represented by tokens.

   The "tokenize" module exposes Python's lexical analyzer. The
   "token" module contains information on the various types of tokens.

üç 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
   The type of a Python object determines what kind of object it is;
   every object has a type.  An object's type is accessible as its
   "__class__" attribute or can be retrieved with "type(obj)".

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

   Type hints are optional and are not enforced by Python but they are
   useful to *static type checkers*. They can also aid IDEs with code
   completion and refactoring.

   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.

walrus operator
   A light-hearted way to refer to the assignment expression operator
   ":=" because it looks a bit like a walrus if you turn your head.

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.
