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