inputoutput.po

# 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: 2022-12-28 22:43+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"

#: tutorial/inputoutput.rst:5
msgid "Input and Output"
msgstr "Girdi ve Çıktı"

#: tutorial/inputoutput.rst:7
msgid ""
"There are several ways to present the output of a program; data can be "
"printed in a human-readable form, or written to a file for future use. This "
"chapter will discuss some of the possibilities."
msgstr ""
"Bir programın çıktısını sunmanın birkaç yolu vardır; veriler okunabilir bir "
"biçimde yazdırılabilir veya ileride kullanılmak üzere bir dosyaya "
"yazılabilir. Bu bölümde bazı olasılıklar tartışılacaktır."

#: tutorial/inputoutput.rst:15
msgid "Fancier Output Formatting"
msgstr "Güzel Çıktı Biçimlendirmesi"

#: tutorial/inputoutput.rst:17
#, fuzzy
msgid ""
"So far we've encountered two ways of writing values: *expression statements* "
"and the :func:`print` function.  (A third way is using the :meth:`~io."
"TextIOBase.write` method of file objects; the standard output file can be "
"referenced as ``sys.stdout``. See the Library Reference for more information "
"on this.)"
msgstr ""
"Şimdiye kadar iki değer yazma yolu ile karşılaştık: *expression statements* "
"ve :func:`print` fonksiyonu.  (Üçüncü bir yol, dosya nesnelerinin :meth:"
"`write` yöntemini kullanmaktır; standart çıktı dosyasına ``sys.stdout`` "
"olarak başvurulabilir. Bu konuda daha fazla bilgi için Kütüphane "
"Referansı'na bakın.)"

#: tutorial/inputoutput.rst:22
msgid ""
"Often you'll want more control over the formatting of your output than "
"simply printing space-separated values. There are several ways to format "
"output."
msgstr ""
"Genellikle, yalnızca boşlukla ayrılmış değerleri yazdırmaktansa, çıktınızın "
"biçimlendirmesi üzerinde daha fazla denetim istersiniz. Çıktıyı "
"biçimlendirmenin birkaç yolu vardır."

#: tutorial/inputoutput.rst:25
msgid ""
"To use :ref:`formatted string literals <tut-f-strings>`, begin a string with "
"``f`` or ``F`` before the opening quotation mark or triple quotation mark. "
"Inside this string, you can write a Python expression between ``{`` and ``}"
"`` characters that can refer to variables or literal values."
msgstr ""
":ref:`formatted string literals <tut-f-strings>` kullanmak için, açılış "
"tırnak işaretinden veya üç tırnak işaretinden önce ``f`` veya ``F`` ile bir "
"dize başlatın. Bu dizenin içinde, değişkenlere veya hazır bilgi değerlerine "
"başvurabilen ``{`` ve ``}`` karakterleri arasında bir Python ifadesi "
"yazabilirsiniz."

#: tutorial/inputoutput.rst:37
msgid ""
"The :meth:`str.format` method of strings requires more manual effort.  "
"You'll still use ``{`` and ``}`` to mark where a variable will be "
"substituted and can provide detailed formatting directives, but you'll also "
"need to provide the information to be formatted."
msgstr ""
":meth:`str.format` dize yöntemi daha manuel çaba gerektirir.  Bir değişkenin "
"değiştirileceği yeri işaretlemek için ``{`` ve ``}`` kullanmaya devam "
"edersiniz ve ayrıntılı biçimlendirme yönergeleri sağlayabilirsiniz, ancak "
"biçimlendirilecek bilgileri de sağlamanız gerekir."

#: tutorial/inputoutput.rst:50
msgid ""
"Finally, you can do all the string handling yourself by using string slicing "
"and concatenation operations to create any layout you can imagine.  The "
"string type has some methods that perform useful operations for padding "
"strings to a given column width."
msgstr ""
"Son olarak, hayal edebileceğiniz herhangi bir düzen oluşturmak için dize "
"dilimleme ve birleştirme işlemlerini kullanarak tüm dize işlemeyi kendiniz "
"yapabilirsiniz.  Dize türü, dizeleri belirli bir sütun genişliğine doldurma "
"için yararlı işlemler gerçekleştiren bazı yöntemlere sahiptir."

#: tutorial/inputoutput.rst:55
msgid ""
"When you don't need fancy output but just want a quick display of some "
"variables for debugging purposes, you can convert any value to a string with "
"the :func:`repr` or :func:`str` functions."
msgstr ""
"Daha güzel görünen bir çıktıya ihtiyacınız olmadığında, ancak hata ayıklama "
"amacıyla bazı değişkenlerin hızlı bir şekilde görüntülenmesini "
"istediğinizde, herhangi bir değeri :func:`repr` veya :func:`str` "
"işlevleriyle bir dizeye dönüştürebilirsiniz."

#: tutorial/inputoutput.rst:59
msgid ""
"The :func:`str` function is meant to return representations of values which "
"are fairly human-readable, while :func:`repr` is meant to generate "
"representations which can be read by the interpreter (or will force a :exc:"
"`SyntaxError` if there is no equivalent syntax).  For objects which don't "
"have a particular representation for human consumption, :func:`str` will "
"return the same value as :func:`repr`.  Many values, such as numbers or "
"structures like lists and dictionaries, have the same representation using "
"either function.  Strings, in particular, have two distinct representations."
msgstr ""
":func:`str` işlevi açıkça okunabilir değerlerin gösterimlerini döndürmek "
"için, :func:`repr` ise yorumlayıcı tarafından okunabilecek gösterimler "
"oluşturmak içindir (veya eş değer bir sözdizimi yoksa :exc:`SyntaxError` 'ı "
"zorlar).  İnsan tüketimi için belirli bir temsili olmayan nesneler için :"
"func:`str`, :func:`repr` ile aynı değeri döndürür.  Sayılar veya listeler ve "
"sözlükler benzeri yapılar gibi birçok değer, her iki işlevi de kullanarak "
"aynı gösterime sahiptir.  Özellikle dizelerin iki farklı gösterimi vardır."

#: tutorial/inputoutput.rst:68
msgid "Some examples::"
msgstr "Bazı örnekler::"

#: tutorial/inputoutput.rst:91
msgid ""
"The :mod:`string` module contains a :class:`~string.Template` class that "
"offers yet another way to substitute values into strings, using placeholders "
"like ``$x`` and replacing them with values from a dictionary, but offers "
"much less control of the formatting."
msgstr ""
":mod:`string` modülü bir :class:`~string.Template` sınıfını içerir; bu "
"sınıf, ``$x`` gibi yer tutucuları kullanarak ve bunları bir sözlükten "
"değerlerle değiştirerek, değerleri dizelerle değiştirmenin başka bir yolunu "
"sunar, ancak biçimlendirme üzerinde çok daha az kontrol sağlar."

#: tutorial/inputoutput.rst:100
msgid "Formatted String Literals"
msgstr "Biçimlendirilmiş Dize Değişmezleri"

#: tutorial/inputoutput.rst:102
msgid ""
":ref:`Formatted string literals <f-strings>` (also called f-strings for "
"short) let you include the value of Python expressions inside a string by "
"prefixing the string with ``f`` or ``F`` and writing expressions as "
"``{expression}``."
msgstr ""
":ref:`Formatted string literals <f-strings>` (kısaltmak için f-string olarak "
"da adlandırılır), dizenin önüne ``f`` veya ``F`` yazarak ve ifadeleri "
"``{expression}`` olarak yazarak Python ifadelerinin değerini bir dizenin "
"içine eklemenize olanak tanır."

#: tutorial/inputoutput.rst:107
msgid ""
"An optional format specifier can follow the expression. This allows greater "
"control over how the value is formatted. The following example rounds pi to "
"three places after the decimal::"
msgstr ""
"Opsiyonel biçim belirleyicisi ifadeyi izleyebilir. Bu, değerin nasıl "
"biçimlendirileceğini daha fazla denetlemenizi sağlar. Aşağıdaki örnek pi "
"sayısını ondalık sayıdan sonra üç basamağa yuvarlar::"

#: tutorial/inputoutput.rst:115
msgid ""
"Passing an integer after the ``':'`` will cause that field to be a minimum "
"number of characters wide.  This is useful for making columns line up. ::"
msgstr ""
"``':'`` öğesinin ardından bir tamsayı geçmek, bu alanın en az sayıda "
"karakter genişliğinde olmasına neden olur.  Bu, sütunların hizaya "
"getirilmesi için yararlıdır. ::"

#: tutorial/inputoutput.rst:126
msgid ""
"Other modifiers can be used to convert the value before it is formatted. ``'!"
"a'`` applies :func:`ascii`, ``'!s'`` applies :func:`str`, and ``'!r'`` "
"applies :func:`repr`::"
msgstr ""
"Diğer değiştiriciler, değeri biçimlendirilmeden önce dönüştürmek için "
"kullanılabilir. ``'!a'`` :func:`ascii`, ``'!s'`` :func:`str`, ve ``'!r'``  :"
"func:`repr` uygular::"

#: tutorial/inputoutput.rst:136
msgid ""
"The ``=`` specifier can be used to expand an expression to the text of the "
"expression, an equal sign, then the representation of the evaluated "
"expression:"
msgstr ""
"``=`` belirleyicisi, bir ifadeyi ifadenin metnine, eşittir işaretine ve "
"ardından değerlendirilen ifadenin temsiline genişletmek için kullanılabilir:"

#: tutorial/inputoutput.rst:145
msgid ""
"See :ref:`self-documenting expressions <bpo-36817-whatsnew>` for more "
"information on the ``=`` specifier. For a reference on these format "
"specifications, see the reference guide for the :ref:`formatspec`."
msgstr ""
"``=`` belirtici hakkında daha fazla bilgi için :ref:`kendi kendini "
"belgeleyen ifadeler <bpo-36817-whatsnew>` konusuna bakın. Bu biçim "
"belirtimleriyle ilgili bir referans için, :ref:`formatspec` için başvuru "
"kılavuzuna bakın."

#: tutorial/inputoutput.rst:152
msgid "The String format() Method"
msgstr "String format() Metodu"

#: tutorial/inputoutput.rst:154
msgid "Basic usage of the :meth:`str.format` method looks like this::"
msgstr ":meth:`str.format` metodunun temel kullanımı şöyle görünür::"

#: tutorial/inputoutput.rst:159
msgid ""
"The brackets and characters within them (called format fields) are replaced "
"with the objects passed into the :meth:`str.format` method.  A number in the "
"brackets can be used to refer to the position of the object passed into the :"
"meth:`str.format` method. ::"
msgstr ""
"İçlerindeki köşeli ayraçlar ve karakterler (format fields olarak "
"adlandırılır) :meth:`str.format` yöntemine geçirilen nesnelerle "
"değiştirilir.  Köşeli ayraçlardaki bir sayı, :meth:`str.format` yöntemine "
"geçirilen nesnenin konumuna başvurmak için kullanılabilir. ::"

#: tutorial/inputoutput.rst:169
msgid ""
"If keyword arguments are used in the :meth:`str.format` method, their values "
"are referred to by using the name of the argument. ::"
msgstr ""
"Anahtar sözcük argümanları :meth:`str.format` yönteminde kullanılıyorsa, "
"değerlerine argümanın adı kullanılarak başvurulmaktadır. ::"

#: tutorial/inputoutput.rst:176
msgid "Positional and keyword arguments can be arbitrarily combined::"
msgstr ""
"Konumsal ve anahtar sözcük argümanları isteğe bağlı olarak "
"birleştirilebilir::"

#: tutorial/inputoutput.rst:182
msgid ""
"If you have a really long format string that you don't want to split up, it "
"would be nice if you could reference the variables to be formatted by name "
"instead of by position.  This can be done by simply passing the dict and "
"using square brackets ``'[]'`` to access the keys. ::"
msgstr ""
"Bölmek istemediğiniz gerçekten uzun biçimli bir dizeniz varsa, konuma göre "
"değil de ada göre biçimlendirilecek değişkenlere başvurursanız iyi olur.  "
"Bu, sadece dict'i geçirerek ve tuşlara erişmek için ``'[]'`` köşeli "
"ayraçları kullanarak yapılabilir. ::"

#: tutorial/inputoutput.rst:192
msgid ""
"This could also be done by passing the ``table`` dictionary as keyword "
"arguments with the ``**`` notation. ::"
msgstr ""
"Bu, ``table`` sözlüğünü ``**`` gösterimiyle anahtar kelime bağımsız "
"değişkenleri olarak ileterek de yapılabilir. ::"

#: tutorial/inputoutput.rst:199
msgid ""
"This is particularly useful in combination with the built-in function :func:"
"`vars`, which returns a dictionary containing all local variables."
msgstr ""
"Bu, özellikle tüm yerel değişkenleri içeren bir sözlük döndüren yerleşik "
"işlev :func:`vars` ile birlikte yararlıdır."

#: tutorial/inputoutput.rst:202
msgid ""
"As an example, the following lines produce a tidily aligned set of columns "
"giving integers and their squares and cubes::"
msgstr ""
"Örnek olarak, aşağıdaki satırlar, tamsayıları ve bunların karelerini ve "
"küplerini veren düzenli bir şekilde hizalanmış bir sütun kümesi oluşturur::"

#: tutorial/inputoutput.rst:219
msgid ""
"For a complete overview of string formatting with :meth:`str.format`, see :"
"ref:`formatstrings`."
msgstr ""
":meth:`str.format` ile dize biçimlendirmeye tam bir genel bakış için bkz. :"
"ref:`formatstrings`."

#: tutorial/inputoutput.rst:224
msgid "Manual String Formatting"
msgstr "Manuel Dize Biçimlendirmesi"

#: tutorial/inputoutput.rst:226
msgid "Here's the same table of squares and cubes, formatted manually::"
msgstr "Manuel olarak biçimlendirilmiş aynı kare ve küp tablosu aşağıdadır::"

#: tutorial/inputoutput.rst:244
msgid ""
"(Note that the one space between each column was added by the way :func:"
"`print` works: it always adds spaces between its arguments.)"
msgstr ""
"(Her sütun arasındaki tek boşluğun :func:`print` çalışma şekliyle ekli "
"olduğunu unutmayın: her zaman argümanları arasına boşluk ekler.)"

#: tutorial/inputoutput.rst:247
msgid ""
"The :meth:`str.rjust` method of string objects right-justifies a string in a "
"field of a given width by padding it with spaces on the left. There are "
"similar methods :meth:`str.ljust` and :meth:`str.center`. These methods do "
"not write anything, they just return a new string. If the input string is "
"too long, they don't truncate it, but return it unchanged; this will mess up "
"your column lay-out but that's usually better than the alternative, which "
"would be lying about a value. (If you really want truncation you can always "
"add a slice operation, as in ``x.ljust(n)[:n]``.)"
msgstr ""
"Dize nesnelerinin :meth:`str.rjust` yöntemi, belirli bir genişlikteki bir "
"alandaki dizeyi soldaki boşluklarla doldurmayı haklı hale getirir. Benzer "
"yöntemler vardır :meth:`str.ljust` ve :meth:`str.center`. Bu yöntemler "
"hiçbir şey yazmaz, yalnızca yeni bir dize döndürür. Giriş dizesi çok uzunsa, "
"onu kesmezler, değiştirmeden döndürürler; bu, sütununuzu mahvedecektir, "
"ancak bu genellikle bir değer hakkında yalan söylemek olan alternatiften "
"daha iyidir. (Gerçekten kesilme istiyorsanız, ``x.ljust(n)[:n]`` gibi her "
"zaman bir dilim işlemi ekleyebilirsiniz.)"

#: tutorial/inputoutput.rst:256
msgid ""
"There is another method, :meth:`str.zfill`, which pads a numeric string on "
"the left with zeros.  It understands about plus and minus signs::"
msgstr ""
"Soldaki sayısal bir dizeyi sıfırlarla dolduran başka bir metot vardır: :meth:"
"`str.zfill`.  Bu metot artı ve eksi işaretlerini anlar::"

#: tutorial/inputoutput.rst:268
msgid "Old string formatting"
msgstr "Eski dize biçimlendirmesi"

#: tutorial/inputoutput.rst:270
msgid ""
"The % operator (modulo) can also be used for string formatting. Given "
"``'string' % values``, instances of ``%`` in ``string`` are replaced with "
"zero or more elements of ``values``. This operation is commonly known as "
"string interpolation. For example::"
msgstr ""
"% operatör (modulo) dize biçimlendirmesi için de kullanılabilir. ``'string' "
"% values`` göz önüne alındığında, ``string`` öğesindeki ``%`` örnekleri "
"sıfır veya daha fazla ``values`` öğesiyle değiştirilir. Bu işlem genellikle "
"dize enterpolasyonu olarak bilinir. Mesela::"

#: tutorial/inputoutput.rst:279
msgid ""
"More information can be found in the :ref:`old-string-formatting` section."
msgstr ""
"Daha fazla bilgiyi :ref:`old-string-formatting` bölümünde bulabilirsiniz."

#: tutorial/inputoutput.rst:285
msgid "Reading and Writing Files"
msgstr "Dosyaları Okuma ve Yazma"

#: tutorial/inputoutput.rst:291
msgid ""
":func:`open` returns a :term:`file object`, and is most commonly used with "
"two positional arguments and one keyword argument: ``open(filename, mode, "
"encoding=None)``"
msgstr ""
":func:`open` bir :term:`file object` döndürür ve en yaygın olarak iki konum "
"argümanı ve bir anahtar sözcük argümanı ile kullanılır: ``open(filename, "
"mode, encoding=None)``"

#: tutorial/inputoutput.rst:304
msgid ""
"The first argument is a string containing the filename.  The second argument "
"is another string containing a few characters describing the way in which "
"the file will be used.  *mode* can be ``'r'`` when the file will only be "
"read, ``'w'`` for only writing (an existing file with the same name will be "
"erased), and ``'a'`` opens the file for appending; any data written to the "
"file is automatically added to the end.  ``'r+'`` opens the file for both "
"reading and writing. The *mode* argument is optional; ``'r'`` will be "
"assumed if it's omitted."
msgstr ""
"İlk parametre dosya adını içeren bir dizedir.  İkinci parametre dosyanın "
"nasıl kullanılacağını açıklayan birkaç karakter içeren başka bir dizedir.  "
"*mode*, dosya yalnızca okunacağı zaman ``'r'``, yalnızca yazmak için ``'w'`` "
"olabilir (aynı ada sahip varolan bir dosya temizlenir) ve ``'a'`` dosyayı "
"ekleme için açar; dosyaya yazılan tüm veriler otomatik olarak sonuna "
"eklenir.  ``'r+'`` dosyayı hem okumak hem de yazmak için açar. *mode* "
"parametresi isteğe bağlıdır; verilmezse ``'r'`` varsayılacaktır."

#: tutorial/inputoutput.rst:313
msgid ""
"Normally, files are opened in :dfn:`text mode`, that means, you read and "
"write strings from and to the file, which are encoded in a specific "
"*encoding*. If *encoding* is not specified, the default is platform "
"dependent (see :func:`open`). Because UTF-8 is the modern de-facto standard, "
"``encoding=\"utf-8\"`` is recommended unless you know that you need to use a "
"different encoding. Appending a ``'b'`` to the mode opens the file in :dfn:"
"`binary mode`. Binary mode data is read and written as :class:`bytes` "
"objects. You can not specify *encoding* when opening file in binary mode."
msgstr ""
"Normalde dosyalar :dfn:`text mode` 'unda açılır, yani belirli bir *kodlamada "
"(encoding)* kodlanmış dizeleri dosyadan okur ve dosyaya yazarsınız. "
"*kodlama* belirtilmezse, varsayılan değer platforma bağlıdır (bakınız :func:"
"`open`). UTF-8 modern de-fakto standart olduğundan, farklı bir kodlama "
"kullanmanız gerekmiyorsa ``encoding=\"utf-8\"`` kullanmanız önerilir. Moda "
"``'b'`` eklemek, dosyayı :dfn:`binary` modunda açar. İkili mod verileri, :"
"class:`bytes` nesneleri olarak okunur ve yazılır. Dosyayı ikili modda "
"açarken *kodlama* belirtemezsiniz."

#: tutorial/inputoutput.rst:323
msgid ""
"In text mode, the default when reading is to convert platform-specific line "
"endings (``\\n`` on Unix, ``\\r\\n`` on Windows) to just ``\\n``.  When "
"writing in text mode, the default is to convert occurrences of ``\\n`` back "
"to platform-specific line endings.  This behind-the-scenes modification to "
"file data is fine for text files, but will corrupt binary data like that in :"
"file:`JPEG` or :file:`EXE` files.  Be very careful to use binary mode when "
"reading and writing such files."
msgstr ""
"Metin modunda, okurken varsayılan değer platforma özgü satır sonlarını "
"(``\\n`` on Unix, ``\\r\\n`` on Windows) yalnızca ``\\n`` olarak "
"dönüştürmektir.  Metin modunda yazarken, varsayılan değer ``\\n`` "
"oluşumlarını platforma özgü satır sonlarına geri dönüştürmektir.  Dosya "
"verilerinde yapılan bu sahne arkası değişikliği metin dosyaları için iyidir, "
"ancak :file:`JPEG` veya :file:`EXE` dosyalarında bunun gibi ikili verileri "
"bozacaktır.  Bu tür dosyaları okurken ve yazarken ikili modu kullanmaya çok "
"dikkat edin."

#: tutorial/inputoutput.rst:331
msgid ""
"It is good practice to use the :keyword:`with` keyword when dealing with "
"file objects.  The advantage is that the file is properly closed after its "
"suite finishes, even if an exception is raised at some point.  Using :"
"keyword:`!with` is also much shorter than writing equivalent :keyword:"
"`try`\\ -\\ :keyword:`finally` blocks::"
msgstr ""
"Dosya nesneleriyle uğraşırken :keyword:`with` anahtar sözcüğünü kullanmak "
"iyi bir uygulamadır.  Avantajı, herhangi bir noktada bir hata oluşsa bile, "
"paketi bittikten sonra dosyanın düzgün bir şekilde kapatılmasıdır.  :keyword:"
"`!with` kullanmak da eş değer :keyword:`try` \\ -\\ :keyword:`finally` "
"blokları yazmaktançok daha kısadır::"

#: tutorial/inputoutput.rst:344
msgid ""
"If you're not using the :keyword:`with` keyword, then you should call ``f."
"close()`` to close the file and immediately free up any system resources "
"used by it."
msgstr ""
":keyword:`with` anahtar sözcüğünü kullanmıyorsanız, dosyayı kapatmak ve "
"kullandığı sistem kaynaklarını hemen boşaltmak için ``f.close()`` metodunu "
"çağırmalısınız."

#: tutorial/inputoutput.rst:349
msgid ""
"Calling ``f.write()`` without using the :keyword:`!with` keyword or calling "
"``f.close()`` **might** result in the arguments of ``f.write()`` not being "
"completely written to the disk, even if the program exits successfully."
msgstr ""
":keyword:`!with` anahtar sözcüğünü kullanmadan ``f.write()`` çağırmak veya "
"``f.close()`` çağırmak, program başarıyla çıksa bile ``f.write()`` "
"parametrelerinin diske tamamen yazılmamasıyla sonuçlanabilir."

#: tutorial/inputoutput.rst:357
msgid ""
"After a file object is closed, either by a :keyword:`with` statement or by "
"calling ``f.close()``, attempts to use the file object will automatically "
"fail. ::"
msgstr ""
"Bir dosya nesnesi kapatıldıktan sonra, bir :keyword:`with` deyimiyle veya "
"``f.close()`` çağırarak dosya nesnesini kullanma girişimleri otomatik olarak "
"başarısız olur. ::"

#: tutorial/inputoutput.rst:371
msgid "Methods of File Objects"
msgstr "Dosya Nesnelerinin Metotları"

#: tutorial/inputoutput.rst:373
msgid ""
"The rest of the examples in this section will assume that a file object "
"called ``f`` has already been created."
msgstr ""
"Bu bölümdeki örneklerin geri kalanı, ``f`` adlı bir dosya nesnesinin zaten "
"oluşturulduğunu varsayar."

#: tutorial/inputoutput.rst:376
msgid ""
"To read a file's contents, call ``f.read(size)``, which reads some quantity "
"of data and returns it as a string (in text mode) or bytes object (in binary "
"mode). *size* is an optional numeric argument.  When *size* is omitted or "
"negative, the entire contents of the file will be read and returned; it's "
"your problem if the file is twice as large as your machine's memory. "
"Otherwise, at most *size* characters (in text mode) or *size* bytes (in "
"binary mode) are read and returned. If the end of the file has been reached, "
"``f.read()`` will return an empty string (``''``).  ::"
msgstr ""
"Bir dosyanın içeriğini okumak için, bir miktar veriyi okuyan ve dize (metin "
"modunda) veya bayt nesnesi (ikili modda) olarak döndüren ``f.read(size)`` "
"öğesini çağırın. *size* isteğe bağlı bir sayısal parametredir.  *size* boş "
"bırakıldığında veya negatif olduğunda, dosyanın tüm içeriği okunur ve "
"döndürülür; dosya makinenizin belleğinden iki kat daha büyükse bu sizin "
"sorununuzdur. Aksi takdirde, en fazla *size* karakterleri (metin modunda) "
"veya *size* bayt (ikili modda) okunur ve döndürülür. Dosyanın sonuna "
"ulaşıldıysa, ``f.read()`` boş bir dize (``''``) döndürür.  ::"

#: tutorial/inputoutput.rst:390
msgid ""
"``f.readline()`` reads a single line from the file; a newline character "
"(``\\n``) is left at the end of the string, and is only omitted on the last "
"line of the file if the file doesn't end in a newline.  This makes the "
"return value unambiguous; if ``f.readline()`` returns an empty string, the "
"end of the file has been reached, while a blank line is represented by "
"``'\\n'``, a string containing only a single newline.  ::"
msgstr ""
"``f.readline()`` dosyadan tek bir satır okur; dizenin sonunda bir newline "
"karakteri (``\\n``) bırakılır ve dosya yalnızca dosya yeni satırda bitmezse "
"dosyanın son satırında atlanır.  Bu, dönüş değerini netleştirir; ``f."
"readline()`` boş bir dize döndürürse, dosyanın sonuna ulaşılmış demektir, "
"boş bir satır ise yalnızca tek bir yeni satır içeren bir dize olan ``'\\n'`` "
"ile temsil edilir.  ::"

#: tutorial/inputoutput.rst:404
msgid ""
"For reading lines from a file, you can loop over the file object. This is "
"memory efficient, fast, and leads to simple code::"
msgstr ""
"Bir dosyadan satırları okumak için, dosya nesnesinin üzerinde döngü "
"oluşturabilirsiniz. Bu bellek verimliliğine, hızlılığına ve basit koda yol "
"açar::"

#: tutorial/inputoutput.rst:413
msgid ""
"If you want to read all the lines of a file in a list you can also use "
"``list(f)`` or ``f.readlines()``."
msgstr ""
"Listedeki bir dosyanın tüm satırlarını okumak istiyorsanız, ``list(f)`` veya "
"``f.readlines()`` öğelerini de kullanabilirsiniz."

#: tutorial/inputoutput.rst:416
msgid ""
"``f.write(string)`` writes the contents of *string* to the file, returning "
"the number of characters written. ::"
msgstr ""
"``f.write(string)`` *string* içeriğini dosyaya yazar ve yazılan karakter "
"sayısını döndürür. ::"

#: tutorial/inputoutput.rst:422
msgid ""
"Other types of objects need to be converted -- either to a string (in text "
"mode) or a bytes object (in binary mode) -- before writing them::"
msgstr ""
"Diğer nesne türlerinin yazmadan önce bir dizeye (metin modunda) veya bayt "
"nesnesine (ikili modda) dönüştürülmesi gerekir::"

#: tutorial/inputoutput.rst:430
msgid ""
"``f.tell()`` returns an integer giving the file object's current position in "
"the file represented as number of bytes from the beginning of the file when "
"in binary mode and an opaque number when in text mode."
msgstr ""
"``f.tell()`` dosya nesnesinin dosyadaki geçerli konumunu ikili moddayken "
"dosyanın başından itibaren bayt sayısı ve metin modundayken opak bir sayı "
"olarak veren bir tamsayı döndürür."

#: tutorial/inputoutput.rst:434
msgid ""
"To change the file object's position, use ``f.seek(offset, whence)``.  The "
"position is computed from adding *offset* to a reference point; the "
"reference point is selected by the *whence* argument.  A *whence* value of 0 "
"measures from the beginning of the file, 1 uses the current file position, "
"and 2 uses the end of the file as the reference point.  *whence* can be "
"omitted and defaults to 0, using the beginning of the file as the reference "
"point. ::"
msgstr ""
"Dosya nesnesinin konumunu değiştirmek için ``f.seek(offset, whence)`` "
"kullanın.  Konum, bir referans noktasına *offset* eklenerek hesaplanır; "
"referans noktası *whence* parametresi tarafından seçilir.  *whence* değeri "
"dosyanın başından itibaren 0 ölçerken, 1 geçerli dosya konumunu, 2 ise "
"başvuru noktası olarak dosyanın sonunu kullanır.  *whence* atlanabilir ve "
"başvuru noktası için dosyanın başlangıcını kullanarak 0 olarak "
"varsayılabilir. ::"

#: tutorial/inputoutput.rst:453
msgid ""
"In text files (those opened without a ``b`` in the mode string), only seeks "
"relative to the beginning of the file are allowed (the exception being "
"seeking to the very file end with ``seek(0, 2)``) and the only valid "
"*offset* values are those returned from the ``f.tell()``, or zero. Any other "
"*offset* value produces undefined behaviour."
msgstr ""
"Metin dosyalarında (mod dizesinde ``b`` olmadan açılanlar), yalnızca "
"dosyanın başına göre aramalara izin verilir (dosyanın sonuna ``seek(0, 2)`` "
"ile arayan özel durum) ve tek geçerli *offset* değerleri ``f.tell()`` veya "
"sıfırdan döndürülen değerlerdir. Başka herhangi bir *offset* değeri tanımsız "
"davranış üretir."

#: tutorial/inputoutput.rst:459
#, fuzzy
msgid ""
"File objects have some additional methods, such as :meth:`~io.IOBase.isatty` "
"and :meth:`~io.IOBase.truncate` which are less frequently used; consult the "
"Library Reference for a complete guide to file objects."
msgstr ""
"Dosya nesnelerinin daha az kullanılan :meth:`~file.isatty` ve :meth:`~file."
"truncate` gibi bazı ek metotları vardır; dosya nesneleri için eksiksiz bir "
"kılavuz için Kütüphane Referansı'na bakın."

#: tutorial/inputoutput.rst:467
msgid "Saving structured data with :mod:`json`"
msgstr "Yapılandırılmış verileri :mod:`json` ile kaydetme"

#: tutorial/inputoutput.rst:471
#, fuzzy
msgid ""
"Strings can easily be written to and read from a file.  Numbers take a bit "
"more effort, since the :meth:`~io.TextIOBase.read` method only returns "
"strings, which will have to be passed to a function like :func:`int`, which "
"takes a string like ``'123'`` and returns its numeric value 123.  When you "
"want to save more complex data types like nested lists and dictionaries, "
"parsing and serializing by hand becomes complicated."
msgstr ""
"Dizeler bir dosyaya kolayca yazılabilir ve dosyadan okunabilir.  Sayılar "
"biraz daha fazla çaba gerektirir, çünkü :meth:`read` yöntemi yalnızca "
"``'123'`` gibi bir dize alan ve sayısal değeri 123'ü döndüren :func:`int` "
"gibi bir işleve geçirilmesi gereken dizeleri döndürür.  İç içe geçmiş "
"listeler ve sözlükler gibi daha karmaşık veri türlerini kaydetmek "
"istediğinizde, elle ayrıştırma ve seri hale getirmek karmaşık hale gelir."

#: tutorial/inputoutput.rst:478
msgid ""
"Rather than having users constantly writing and debugging code to save "
"complicated data types to files, Python allows you to use the popular data "
"interchange format called `JSON (JavaScript Object Notation) <https://json."
"org>`_.  The standard module called :mod:`json` can take Python data "
"hierarchies, and convert them to string representations; this process is "
"called :dfn:`serializing`.  Reconstructing the data from the string "
"representation is called :dfn:`deserializing`.  Between serializing and "
"deserializing, the string representing the object may have been stored in a "
"file or data, or sent over a network connection to some distant machine."
msgstr ""
"Python, kullanıcıların karmaşık veri türlerini dosyalara kaydetmek için "
"sürekli olarak kod yazmasını ve hata ayıklamasını sağlamak yerine, `JSON "
"(JavaScript Object Notation) <https://json.org>`_ adlı popüler veri değişim "
"biçimini kullanmanıza olanak tanır.  :mod:`json` adlı standart modül, Python "
"veri hiyerarşilerini alabilir ve bunları dize temsillerine dönüştürebilir; "
"bu işleme :dfn:`serializing` adı verilir.  Dize gösteriminden verilerin "
"yeniden yapılandırılmasına :dfn:`deserializing` denir.  Serileştirme ve seri "
"durumdan çıkarma arasında, nesneyi temsil eden dizi bir dosyada veya veride "
"saklanmış olabilir veya bir ağ bağlantısı üzerinden uzaktaki bir makineye "
"gönderilmiş olabilir."

#: tutorial/inputoutput.rst:489
msgid ""
"The JSON format is commonly used by modern applications to allow for data "
"exchange.  Many programmers are already familiar with it, which makes it a "
"good choice for interoperability."
msgstr ""
"JSON biçimi, veri alışverişine izin vermek için modern uygulamalar "
"tarafından yaygın olarak kullanılır.  Birçok programcı zaten buna aşinadır, "
"bu da onu birlikte çalışabilirlik için iyi bir seçim haline getirir."

#: tutorial/inputoutput.rst:493
msgid ""
"If you have an object ``x``, you can view its JSON string representation "
"with a simple line of code::"
msgstr ""
"``x`` nesnesiniz varsa, JSON dize gösterimini basit bir kod satırıyla "
"görüntüleyebilirsiniz::"

#: tutorial/inputoutput.rst:501
msgid ""
"Another variant of the :func:`~json.dumps` function, called :func:`~json."
"dump`, simply serializes the object to a :term:`text file`.  So if ``f`` is "
"a :term:`text file` object opened for writing, we can do this::"
msgstr ""
":func:`~json.dumps` işlevinin başka bir çeşidi, :func:`~json.dump` adı "
"verilen nesneyi bir :term:`text file` (metin dosyası) olarak seri hale "
"getirmektedir.  Yani ``f`` bir :term:`text file` nesnesi yazmak için "
"açılmışsa, bunu yapabiliriz::"

#: tutorial/inputoutput.rst:507
msgid ""
"To decode the object again, if ``f`` is a :term:`binary file` or :term:`text "
"file` object which has been opened for reading::"
msgstr ""
"Nesnenin kodunu tekrar çözmek için, ``f`` okuma için açılmış bir :term:"
"`binary file` veya :term:`text file` nesnesiyse::"

#: tutorial/inputoutput.rst:513
msgid ""
"JSON files must be encoded in UTF-8. Use ``encoding=\"utf-8\"`` when opening "
"JSON file as a :term:`text file` for both of reading and writing."
msgstr ""
"JSON dosyaları UTF-8'de kodlanmalıdır. Hem okuma hem de yazma için JSON "
"dosyasını :term:`text file` olarak açarken ``encoding=\"utf-8\"`` kullanın."

#: tutorial/inputoutput.rst:516
msgid ""
"This simple serialization technique can handle lists and dictionaries, but "
"serializing arbitrary class instances in JSON requires a bit of extra "
"effort. The reference for the :mod:`json` module contains an explanation of "
"this."
msgstr ""
"Bu basit seri hale getirme tekniği listeleri ve sözlükleri işleyebilir, "
"ancak JSON'da rasgele sınıf örneklerini seri hale getirmek biraz daha fazla "
"çaba gerektirir. :mod:`json` modülü için olan örnek bunun bir açıklamasını "
"içerir."

#: tutorial/inputoutput.rst:522
msgid ":mod:`pickle` - the pickle module"
msgstr ":mod:`pickle` - pickle modülü"

#: tutorial/inputoutput.rst:524
msgid ""
"Contrary to :ref:`JSON <tut-json>`, *pickle* is a protocol which allows the "
"serialization of arbitrarily complex Python objects.  As such, it is "
"specific to Python and cannot be used to communicate with applications "
"written in other languages.  It is also insecure by default: deserializing "
"pickle data coming from an untrusted source can execute arbitrary code, if "
"the data was crafted by a skilled attacker."
msgstr ""
":ref:`JSON <tut-json>` ifadesinin aksine, *pickle*, gelişigüzel olarak "
"karmaşık Python nesnelerinin seri hale getirilmesine izin veren bir "
"protokoldür.  Bu nedenle, Python'a özgüdür ve diğer dillerde yazılmış "
"uygulamalarla iletişim kurmak için kullanılamaz.  Varsayılan olarak da "
"güvensizdir: güvenilmeyen bir kaynaktan gelen pickle verilerinin dizilerinin "
"seri halden çıkarılması, veriler yetenekli bir saldırgan tarafından "
"hazırlanmışsa rasgele kod yürütebilir."

#: tutorial/inputoutput.rst:287
msgid "built-in function"
msgstr ""

#: tutorial/inputoutput.rst:287
msgid "open"
msgstr ""

#: tutorial/inputoutput.rst:287
msgid "object"
msgstr ""

#: tutorial/inputoutput.rst:287
msgid "file"
msgstr ""

#: tutorial/inputoutput.rst:469
msgid "module"
msgstr ""

#: tutorial/inputoutput.rst:469
msgid "json"
msgstr ""