# Python Documentation Turkish Translation

# Copyright (C) 2001-2023, Python Software Foundation

# This file is distributed under the same license as the Python package.

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3.12\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2023-09-18 22:33+0300\n"

"PO-Revision-Date: 2022-12-28 16:12-0500\n"

"Last-Translator: \n"

"Language-Team: TURKISH <python.docs.tr@gmail.com>\n"

"Language: tr\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"X-Generator: Poedit 3.2.2\n"

#: glossary.rst:5

msgid "Glossary"

msgstr "Sözlük"

#: glossary.rst:10

msgid "``>>>``"

msgstr "``>>>``"

#: glossary.rst:12

msgid ""

"The default Python prompt of the interactive shell. Often seen for code "

"examples which can be executed interactively in the interpreter."

msgstr ""

"Etkileşimli kabuğun varsayılan Python istemi. Genellikle yorumlayıcıda "

"etkileşimli olarak yürütülebilen kod örnekleri için görülür."

#: glossary.rst:14

msgid "``...``"

msgstr "``...``"

#: glossary.rst:16

msgid "Can refer to:"

msgstr "Şunlara başvurabilir:"

#: glossary.rst:18

msgid ""

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

msgstr ""

"Girintili bir kod bloğu için kod girerken, eşleşen bir çift sol ve sağ "

"sınırlayıcı (parantez, köşeli parantez, kaşlı ayraç veya üçlü tırnak) "

"içindeyken veya bir dekoratör belirttikten sonra etkileşimli kabuğun "

"varsayılan Python istemi."

#: glossary.rst:23

msgid "The :const:`Ellipsis` built-in constant."

msgstr ":const:`Elipsis` yerleşik sabiti."

#: glossary.rst:24

msgid "2to3"

msgstr "2to3"

#: glossary.rst:26

msgid ""

"A tool that tries to convert Python 2.x code to Python 3.x code by handling "

"most of the incompatibilities which can be detected by parsing the source "

"and traversing the parse tree."

msgstr ""

"Kaynağı ayrıştırarak ve ayrıştırma ağacında gezinerek tespit edilebilecek "

"uyumsuzlukların çoğunu işleyerek Python 2.x kodunu Python 3.x koduna "

"dönüştürmeye çalışan bir araç."

#: glossary.rst:30

msgid ""

"2to3 is available in the standard library as :mod:`lib2to3`; a standalone "

"entry point is provided as :file:`Tools/scripts/2to3`. See :ref:`2to3-"

"reference`."

msgstr ""

"2to3, standart kütüphanede :mod:`lib2to3'; bağımsız bir giriş noktası şu "

"şekilde sağlanır:file:`Tools/scripts/2to3`. Bakınız :ref:`2to3-reference`."

#: glossary.rst:33

msgid "abstract base class"

msgstr "soyut temel sınıf"

#: glossary.rst:35

msgid ""

"Abstract base classes complement :term:`duck-typing` by providing a way to "

"define interfaces when other techniques like :func:`hasattr` would be clumsy "

"or subtly wrong (for example with :ref:`magic methods <special-lookup>`). "

"ABCs introduce virtual subclasses, which are classes that don't inherit from "

"a class but are still recognized by :func:`isinstance` and :func:"

"`issubclass`; see the :mod:`abc` module documentation. Python comes with "

"many built-in ABCs for data structures (in the :mod:`collections.abc` "

"module), numbers (in the :mod:`numbers` module), streams (in the :mod:`io` "

"module), import finders and loaders (in the :mod:`importlib.abc` module). "

"You can create your own ABCs with the :mod:`abc` module."

msgstr ""

"Soyut temel sınıflar :term:`duck-typing` 'i, :func:`hasattr` gibi diğer "

"teknikler beceriksiz veya tamamen yanlış olduğunda arayüzleri tanımlamanın "

"bir yolunu sağlayarak tamamlar (örneğin :ref:`sihirli yöntemlerle <special-"

"lookup>`). ABC'ler, bir sınıftan miras almayan ancak yine de :func:"

"`isinstance` ve :func:`issubclass` tarafından tanınan sınıflar olan sanal "

"alt sınıfları tanıtır; :mod:`abc` modül belgelerine bakın. Python comes "

"with many built-in ABCs for data structures (in the :mod:`collections.abc` "

"module), numbers (in the :mod:`numbers` module), streams (in the :mod:`io` "

"module), import finders and loaders (in the :mod:`importlib.abc` module). :"

"mod:`abc` modülü ile kendi ABC'lerinizi oluşturabilirsiniz."

#: glossary.rst:46

msgid "annotation"

msgstr "dipnot"

#: glossary.rst:48

msgid ""

"A label associated with a variable, a class attribute or a function "

"parameter or return value, used by convention as a :term:`type hint`."

msgstr ""

"Bir değişkenle, bir sınıf niteliğiyle veya bir fonksiyon parametresiyle veya "

"bir dönüş değeriyle ilişkilendirilen, gelenek olarak :term:`type hint <type "

"hint>` biçiminde kullanılan bir etiket."

#: glossary.rst:52

msgid ""

"Annotations of local variables cannot be accessed at runtime, but "

"annotations of global variables, class attributes, and functions are stored "

"in the :attr:`__annotations__` special attribute of modules, classes, and "

"functions, respectively."

msgstr ""

"Yerel değişkenlerin açıklamalarına çalışma zamanında erişilemez, ancak "

"global değişkenlerin, sınıf niteliklerinin ve işlevlerin açıklamaları, "

"sırasıyla modüllerin, sınıfların ve işlevlerin :attr:`__annotations__` özel "

"özelliğinde saklanır."

#: glossary.rst:58

msgid ""

"See :term:`variable annotation`, :term:`function annotation`, :pep:`484` "

"and :pep:`526`, which describe this functionality. Also see :ref:"

"`annotations-howto` for best practices on working with annotations."

msgstr ""

"Bu işlevi açıklayan :term:`variable annotation`, :term:`function "

"annotation`, :pep:`484` ve :pep:`526`'e bakın. Ek açıklamalarla çalışmaya "

"ilişkin en iyi uygulamalar için ayrıca bkz. :ref:`annotations-howto`."

#: glossary.rst:62

msgid "argument"

msgstr "argüman"

#: glossary.rst:64

msgid ""

"A value passed to a :term:`function` (or :term:`method`) when calling the "

"function. There are two kinds of argument:"

msgstr ""

"Fonksiyon çağrılırken bir :term:`function` 'a (veya :term:`method`) "

"geçirilen bir değer. İki tür argüman vardır:"

#: glossary.rst:67

msgid ""

":dfn:`keyword argument`: an argument preceded by an identifier (e.g. "

"``name=``) in a function call or passed as a value in a dictionary preceded "

"by ``**``. For example, ``3`` and ``5`` are both keyword arguments in the "

"following calls to :func:`complex`::"

msgstr ""

":dfn:`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 :func:`complex`: "

"çağrılarında anahtar kelimenin argümanleridir:"

#: glossary.rst:75

msgid ""

":dfn:`positional argument`: an argument that is not a keyword argument. "

"Positional arguments can appear at the beginning of an argument list and/or "

"be passed as elements of an :term:`iterable` preceded by ``*``. For example, "

"``3`` and ``5`` are both positional arguments in the following calls::"

msgstr ""

":dfn:`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 :term:`iterable` öğesinin öğeleri olarak "

"iletilebilir. Örneğin, ``3`` ve ``5``, aşağıdaki çağrılarda konumsal "

"argümanlerdir:"

#: glossary.rst:84

msgid ""

"Arguments are assigned to the named local variables in a function body. See "

"the :ref:`calls` section for the rules governing this assignment. "

"Syntactically, any expression can be used to represent an argument; the "

"evaluated value is assigned to the local variable."

msgstr ""

"Argümanler, bir fonksiyon gövdesindeki adlandırılmış yerel değişkenlere "

"atanır. Bu atamayı yöneten kurallar için :ref:`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."

#: glossary.rst:89

msgid ""

"See also the :term:`parameter` glossary entry, the FAQ question on :ref:`the "

"difference between arguments and parameters <faq-argument-vs-parameter>`, "

"and :pep:`362`."

msgstr ""

"Ayrıca :term:`parameter` sözlüğü girişine, :ref:`the difference between "

"arguments and parameters <faq-argument-vs-parameter>` hakkındaki SSS "

"sorusuna ve :pep:`362` 'ye bakın."

#: glossary.rst:92

msgid "asynchronous context manager"

msgstr "asenkron bağlam yöneticisi"

#: glossary.rst:94

#, fuzzy

msgid ""

"An object which controls the environment seen in an :keyword:`async with` "

"statement by defining :meth:`~object.__aenter__` and :meth:`~object."

"__aexit__` methods. Introduced by :pep:`492`."

msgstr ""

":keyword:`async with` ifadesinde görülen ortamı :meth:`__aenter__` ve :meth:"

"`__aexit__` yöntemlerini tanımlayarak kontrol eden bir nesne. :pep:`492` de "

"anlatıldı."

#: glossary.rst:97

msgid "asynchronous generator"

msgstr "asenkron jeneratör"

#: glossary.rst:99

msgid ""

"A function which returns an :term:`asynchronous generator iterator`. It "

"looks like a coroutine function defined with :keyword:`async def` except "

"that it contains :keyword:`yield` expressions for producing a series of "

"values usable in an :keyword:`async for` loop."

msgstr ""

":term:`asynchronous generator iterator` döndüren bir işlev. Bir :keyword:"

"`async for` döngüsünde kullanılabilen bir dizi değer üretmek için :keyword:"

"`yield` ifadeleri içermesi dışında :keyword:`async def` ile tanımlanmış bir "

"eşyordam işlevine benziyor."

#: glossary.rst:104

msgid ""

"Usually refers to an asynchronous generator function, but may refer to an "

"*asynchronous generator iterator* in some contexts. In cases where the "

"intended meaning isn't clear, using the full terms avoids ambiguity."

msgstr ""

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

#: glossary.rst:108

msgid ""

"An asynchronous generator function may contain :keyword:`await` expressions "

"as well as :keyword:`async for`, and :keyword:`async with` statements."

msgstr ""

"Bir asenkron üretici fonksiyonu, :keyword:`await` ifadelerinin yanı sıra :"

"keyword:`async for` ve :keyword:`async with` ifadeleri içerebilir."

#: glossary.rst:111

msgid "asynchronous generator iterator"

msgstr "asenkron jeneratör yineleyici"

#: glossary.rst:113

msgid "An object created by a :term:`asynchronous generator` function."

msgstr ""

"Bir :term:`asynchronous generator` işlevi tarafından oluşturulan bir nesne."

#: glossary.rst:115

#, fuzzy

msgid ""

"This is an :term:`asynchronous iterator` which when called using the :meth:"

"`~object.__anext__` method returns an awaitable object which will execute "

"the body of the asynchronous generator function until the next :keyword:"

"`yield` expression."

msgstr ""

"Bu, :meth:`__anext__` yöntemi kullanılarak çağrıldığında, bir sonraki :"

"keyword:`yield` ifadesine kadar asynchronous generator işlevinin gövdesini "

"yürütecek, beklenebilir bir nesne döndüren bir :term:`asynchronous iterator`."

#: glossary.rst:120

#, fuzzy

msgid ""

"Each :keyword:`yield` temporarily suspends processing, remembering the "

"location execution state (including local variables and pending try-"

"statements). When the *asynchronous generator iterator* effectively resumes "

"with another awaitable returned by :meth:`~object.__anext__`, it picks up "

"where it left off. See :pep:`492` and :pep:`525`."

msgstr ""

"Her :keyword:`yield`, konum yürütme durumunu hatırlayarak (yerel değişkenler "

"ve bekleyen try ifadeleri dahil) işlemeyi geçici olarak askıya alır. "

"*asynchronous generator iterator*, :meth:`__anext__` tarafından döndürülen "

"başka birbeklenebilir ile etkili bir şekilde devam ettiğinde, kaldığı yerden "

"devam eder. Bkz. :pep:`492` ve :pep:`525`."

#: glossary.rst:125

msgid "asynchronous iterable"

msgstr "eşzamansız yinelenebilir"

#: glossary.rst:127

#, fuzzy

msgid ""

"An object, that can be used in an :keyword:`async for` statement. Must "

"return an :term:`asynchronous iterator` from its :meth:`~object.__aiter__` "

"method. Introduced by :pep:`492`."

msgstr ""

"Bir :keyword:`async for` ifadesinde kullanılabilen bir nesne. :meth:"

"`__aiter__` yönteminden bir :term:`asynchronous iterator` döndürmelidir. :"

"pep:`492` 'de tanıtıldı."

#: glossary.rst:130

msgid "asynchronous iterator"

msgstr "asenkron yineleyici"

#: glossary.rst:132

#, fuzzy

msgid ""

"An object that implements the :meth:`~object.__aiter__` and :meth:`~object."

"__anext__` methods. :meth:`~object.__anext__` must return an :term:"

"`awaitable` object. :keyword:`async for` resolves the awaitables returned by "

"an asynchronous iterator's :meth:`~object.__anext__` method until it raises "

"a :exc:`StopAsyncIteration` exception. Introduced by :pep:`492`."

msgstr ""

":meth:`__aiter__` ve :meth:`__anext__` yöntemlerini uygulayan bir nesne. "

"``__anext__`` bir :term:`awaitable` nesnesi döndürmelidir. :keyword:`async "

"for`, bir asenkron yineleyicinin :meth:`__anext__` yöntemi tarafından "

"döndürülen beklenebilirleri bir :exc:`StopAsyncIteration` istisnası "

"oluşturana kadar çözer. :pep:`492` 'de açıklandı."

#: glossary.rst:137

msgid "attribute"

msgstr "nitelik"

#: glossary.rst:139

msgid ""

"A value associated with an object which is usually referenced by name using "

"dotted expressions. For example, if an object *o* has an attribute *a* it "

"would be referenced as *o.a*."

msgstr ""

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

#: glossary.rst:144

msgid ""

"It is possible to give an object an attribute whose name is not an "

"identifier as defined by :ref:`identifiers`, for example using :func:"

"`setattr`, if the object allows it. Such an attribute will not be accessible "

"using a dotted expression, and would instead need to be retrieved with :func:"

"`getattr`."

msgstr ""

"Bir nesneye, eğer nesne izin veriyorsa, örneğin :func:`setattr` kullanarak, "

"adı :ref:`identifiers` 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 :func:`getattr` ile alınması gerekir."

#: glossary.rst:149

msgid "awaitable"

msgstr "beklenebilir"

#: glossary.rst:151

#, fuzzy

msgid ""

"An object that can be used in an :keyword:`await` expression. Can be a :"

"term:`coroutine` or an object with an :meth:`~object.__await__` method. See "

"also :pep:`492`."

msgstr ""

":keyword:`await` ifadesinde kullanılabilen bir nesne. Bir :term:`coroutine` "

"veya :meth:`__await__` yöntemine sahip bir nesne olabilir. Ayrıca bakınız :"

"pep:`492`."

#: glossary.rst:154

msgid "BDFL"

msgstr "BDFL"

#: glossary.rst:156

msgid ""

"Benevolent Dictator For Life, a.k.a. `Guido van Rossum <https://gvanrossum."

"github.io/>`_, Python's creator."

msgstr ""

"Benevolent Dictator For Life, namı diğer `Guido van Rossum <https://"

"gvanrossum.github.io/>`_, Python'un yaratıcısı."

#: glossary.rst:158

msgid "binary file"

msgstr "ikili dosya"

#: glossary.rst:160

msgid ""

"A :term:`file object` able to read and write :term:`bytes-like objects "

"<bytes-like object>`. Examples of binary files are files opened in binary "

"mode (``'rb'``, ``'wb'`` or ``'rb+'``), :data:`sys.stdin.buffer`, :data:`sys."

"stdout.buffer`, and instances of :class:`io.BytesIO` and :class:`gzip."

"GzipFile`."

msgstr ""

"Bir :term:`dosya nesnesi <file object>` :term:`bayt benzeri nesneler <bytes-"

"like object>` okuyabilir ve yazabilir. İkili dosya örnekleri, ikili modda "

"açılan dosyalardır (``'rb'``, ``'wb'`` veya ``'rb+'``), :data:`sys.stdin."

"buffer`, :data:`sys.stdout.buffer` ve :class:`io.BytesIO` ve :class:`gzip."

"GzipFile` örnekleri."

#: glossary.rst:167

msgid ""

"See also :term:`text file` for a file object able to read and write :class:"

"`str` objects."

msgstr ""

"Ayrıca :class:`str` nesnelerini okuyabilen ve yazabilen bir dosya nesnesi "

"için :term:`text file` 'a bakın."

#: glossary.rst:169

msgid "borrowed reference"

msgstr "ödünç alınan referans"

#: glossary.rst:171

#, fuzzy

msgid ""

"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 :term:`strong reference` to the object and so destroy it."

msgstr ""

"Python'un C API 'sinde ödünç alınan referans, bir nesneye yapılan bir "

"referanstır. Nesne referans sayısını değiştirmez. Nesne yok edilirse sarkan "

"bir işaretçi olur. Örneğin, bir çöp toplama, nesneye yapılan son :term:"

"`strong reference` kaldırabilir ve böylece onu yok edebilir."

#: glossary.rst:177

msgid ""

"Calling :c:func:`Py_INCREF` on the :term:`borrowed reference` is recommended "

"to convert it to a :term:`strong reference` in-place, except when the object "

"cannot be destroyed before the last usage of the borrowed reference. The :c:"

"func:`Py_NewRef` function can be used to create a new :term:`strong "

"reference`."

msgstr ""

":term:`borrowed reference` üzerinde :c:func:`Py_INCREF` çağırmak, nesnenin "

"ödünç alınanın son kullanımından önce yok edilemediği durumlar dışında, onu "

"yerinde bir :term:`strong reference` 'a dönüştürmek için tavsiye edilir. "

"referans. :c:func:`Py_NewRef` işlevi, yeni bir :term:`strong reference` "

"oluşturmak için kullanılabilir."

#: glossary.rst:182

msgid "bytes-like object"

msgstr "bayt benzeri nesne"

#: glossary.rst:184

msgid ""

"An object that supports the :ref:`bufferobjects` and can export a C-:term:"

"`contiguous` buffer. This includes all :class:`bytes`, :class:`bytearray`, "

"and :class:`array.array` objects, as well as many common :class:`memoryview` "

"objects. Bytes-like objects can be used for various operations that work "

"with binary data; these include compression, saving to a binary file, and "

"sending over a socket."

msgstr ""

":ref:`bufferobjects` 'i destekleyen ve bir C-:term:`contiguous` arabelleğini "

"dışa aktarabilen bir nesne. Bu, tüm :class:`bytes`, :class:`bytearray` ve :"

"class:`array.array` nesnelerinin yanı sıra birçok yaygın :class:`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."

#: glossary.rst:191

msgid ""

"Some operations need the binary data to be mutable. The documentation often "

"refers to these as \"read-write bytes-like objects\". Example mutable "

"buffer objects include :class:`bytearray` and a :class:`memoryview` of a :"

"class:`bytearray`. Other operations require the binary data to be stored in "

"immutable objects (\"read-only bytes-like objects\"); examples of these "

"include :class:`bytes` and a :class:`memoryview` of a :class:`bytes` object."

msgstr ""

"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 :class:`bytearray` ve "

"bir :class:`bytearray` :class:`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 :class:`bytes` ve bir :"

"class:`bytes` nesnesinin :class:`memoryview` bulunur."

#: glossary.rst:199

msgid "bytecode"

msgstr "bayt kodu"

#: glossary.rst:201

msgid ""

"Python source code is compiled into bytecode, the internal representation of "

"a Python program in the CPython interpreter. The bytecode is also cached in "

"``.pyc`` files so that executing the same file is faster the second time "

"(recompilation from source to bytecode can be avoided). This \"intermediate "

"language\" is said to run on a :term:`virtual machine` that executes the "

"machine code corresponding to each bytecode. Do note that bytecodes are not "

"expected to work between different Python virtual machines, nor to be stable "

"between Python releases."

msgstr ""

"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 :term:`sanal "

"makine <virtual machine>` ü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."

#: glossary.rst:211

msgid ""

"A list of bytecode instructions can be found in the documentation for :ref:"

"`the dis module <bytecodes>`."

msgstr ""

"Bayt kodu talimatlarının bir listesi :ref:`bytecodes` dokümanında "

"bulunabilir."

#: glossary.rst:213

msgid "callable"

msgstr "çağırılabilir"

#: glossary.rst:215

msgid ""

"A callable is an object that can be called, possibly with a set of arguments "

"(see :term:`argument`), with the following syntax::"

msgstr ""

"Bir çağrılabilir, muhtemelen bir dizi argümanla (bkz. :term:`argument`) ve "

"aşağıdaki sözdizimiyle çağrılabilen bir nesnedir::"

#: glossary.rst:220

msgid ""

"A :term:`function`, and by extension a :term:`method`, is a callable. An "

"instance of a class that implements the :meth:`~object.__call__` method is "

"also a callable."

msgstr ""

"Bir :term:`fonksiyon <function>` ve uzantısı olarak bir :term:`metot "

"<method>` bir çağrılabilirdir. :meth:`~object.__call__` yöntemini uygulayan "

"bir sınıf örneği de bir çağrılabilirdir."

#: glossary.rst:223

msgid "callback"

msgstr "geri çağırmak"

#: glossary.rst:225

msgid ""

"A subroutine function which is passed as an argument to be executed at some "

"point in the future."

msgstr ""

"Gelecekte bir noktada yürütülecek bir argüman olarak iletilen bir alt "

"program işlevi."

#: glossary.rst:227

msgid "class"

msgstr "sınıf"

#: glossary.rst:229

msgid ""

"A template for creating user-defined objects. Class definitions normally "

"contain method definitions which operate on instances of the class."

msgstr ""

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

#: glossary.rst:232

msgid "class variable"

msgstr "sınıf değişkeni"

#: glossary.rst:234

msgid ""

"A variable defined in a class and intended to be modified only at class "

"level (i.e., not in an instance of the class)."

msgstr ""

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

#: glossary.rst:236

msgid "complex number"

msgstr "karmaşık sayı"

#: glossary.rst:238

msgid ""

"An extension of the familiar real number system in which all numbers are "

"expressed as a sum of a real part and an imaginary part. Imaginary numbers "

"are real multiples of the imaginary unit (the square root of ``-1``), often "

"written ``i`` in mathematics or ``j`` in engineering. Python has built-in "

"support for complex numbers, which are written with this latter notation; "

"the imaginary part is written with a ``j`` suffix, e.g., ``3+1j``. To get "

"access to complex equivalents of the :mod:`math` module, use :mod:`cmath`. "

"Use of complex numbers is a fairly advanced mathematical feature. If you're "

"not aware of a need for them, it's almost certain you can safely ignore them."

msgstr ""

"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``. :mod:`math` modülünün "

"karmaşık eş değerlerine erişmek için :mod:`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."

#: glossary.rst:248

msgid "context manager"

msgstr "bağlam yöneticisi"

#: glossary.rst:250

msgid ""

"An object which controls the environment seen in a :keyword:`with` statement "

"by defining :meth:`__enter__` and :meth:`__exit__` methods. See :pep:`343`."

msgstr ""

":keyword:`with` ifadesinde görülen ortamı :meth:`__enter__` ve :meth:"

"`__exit__` yöntemlerini tanımlayarak kontrol eden bir nesne. Bakınız :pep:"

"`343`."

#: glossary.rst:253

msgid "context variable"

msgstr "bağlam değişkeni"

#: glossary.rst:255

msgid ""

"A variable which can have different values depending on its context. This is "

"similar to Thread-Local Storage in which each execution thread may have a "

"different value for a variable. However, with context variables, there may "

"be several contexts in one execution thread and the main usage for context "

"variables is to keep track of variables in concurrent asynchronous tasks. "

"See :mod:`contextvars`."

msgstr ""

"Bağlamına bağlı olarak farklı değerler alabilen bir değişken. Bu, her "

"yürütme iş parçacığının bir değişken için farklı bir değere sahip "

"olabileceği Thread-Local Storage'a benzer. Bununla birlikte, bağlam "

"değişkenleriyle, bir yürütme iş parçacığında birkaç bağlam olabilir ve "

"bağlam değişkenlerinin ana kullanımı, eşzamanlı zaman uyumsuz görevlerde "

"değişkenleri izlemektir. Bakınız :mod:`contextvars`."

#: glossary.rst:262

msgid "contiguous"

msgstr "bitişik"

#: glossary.rst:266

msgid ""

"A buffer is considered contiguous exactly if it is either *C-contiguous* or "

"*Fortran contiguous*. Zero-dimensional buffers are C and Fortran "

"contiguous. In one-dimensional arrays, the items must be laid out in memory "

"next to each other, in order of increasing indexes starting from zero. In "

"multidimensional C-contiguous arrays, the last index varies the fastest when "

"visiting items in order of memory address. However, in Fortran contiguous "

"arrays, the first index varies the fastest."

msgstr ""

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

#: glossary.rst:274

msgid "coroutine"

msgstr "eşyordam"

#: glossary.rst:276

msgid ""

"Coroutines are a more generalized form of subroutines. Subroutines are "

"entered at one point and exited at another point. Coroutines can be "

"entered, exited, and resumed at many different points. They can be "

"implemented with the :keyword:`async def` statement. See also :pep:`492`."

msgstr ""

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

"keyword:`async def` ifadesi ile uygulanabilirler. Ayrıca bakınız :pep:`492`."

#: glossary.rst:281

msgid "coroutine function"

msgstr "eşyordam işlevi"

#: glossary.rst:283

msgid ""

"A function which returns a :term:`coroutine` object. A coroutine function "

"may be defined with the :keyword:`async def` statement, and may contain :"

"keyword:`await`, :keyword:`async for`, and :keyword:`async with` keywords. "

"These were introduced by :pep:`492`."

msgstr ""

"Bir :term:`coroutine` nesnesi döndüren bir işlev. Bir eşyordam işlevi :"

"keyword:`async def` ifadesiyle tanımlanabilir ve :keyword:`await`, :keyword:"

"`async for` ve :keyword:`async with` anahtar kelimelerini içerebilir. "

"Bunlar :pep:`492` tarafından tanıtıldı."

#: glossary.rst:288

msgid "CPython"

msgstr "CPython"

#: glossary.rst:290

msgid ""

"The canonical implementation of the Python programming language, as "

"distributed on `python.org <https://www.python.org>`_. The term \"CPython\" "

"is used when necessary to distinguish this implementation from others such "

"as Jython or IronPython."

msgstr ""

"Python programlama dilinin `python.org <https://www.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."

#: glossary.rst:294

msgid "decorator"

msgstr "dekoratör"

#: glossary.rst:296

msgid ""

"A function returning another function, usually applied as a function "

"transformation using the ``@wrapper`` syntax. Common examples for "

"decorators are :func:`classmethod` and :func:`staticmethod`."

msgstr ""

"Genellikle ``@wrapper`` sözdizimi kullanılarak bir işlev dönüşümü olarak "

"uygulanan, başka bir işlevi döndüren bir işlev. Dekoratörler için yaygın "

"örnekler şunlardır: :func:`classmethod` ve :func:`staticmethod`."

#: glossary.rst:300

msgid ""

"The decorator syntax is merely syntactic sugar, the following two function "

"definitions are semantically equivalent::"

msgstr ""

"Dekoratör sözdizimi yalnızca sözdizimsel şekerdir, aşağıdaki iki işlev "

"tanımı anlamsal olarak eş değerdir:"

#: glossary.rst:311

msgid ""

"The same concept exists for classes, but is less commonly used there. See "

"the documentation for :ref:`function definitions <function>` and :ref:`class "

"definitions <class>` for more about decorators."

msgstr ""

"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 :ref:`function definitions "

"<function>` ve :ref:`class definitions <class>` belgelerine bakın."

#: glossary.rst:314

msgid "descriptor"

msgstr "tanımlayıcı"

#: glossary.rst:316

msgid ""

"Any object which defines the methods :meth:`__get__`, :meth:`__set__`, or :"

"meth:`__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."

msgstr ""

":meth:`__get__`, :meth:`__set__` veya :meth:`__delete__` yöntemlerini "

"tanımlayan herhangi bir nesne. Bir sınıf özniteliği bir tanımlayıcı "

"olduğunda, öznitelik araması üzerine özel bağlama davranışı tetiklenir. "

"Normalde, bir özniteliği almak, ayarlamak veya silmek için *a.b* kullanmak, "

"*a* için sınıf sözlüğünde *b* adlı nesneyi arar, ancak *b* bir tanımlayıcı "

"ise, ilgili tanımlayıcı yöntemi çağrılır. Tanımlayıcıları anlamak, Python'u "

"derinlemesine anlamanın anahtarıdır çünkü bunlar, işlevler, yöntemler, "

"özellikler, sınıf yöntemleri, statik yöntemler ve süper sınıflara başvuru "

"gibi birçok özelliğin temelidir."

#: glossary.rst:326

msgid ""

"For more information about descriptors' methods, see :ref:`descriptors` or "

"the :ref:`Descriptor How To Guide <descriptorhowto>`."

msgstr ""

"Tanımlayıcıların yöntemleri hakkında daha fazla bilgi için, bkz. :ref:"

"`descriptors` veya :ref:`Descriptor How To Guide <descriptorhowto>`."

#: glossary.rst:328

msgid "dictionary"

msgstr "sözlük"

#: glossary.rst:330

msgid ""

"An associative array, where arbitrary keys are mapped to values. The keys "

"can be any object with :meth:`__hash__` and :meth:`__eq__` methods. Called a "

"hash in Perl."

msgstr ""

"Rasgele anahtarların değerlerle eşlendiği ilişkisel bir dizi. Anahtarlar, :"

"meth:`__hash__` ve :meth:`__eq__` yöntemleriyle herhangi bir nesne olabilir. "

"Perl'de karma denir."

#: glossary.rst:333

msgid "dictionary comprehension"

msgstr "sözlük anlama"

#: glossary.rst:335

msgid ""

"A compact way to process all or part of the elements in an iterable and "

"return a dictionary with the results. ``results = {n: n ** 2 for n in "

"range(10)}`` generates a dictionary containing key ``n`` mapped to value ``n "

"** 2``. See :ref:`comprehensions`."

msgstr ""

"Öğ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. :ref:`comprehensions`."

#: glossary.rst:339

msgid "dictionary view"

msgstr "sözlük görünümü"

#: glossary.rst:341

msgid ""

"The objects returned from :meth:`dict.keys`, :meth:`dict.values`, and :meth:"

"`dict.items` are called dictionary views. They provide a dynamic view on the "

"dictionary’s entries, which means that when the dictionary changes, the view "

"reflects these changes. To force the dictionary view to become a full list "

"use ``list(dictview)``. See :ref:`dict-views`."

msgstr ""

":meth:`dict.keys`, :meth:`dict.values` ve :meth:`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 :ref:`dict-views`."

#: glossary.rst:347

msgid "docstring"

msgstr "belge dizisi"

#: glossary.rst:349

msgid ""

"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 :attr:`__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."

msgstr ""

"Bir sınıf, işlev veya modülde ilk ifade olarak görünen bir dize değişmezi. "

"Paket yürütüldüğünde yoksayılırken, derleyici tarafından tanınır ve "

"çevreleyen sınıfın, işlevin veya modülün :attr:`__doc__` özniteliğine "

"yerleştirilir. İç gözlem yoluyla erişilebilir olduğundan, nesnenin "

"belgelenmesi için kurallı yerdir."

#: glossary.rst:355

msgid "duck-typing"

msgstr "ördek yazma"

#: glossary.rst:357

msgid ""

"A programming style which does not look at an object's type to determine if "

"it has the right interface; instead, the method or attribute is simply "

"called or used (\"If it looks like a duck and quacks like a duck, it must be "

"a duck.\") By emphasizing interfaces rather than specific types, well-"

"designed code improves its flexibility by allowing polymorphic "

"substitution. Duck-typing avoids tests using :func:`type` or :func:"

"`isinstance`. (Note, however, that duck-typing can be complemented with :"

"term:`abstract base classes <abstract base class>`.) Instead, it typically "

"employs :func:`hasattr` tests or :term:`EAFP` programming."

msgstr ""

"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, :func:`type` veya :func:`isinstance` kullanan "

"testleri önler. (Ancak, ördek yazmanın :term:`abstract base class` ile "

"tamamlanabileceğini unutmayın.) Bunun yerine, genellikle :func:`hasattr` "

"testleri veya :term:`EAFP` programlamasını kullanır."

#: glossary.rst:366

msgid "EAFP"

msgstr "EAFP"

#: glossary.rst:368

msgid ""

"Easier to ask for forgiveness than permission. This common Python coding "

"style assumes the existence of valid keys or attributes and catches "

"exceptions if the assumption proves false. This clean and fast style is "

"characterized by the presence of many :keyword:`try` and :keyword:`except` "

"statements. The technique contrasts with the :term:`LBYL` style common to "

"many other languages such as C."

msgstr ""

"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 :keyword:`try` ve :keyword:`except` ifadesinin varlığı ile "

"karakterize edilir. Teknik, C gibi diğer birçok dilde ortak olan :term:"

"`LBYL` stiliyle çelişir."

#: glossary.rst:374

msgid "expression"

msgstr "ifade (değer döndürür)"

#: glossary.rst:376

msgid ""

"A piece of syntax which can be evaluated to some value. In other words, an "

"expression is an accumulation of expression elements like literals, names, "

"attribute access, operators or function calls which all return a value. In "

"contrast to many other languages, not all language constructs are "

"expressions. There are also :term:`statement`\\s which cannot be used as "

"expressions, such as :keyword:`while`. Assignments are also statements, not "

"expressions."

msgstr ""

"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 :keyword:`while` gibi kullanılamayan :term:`ifadeler <statement>` de "

"vardır. Atamalar da değer döndürmeyen ifadelerdir (statement)."

#: glossary.rst:383

msgid "extension module"

msgstr "uzatma modülü"

#: glossary.rst:385

msgid ""

"A module written in C or C++, using Python's C API to interact with the core "

"and with user code."

msgstr ""

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

#: glossary.rst:387

msgid "f-string"

msgstr "f-string"

#: glossary.rst:389

msgid ""

"String literals prefixed with ``'f'`` or ``'F'`` are commonly called \"f-"

"strings\" which is short for :ref:`formatted string literals <f-strings>`. "

"See also :pep:`498`."

msgstr ""

"Ön eki ``'f'`` veya ``'F'`` olan dize değişmezleri genellikle \"f-strings\" "

"olarak adlandırılır; bu, :ref:`formatted string literals <f-strings>` 'ın "

"kısaltmasıdır. Ayrıca bkz. :pep:`498`."

#: glossary.rst:392

msgid "file object"

msgstr "dosya nesnesi"

#: glossary.rst:394

msgid ""

"An object exposing a file-oriented API (with methods such as :meth:`read()` "

"or :meth:`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 :dfn:`file-like objects` or :dfn:`streams`."

msgstr ""

"Dosya yönelimli bir API'yi (:meth:`read()` veya :meth:`write()` gibi "

"yöntemlerle) temel alınan bir kaynağa gösteren bir nesne. Oluşturulma "

"şekline bağlı olarak, bir dosya nesnesi gerçek bir disk üzerindeki dosyaya "

"veya başka bir tür depolama veya iletişim aygıtına (örneğin standart giriş/"

"çıkış, bellek içi arabellekler, yuvalar, borular vb.) erişime aracılık "

"edebilir. . Dosya nesneleri ayrıca :dfn:`file-like objects` veya :dfn:"

"`streams` olarak da adlandırılır."

#: glossary.rst:402

msgid ""

"There are actually three categories of file objects: raw :term:`binary files "

"<binary file>`, buffered :term:`binary files <binary file>` and :term:`text "

"files <text file>`. Their interfaces are defined in the :mod:`io` module. "

"The canonical way to create a file object is by using the :func:`open` "

"function."

msgstr ""

"Aslında üç dosya nesnesi kategorisi vardır: ham :term:`binary files <binary "

"file>`, arabelleğe alınmış :term:`binary files <binary file>` ve :term:`text "

"files <text file>`. Arayüzleri :mod:`io` modülünde tanımlanmıştır. Bir "

"dosya nesnesi yaratmanın kurallı yolu :func:`open` işlevini kullanmaktır."

#: glossary.rst:407

msgid "file-like object"

msgstr "dosya benzeri nesne"

#: glossary.rst:409

msgid "A synonym for :term:`file object`."

msgstr ":term:`dosya nesnesi` ile eşanlamlıdır."

#: glossary.rst:410

msgid "filesystem encoding and error handler"

msgstr "dosya sistemi kodlaması ve hata işleyicisi"

#: glossary.rst:412

msgid ""

"Encoding and error handler used by Python to decode bytes from the operating "

"system and encode Unicode to the operating system."

msgstr ""

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

#: glossary.rst:415

msgid ""

"The filesystem encoding must guarantee to successfully decode all bytes "

"below 128. If the file system encoding fails to provide this guarantee, API "

"functions can raise :exc:`UnicodeError`."

msgstr ""

"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 :exc:`UnicodeError` değerini yükseltebilir."

#: glossary.rst:419

msgid ""

"The :func:`sys.getfilesystemencoding` and :func:`sys."

"getfilesystemencodeerrors` functions can be used to get the filesystem "

"encoding and error handler."

msgstr ""

":func:`sys.getfilesystemencoding` ve :func:`sys.getfilesystemencodeerrors` "

"işlevleri, dosya sistemi kodlamasını ve hata işleyicisini almak için "

"kullanılabilir."

#: glossary.rst:423

msgid ""

"The :term:`filesystem encoding and error handler` are configured at Python "

"startup by the :c:func:`PyConfig_Read` function: see :c:member:`~PyConfig."

"filesystem_encoding` and :c:member:`~PyConfig.filesystem_errors` members of :"

"c:type:`PyConfig`."

msgstr ""

":term:`filesystem encoding and error handler` Python başlangıcında :c:func:"

"`PyConfig_Read` işleviyle yapılandırılır: bkz. :c:member:`~PyConfig."

"filesystem_encoding` ve :c:member:`~PyConfig. filesystem_errors` üyeleri :c:"