# Python Documentation Turkish Translation
# Copyright (C) 2001-2024, 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: 2024-11-01 00:21+0000\n"
"PO-Revision-Date: 2024-04-10 21:30+0300\n"
"Last-Translator: \n"
"Language-Team: TURKISH \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.4.2\n"

#: tutorial/modules.rst:5
msgid "Modules"
msgstr "Modller"

#: tutorial/modules.rst:7
msgid ""
"If you quit from the Python interpreter and enter it again, the definitions "
"you have made (functions and variables) are lost. Therefore, if you want to "
"write a somewhat longer program, you are better off using a text editor to "
"prepare the input for the interpreter and running it with that file as input "
"instead.  This is known as creating a *script*.  As your program gets "
"longer, you may want to split it into several files for easier maintenance.  "
"You may also want to use a handy function that you've written in several "
"programs without copying its definition into each program."
msgstr ""
"Python yorumlaycsndan kp tekrar girerseniz, yaptnz tanmlar "
"(fonksiyonlar  ve deikenler) kaybolur. Bu nedenle, daha uzun bir program "
"yazmak istiyorsanz, girdiyi yorumlaycya hazrlarken bir metin "
"dzenleyicisi kullanmak ve o dosyayla girdi olarak altrmak daha iyidir.  "
"Bu bir *script* oluturma olarak bilinir.  Programnz uzadka, daha kolay "
"bakm iin birka dosyaya blmek isteyebilirsiniz.  Ayrca, tanmn her "
"programa kopyalamadan, birka programda yazdnz kullanl bir fonksiyonu "
"kullanmak isteyebilirsiniz."

#: tutorial/modules.rst:16
msgid ""
"To support this, Python has a way to put definitions in a file and use them "
"in a script or in an interactive instance of the interpreter. Such a file is "
"called a *module*; definitions from a module can be *imported* into other "
"modules or into the *main* module (the collection of variables that you have "
"access to in a script executed at the top level and in calculator mode)."
msgstr ""
"Bunu desteklemek iin Python, tanmlar bir dosyaya koymann ve bunlar bir "
"komut dosyasnda veya yorumlaycnn etkileimli bir rneinde kullanmann "
"bir yolunu salar. Byle bir dosyaya *module* denir; bir modlden alnan "
"tanmlar dier modllere veya *main* modlne (en st dzeyde ve hesap "
"makinesi modunda yrtlen bir komut dosyasnda eriiminiz olan "
"deikenlerin derlenmesi) aktarlabilir."

#: tutorial/modules.rst:22
msgid ""
"A module is a file containing Python definitions and statements.  The file "
"name is the module name with the suffix :file:`.py` appended.  Within a "
"module, the module's name (as a string) is available as the value of the "
"global variable ``__name__``.  For instance, use your favorite text editor "
"to create a file called :file:`fibo.py` in the current directory with the "
"following contents::"
msgstr ""
"Modl, Python tanmlarn ve ifadelerini ieren bir dosyadr.  Dosya ad, :"
"file:`.py` son ekini ieren modl addr.  Bir modl iinde, modln ad "
"(dize olarak) ``__name__`` genel deikeninin deeri olarak kullanlabilir.  "
"rnein, geerli dizinde aadaki ieriklerle :file:`fibo.py` adl bir "
"dosya oluturmak iin en sevdiiniz metin dzenleyicisini kullann::"

#: tutorial/modules.rst:28
msgid ""
"# Fibonacci numbers module\n"
"\n"
"def fib(n):    # write Fibonacci series up to n\n"
"    a, b = 0, 1\n"
"    while a < n:\n"
"        print(a, end=' ')\n"
"        a, b = b, a+b\n"
"    print()\n"
"\n"
"def fib2(n):   # return Fibonacci series up to n\n"
"    result = []\n"
"    a, b = 0, 1\n"
"    while a < n:\n"
"        result.append(a)\n"
"        a, b = b, a+b\n"
"    return result"
msgstr ""

#: tutorial/modules.rst:45
msgid ""
"Now enter the Python interpreter and import this module with the following "
"command::"
msgstr ""
"imdi Python yorumlaycsna girin ve bu modl aadaki komutla ie "
"aktarn::"

#: tutorial/modules.rst:48
msgid ">>> import fibo"
msgstr ""

#: tutorial/modules.rst:50
msgid ""
"This does not add the names of the functions defined in ``fibo``  directly "
"to the current :term:`namespace` (see :ref:`tut-scopes` for more details); "
"it only adds the module name ``fibo`` there. Using the module name you can "
"access the functions::"
msgstr ""
"Bu, ``fibo`` 'da tanmlanan ilevlerin adlarn dorudan geerli :term:"
"`namespace` 'e  eklemez (daha fazla ayrnt iin bkz. :ref:`tut-scopes`); "
"oraya sadece ``fibo`` modl adn ekler. Modl adn kullanarak u ilevlere "
"eriebilirsiniz:"

#: tutorial/modules.rst:55
msgid ""
">>> fibo.fib(1000)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987\n"
">>> fibo.fib2(100)\n"
"[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n"
">>> fibo.__name__\n"
"'fibo'"
msgstr ""

#: tutorial/modules.rst:62
msgid ""
"If you intend to use a function often you can assign it to a local name::"
msgstr ""
"Bir ilevi sk sk kullanmay dnyorsanz, ilevi yerel bir ada "
"atayabilirsiniz::"

#: tutorial/modules.rst:64
msgid ""
">>> fib = fibo.fib\n"
">>> fib(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
msgstr ""

#: tutorial/modules.rst:72
msgid "More on Modules"
msgstr "Modller hakknda daha fazla"

#: tutorial/modules.rst:74
msgid ""
"A module can contain executable statements as well as function definitions. "
"These statements are intended to initialize the module. They are executed "
"only the *first* time the module name is encountered in an import statement. "
"[#]_ (They are also run if the file is executed as a script.)"
msgstr ""
"Bir modl, ilev tanmlarnn yan sra altrlabilir ifadeler de "
"ierebilir. Bu ifadeler modl balatmay amalamaktadr. Yalnzca bir "
"import ifadesinde modl adyla karlaldnda *ilk* kez yrtlrler. "
"[#]_ (Dosya komut dosyas olarak yrtlrse de altrlrlar.)"

#: tutorial/modules.rst:79
msgid ""
"Each module has its own private namespace, which is used as the global "
"namespace by all functions defined in the module. Thus, the author of a "
"module can use global variables in the module without worrying about "
"accidental clashes with a user's global variables. On the other hand, if you "
"know what you are doing you can touch a module's global variables with the "
"same notation used to refer to its functions, ``modname.itemname``."
msgstr ""
"Her modln, modlde tanmlanan tm ilevler tarafndan genel ad alan "
"olarak kullanlan kendi zel ad alan vardr. Bylece, bir modln yazar, "
"bir kullancnn genel deikenleriyle yanllkla akma endiesi "
"duymadan, modldeki genel deikenleri kullanabilir. te yandan, ne "
"yaptnz biliyorsanz, bir modln global deikenlerine, ilevlerine "
"atfta bulunmak iin kullanlan ``modname.itemname`` notasyonuyla "
"dokunabilirsiniz."

#: tutorial/modules.rst:86
msgid ""
"Modules can import other modules.  It is customary but not required to place "
"all :keyword:`import` statements at the beginning of a module (or script, "
"for that matter).  The imported module names, if placed at the top level of "
"a module (outside any functions or classes), are added to the module's "
"global namespace."
msgstr ""
"Modller dier modlleri ie aktarabilir. Tm :keyword:`import` ifadelerinin "
"bir modln (veya bu konuda betiin) bana yerletirilmesi allm bir "
"durumdur ancak gerekli deildir. e aktarlan modl adlar, bir modln en "
"st dzeyine yerletirilirse (herhangi bir ilev veya snfn dnda), "
"modln genel ad alanna eklenir."

#: tutorial/modules.rst:91
msgid ""
"There is a variant of the :keyword:`import` statement that imports names "
"from a module directly into the importing module's namespace.  For example::"
msgstr ""
":keyword:`import` ifadesinin, bir modlden adlar dorudan ie aktaran "
"modln ad alanna aktaran bir eidi vardr. rnein::"

#: tutorial/modules.rst:94
msgid ""
">>> from fibo import fib, fib2\n"
">>> fib(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
msgstr ""

#: tutorial/modules.rst:98
msgid ""
"This does not introduce the module name from which the imports are taken in "
"the local namespace (so in the example, ``fibo`` is not defined)."
msgstr ""
"Bu, ie aktarmalarn yerel ad alannda alnd modl adn tantmaz(bu "
"nedenle rnekte ``fibo`` tanmlanmamtr)."

#: tutorial/modules.rst:101
msgid "There is even a variant to import all names that a module defines::"
msgstr ""
"Bir modln tanmlad tm adlar ie aktarmak iin bir varyant bile "
"vardr::"

#: tutorial/modules.rst:103
msgid ""
">>> from fibo import *\n"
">>> fib(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
msgstr ""

#: tutorial/modules.rst:107
msgid ""
"This imports all names except those beginning with an underscore (``_``). In "
"most cases Python programmers do not use this facility since it introduces "
"an unknown set of names into the interpreter, possibly hiding some things "
"you have already defined."
msgstr ""
"Bu, alt izgiyle balayanlar (``_``) dndaki tm isimleri alr. ou "
"durumda Python programclar bu zellii kullanmaz, nk yorumlaycya "
"bilinmeyen bir ad kmesi ekler ve muhtemelen nceden tanmladnz baz "
"eyleri gizler."

#: tutorial/modules.rst:112
msgid ""
"Note that in general the practice of importing ``*`` from a module or "
"package is frowned upon, since it often causes poorly readable code. "
"However, it is okay to use it to save typing in interactive sessions."
msgstr ""
"Genel olarak, bir modlden veya paketten ``*`` ieri aktarma uygulamasnn, "
"genellikle okunamayan koda neden olduundan ho karlanmadna dikkat "
"edin. Ancak, etkileimli oturumlarda yazmay kaydetmek iin kullanmak sorun "
"deildir."

#: tutorial/modules.rst:116
msgid ""
"If the module name is followed by :keyword:`!as`, then the name following :"
"keyword:`!as` is bound directly to the imported module."
msgstr ""
"Modl adnn ardndan :keyword:`!as` geliyorsa, :keyword:`!as` 'den sonraki "
"ad dorudan ie aktarlan modle balanr."

#: tutorial/modules.rst:121
msgid ""
">>> import fibo as fib\n"
">>> fib.fib(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
msgstr ""

#: tutorial/modules.rst:125
msgid ""
"This is effectively importing the module in the same way that ``import "
"fibo`` will do, with the only difference of it being available as ``fib``."
msgstr ""
"Bu, modln ``import fibo`` 'nun yapaca ekilde etkin bir ekilde ie "
"aktarlmasdr, tek fark ``fib`` olarak mevcut olmasdr."

#: tutorial/modules.rst:128
msgid ""
"It can also be used when utilising :keyword:`from` with similar effects::"
msgstr ""
"Benzer efektlere sahip :keyword:`from` kullanlrken de kullanlabilir::"

#: tutorial/modules.rst:130
msgid ""
">>> from fibo import fib as fibonacci\n"
">>> fibonacci(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
msgstr ""

#: tutorial/modules.rst:137
msgid ""
"For efficiency reasons, each module is only imported once per interpreter "
"session.  Therefore, if you change your modules, you must restart the "
"interpreter -- or, if it's just one module you want to test interactively, "
"use :func:`importlib.reload`, e.g. ``import importlib; importlib."
"reload(modulename)``."
msgstr ""
"Verimlilik nedeniyle, her modl yorumlayc oturumu bana yalnzca bir kez "
"ie aktarlr.  Bu nedenle, modllerinizi deitirirseniz, yorumlaycy "
"yeniden balatmanz gerekir - veya etkileimli olarak test etmek istediiniz "
"tek bir modlse, :func:`importlib.reload`, rnein ``importlib; importlib."
"reload(modulename)``."

#: tutorial/modules.rst:147
msgid "Executing modules as scripts"
msgstr "Modlleri komut dosyas olarak yrtme"

#: tutorial/modules.rst:149
msgid "When you run a Python module with ::"
msgstr "Bir Python modln :: ile altrdnzda::"

#: tutorial/modules.rst:151
msgid "python fibo.py "
msgstr ""

#: tutorial/modules.rst:153
msgid ""
"the code in the module will be executed, just as if you imported it, but "
"with the ``__name__`` set to ``\"__main__\"``.  That means that by adding "
"this code at the end of your module::"
msgstr ""
"modldeki kod, ie aktardnz gibi yrtlr, ancak ``__name__`` "
"``\"__main__\"`` olarak ayarlanr. Bu, modlnzn sonuna bu kodu ekleyerek:"

#: tutorial/modules.rst:157
msgid ""
"if __name__ == \"__main__\":\n"
"    import sys\n"
"    fib(int(sys.argv[1]))"
msgstr ""

#: tutorial/modules.rst:161
msgid ""
"you can make the file usable as a script as well as an importable module, "
"because the code that parses the command line only runs if the module is "
"executed as the \"main\" file:"
msgstr ""
"dosyay bir komut dosyas ve ie aktarlabilir bir modl olarak "
"kullanlabilir hale getirebilirsiniz, nk komut satrn ayrtran kod "
"yalnzca modl \"main\" dosya olarak yrtlrse alr:"

#: tutorial/modules.rst:165
msgid ""
"$ python fibo.py 50\n"
"0 1 1 2 3 5 8 13 21 34"
msgstr ""

#: tutorial/modules.rst:170
msgid "If the module is imported, the code is not run::"
msgstr "Modl ie aktarlrsa kod altrlmaz::"

#: tutorial/modules.rst:172
msgid ""
">>> import fibo\n"
">>>"
msgstr ""

#: tutorial/modules.rst:175
msgid ""
"This is often used either to provide a convenient user interface to a "
"module, or for testing purposes (running the module as a script executes a "
"test suite)."
msgstr ""
"Bu genellikle bir modle uygun bir kullanc arabirimi salamak veya test "
"amacyla kullanlr (modl komut dosyas olarak altrmak bir test paketi "
"yrtr)."

#: tutorial/modules.rst:182
msgid "The Module Search Path"
msgstr "Modl Arama Yolu"

#: tutorial/modules.rst:186
msgid ""
"When a module named :mod:`!spam` is imported, the interpreter first searches "
"for a built-in module with that name. These module names are listed in :data:"
"`sys.builtin_module_names`. If not found, it then searches for a file named :"
"file:`spam.py` in a list of directories given by the variable :data:`sys."
"path`.  :data:`sys.path` is initialized from these locations:"
msgstr ""
":mod:`!spam` adnda bir modl ie aktarldnda, yorumlayc ilk olarak bu "
"ada sahip gml bir modl arar. Bu modl adlar :data:`sys."
"builtin_module_names` iinde listelenir. Bulamazsa, :data:`sys.path` "
"deikeni tarafndan verilen dizin listesinde :file:`spam.py` adl bir dosya "
"arar. :data:`sys.path` bu konumlardan balatlr:"

#: tutorial/modules.rst:192
msgid ""
"The directory containing the input script (or the current directory when no "
"file is specified)."
msgstr ""
"Girdi komut dosyasn ieren dizin (veya dosya belirtilmediinde geerli "
"dizin)."

#: tutorial/modules.rst:194
msgid ""
":envvar:`PYTHONPATH` (a list of directory names, with the same syntax as the "
"shell variable :envvar:`PATH`)."
msgstr ""
":envvar:`PYTHONPATH` (kabuk deikeni :envvar:`PATH` ile ayn szdizimine "
"sahip dizin adlarnn listesi)."

#: tutorial/modules.rst:196
msgid ""
"The installation-dependent default (by convention including a ``site-"
"packages`` directory, handled by the :mod:`site` module)."
msgstr ""
"Kuruluma bal varsaylan (kural olarak, :mod:`site` modl tarafndan "
"ilenen bir \"site-packages\" dizini dahil)."

#: tutorial/modules.rst:199
msgid "More details are at :ref:`sys-path-init`."
msgstr "Daha fazla ayrnt :ref:`sys-path-init` adresindedir."

#: tutorial/modules.rst:202
msgid ""
"On file systems which support symlinks, the directory containing the input "
"script is calculated after the symlink is followed. In other words the "
"directory containing the symlink is **not** added to the module search path."
msgstr ""
"Symlink'leri destekleyen dosya sistemlerinde, symlink izlendikten sonra "
"girdi komut dosyasn ieren dizin hesaplanr. Baka bir deyile, symlink "
"ieren dizin modl arama yoluna **not** eklenir."

#: tutorial/modules.rst:206
msgid ""
"After initialization, Python programs can modify :data:`sys.path`.  The "
"directory containing the script being run is placed at the beginning of the "
"search path, ahead of the standard library path. This means that scripts in "
"that directory will be loaded instead of modules of the same name in the "
"library directory. This is an error unless the replacement is intended.  See "
"section :ref:`tut-standardmodules` for more information."
msgstr ""
"Balatldktan sonra Python programlar :data:`sys.path` deitirebilir.  "
"altrlmakta olan komut dosyasn ieren dizin, arama yolunun bana, "
"standart kitaplk yolunun nne yerletirilir. Bu, kitaplk dizininde ayn "
"ada sahip modller yerine bu dizindeki komut dosyalarnn yklanaca "
"anlamna gelir. Deitirme amalanmad srece bu bir hatadr.  Daha fazla "
"bilgi iin :ref:`tut-standardmodules` blmne bakn."

#: tutorial/modules.rst:219
msgid "\"Compiled\" Python files"
msgstr "\"Derlenmi\" Python dosyalar"

#: tutorial/modules.rst:221
msgid ""
"To speed up loading modules, Python caches the compiled version of each "
"module in the ``__pycache__`` directory under the name :file:`module."
"{version}.pyc`, where the version encodes the format of the compiled file; "
"it generally contains the Python version number.  For example, in CPython "
"release 3.3 the compiled version of spam.py would be cached as ``__pycache__/"
"spam.cpython-33.pyc``.  This naming convention allows compiled modules from "
"different releases and different versions of Python to coexist."
msgstr ""
"Modllerin yklenmesini hzlandrmak iin Python, her modln derlenmi "
"srmn ``__pycache__`` dizininde :file:`module.{version}.pyc` ad altnda "
"nbellee alr; burada srm, derlenen dosyann biimini kodlar; genellikle "
"Python srm numarasn ierir. rnein, CPython 3.3 srmnde spam.py'nin "
"derlenmi srm ``__pycache__/spam.cpython-33.pyc`` olarak nbellee "
"alnacaktr. Bu adlandrma kural, farkl srmlerden ve Python'un farkl "
"srmlerinden derlenmi modllerin bir arada var olmasna izin verir."

#: tutorial/modules.rst:229
msgid ""
"Python checks the modification date of the source against the compiled "
"version to see if it's out of date and needs to be recompiled.  This is a "
"completely automatic process.  Also, the compiled modules are platform-"
"independent, so the same library can be shared among systems with different "
"architectures."
msgstr ""
"Python, eski olup olmadn ve yeniden derlenmesi gerekip gerekmediini "
"grmek iin kaynan deiiklik tarihini derlenmi srmle karlatrr. Bu "
"tamamen otomatik bir ilemdir. Ayrca, derlenen modller platformdan "
"bamszdr, bu nedenle ayn kitaplk farkl mimarilere sahip sistemler "
"arasnda paylalabilir."

#: tutorial/modules.rst:234
msgid ""
"Python does not check the cache in two circumstances.  First, it always "
"recompiles and does not store the result for the module that's loaded "
"directly from the command line.  Second, it does not check the cache if "
"there is no source module.  To support a non-source (compiled only) "
"distribution, the compiled module must be in the source directory, and there "
"must not be a source module."
msgstr ""
"Python iki durumda nbellei kontrol etmez. lk olarak, dorudan komut "
"satrndan yklenen modln sonucunu her zaman yeniden derler ve saklamaz. "
"kincisi, kaynak modl yoksa nbellei kontrol etmez. Kaynak olmayan "
"(yalnzca derlenmi) bir datm desteklemek iin, derlenen modl kaynak "
"dizinde olmal ve bir kaynak modl olmamaldr."

#: tutorial/modules.rst:241
msgid "Some tips for experts:"
msgstr "Uzmanlar iin baz ipular:"

#: tutorial/modules.rst:243
msgid ""
"You can use the :option:`-O` or :option:`-OO` switches on the Python command "
"to reduce the size of a compiled module.  The ``-O`` switch removes assert "
"statements, the ``-OO`` switch removes both assert statements and __doc__ "
"strings.  Since some programs may rely on having these available, you should "
"only use this option if you know what you're doing.  \"Optimized\" modules "
"have an ``opt-`` tag and are usually smaller.  Future releases may change "
"the effects of optimization."
msgstr ""
"Derlenmi bir modln boyutunu kltmek iin Python komutundaki :option:`-"
"O` veya :option:`-OO` anahtarlarn kullanabilirsiniz. ``-O`` anahtar, "
"onaylama ifadelerini kaldrr, ``-OO`` anahtar, hem assert ifadelerini hem "
"de __doc__ dizelerini kaldrr. Baz programlar bunlarn kullanlabilir "
"olmasna gvenebileceinden, bu seenei yalnzca ne yaptnz "
"biliyorsanz kullanmalsnz. \"Optimize edilmi\" modller bir \"opt-\" "
"etiketine sahiptir ve genellikle daha kktr. Gelecekteki srmler, "
"optimizasyonun etkilerini deitirebilir."

#: tutorial/modules.rst:251
msgid ""
"A program doesn't run any faster when it is read from a ``.pyc`` file than "
"when it is read from a ``.py`` file; the only thing that's faster about ``."
"pyc`` files is the speed with which they are loaded."
msgstr ""
"Bir program ``.pyc`` dosyasndan okunduunda, ``.py`` dosyasndan "
"okunduundan daha hzl almaz; ``.pyc`` dosyalar hakknda daha hzl "
"olan tek ey, yklenme hzlardr."

#: tutorial/modules.rst:255
msgid ""
"The module :mod:`compileall` can create .pyc files for all modules in a "
"directory."
msgstr ""
":mod:`compileall` modl, bir dizindeki tm modller iin .pyc dosyalar "
"oluturabilir."

#: tutorial/modules.rst:258
msgid ""
"There is more detail on this process, including a flow chart of the "
"decisions, in :pep:`3147`."
msgstr ""
":pep:`3147` 'de, kararlarn bir ak emas da dahil olmak zere, bu sre "
"hakknda daha fazla ayrnt bulunmaktadr."

#: tutorial/modules.rst:265
msgid "Standard Modules"
msgstr "Standart modller"

#: tutorial/modules.rst:269
msgid ""
"Python comes with a library of standard modules, described in a separate "
"document, the Python Library Reference (\"Library Reference\" hereafter).  "
"Some modules are built into the interpreter; these provide access to "
"operations that are not part of the core of the language but are "
"nevertheless built in, either for efficiency or to provide access to "
"operating system primitives such as system calls.  The set of such modules "
"is a configuration option which also depends on the underlying platform.  "
"For example, the :mod:`winreg` module is only provided on Windows systems. "
"One particular module deserves some attention: :mod:`sys`, which is built "
"into every Python interpreter.  The variables ``sys.ps1`` and ``sys.ps2`` "
"define the strings used as primary and secondary prompts::"
msgstr ""
"Python, ayr bir belge olan Python Ktphane Referansnda (buradan itibaren "
"\"Ktphane Referans\") aklanan standart modllerden oluan bir "
"ktphaneyle birlikte gelir.  Baz modller yorumlaycda yerleik olarak "
"bulunur; bunlar dilin ekirdeinin bir paras olmayan ancak yine de "
"verimlilik iin veya sistem arlar gibi iletim sistemi ilkellerine "
"eriim salamak iin yerleik olarak bulunan ilemlere eriim salar.  Bu "
"tr modllerin kmesi, altta yatan platforma da bal olan bir yaplandrma "
"seeneidir.  rnein, :mod:`winreg` modl yalnzca Windows sistemlerinde "
"salanr. Belirli bir modl biraz ilgiyi hak ediyor: :mod:`sys`, her Python "
"yorumlaycsnda yerleik olarak bulunur.  ``sys.ps1`` ve ``sys.ps2`` "
"deikenleri birincil ve ikincil istemler olarak kullanlan dizeleri "
"tanmlar::"

#: tutorial/modules.rst:281
msgid ""
">>> import sys\n"
">>> sys.ps1\n"
"'>>> '\n"
">>> sys.ps2\n"
"'... '\n"
">>> sys.ps1 = 'C> '\n"
"C> print('Yuck!')\n"
"Yuck!\n"
"C>"
msgstr ""

#: tutorial/modules.rst:292
msgid ""
"These two variables are only defined if the interpreter is in interactive "
"mode."
msgstr "Bu iki deiken yalnzca yorumlayc etkileimli moddaysa tanmlanr."

#: tutorial/modules.rst:294
msgid ""
"The variable ``sys.path`` is a list of strings that determines the "
"interpreter's search path for modules. It is initialized to a default path "
"taken from the environment variable :envvar:`PYTHONPATH`, or from a built-in "
"default if :envvar:`PYTHONPATH` is not set.  You can modify it using "
"standard list operations::"
msgstr ""
"``sys.path`` deikeni, yorumlaycnn modller iin arama yolunu belirleyen "
"bir dizeler listesidir. :envvar:`PYTHONPATH` ortam deikeninden veya :"
"envvar:`PYTHONPATH` ayarlanmamsa yerleik bir varsaylan deerden alnan "
"varsaylan bir yola balatlr. Standart liste ilemlerini kullanarak "
"deitirebilirsiniz::"

#: tutorial/modules.rst:300
msgid ""
">>> import sys\n"
">>> sys.path.append('/ufs/guido/lib/python')"
msgstr ""

#: tutorial/modules.rst:307
msgid "The :func:`dir` Function"
msgstr ":func:`dir` Fonksiyonu"

#: tutorial/modules.rst:309
msgid ""
"The built-in function :func:`dir` is used to find out which names a module "
"defines.  It returns a sorted list of strings::"
msgstr ""
"Yerleik fonksiyon :func:`dir`, bir modln hangi adlar tanmladn "
"bulmak iin kullanlr. Sralanm bir dize listesi dndrr::"

#: tutorial/modules.rst:312
msgid ""
">>> import fibo, sys\n"
">>> dir(fibo)\n"
"['__name__', 'fib', 'fib2']\n"
">>> dir(sys)  \n"
"['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__',\n"
" '__interactivehook__', '__loader__', '__name__', '__package__', "
"'__spec__',\n"
" '__stderr__', '__stdin__', '__stdout__', '__unraisablehook__',\n"
" '_clear_type_cache', '_current_frames', '_debugmallocstats', '_framework',\n"
" '_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook',\n"
" 'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix',\n"
" 'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing',\n"
" 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', "
"'exc_info',\n"
" 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info',\n"
" 'float_repr_style', 'get_asyncgen_hooks', "
"'get_coroutine_origin_tracking_depth',\n"
" 'getallocatedblocks', 'getdefaultencoding', 'getdlopenflags',\n"
" 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile',\n"
" 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval',\n"
" 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',\n"
" 'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value',\n"
" 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks',\n"
" 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', "
"'pycache_prefix',\n"
" 'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', "
"'setdlopenflags',\n"
" 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', "
"'stderr',\n"
" 'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', "
"'version_info',\n"
" 'warnoptions']"
msgstr ""

#: tutorial/modules.rst:338
msgid ""
"Without arguments, :func:`dir` lists the names you have defined currently::"
msgstr ""
"Argmanlar olmadan, :func:`dir`, u anda tanmladnz adlar listeler::"

#: tutorial/modules.rst:340
msgid ""
">>> a = [1, 2, 3, 4, 5]\n"
">>> import fibo\n"
">>> fib = fibo.fib\n"
">>> dir()\n"
"['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']"
msgstr ""

#: tutorial/modules.rst:346
msgid ""
"Note that it lists all types of names: variables, modules, functions, etc."
msgstr ""
"Her tr adn listelendiini unutmayn: deikenler, modller, fonksiyonlar "
"vb."

#: tutorial/modules.rst:350
msgid ""
":func:`dir` does not list the names of built-in functions and variables.  If "
"you want a list of those, they are defined in the standard module :mod:"
"`builtins`::"
msgstr ""
":func:`dir` yerleik fonksiyonlarun ve deikenlerin adlarn listelemez. "
"Bunlarn bir listesini istiyorsanz, standart modl :mod:`builtins` 'de "
"tanmlanrlar::"

#: tutorial/modules.rst:354
msgid ""
">>> import builtins\n"
">>> dir(builtins)  \n"
"['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',\n"
" 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning',\n"
" 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',\n"
" 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning',\n"
" 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',\n"
" 'FileExistsError', 'FileNotFoundError', 'FloatingPointError',\n"
" 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',\n"
" 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError',\n"
" 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError',\n"
" 'MemoryError', 'NameError', 'None', 'NotADirectoryError', "
"'NotImplemented',\n"
" 'NotImplementedError', 'OSError', 'OverflowError',\n"
" 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError',\n"
" 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning',\n"
" 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',\n"
" 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError',\n"
" 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',\n"
" 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning',\n"
" 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__build_class__',\n"
" '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs',\n"
" 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable',\n"
" 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits',\n"
" 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit',\n"
" 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr',\n"
" 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass',\n"
" 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview',\n"
" 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property',\n"
" 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice',\n"
" 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars',\n"
" 'zip']"
msgstr ""

#: tutorial/modules.rst:389
msgid "Packages"
msgstr "Paketler"

#: tutorial/modules.rst:391
msgid ""
"Packages are a way of structuring Python's module namespace by using "
"\"dotted module names\".  For example, the module name :mod:`!A.B` "
"designates a submodule named ``B`` in a package named ``A``.  Just like the "
"use of modules saves the authors of different modules from having to worry "
"about each other's global variable names, the use of dotted module names "
"saves the authors of multi-module packages like NumPy or Pillow from having "
"to worry about each other's module names."
msgstr ""
"Paketler, Python'un modl isim alann \"noktal modl isimleri\" kullanarak "
"yaplandrmann bir yoludur.  rnein, :mod:`!A.B` modl ad, ``A`` adl bir "
"paketteki ``B`` adl bir alt modl belirtir.  Modl kullanmnn farkl "
"modllerin yazarlarn birbirlerinin global deiken isimleri hakknda "
"endielenmekten kurtarmas gibi, noktal modl isimlerinin kullanm da "
"NumPy veya Pillow gibi ok modll paketlerin yazarlarn birbirlerinin "
"modl isimleri hakknda endielenmekten kurtarr."

#: tutorial/modules.rst:399
msgid ""
"Suppose you want to design a collection of modules (a \"package\") for the "
"uniform handling of sound files and sound data.  There are many different "
"sound file formats (usually recognized by their extension, for example: :"
"file:`.wav`, :file:`.aiff`, :file:`.au`), so you may need to create and "
"maintain a growing collection of modules for the conversion between the "
"various file formats. There are also many different operations you might "
"want to perform on sound data (such as mixing, adding echo, applying an "
"equalizer function, creating an artificial stereo effect), so in addition "
"you will be writing a never-ending stream of modules to perform these "
"operations.  Here's a possible structure for your package (expressed in "
"terms of a hierarchical filesystem):"
msgstr ""
"Ses dosyalarnn ve ses verilerinin tek tip ilenmesi iin bir modl "
"koleksiyonu (\"paket\") tasarlamak istediinizi varsayalm. Birok farkl "
"ses dosyas biimi vardr (genellikle uzantlaryla tannr, rnein: :file:"
"`.wav`, :file:`.aiff`, :file:`.au`) bu nedenle, eitli dosya biimleri "
"arasnda dnm iin byyen bir modl koleksiyonu oluturmanz ve "
"srdrmeniz gerekebilir. Ses verileri zerinde gerekletirmek "
"isteyebileceiniz birok farkl ilem de vardr (kartrma, eko ekleme, "
"ekolayzr ilevi uygulama, yapay bir stereo efekti oluturma gibi) bu "
"nedenle ek olarak, bu ilemleri gerekletirmek iin hi bitmeyen bir modl "
"ak yazyor olacaksnz. te paketiniz iin olas bir yap (hiyerarik "
"bir dosya sistemi cinsinden ifade edilir):"

#: tutorial/modules.rst:410
msgid ""
"sound/                          Top-level package\n"
"      __init__.py               Initialize the sound package\n"
"      formats/                  Subpackage for file format conversions\n"
"              __init__.py\n"
"              wavread.py\n"
"              wavwrite.py\n"
"              aiffread.py\n"
"              aiffwrite.py\n"
"              auread.py\n"
"              auwrite.py\n"
"              ...\n"
"      effects/                  Subpackage for sound effects\n"
"              __init__.py\n"
"              echo.py\n"
"              surround.py\n"
"              reverse.py\n"
"              ...\n"
"      filters/                  Subpackage for filters\n"
"              __init__.py\n"
"              equalizer.py\n"
"              vocoder.py\n"
"              karaoke.py\n"
"              ..."
msgstr ""

#: tutorial/modules.rst:436
msgid ""
"When importing the package, Python searches through the directories on ``sys."
"path`` looking for the package subdirectory."
msgstr ""
"Paketi ie aktarrken Python, paket alt dizinini arayan ``sys.path`` "
"zerindeki dizinleri arar."

#: tutorial/modules.rst:439
msgid ""
"The :file:`__init__.py` files are required to make Python treat directories "
"containing the file as packages (unless using a :term:`namespace package`, a "
"relatively advanced feature). This prevents directories with a common name, "
"such as ``string``, from unintentionally hiding valid modules that occur "
"later on the module search path. In the simplest case, :file:`__init__.py` "
"can just be an empty file, but it can also execute initialization code for "
"the package or set the ``__all__`` variable, described later."
msgstr ""
":file:`__init__.py` dosyalar, Python'un dosyay ieren dizinleri paket "
"olarak ele almasn salamak iin gereklidir (nispeten gelimi bir zellik "
"olan :term:`namespace package` kullanlmad srece). Bu, ``string`` gibi "
"ortak bir ada sahip dizinlerin, modl arama yolunda daha sonra ortaya kan "
"geerli modlleri istemeden gizlemesini nler. En basit durumda, :file:"
"`__init__.py` sadece bo bir dosya olabilir, ancak ayn zamanda paket iin "
"balatma kodunu altrabilir veya daha sonra aklanacak olan ``__all__`` "
"deikenini ayarlayabilir."

#: tutorial/modules.rst:447
msgid ""
"Users of the package can import individual modules from the package, for "
"example::"
msgstr ""
"Paketin kullanclar, paketin iindeki ayr modlleri ie aktarabilir, "
"rnein::"

#: tutorial/modules.rst:450
msgid "import sound.effects.echo"
msgstr ""

#: tutorial/modules.rst:452
msgid ""
"This loads the submodule :mod:`!sound.effects.echo`.  It must be referenced "
"with its full name. ::"
msgstr ""
"Bu, :mod:`!sound.effects.echo` alt modln ykler.  Tam ad ile referans "
"verilmelidir. ::"

#: tutorial/modules.rst:455
msgid "sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)"
msgstr ""

#: tutorial/modules.rst:457
msgid "An alternative way of importing the submodule is::"
msgstr "Alt modl ie aktarmann alternatif bir yolu::"

#: tutorial/modules.rst:459
msgid "from sound.effects import echo"
msgstr ""

#: tutorial/modules.rst:461
msgid ""
"This also loads the submodule :mod:`!echo`, and makes it available without "
"its package prefix, so it can be used as follows::"
msgstr ""
"Bu ayn zamanda :mod:`!echo` alt modln ykler ve paket neki olmadan "
"kullanlabilir hale getirir, bylece aadaki gibi kullanlabilir::"

#: tutorial/modules.rst:464
msgid "echo.echofilter(input, output, delay=0.7, atten=4)"
msgstr ""

#: tutorial/modules.rst:466
msgid ""
"Yet another variation is to import the desired function or variable "
"directly::"
msgstr ""
"Yine baka bir varyasyon, istenen ilevi veya deikeni dorudan ie "
"aktarmaktr::"

#: tutorial/modules.rst:468
msgid "from sound.effects.echo import echofilter"
msgstr ""

#: tutorial/modules.rst:470
msgid ""
"Again, this loads the submodule :mod:`!echo`, but this makes its function :"
"func:`!echofilter` directly available::"
msgstr ""
"Yine, bu, :mod:`!echo` alt modln ykler, ancak bu, :func:`!echofilter` "
"fonksiyonunu dorudan kullanlabilir hale getirir::"

#: tutorial/modules.rst:473
msgid "echofilter(input, output, delay=0.7, atten=4)"
msgstr ""

#: tutorial/modules.rst:475
msgid ""
"Note that when using ``from package import item``, the item can be either a "
"submodule (or subpackage) of the package, or some  other name defined in the "
"package, like a function, class or variable.  The ``import`` statement first "
"tests whether the item is defined in the package; if not, it assumes it is a "
"module and attempts to load it.  If it fails to find it, an :exc:"
"`ImportError` exception is raised."
msgstr ""
"``from package import item`` kullanrken, enin paketin bir alt modl "
"(veya alt paketi) veya pakette tanmlanm bir fonksiyon, snf veya "
"deiken gibi baka bir ad olabileceini unutmayn. ``import`` ifadesi nce "
"enin pakette tanmlanp tanmlanmadn test eder; deilse modl olduunu "
"varsayar ve yklemeye alr. Onu bulamazsa, bir :exc:`ImportError` "
"istisnas ortaya kar."

#: tutorial/modules.rst:482
msgid ""
"Contrarily, when using syntax like ``import item.subitem.subsubitem``, each "
"item except for the last must be a package; the last item can be a module or "
"a package but can't be a class or function or variable defined in the "
"previous item."
msgstr ""
"Aksine, ``import item.subitem.subsubitem`` gibi bir szdizimi kullanrken, "
"sonuncusu hari her e bir paket olmaldr; son e bir modl veya paket "
"olabilir, ancak nceki ede tanmlanan bir snf, fonksiyon veya deiken "
"olamaz."

#: tutorial/modules.rst:491
msgid "Importing \\* From a Package"
msgstr "Bir Paketten \\* e Aktarma"

#: tutorial/modules.rst:495
msgid ""
"Now what happens when the user writes ``from sound.effects import *``?  "
"Ideally, one would hope that this somehow goes out to the filesystem, finds "
"which submodules are present in the package, and imports them all.  This "
"could take a long time and importing sub-modules might have unwanted side-"
"effects that should only happen when the sub-module is explicitly imported."
msgstr ""
"imdi, kullanc ``from sound.effects import *`` yazdnda ne olur? deal "
"olarak, bunun bir ekilde dosya sistemine gitmesi, pakette hangi alt "
"modllerin bulunduunu bulmas ve hepsini ie aktarmas umulur. Bu uzun "
"zaman alabilir ve alt modllerin ie aktarlmas, yalnzca alt modl aka "
"ie aktarldnda gereklemesi gereken istenmeyen yan etkilere neden "
"olabilir."

#: tutorial/modules.rst:501
msgid ""
"The only solution is for the package author to provide an explicit index of "
"the package.  The :keyword:`import` statement uses the following convention: "
"if a package's :file:`__init__.py` code defines a list named ``__all__``, it "
"is taken to be the list of module names that should be imported when ``from "
"package import *`` is encountered.  It is up to the package author to keep "
"this list up-to-date when a new version of the package is released.  Package "
"authors may also decide not to support it, if they don't see a use for "
"importing \\* from their package.  For example, the file :file:`sound/"
"effects/__init__.py` could contain the following code::"
msgstr ""
"Tek zm, paket yazarnn paketin ak bir dizinini salamasdr. :keyword:"
"`import` ifadesi aadaki kural kullanr: eer bir paketin :file:`__init__."
"py` kodu ``__all__`` adl bir liste tanmlarsa, ``from package import *`` "
"ile karlaldnda alnmas gereken modl adlarnn listesi olarak "
"alnr. Paketin yeni bir srm yaynlandnda bu listeyi gncel tutmak "
"paket yazarnn sorumluluundadr. Paket yazarlar, paketlerinden \\* ie "
"aktarmak iin bir kullanm grmezlerse, onu desteklememeye de karar "
"verebilirler. rnein, :file:`sound/effects/__init__.py` dosyas u kodu "
"ierebilir::"

#: tutorial/modules.rst:511
msgid "__all__ = [\"echo\", \"surround\", \"reverse\"]"
msgstr ""

#: tutorial/modules.rst:513
msgid ""
"This would mean that ``from sound.effects import *`` would import the three "
"named submodules of the :mod:`!sound.effects` package."
msgstr ""
"Bu, ``from sound.effects import *`` ifadesinin :mod:`!sound.effects` "
"paketinin  adlandrlm alt modln ie aktaraca anlamna gelir."

#: tutorial/modules.rst:516
msgid ""
"Be aware that submodules might become shadowed by locally defined names. For "
"example, if you added a ``reverse`` function to the :file:`sound/effects/"
"__init__.py` file, the ``from sound.effects import *`` would only import the "
"two submodules ``echo`` and ``surround``, but *not* the ``reverse`` "
"submodule, because it is shadowed by the locally defined ``reverse`` "
"function::"
msgstr ""
"Alt modllerin yerel olarak tanmlanm isimler tarafndan "
"glgelenebileceini unutmayn. rnein, :file:`sound/effects/__init__.py` "
"dosyasna bir ``reverse`` fonksiyonu eklediyseniz, ``from sound.effects "
"import *`` sadece iki alt modl olan ``echo`` ve ``surround``u ie aktarr, "
"ancak *reverse`` alt modln ie aktarmaz, nk yerel olarak tanmlanm "
"``reverse`` fonksiyonu tarafndan glgelenir::"

#: tutorial/modules.rst:523
msgid ""
"__all__ = [\n"
"    \"echo\",      # refers to the 'echo.py' file\n"
"    \"surround\",  # refers to the 'surround.py' file\n"
"    \"reverse\",   # !!! refers to the 'reverse' function now !!!\n"
"]\n"
"\n"
"def reverse(msg: str):  #