# 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.11\n"

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

"POT-Creation-Date: 2023-09-18 19:05+0000\n"

"PO-Revision-Date: 2023-05-02 01:31+0300\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"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

"X-Generator: Poedit 3.2.2\n"

#: howto/clinic.rst:7

msgid "Argument Clinic How-To"

msgstr "Argüman Kliniği Nasıl Yapılır"

#: howto/clinic.rst:0

msgid "author"

msgstr "yazar"

#: howto/clinic.rst:9

msgid "Larry Hastings"

msgstr "Larry Hastings"

#: howto/clinic.rst:11

msgid "**Source code:** :source:`Tools/clinic/clinic.py`."

msgstr ""

#: howto/clinic.rst:7

msgid "Abstract"

msgstr "Soyut"

#: howto/clinic.rst:15

msgid ""

"Argument Clinic is a preprocessor for CPython C files. It was introduced in "

"Python 3.4 with :pep:`436`, in order to provide introspection signatures, "

"and to generate performant and tailor-made boilerplate code for argument "

"parsing in CPython builtins, module level functions, and class methods. This "

"document is divided in four major sections:"

msgstr ""

#: howto/clinic.rst:23

msgid ""

":ref:`clinic-background` talks about the basic concepts and goals of "

"Argument Clinic."

msgstr ""

#: howto/clinic.rst:25

msgid ""

":ref:`clinic-reference` describes the command-line interface and Argument "

"Clinic terminology."

msgstr ""

#: howto/clinic.rst:27

msgid ""

":ref:`clinic-tutorial` guides you through all the steps required to adapt an "

"existing C function to Argument Clinic."

msgstr ""

#: howto/clinic.rst:29

msgid ":ref:`clinic-howtos` details how to handle specific tasks."

msgstr ""

#: howto/clinic.rst:34

#, fuzzy

msgid ""

"Argument Clinic is considered internal-only for CPython. Its use is not "

"supported for files outside CPython, and no guarantees are made regarding "

"backwards compatibility for future versions. In other words: if you "

"maintain an external C extension for CPython, you're welcome to experiment "

"with Argument Clinic in your own code. But the version of Argument Clinic "

"that ships with the next version of CPython *could* be totally incompatible "

"and break all your code."

msgstr ""

"Şu anda Argüman Kliniği CPython için dahili olarak kabul edilmektedir. "

"CPython dışındaki dosyalar için kullanımı desteklenmemektedir ve gelecek "

"sürümler için geriye dönük uyumluluk konusunda herhangi bir garanti "

"verilmemektedir. Başka bir deyişle: CPython için harici bir C uzantısına "

"sahipseniz, Argüman Kliniği'ni kendi kodunuzda deneyebilirsiniz. Ancak "

"CPython'un bir sonraki sürümüyle birlikte gelen Argüman Kliniği sürümü * "

"tamamen uyumsuz olabilir ve tüm kodunuzu bozabilir."

#: howto/clinic.rst:47

msgid "Background"

msgstr ""

#: howto/clinic.rst:50

#, fuzzy

msgid "Basic concepts"

msgstr "Temel Kavramlar ve Kullanım"

#: howto/clinic.rst:52

msgid ""

"When Argument Clinic is run on a file, either via the :ref:`clinic-cli` or "

"via ``make clinic``, it will scan over the input files looking for :term:"

"`start lines <start line>`:"

msgstr ""

#: howto/clinic.rst:60

#, fuzzy

msgid "When it finds one, it reads everything up to the :term:`end line`:"

msgstr ""

"Bir tane bulduğunda, tam olarak buna benzeyen bir satıra kadar her şeyi okur:"

#: howto/clinic.rst:66

msgid ""

"Everything in between these two lines is Argument Clinic :term:`input`. When "

"Argument Clinic parses input, it generates :term:`output`. The output is "

"rewritten into the C file immediately after the input, followed by a :term:"

"`checksum line`. All of these lines, including the :term:`start line` and :"

"term:`checksum line`, are collectively called an Argument Clinic :term:"

"`block`:"

msgstr ""

#: howto/clinic.rst:81

#, fuzzy

msgid ""

"If you run Argument Clinic on the same file a second time, Argument Clinic "

"will discard the old :term:`output` and write out the new output with a "

"fresh :term:`checksum line`. If the :term:`input` hasn't changed, the output "

"won't change either."

msgstr ""

"Argüman Kliniği'ni aynı dosya üzerinde ikinci kez çalıştırırsanız, Argüman "

"Kliniği eski çıktıyı atacak ve yeni çıktıyı yeni bir sağlama toplamı "

"satırıyla birlikte yazacaktır. Ancak, girdi değişmemişse, çıktı da "

"değişmeyecektir."

#: howto/clinic.rst:88

msgid ""

"You should never modify the output of an Argument Clinic block, as any "

"change will be lost in future Argument Clinic runs; Argument Clinic will "

"detect an output checksum mismatch and regenerate the correct output. If you "

"are not happy with the generated output, you should instead change the input "

"until it produces the output you want."

msgstr ""

#: howto/clinic.rst:99

msgid "Reference"

msgstr ""

#: howto/clinic.rst:105

msgid "Terminology"

msgstr ""

#: howto/clinic.rst:108

msgid "start line"

msgstr ""

#: howto/clinic.rst:110

msgid ""

"The line ``/*[clinic input]``. This line marks the beginning of Argument "

"Clinic input. Note that the *start line* opens a C block comment."

msgstr ""

#: howto/clinic.rst:113

msgid "end line"

msgstr ""

#: howto/clinic.rst:115

msgid ""

"The line ``[clinic start generated code]*/``. The *end line* marks the _end_ "

"of Argument Clinic :term:`input`, but at the same time marks the _start_ of "

"Argument Clinic :term:`output`, thus the text *\"clinic start start "

"generated code\"* Note that the *end line* closes the C block comment opened "

"by the *start line*."

msgstr ""

#: howto/clinic.rst:121

msgid "checksum"

msgstr ""

#: howto/clinic.rst:123

msgid ""

"A hash to distinguish unique :term:`inputs <input>` and :term:`outputs "

"<output>`."

msgstr ""

#: howto/clinic.rst:125

msgid "checksum line"

msgstr ""

#: howto/clinic.rst:127

msgid ""

"A line that looks like ``/*[clinic end generated code: ...]*/``. The three "

"dots will be replaced by a :term:`checksum` generated from the :term:"

"`input`, and a :term:`checksum` generated from the :term:`output`. The "

"checksum line marks the end of Argument Clinic generated code, and is used "

"by Argument Clinic to determine if it needs to regenerate output."

msgstr ""

#: howto/clinic.rst:133

msgid "input"

msgstr ""

#: howto/clinic.rst:135

msgid ""

"The text between the :term:`start line` and the :term:`end line`. Note that "

"the start and end lines open and close a C block comment; the *input* is "

"thus a part of that same C block comment."

msgstr ""

#: howto/clinic.rst:138

msgid "output"

msgstr ""

#: howto/clinic.rst:140

#, fuzzy

msgid "The text between the :term:`end line` and the :term:`checksum line`."

msgstr "Bitiş satırı ile sağlama toplamı satırı arasında *çıktı* bulunur."

#: howto/clinic.rst:141

#, fuzzy

msgid "block"

msgstr "``block````block``"

#: howto/clinic.rst:143

msgid ""

"All text from the :term:`start line` to the :term:`checksum line` "

"inclusively."

msgstr ""

#: howto/clinic.rst:149

msgid "Command-line interface"

msgstr ""

#: howto/clinic.rst:151

msgid ""

"The Argument Clinic :abbr:`CLI (Command-Line Interface)` is typically used "

"to process a single source file, like this:"

msgstr ""

#: howto/clinic.rst:158

msgid "The CLI supports the following options:"

msgstr ""

#: howto/clinic.rst:165

msgid "Print CLI usage."

msgstr ""

#: howto/clinic.rst:169

msgid "Force output regeneration."

msgstr ""

#: howto/clinic.rst:173

msgid "Redirect file output to OUTPUT"

msgstr ""

#: howto/clinic.rst:177

msgid "Enable verbose mode."

msgstr ""

#: howto/clinic.rst:181

msgid "Print a list of all supported converters and return converters."

msgstr ""

#: howto/clinic.rst:185

msgid "Walk :option:`--srcdir` to run over all relevant files."

msgstr ""

#: howto/clinic.rst:189

msgid "The directory tree to walk in :option:`--make` mode."

msgstr ""

#: howto/clinic.rst:193

msgid "The list of files to process."

msgstr ""

#: howto/clinic.rst:199

#, fuzzy

msgid "Classes for extending Argument Clinic"

msgstr "Argüman Kliniğinin Hedefleri"

#: howto/clinic.rst:205

msgid ""

"The base class for all converters. See :ref:`clinic-howto-custom-converter` "

"for how to subclass this class."

msgstr ""

#: howto/clinic.rst:210

#, fuzzy

msgid ""

"The C type to use for this variable. :attr:`!type` should be a Python string "

"specifying the type, e.g. ``'int'``. If this is a pointer type, the type "

"string should end with ``' *'``."

msgstr ""

"Bu değişken için kullanılacak C türü. ``type`` türü belirten bir Python "

"dizesi olmalıdır, örneğin ``int``. Eğer bu bir gösterici tipiyse, tip dizesi "

"``' *'`` ile bitmelidir."

#: howto/clinic.rst:217

msgid ""

"The Python default value for this parameter, as a Python value. Or the magic "

"value ``unspecified`` if there is no default."

msgstr ""

"Bir Python değeri olarak bu parametre için Python varsayılan değeri. Veya "

"varsayılan değer yoksa ``unspecified`` sihirli değeri."

#: howto/clinic.rst:222

#, fuzzy

msgid ""

":attr:`!default` as it should appear in Python code, as a string. Or "

"``None`` if there is no default."

msgstr ""

"``default`` Python kodunda görünmesi gerektiği gibi, bir string olarak. Veya "

"varsayılan yoksa ``None``."

#: howto/clinic.rst:228

#, fuzzy

msgid ""

":attr:`!default` as it should appear in C code, as a string. Or ``None`` if "

"there is no default."

msgstr ""

"C kodunda görünmesi gerektiği gibi, bir dize olarak ``default``. Veya "

"varsayılan yoksa ``None``."

#: howto/clinic.rst:234

msgid ""

"The default value used to initialize the C variable when there is no "

"default, but not specifying a default may result in an \"uninitialized "

"variable\" warning. This can easily happen when using option groups—"

"although properly written code will never actually use this value, the "

"variable does get passed in to the impl, and the C compiler will complain "

"about the \"use\" of the uninitialized value. This value should always be a "

"non-empty string."

msgstr ""

"Varsayılan bir değer olmadığında C değişkenini başlatmak için kullanılan "

"varsayılan değerdir, ancak varsayılan bir değer belirtilmemesi "

"\"başlatılmamış değişken\" uyarısına neden olabilir. Bu durum, seçenek "

"grupları kullanıldığında kolaylıkla meydana gelebilir; doğru yazılmış kod bu "

"değeri hiçbir zaman kullanmayacak olsa da, değişken impl'ye aktarılır ve C "

"derleyicisi başlatılmamış değerin \"kullanımından\" şikayet eder. Bu değer "

"her zaman boş olmayan bir dize olmalıdır."

#: howto/clinic.rst:246

msgid "The name of the C converter function, as a string."

msgstr "C dönüştürücü işlevinin bir dize olarak adı."

#: howto/clinic.rst:250

msgid ""

"A boolean value. If true, Argument Clinic will add a ``&`` in front of the "

"name of the variable when passing it into the impl function."

msgstr ""

"Boolean bir değer. Eğer true ise, Argüman Kliniği değişkeni impl "

"fonksiyonuna aktarırken değişkenin isminin önüne bir ``&`` ekler."

#: howto/clinic.rst:256

msgid ""

"A boolean value. If true, Argument Clinic will add a ``&`` in front of the "

"name of the variable when passing it into :c:func:`PyArg_ParseTuple`."

msgstr ""

"Boolean bir değer. Eğer true ise, Argüman Kliniği :c:func:"

"`PyArg_ParseTuple` içine aktarırken değişkenin isminin önüne bir ``&`` "

"ekleyecektir."

#: howto/clinic.rst:264

msgid "Tutorial"

msgstr ""

#: howto/clinic.rst:266

#, fuzzy

msgid ""

"The best way to get a sense of how Argument Clinic works is to convert a "

"function to work with it. Here, then, are the bare minimum steps you'd need "

"to follow to convert a function to work with Argument Clinic. Note that for "

"code you plan to check in to CPython, you really should take the conversion "

"farther, using some of the :ref:`advanced concepts <clinic-howtos>` you'll "

"see later on in the document, like :ref:`clinic-howto-return-converters` "

"and :ref:`clinic-howto-self-converter`. But we'll keep it simple for this "

"walkthrough so you can learn."

msgstr ""

"Argüman Kliniği'nin nasıl çalıştığını anlamanın en iyi yolu, bir fonksiyonu "

"onunla çalışacak şekilde dönüştürmektir. O halde burada, bir fonksiyonu "

"Argüman Kliniği ile çalışacak şekilde dönüştürmek için izlemeniz gereken "

"asgari adımlar yer almaktadır. CPython'da kontrol etmeyi planladığınız kod "

"için, belgede daha sonra göreceğiniz bazı gelişmiş kavramları (\"dönüş "

"dönüştürücüler\" ve \"öz dönüştürücüler\" gibi) kullanarak dönüştürmeyi "

"gerçekten daha ileri götürmeniz gerektiğini unutmayın. Ancak öğrenebilmeniz "

"için bu kılavuz için basit tutacağız."

#: howto/clinic.rst:277

#, fuzzy

msgid ""

"First, make sure you're working with a freshly updated checkout of the "

"CPython trunk."

msgstr ""

"CPython trunk'ın yeni güncellenmiş bir checkout'u ile çalıştığınızdan emin "

"olun."

#: howto/clinic.rst:280

#, fuzzy

msgid ""

"Next, find a Python builtin that calls either :c:func:`PyArg_ParseTuple` or :"

"c:func:`PyArg_ParseTupleAndKeywords`, and hasn't been converted to work with "

"Argument Clinic yet. For this tutorial, we'll be using :py:meth:`_pickle."

"Pickler.dump <pickle.Pickler.dump>`."

msgstr ""

":c:func:`PyArg_ParseTuple` veya :c:func:`PyArg_ParseTupleAndKeywords` "

"çağıran ve henüz Argüman Kliniği ile çalışmak üzere dönüştürülmemiş bir "

"Python yerleşik bileşeni bulun. Benim örneğim için ``_pickle.Pickler."

"dump()`` kullanıyorum."

#: howto/clinic.rst:286

#, fuzzy

msgid ""

"If the call to the :c:func:`!PyArg_Parse*` function uses any of the "

"following format units...:"

msgstr ""

"Eğer ``PyArg_Parse`` fonksiyonuna yapılan çağrı aşağıdaki format "

"birimlerinden herhangi birini kullanıyorsa:"

#: howto/clinic.rst:298

#, fuzzy

msgid ""

"... or if it has multiple calls to :c:func:`PyArg_ParseTuple`, you should "

"choose a different function. (See :ref:`clinic-howto-advanced-converters` "

"for those scenarios.)"

msgstr ""

"veya :c:func:`PyArg_ParseTuple` için birden fazla çağrı varsa, farklı bir "

"işlev seçmelisiniz. Argüman Kliniği bu senaryoların tümünü *destekler*. "

"Ancak bunlar ileri düzey konulardır - ilk fonksiyonunuz için daha basit bir "

"şey yapalım."

#: howto/clinic.rst:302

#, fuzzy

msgid ""

"Also, if the function has multiple calls to :c:func:`!PyArg_ParseTuple` or :"

"c:func:`PyArg_ParseTupleAndKeywords` where it supports different types for "

"the same argument, or if the function uses something besides :c:func:`!"

"PyArg_Parse*` functions to parse its arguments, it probably isn't suitable "

"for conversion to Argument Clinic. Argument Clinic doesn't support generic "

"functions or polymorphic parameters."

msgstr ""

"Ayrıca, fonksiyonun aynı argüman için farklı türleri desteklediği :c:func:"

"`PyArg_ParseTuple` veya :c:func:`PyArg_ParseTupleAndKeywords` için birden "

"fazla çağrısı varsa veya fonksiyon argümanlarını ayrıştırmak için "

"PyArg_Parse fonksiyonları dışında bir şey kullanıyorsa, muhtemelen Argüman "

"Kliniğine dönüştürmek için uygun değildir. Argüman Kliniği genel "

"fonksiyonları veya çok biçimli parametreleri desteklemez."

#: howto/clinic.rst:309

#, fuzzy

msgid ""

"Next, add the following boilerplate above the function, creating our input "

"block::"

msgstr ""

"Bloğumuzu oluşturmak için fonksiyonun üzerine aşağıdaki şablonu ekleyin::"

#: howto/clinic.rst:315

#, fuzzy

msgid ""

"Cut the docstring and paste it in between the ``[clinic]`` lines, removing "

"all the junk that makes it a properly quoted C string. When you're done you "

"should have just the text, based at the left margin, with no line wider than "

"80 characters. Argument Clinic will preserve indents inside the docstring."

msgstr ""

"Doküman dizesini kesin ve ``[clinic]`` satırları arasına yapıştırın, düzgün "

"bir şekilde alıntılanmış bir C dizesi haline getiren tüm gereksiz şeyleri "

"kaldırın. İşiniz bittiğinde, 80 karakterden daha geniş bir satır olmadan, "

"sol kenar boşluğuna dayalı olarak yalnızca metne sahip olmalısınız. (Argüman "

"Kliniği, doküman dizesi içindeki girintileri koruyacaktır.)"

#: howto/clinic.rst:321

#, fuzzy

msgid ""

"If the old docstring had a first line that looked like a function signature, "

"throw that line away; The docstring doesn't need it anymore --- when you "

"use :py:func:`help` on your builtin in the future, the first line will be "

"built automatically based on the function's signature."

msgstr ""

"Eğer eski dokümanda fonksiyon imzasına benzeyen bir ilk satır varsa, o "

"satırı atın. (Doküman dizesinin artık buna ihtiyacı yoktur - gelecekte "

"yerleşik öğenizde ``help()`` kullandığınızda, ilk satır işlevin imzasına "

"göre otomatik olarak oluşturulacaktır)."

#: howto/clinic.rst:326

msgid "Example docstring summary line::"

msgstr ""

#: howto/clinic.rst:332

#, fuzzy

msgid ""

"If your docstring doesn't have a \"summary\" line, Argument Clinic will "

"complain, so let's make sure it has one. The \"summary\" line should be a "

"paragraph consisting of a single 80-column line at the beginning of the "

"docstring. (See :pep:`257` regarding docstring conventions.)"

msgstr ""

"Eğer doküman dizinizde bir \"özet\" satırı yoksa Argüman Kliniği şikayet "

"edecektir. Bu yüzden bir tane olduğundan emin olalım. \"Özet\" satırı, "

"doküman dizesinin başında 80 sütunlu tek bir satırdan oluşan bir paragraf "

"olmalıdır."

#: howto/clinic.rst:338

#, fuzzy

msgid ""

"Our example docstring consists solely of a summary line, so the sample code "

"doesn't have to change for this step."

msgstr ""

"(Örnek doküman dizimiz yalnızca bir özet satırından oluşmaktadır, bu nedenle "

"örnek kodun bu adım için değişmesi gerekmez.)"

#: howto/clinic.rst:341

#, fuzzy

msgid ""

"Now, above the docstring, enter the name of the function, followed by a "

"blank line. This should be the Python name of the function, and should be "

"the full dotted path to the function --- it should start with the name of "

"the module, include any sub-modules, and if the function is a method on a "

"class it should include the class name too."

msgstr ""

"Döküman dizisinin üstüne fonksiyonun adını girin ve ardından boş bir satır "

"ekleyin. Bu, işlevin Python adı olmalı ve işlevin tam noktalı yolu "

"olmalıdır - modülün adıyla başlamalı, tüm alt modülleri içermeli ve işlev "

"bir sınıf üzerindeki bir yöntemse sınıf adını da içermelidir."

#: howto/clinic.rst:348

msgid ""

"In our example, :mod:`!_pickle` is the module, :py:class:`!Pickler` is the "

"class, and :py:meth:`!dump` is the method, so the name becomes :py:meth:`!"

"_pickle.Pickler.dump`::"

msgstr ""

#: howto/clinic.rst:358

#, fuzzy

msgid ""

"If this is the first time that module or class has been used with Argument "

"Clinic in this C file, you must declare the module and/or class. Proper "

"Argument Clinic hygiene prefers declaring these in a separate block "

"somewhere near the top of the C file, in the same way that include files and "

"statics go at the top. In our sample code we'll just show the two blocks "

"next to each other."

msgstr ""

"Eğer bu modül veya sınıf bu C dosyasında Argüman Kliniği ile ilk kez "

"kullanılıyorsa, modülü ve/veya sınıfı bildirmeniz gerekir. Uygun Argüman "

"Kliniği hijyeni, bunları C dosyasının üst kısmına yakın bir yerde ayrı bir "

"blokta bildirmeyi tercih eder, aynı şekilde include dosyaları ve statikler "

"de en üstte yer alır. (Örnek kodumuzda sadece iki bloğu yan yana "

"göstereceğiz)."

#: howto/clinic.rst:366

msgid ""

"The name of the class and module should be the same as the one seen by "

"Python. Check the name defined in the :c:type:`PyModuleDef` or :c:type:"

"`PyTypeObject` as appropriate."

msgstr ""

"Sınıfın ve modülün adı Python tarafından görülenle aynı olmalıdır. :c:type:"

"`PyModuleDef` veya :c:type:`PyTypeObject` içinde tanımlanan ismi kontrol "

"edin."

#: howto/clinic.rst:370

#, fuzzy

msgid ""

"When you declare a class, you must also specify two aspects of its type in "

"C: the type declaration you'd use for a pointer to an instance of this "

"class, and a pointer to the :c:type:`!PyTypeObject` for this class::"

msgstr ""

"Bir sınıfı bildirdiğinizde, C'deki türünün iki yönünü de belirtmeniz "

"gerekir: bu sınıfın bir örneğine bir işaretçi için kullanacağınız tür "

"bildirimi ve bu sınıf için :c:type:`PyTypeObject` işaretçisi."

#: howto/clinic.rst:385

#, fuzzy

msgid ""

"Declare each of the parameters to the function. Each parameter should get "

"its own line. All the parameter lines should be indented from the function "

"name and the docstring. The general form of these parameter lines is as "

"follows:"

msgstr ""

"Her bir parametreyi fonksiyona ilan edin. Her parametre kendi satırını "

"almalıdır. Tüm parametre satırları fonksiyon adından ve döküman dizisinden "

"girintili olmalıdır."

#: howto/clinic.rst:394

msgid "If the parameter has a default value, add that after the converter:"

msgstr ""

"Parametrenin varsayılan bir değeri varsa, bunu dönüştürücüden sonra ekleyin:"

#: howto/clinic.rst:401

#, fuzzy

msgid ""

"Argument Clinic's support for \"default values\" is quite sophisticated; "

"see :ref:`clinic-howto-default-values` for more information."

msgstr ""

"Argüman Kliniğinin \"varsayılan değerler\" desteği oldukça karmaşıktır; daha "

"fazla bilgi için lütfen :ref:`the section below on default values "

"<default_values>` bölümüne bakın."

#: howto/clinic.rst:404

#, fuzzy

msgid "Next, add a blank line below the parameters."

msgstr "Parametrelerin altına boş bir satır ekleyin."

#: howto/clinic.rst:406

#, fuzzy

msgid ""

"What's a \"converter\"? It establishes both the type of the variable used in "

"C, and the method to convert the Python value into a C value at runtime. For "

"now you're going to use what's called a \"legacy converter\" --- a "

"convenience syntax intended to make porting old code into Argument Clinic "

"easier."

msgstr ""

"\"Dönüştürücü\" nedir? Hem C'de kullanılan değişkenin türünü hem de Python "

"değerini çalışma zamanında C değerine dönüştürme yöntemini belirler. "

"Şimdilik \"eski dönüştürücü\" denilen şeyi kullanacaksınız - eski kodu "

"Argüman Kliniği'ne taşımayı kolaylaştırmak için tasarlanmış bir kolaylık "

"dizesi."

#: howto/clinic.rst:413

#, fuzzy

msgid ""

"For each parameter, copy the \"format unit\" for that parameter from the :c:"

"func:`PyArg_Parse` format argument and specify *that* as its converter, as a "

"quoted string. The \"format unit\" is the formal name for the one-to-three "

"character substring of the *format* parameter that tells the argument "

"parsing function what the type of the variable is and how to convert it. For "

"more on format units please see :ref:`arg-parsing`."

msgstr ""

"Her parametre için, ``PyArg_Parse()`` format argümanından o parametrenin "

"\"format birimini\" kopyalayın ve dönüştürücü olarak *bunu* tırnaklı bir "

"dize olarak belirtin. (\"format unit\", ``format`` parametresinin bir ila "

"üç karakterlik alt dizesinin resmi adıdır ve argüman ayrıştırma fonksiyonuna "

"değişkenin türünün ne olduğunu ve nasıl dönüştürüleceğini söyler. Biçim "

"birimleri hakkında daha fazla bilgi için lütfen :ref:`arg-parsing` bölümüne "

"bakın)"

#: howto/clinic.rst:422

msgid ""

"For multicharacter format units like ``z#``, use the entire two-or-three "

"character string."

msgstr ""

"``z#`` gibi çok karakterli format birimleri için iki veya üç karakterli "

"dizenin tamamını kullanın."

#: howto/clinic.rst:460 howto/clinic.rst:594 howto/clinic.rst:647

msgid "Sample::"

msgstr "Örnek::"

#: howto/clinic.rst:440

#, fuzzy

msgid ""

"If your function has ``|`` in the format string, meaning some parameters "

"have default values, you can ignore it. Argument Clinic infers which "

"parameters are optional based on whether or not they have default values."

msgstr ""

"Eğer fonksiyonunuzun biçim dizesinde ``|`` varsa, yani bazı parametrelerin "

"varsayılan değerleri varsa, bunu yok sayabilirsiniz. Argüman Kliniği, "

"varsayılan değerlere sahip olup olmadıklarına göre hangi parametrelerin "

"isteğe bağlı olduğunu çıkarır."

#: howto/clinic.rst:445

msgid ""

"If your function has ``$`` in the format string, meaning it takes keyword-"

"only arguments, specify ``*`` on a line by itself before the first keyword-"

"only argument, indented the same as the parameter lines."

msgstr ""

"İşlevinizin biçim dizesinde ``$`` varsa, yani yalnızca anahtar sözcüklerden "

"oluşan bağımsız değişkenler alıyorsa, ``*`` ifadesini yalnızca anahtar "

"sözcüklerden oluşan ilk bağımsız değişkenden önce, parametre satırlarıyla "

"aynı şekilde girintili olarak tek başına bir satırda belirtin."

#: howto/clinic.rst:450

#, fuzzy

msgid ""

":py:meth:`!_pickle.Pickler.dump` has neither, so our sample is unchanged."

msgstr ""

"(``_pickle.Pickler.dump`` ikisine de sahip değildir, bu nedenle örneğimiz "

"değişmemiştir.)"

#: howto/clinic.rst:452

#, fuzzy

msgid ""

"Next, if the existing C function calls :c:func:`PyArg_ParseTuple` (as "

"opposed to :c:func:`PyArg_ParseTupleAndKeywords`), then all its arguments "

"are positional-only."

msgstr ""

"Eğer mevcut C fonksiyonu :c:func:`PyArg_ParseTuple` (:c:func:"

"`PyArg_ParseTupleAndKeywords` yerine) çağrısı yapıyorsa, tüm argümanları "

"sadece konumsaldır."

#: howto/clinic.rst:456

#, fuzzy

msgid ""

"To mark parameters as positional-only in Argument Clinic, add a ``/`` on a "

"line by itself after the last positional-only parameter, indented the same "

"as the parameter lines."

msgstr ""

"Argüman Kliniğinde tüm parametreleri sadece konumsal olarak işaretlemek "

"için, son parametreden sonra tek başına bir satıra parametre satırlarıyla "

"aynı şekilde girintili bir ``/`` ekleyin."

#: howto/clinic.rst:476

#, fuzzy

msgid ""

"It can be helpful to write a per-parameter docstring for each parameter. "

"Since per-parameter docstrings are optional, you can skip this step if you "

"prefer."

msgstr ""

"Her parametre için parametre başına bir doküman yazmak faydalıdır. Ancak "

"parametre başına dokümanlar isteğe bağlıdır; isterseniz bu adımı "

"atlayabilirsiniz."

#: howto/clinic.rst:480

#, fuzzy

msgid ""

"Nevertheless, here's how to add a per-parameter docstring. The first line of "

"the per-parameter docstring must be indented further than the parameter "

"definition. The left margin of this first line establishes the left margin "

"for the whole per-parameter docstring; all the text you write will be "

"outdented by this amount. You can write as much text as you like, across "

"multiple lines if you wish."

msgstr ""

"Parametre başına doküman dizisinin nasıl ekleneceği aşağıda açıklanmıştır. "

"Parametre başına doküman dizesinin ilk satırı parametre tanımından daha "

"fazla girintili olmalıdır. Bu ilk satırın sol kenar boşluğu, parametre "

"başına doküman dizesinin tamamı için sol kenar boşluğunu belirler; "

"yazdığınız tüm metin bu miktarda girintili olacaktır. Dilerseniz birden "

"fazla satıra istediğiniz kadar metin yazabilirsiniz."

#: howto/clinic.rst:505

#, fuzzy

msgid ""

"Save and close the file, then run ``Tools/clinic/clinic.py`` on it. With "

"luck everything worked---your block now has output, and a :file:`.c.h` file "

"has been generated! Reload the file in your text editor to see the generated "

"code::"

msgstr ""

"Dosyayı kaydedin ve kapatın, ardından ``Tools/clinic/clinic.py`` dosyasını "

"çalıştırın. Şansınız varsa her şey işe yaradı--- bloğunuzun artık bir "

"çıktısı var ve bir ``.c.h`` dosyası oluşturuldu! Görmek için dosyayı metin "

"düzenleyicinizde yeniden açın::"

#: howto/clinic.rst:524

#, fuzzy

msgid ""

"Obviously, if Argument Clinic didn't produce any output, it's because it "

"found an error in your input. Keep fixing your errors and retrying until "

"Argument Clinic processes your file without complaint."

msgstr ""

"Açıkçası, Argüman Kliniği herhangi bir çıktı üretmediyse, bunun nedeni "

"girdinizde bir hata bulmasıdır. Argüman Kliniği dosyanızı şikayet etmeden "

"işleyene kadar hatalarınızı düzeltmeye ve yeniden denemeye devam edin."

#: howto/clinic.rst:529

#, fuzzy

msgid ""

"For readability, most of the glue code has been generated to a :file:`.c.h` "

"file. You'll need to include that in your original :file:`.c` file, "

"typically right after the clinic module block::"

msgstr ""

"Okunabilirlik için, tutkal kodunun çoğu bir ``.c.h`` dosyasında "

"oluşturulmuştur. Bunu orijinal ``.c`` dosyanıza eklemeniz gerekir, tipik "

"olarak klinik modül bloğundan hemen sonra::"

#: howto/clinic.rst:535

msgid ""

"Double-check that the argument-parsing code Argument Clinic generated looks "

"basically the same as the existing code."

msgstr ""

"Argüman Kliniği'nin ürettiği argüman ayrıştırma kodunun temelde mevcut kodla "

"aynı göründüğünü iki kez kontrol edin."

#: howto/clinic.rst:538

msgid ""

"First, ensure both places use the same argument-parsing function. The "

"existing code must call either :c:func:`PyArg_ParseTuple` or :c:func:"

"`PyArg_ParseTupleAndKeywords`; ensure that the code generated by Argument "

"Clinic calls the *exact* same function."

msgstr ""

"İlk olarak, her iki yerin de aynı argüman ayrıştırma işlevini kullandığından "

"emin olun. Mevcut kod :c:func:`PyArg_ParseTuple` veya :c:func:"

"`PyArg_ParseTupleAndKeywords` fonksiyonlarından birini çağırmalıdır; Argüman "

"Kliniği tarafından oluşturulan kodun *tam olarak* aynı fonksiyonu "

"çağırdığından emin olun."

#: howto/clinic.rst:544

#, fuzzy

msgid ""

"Second, the format string passed in to :c:func:`!PyArg_ParseTuple` or :c:"

"func:`!PyArg_ParseTupleAndKeywords` should be *exactly* the same as the hand-"

"written one in the existing function, up to the colon or semi-colon."

msgstr ""

"İkinci olarak, :c:func:`PyArg_ParseTuple` veya :c:func:"

"`PyArg_ParseTupleAndKeywords` işlevine aktarılan biçim dizesi, iki nokta üst "

"üste veya noktalı virgülüne kadar mevcut işlevde elle yazılmış olanla *tam "

"olarak* aynı olmalıdır."

#: howto/clinic.rst:549

#, fuzzy

msgid ""

"Argument Clinic always generates its format strings with a ``:`` followed by "

"the name of the function. If the existing code's format string ends with ``;"

"``, to provide usage help, this change is harmless --- don't worry about it."

msgstr ""

"(Argüman Kliniği, biçim dizelerini her zaman ``:`` ve ardından işlevin adı "

"ile oluşturur. Mevcut kodun biçim dizesi, kullanım yardımı sağlamak için ``;"

"`` ile bitiyorsa, bu değişiklik zararsızdır - bu konuda endişelenmeyin)"

#: howto/clinic.rst:554

#, fuzzy

msgid ""

"Third, for parameters whose format units require two arguments, like a "

"length variable, an encoding string, or a pointer to a conversion function, "

"ensure that the second argument is *exactly* the same between the two "

"invocations."

msgstr ""

"Üçüncü olarak, biçim birimleri iki bağımsız değişken gerektiren parametreler "

"için (uzunluk değişkeni veya kodlama dizesi veya dönüştürme işlevine "

"işaretçi gibi), ikinci bağımsız değişkenin iki çağırma arasında *tam olarak* "

"aynı olduğundan emin olun."

#: howto/clinic.rst:559

#, fuzzy

msgid ""

"Fourth, inside the output portion of the block, you'll find a preprocessor "

"macro defining the appropriate static :c:type:`PyMethodDef` structure for "

"this builtin::"

msgstr ""

"Dördüncü olarak, bloğun çıktı kısmının içinde bu yerleşik: için uygun "

"statik :c:type:`PyMethodDef` yapısını tanımlayan bir önişlemci makrosu "

"bulacaksınız:"

#: howto/clinic.rst:566

#, fuzzy

msgid ""

"This static structure should be *exactly* the same as the existing static :c:"

"type:`!PyMethodDef` structure for this builtin."

msgstr ""

"Bu statik yapı, bu yerleşik için mevcut statik :c:type:`PyMethodDef` yapısı "

"ile *tam olarak* aynı olmalıdır."

#: howto/clinic.rst:569

msgid ""

"If any of these items differ in *any way*, adjust your Argument Clinic "

"function specification and rerun ``Tools/clinic/clinic.py`` until they *are* "

"the same."

msgstr ""

"Bu öğelerden herhangi biri *herhangi bir şekilde* farklıysa, Argüman Kliniği "

"işlev belirtiminizi ayarlayın ve *aynı* olana kadar ``Tools/clinic/clinic."

"py`` dosyasını yeniden çalıştırın."

#: howto/clinic.rst:573

msgid ""

"Notice that the last line of its output is the declaration of your \"impl\" "

"function. This is where the builtin's implementation goes. Delete the "

"existing prototype of the function you're modifying, but leave the opening "

"curly brace. Now delete its argument parsing code and the declarations of "

"all the variables it dumps the arguments into. Notice how the Python "

"arguments are now arguments to this impl function; if the implementation "

"used different names for these variables, fix it."

msgstr ""

"Çıktısının son satırının \"impl\" fonksiyonunuzun bildirimi olduğuna dikkat "

"edin. Bu, yerleşik uygulamanın gittiği yerdir. Değiştirdiğiniz fonksiyonun "

"mevcut prototipini silin, ancak açılış küme parantezini bırakın. Şimdi "

"argüman ayrıştırma kodunu ve argümanları içine attığı tüm değişkenlerin "

"bildirimlerini silin. Python argümanlarının artık bu impl fonksiyonunun "

"argümanları olduğuna dikkat edin; eğer uygulama bu değişkenler için farklı "

"isimler kullandıysa, bunu düzeltin."

#: howto/clinic.rst:581

#, fuzzy

msgid ""

"Let's reiterate, just because it's kind of weird. Your code should now look "

"like this::"

msgstr ""

"Biraz garip olduğu için tekrarlayalım. Kodunuz şimdi şöyle görünmelidir::"

#: howto/clinic.rst:590

#, fuzzy

msgid ""

"Argument Clinic generated the checksum line and the function prototype just "

"above it. You should write the opening and closing curly braces for the "

"function, and the implementation inside."

msgstr ""

"Argüman Kliniği sağlama toplamı satırını ve hemen üstünde fonksiyon "

"prototipini oluşturdu. Fonksiyonun açılış (ve kapanış) küme parantezlerini "

"ve içindeki uygulamayı yazmalısınız."

#: howto/clinic.rst:636

#, fuzzy

msgid ""

"Remember the macro with the :c:type:`PyMethodDef` structure for this "

"function? Find the existing :c:type:`!PyMethodDef` structure for this "

"function and replace it with a reference to the macro. If the builtin is at "

"module scope, this will probably be very near the end of the file; if the "

"builtin is a class method, this will probably be below but relatively near "

"to the implementation."

msgstr ""

"Bu fonksiyon için :c:type:`PyMethodDef` yapısına sahip makroyu hatırlıyor "

"musunuz? Bu fonksiyon için mevcut :c:type:`PyMethodDef` yapısını bulun ve "

"makroya bir referans ile değiştirin. (Yerleşik modül kapsamındaysa, bu "

"muhtemelen dosyanın sonuna çok yakın olacaktır; yerleşik bir sınıf "

"yöntemiyse, bu muhtemelen uygulamanın altında ancak nispeten yakınında "

"olacaktır)"

#: howto/clinic.rst:643

#, fuzzy

msgid ""

"Note that the body of the macro contains a trailing comma; when you replace "

"the existing static :c:type:`!PyMethodDef` structure with the macro, *don't* "

"add a comma to the end."

msgstr ""

"Makronun gövdesinin sonda bir virgül içerdiğine dikkat edin. Bu nedenle, "

"mevcut statik :c:type:`PyMethodDef` yapısını makro ile değiştirdiğinizde, "

"*sonuna virgül eklemeyin*."

#: howto/clinic.rst:655

#, fuzzy

msgid ""

"Finally, compile, then run the relevant portions of the regression-test "

"suite. This change should not introduce any new compile-time warnings or "

"errors, and there should be no externally visible change to Python's "

"behavior, except for one difference: :py:func:`inspect.signature` run on "

"your function should now provide a valid signature!"

msgstr ""

"Derleyin, ardından regresyon testi paketinin ilgili bölümlerini çalıştırın. "

"Bu değişiklik herhangi bir yeni derleme zamanı uyarısı veya hatası "

"getirmemeli ve Python'un davranışında dışarıdan görülebilir bir değişiklik "

"olmamalıdır."

#: howto/clinic.rst:661

msgid ""

"Congratulations, you've ported your first function to work with Argument "

"Clinic!"

msgstr ""

"Tebrikler, ilk fonksiyonunuzu Argüman Kliniği ile çalışmak üzere taşıdınız!"

#: howto/clinic.rst:667

msgid "How-to guides"

msgstr ""

#: howto/clinic.rst:671

#, fuzzy

msgid "How to rename C functions and variables generated by Argument Clinic"

msgstr ""

"Argüman Kliniği tarafından oluşturulan C işlevlerini ve değişkenlerini "

"yeniden adlandırma"

#: howto/clinic.rst:673

msgid ""

"Argument Clinic automatically names the functions it generates for you. "

"Occasionally this may cause a problem, if the generated name collides with "

"the name of an existing C function. There's an easy solution: override the "

"names used for the C functions. Just add the keyword ``\"as\"`` to your "

"function declaration line, followed by the function name you wish to use. "

"Argument Clinic will use that function name for the base (generated) "

"function, then add ``\"_impl\"`` to the end and use that for the name of the "

"impl function."

msgstr ""

"Argüman Kliniği sizin için ürettiği fonksiyonlara otomatik olarak isim "

"verir. Bazen, oluşturulan ad mevcut bir C işlevinin adıyla çakışırsa bu bir "

"soruna neden olabilir. Bunun kolay bir çözümü vardır: C fonksiyonları için "

"kullanılan isimleri geçersiz kılın. Fonksiyon bildirim satırınıza "

"``\"as\"`` anahtar sözcüğünü ve ardından kullanmak istediğiniz fonksiyon "

"adını eklemeniz yeterlidir. Argument Clinic, temel (oluşturulan) işlev için "

"bu işlev adını kullanacak, ardından sonuna ``\"_impl\"`` ekleyecek ve impl "

"işlevinin adı için bunu kullanacaktır."

#: howto/clinic.rst:681

#, fuzzy

msgid ""

"For example, if we wanted to rename the C function names generated for :py:"

"meth:`pickle.Pickler.dump`, it'd look like this::"

msgstr ""

"Örneğin, ``pickle.Pickler.dump`` için oluşturulan C fonksiyon adlarını "

"yeniden adlandırmak istersek, şöyle görünecektir::"

#: howto/clinic.rst:689

#, fuzzy

msgid ""

"The base function would now be named :c:func:`!pickler_dumper`, and the impl "

"function would now be named :c:func:`!pickler_dumper_impl`."

msgstr ""

"Temel işlev artık ``pickler_dumper()`` olarak adlandırılacak ve impl işlevi "

"artık ``pickler_dumper_impl()`` olarak adlandırılacaktır."

#: howto/clinic.rst:693

msgid ""

"Similarly, you may have a problem where you want to give a parameter a "

"specific Python name, but that name may be inconvenient in C. Argument "

"Clinic allows you to give a parameter different names in Python and in C, "

"using the same ``\"as\"`` syntax::"

msgstr ""

"Benzer şekilde, bir parametreye belirli bir Python adı vermek istediğinizde "

"bir sorunla karşılaşabilirsiniz, ancak bu ad C'de uygun olmayabilir. "

"Argument Clinic, aynı ``\"as\"`` sözdizimini kullanarak bir parametreye "

"Python'da ve C'de farklı adlar vermenize olanak tanır::"

#: howto/clinic.rst:707

#, fuzzy

msgid ""

"Here, the name used in Python (in the signature and the ``keywords`` array) "

"would be *file*, but the C variable would be named ``file_obj``."

msgstr ""

"Burada, Python'da kullanılan isim (imzada ve ``keywords`` dizisinde) "