# Python Documentation Turkish Translation

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

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

#

msgid ""

msgstr ""

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

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

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

"PO-Revision-Date: 2022-12-28 21:39+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/datastructures.rst:5

msgid "Data Structures"

msgstr "Veri Yapıları"

#: tutorial/datastructures.rst:7

msgid ""

"This chapter describes some things you've learned about already in more "

"detail, and adds some new things as well."

msgstr ""

"Bu bölüm, daha önce öğrendiğiniz bazı şeyleri daha ayrıntılı olarak "

"açıklamakta ve bazı yeni şeyler de eklemektedir."

#: tutorial/datastructures.rst:13

msgid "More on Lists"

msgstr "Listeler Üzerine"

#: tutorial/datastructures.rst:15

msgid ""

"The list data type has some more methods. Here are all of the methods of "

"list objects:"

msgstr ""

"Liste veri türünün bazı yöntemleri daha vardır. Liste nesnelerinin tüm "

"metotları şunlardır:"

#: tutorial/datastructures.rst:22

msgid ""

"Add an item to the end of the list. Equivalent to ``a[len(a):] = [x]``."

msgstr "Listenin sonuna bir öğe ekleyin. ``a[len(a):] = [x]`` ile eş değerdir."

#: tutorial/datastructures.rst:28

msgid ""

"Extend the list by appending all the items from the iterable. Equivalent to "

"``a[len(a):] = iterable``."

msgstr ""

"Listeyi iterable'daki tüm öğeleri ekleyerek genişletin. ``a[len(a):] = "

"iterable`` ile eş değerdir."

#: tutorial/datastructures.rst:35

msgid ""

"Insert an item at a given position. The first argument is the index of the "

"element before which to insert, so ``a.insert(0, x)`` inserts at the front "

"of the list, and ``a.insert(len(a), x)`` is equivalent to ``a.append(x)``."

msgstr ""

"Verilen pozisyona bir öğe ekleyin. İlk argüman, daha önce ekleyeceğiniz "

"öğenin indeksidir, bu nedenle ``a.insert(0, x)`` listenin önüne ekler ve ``a."

"insert(len(a), x)`` komutu ``a.append(x)`` komutu ile eş değerdir."

#: tutorial/datastructures.rst:43

msgid ""

"Remove the first item from the list whose value is equal to *x*. It raises "

"a :exc:`ValueError` if there is no such item."

msgstr ""

"Değeri *x*'e eşit olan ilk öğeyi listeden kaldırır. Böyle bir öğe yoksa :"

"exc:`ValueError` hatası ortaya çıkar."

#: tutorial/datastructures.rst:50

msgid ""

"Remove the item at the given position in the list, and return it. If no "

"index is specified, ``a.pop()`` removes and returns the last item in the "

"list. (The square brackets around the *i* in the method signature denote "

"that the parameter is optional, not that you should type square brackets at "

"that position. You will see this notation frequently in the Python Library "

"Reference.)"

msgstr ""

"Listede verilen konumdaki öğeyi kaldırır ve geri döndürür. Herhangi bir "

"indis belirtilmezse, ``a.pop()`` listedeki son öğeyi kaldırır ve döndürür. "

"(Yöntem imzasındaki *i* parametresinin etrafındaki köşeli parantezler, "

"parametrenin isteğe bağlı olduğunu belirtir, o konumda köşeli parantez "

"yazmanız gerektiğini değil. Bu gösterimi Python Kütüphane Referansında "

"sıkça göreceksiniz)"

#: tutorial/datastructures.rst:60

msgid "Remove all items from the list. Equivalent to ``del a[:]``."

msgstr "Listeden tüm öğeleri kaldırır. ``del a[:]`` ile eş değerdir."

#: tutorial/datastructures.rst:66

msgid ""

"Return zero-based index in the list of the first item whose value is equal "

"to *x*. Raises a :exc:`ValueError` if there is no such item."

msgstr ""

"Değeri *x*'e eşit olan ilk öğenin listedeki sıfır tabanlı indeksini "

"döndürür. Böyle bir öğe yoksa :exc:`ValueError` hatası ortaya çıkar."

#: tutorial/datastructures.rst:69

msgid ""

"The optional arguments *start* and *end* are interpreted as in the slice "

"notation and are used to limit the search to a particular subsequence of the "

"list. The returned index is computed relative to the beginning of the full "

"sequence rather than the *start* argument."

msgstr ""

"İsteğe bağlı *start* ve *end* argümanları dilim gösteriminde olduğu gibi "

"yorumlanır ve aramayı listenin belirli bir alt dizisiyle sınırlamak için "

"kullanılır. Döndürülen dizin, *start* bağımsız değişkeni yerine tam dizinin "

"başlangıcına göre hesaplanır."

#: tutorial/datastructures.rst:78

msgid "Return the number of times *x* appears in the list."

msgstr "Listede *x* öğesinin kaç kez göründüğünü döndürür."

#: tutorial/datastructures.rst:84

msgid ""

"Sort the items of the list in place (the arguments can be used for sort "

"customization, see :func:`sorted` for their explanation)."

msgstr ""

"Listenin öğelerini yerinde sıralayın (argümanlar sıralama özelleştirmesi "

"için kullanılabilir, açıklamaları için bkz: :func:`sorted`)."

#: tutorial/datastructures.rst:91

msgid "Reverse the elements of the list in place."

msgstr "Listenin öğelerini yerinde ters çevirir."

#: tutorial/datastructures.rst:97

msgid "Return a shallow copy of the list. Equivalent to ``a[:]``."

msgstr "Listenin yüzeysel bir kopyasını döndürür. ``a[:]`` ile eş değerdir."

#: tutorial/datastructures.rst:100

msgid "An example that uses most of the list methods::"

msgstr "Liste yöntemlerinin çoğunu kullanan bir örnek::"

#: tutorial/datastructures.rst:123

msgid ""

"You might have noticed that methods like ``insert``, ``remove`` or ``sort`` "

"that only modify the list have no return value printed -- they return the "

"default ``None``. [#]_ This is a design principle for all mutable data "

"structures in Python."

msgstr ""

"Listeyi yalnızca değiştiren ``insert``, ``remove`` veya ``sort`` gibi "

"yöntemlerin hiçbir dönüş değeri yazdırmadığını fark etmiş olabilirsiniz -- "

"onlar varsayılan ``None`` değerini döndürürler. [#]_ Bu, Python'daki tüm "

"değiştirilebilir veri yapıları için bir tasarım ilkesidir."

#: tutorial/datastructures.rst:128

msgid ""

"Another thing you might notice is that not all data can be sorted or "

"compared. For instance, ``[None, 'hello', 10]`` doesn't sort because "

"integers can't be compared to strings and *None* can't be compared to other "

"types. Also, there are some types that don't have a defined ordering "

"relation. For example, ``3+4j < 5+7j`` isn't a valid comparison."

msgstr ""

"Fark edebileceğiniz bir başka şey de tüm verilerin sıralanamayacağı veya "

"karşılaştırılamayacağıdır. Örneğin, ``[None, 'hello', 10]`` sıralanamaz "

"çünkü tamsayılar dizelerle karşılaştırılamaz ve *None* diğer türlerle "

"karşılaştırılamaz. Ayrıca, tanımlanmış bir sıralama ilişkisine sahip "

"olmayan bazı türler de vardır. Örneğin, ``3+4j < 5+7j`` geçerli bir "

"karşılaştırma değildir."

#: tutorial/datastructures.rst:139

msgid "Using Lists as Stacks"

msgstr "Listeleri Yığın Olarak Kullanma"

#: tutorial/datastructures.rst:144

#, fuzzy

msgid ""

"The list methods make it very easy to use a list as a stack, where the last "

"element added is the first element retrieved (\"last-in, first-out\"). To "

"add an item to the top of the stack, use :meth:`~list.append`. To retrieve "

"an item from the top of the stack, use :meth:`~list.pop` without an explicit "

"index. For example::"

msgstr ""

"Liste yöntemleri, bir listeyi, eklenen son öğenin alınan ilk öğe olduğu bir "

"yığın olarak kullanmayı çok kolaylaştırır (\"son giren ilk çıkar\"). "

"Yığının en üstüne bir öğe eklemek için :meth:`append` kullanın. Yığının en "

"üstünden bir öğe almak için, açık bir indeks olmadan :meth:`pop` kullanın. "

"Örneğin::"

#: tutorial/datastructures.rst:169

msgid "Using Lists as Queues"

msgstr "Listeleri Kuyruk Olarak Kullanma"

#: tutorial/datastructures.rst:173

msgid ""

"It is also possible to use a list as a queue, where the first element added "

"is the first element retrieved (\"first-in, first-out\"); however, lists are "

"not efficient for this purpose. While appends and pops from the end of list "

"are fast, doing inserts or pops from the beginning of a list is slow "

"(because all of the other elements have to be shifted by one)."

msgstr ""

"Bir listeyi, eklenen ilk elemanın alınan ilk eleman olduğu bir kuyruk olarak "

"kullanmak da mümkündür (\"ilk giren ilk çıkar\"); ancak listeler bu amaç "

"için verimli değildir. Listenin sonundan ekleme ve çıkarma işlemleri "

"hızlıyken, listenin başından ekleme veya çıkarma yapmak yavaştır (çünkü "

"diğer tüm öğelerin bir adım kaydırılması gerekir)."

#: tutorial/datastructures.rst:179

msgid ""

"To implement a queue, use :class:`collections.deque` which was designed to "

"have fast appends and pops from both ends. For example::"

msgstr ""

"Bir kuyruk uygulamak için, her iki uçtan da hızlı ekleme ve çıkarma yapmak "

"üzere tasarlanmış :class:`collections.deque` kullanın. Örneğin::"

#: tutorial/datastructures.rst:197

msgid "List Comprehensions"

msgstr "Liste Kavramaları"

#: tutorial/datastructures.rst:199

msgid ""

"List comprehensions provide a concise way to create lists. Common "

"applications are to make new lists where each element is the result of some "

"operations applied to each member of another sequence or iterable, or to "

"create a subsequence of those elements that satisfy a certain condition."

msgstr ""

"Liste kavramaları, listeler oluşturmak için kısa bir yol sağlar. Yaygın "

"uygulamalar, her bir öğenin başka bir dizinin veya yinelenebilir öğenin her "

"bir üyesine uygulanan bazı işlemlerin sonucu olduğu yeni listeler oluşturmak "

"veya belirli bir koşulu karşılayan öğelerin bir alt dizisini oluşturmaktır."

#: tutorial/datastructures.rst:204

msgid "For example, assume we want to create a list of squares, like::"

msgstr ""

"Örneğin, aşağıdaki gibi bir kareler listesi oluşturmak istediğimizi "

"varsayalım:"

#: tutorial/datastructures.rst:213

msgid ""

"Note that this creates (or overwrites) a variable named ``x`` that still "

"exists after the loop completes. We can calculate the list of squares "

"without any side effects using::"

msgstr ""

"Bunun, ``x`` adında bir değişken yarattığına (veya üzerine yazdığına) ve bu "

"değişkenin döngü tamamlandıktan sonra da var olduğuna dikkat edin. Kareler "

"listesini, şunu kullanarak herhangi bir yan etki olmadan hesaplayabiliriz:"

#: tutorial/datastructures.rst:219

msgid "or, equivalently::"

msgstr "veya aynı şekilde::"

#: tutorial/datastructures.rst:223

msgid "which is more concise and readable."

msgstr "ki bu daha kısa ve okunaklıdır."

#: tutorial/datastructures.rst:225

msgid ""

"A list comprehension consists of brackets containing an expression followed "

"by a :keyword:`!for` clause, then zero or more :keyword:`!for` or :keyword:`!"

"if` clauses. The result will be a new list resulting from evaluating the "

"expression in the context of the :keyword:`!for` and :keyword:`!if` clauses "

"which follow it. For example, this listcomp combines the elements of two "

"lists if they are not equal::"

msgstr ""

"Bir liste kavrayışı, bir ifade içeren parantezlerden ve ardından bir :"

"keyword:`!for` cümlesinden, ardından sıfır veya daha fazla :keyword:`!for` "

"veya :keyword:`!if` cümlesinden oluşur. Sonuç, ifadenin kendisini takip "

"eden :keyword:`!for` ve :keyword:`!if` cümleleri bağlamında "

"değerlendirilmesiyle elde edilen yeni bir liste olacaktır. Örneğin, "

"listcomp, eşit değillerse iki listenin öğelerini birleştirir::"

#: tutorial/datastructures.rst:235

msgid "and it's equivalent to::"

msgstr "ve şuna eş değerdir::"

#: tutorial/datastructures.rst:246

msgid ""

"Note how the order of the :keyword:`for` and :keyword:`if` statements is the "

"same in both these snippets."

msgstr ""

"Her iki kod parçacığında da :keyword:`for` ve :keyword:`if` ifadelerinin "

"sıralamasının aynı olduğuna dikkat edin."

#: tutorial/datastructures.rst:249

msgid ""

"If the expression is a tuple (e.g. the ``(x, y)`` in the previous example), "

"it must be parenthesized. ::"

msgstr ""

"Eğer ifade bir veri grubu ise (örneğin önceki örnekteki ``(x, y)``), "

"parantez içine alınmalıdır. ::"

#: tutorial/datastructures.rst:280

msgid ""

"List comprehensions can contain complex expressions and nested functions::"

msgstr ""

"Liste kavramaları karmaşık ifadeler ve iç içe geçmiş fonksiyonlar "

"içerebilir::"

#: tutorial/datastructures.rst:287

msgid "Nested List Comprehensions"

msgstr "İç İçe Liste Kavramaları"

#: tutorial/datastructures.rst:289

msgid ""

"The initial expression in a list comprehension can be any arbitrary "

"expression, including another list comprehension."

msgstr ""

"Bir liste kavrayışındaki ilk ifade, başka bir liste kavrayışı da dahil olmak "

"üzere rastgele herhangi bir ifade olabilir."

#: tutorial/datastructures.rst:292

msgid ""

"Consider the following example of a 3x4 matrix implemented as a list of 3 "

"lists of length 4::"

msgstr ""

"Uzunluğu 4 olan 3 listeden oluşan bir liste olarak uygulanan 3x4'lük bir "

"matrisin aşağıdaki örneğini düşünün::"

#: tutorial/datastructures.rst:301

msgid "The following list comprehension will transpose rows and columns::"

msgstr "Aşağıdaki liste kavraması satır ve sütunların yerlerini değiştirir::"

#: tutorial/datastructures.rst:306

msgid ""

"As we saw in the previous section, the inner list comprehension is evaluated "

"in the context of the :keyword:`for` that follows it, so this example is "

"equivalent to::"

msgstr ""

"Önceki bölümde gördüğümüz gibi, iç liste kavrayışı, onu takip eden :keyword:"

"`for` bağlamında değerlendirilir, bu nedenle bu örnek şuna eş değerdir::"

#: tutorial/datastructures.rst:317

msgid "which, in turn, is the same as::"

msgstr "ki bu da şununla aynıdır::"

#: tutorial/datastructures.rst:330

msgid ""

"In the real world, you should prefer built-in functions to complex flow "

"statements. The :func:`zip` function would do a great job for this use case::"

msgstr ""

"Gerçek dünyada, karmaşık akışlı ifadeler yerine yerleşik işlevleri tercih "

"etmelisiniz. Bu kullanım durumu için :func:`zip` fonksiyonu harika bir iş "

"çıkaracaktır::"

#: tutorial/datastructures.rst:336

msgid ""

"See :ref:`tut-unpacking-arguments` for details on the asterisk in this line."

msgstr ""

"Bu satırdaki yıldız işaretiyle ilgili ayrıntılar için :ref:`tut-unpacking-"

"arguments` bölümüne bakın."

#: tutorial/datastructures.rst:341

msgid "The :keyword:`!del` statement"

msgstr ":keyword:`!del` ifadesi"

#: tutorial/datastructures.rst:343

#, fuzzy

msgid ""

"There is a way to remove an item from a list given its index instead of its "

"value: the :keyword:`del` statement. This differs from the :meth:`~list."

"pop` method which returns a value. The :keyword:`!del` statement can also "

"be used to remove slices from a list or clear the entire list (which we did "

"earlier by assignment of an empty list to the slice). For example::"

msgstr ""

"Değer yerine indeksi verilen bir öğeyi listeden kaldırmanın bir yolu "

"vardır: :keyword:`del` ifadesi. Bu, bir değer döndüren :meth:`pop` "

"yönteminden farklıdır. :keyword:`!del` ifadesi ayrıca bir listeden dilimleri "

"kaldırmak veya tüm listeyi temizlemek için de kullanılabilir (bunu daha önce "

"dilime boş bir liste atayarak yapmıştık). Örneğin::"

#: tutorial/datastructures.rst:360

msgid ":keyword:`del` can also be used to delete entire variables::"

msgstr ":keyword:`del` değişkenlerin tamamını silmek için de kullanılabilir::"

#: tutorial/datastructures.rst:364

msgid ""

"Referencing the name ``a`` hereafter is an error (at least until another "

"value is assigned to it). We'll find other uses for :keyword:`del` later."

msgstr ""

"Bundan sonra ``a`` ismine referans vermek bir hatadır (en azından ona başka "

"bir değer atanana kadar). Daha sonra :keyword:`del` için başka kullanımlar "

"bulacağız."

#: tutorial/datastructures.rst:371

msgid "Tuples and Sequences"

msgstr "Veri Grupları ve Diziler"

#: tutorial/datastructures.rst:373

msgid ""

"We saw that lists and strings have many common properties, such as indexing "

"and slicing operations. They are two examples of *sequence* data types "

"(see :ref:`typesseq`). Since Python is an evolving language, other sequence "

"data types may be added. There is also another standard sequence data type: "

"the *tuple*."

msgstr ""

"Listelerin ve dizelerin indeksleme ve dilimleme işlemleri gibi birçok ortak "

"özelliğe sahip olduğunu gördük. Bunlar *dizi* veri tiplerinin iki örneğidir "

"(bkz. :ref:`typesseq`). Python gelişen bir dil olduğu için başka dizi veri "

"tipleri de eklenebilir. Ayrıca başka bir standart dizi veri tipi daha "

"vardır: *tuple*."

#: tutorial/datastructures.rst:379

msgid ""

"A tuple consists of a number of values separated by commas, for instance::"

msgstr "Bir veri grubu, virgülle ayrılmış bir dizi değerden oluşur, örneğin::"

#: tutorial/datastructures.rst:401

msgid ""

"As you see, on output tuples are always enclosed in parentheses, so that "

"nested tuples are interpreted correctly; they may be input with or without "

"surrounding parentheses, although often parentheses are necessary anyway (if "

"the tuple is part of a larger expression). It is not possible to assign to "

"the individual items of a tuple, however it is possible to create tuples "

"which contain mutable objects, such as lists."

msgstr ""

"Gördüğünüz gibi, çıktıda veri grupları her zaman parantez içine alınır, "

"böylece iç içe geçmiş veri grupları doğru şekilde yorumlanır; parantezli "

"veya parantezsiz olarak girilebilirler, ancak genellikle parantezler "

"gereklidir (eğer grup daha büyük bir ifadenin parçasıysa). Bir veri "

"grubunun öğelerine tek tek atama yapmak mümkün değildir, ancak listeler gibi "

"değiştirilebilir nesneler içeren veri grupları oluşturmak mümkündür."

#: tutorial/datastructures.rst:408

msgid ""

"Though tuples may seem similar to lists, they are often used in different "

"situations and for different purposes. Tuples are :term:`immutable`, and "

"usually contain a heterogeneous sequence of elements that are accessed via "

"unpacking (see later in this section) or indexing (or even by attribute in "

"the case of :func:`namedtuples <collections.namedtuple>`). Lists are :term:"

"`mutable`, and their elements are usually homogeneous and are accessed by "

"iterating over the list."

msgstr ""

"Veri grupları listelere benzer görünse de, genellikle farklı durumlarda ve "

"farklı amaçlar için kullanılırlar. Veri grupları :term:`immutable` 'dır ve "

"genellikle paket açma (bu bölümün ilerleyen kısımlarına bakınız) veya "

"indeksleme (hatta :func:`namedtuples <collections.namedtuple>` durumunda "

"öznitelik ile) yoluyla erişilen heterojen bir dizi eleman içerir. Listeler :"

"term:`mutable` 'dır ve elemanları genellikle homojendir ve listenin üzerinde "

"yinelenerek erişilir."

#: tutorial/datastructures.rst:416

msgid ""

"A special problem is the construction of tuples containing 0 or 1 items: the "

"syntax has some extra quirks to accommodate these. Empty tuples are "

"constructed by an empty pair of parentheses; a tuple with one item is "

"constructed by following a value with a comma (it is not sufficient to "

"enclose a single value in parentheses). Ugly, but effective. For example::"

msgstr ""

"Özel bir sorun, 0 veya 1 öğe içeren veri gruplarının oluşturulmasıdır: söz "

"diziminin bunlar ile başa çıkan bazı ekstra tuhaflıkları vardır. Boş veri "

"grupları boş bir parantez çifti ile oluşturulur; bir öğeli bir veri grubu, "

"bir değeri virgülle takip ederek oluşturulur (tek bir değeri parantez içine "

"almak yeterli değildir). Çirkin olsa da etkilidir. Örneğin::"

#: tutorial/datastructures.rst:431

msgid ""

"The statement ``t = 12345, 54321, 'hello!'`` is an example of *tuple "

"packing*: the values ``12345``, ``54321`` and ``'hello!'`` are packed "

"together in a tuple. The reverse operation is also possible::"

msgstr ""

"``t = 12345, 54321, ‘hello!’`` ifadesi bir *veri grubu paketleme* örneğidir: "

"``12345``, ``54321`` ve ``'hello!'`` değerleri bir veri grubu içinde bir "

"araya getirilmiştir. Bu işlemin tersi de mümkündür::"

#: tutorial/datastructures.rst:437

msgid ""

"This is called, appropriately enough, *sequence unpacking* and works for any "

"sequence on the right-hand side. Sequence unpacking requires that there are "

"as many variables on the left side of the equals sign as there are elements "

"in the sequence. Note that multiple assignment is really just a combination "

"of tuple packing and sequence unpacking."

msgstr ""

"Buna uygun bir şekilde *dizi açma (sequence unpacking)* denir ve sağ "

"taraftaki herhangi bir dizi için çalışır. Dizi açma, eşittir işaretinin sol "

"tarafında dizideki eleman sayısı kadar değişken olmasını gerektirir. Çoklu "

"atamanın aslında tuple paketleme ve dizi açmanın bir kombinasyonu olduğunu "

"unutmayın."

#: tutorial/datastructures.rst:447

msgid "Sets"

msgstr "Kümeler"

#: tutorial/datastructures.rst:449

msgid ""

"Python also includes a data type for *sets*. A set is an unordered "

"collection with no duplicate elements. Basic uses include membership "

"testing and eliminating duplicate entries. Set objects also support "

"mathematical operations like union, intersection, difference, and symmetric "

"difference."

msgstr ""

"Python ayrıca *kümeler* için bir veri türü içerir. Bir küme, yinelenen "

"öğeleri olmayan sırasız bir koleksiyondur. Temel kullanımları içerisinde "

"üyelik testi ve yinelenen girdilerin elenmesi yer alır. Küme nesneleri "

"ayrıca birleşim, kesişim, fark ve simetrik fark gibi matematiksel işlemleri "

"de destekler."

#: tutorial/datastructures.rst:454

msgid ""

"Curly braces or the :func:`set` function can be used to create sets. Note: "

"to create an empty set you have to use ``set()``, not ``{}``; the latter "

"creates an empty dictionary, a data structure that we discuss in the next "

"section."

msgstr ""

"Küme oluşturmak için küme parantezleri veya :func:`set` fonksiyonu "

"kullanılabilir. Not: boş bir küme oluşturmak için ``{}`` değil ``set()`` "

"kullanmanız gerekir, çünkü birincisi boş bir sözlük oluşturur, ki bu da bir "

"sonraki bölümde tartışacağımız bir veri yapısıdır."

#: tutorial/datastructures.rst:458

msgid "Here is a brief demonstration::"

msgstr "İşte kısa bir gösterim::"

#: tutorial/datastructures.rst:483

msgid ""

"Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions "

"are also supported::"

msgstr ""

":ref:`liste kavramaları <tut-listcomps>` gibi küme kavramaları da "

"desteklenmektedir::"

#: tutorial/datastructures.rst:494

msgid "Dictionaries"

msgstr "Sözlükler"

#: tutorial/datastructures.rst:496

#, fuzzy

msgid ""

"Another useful data type built into Python is the *dictionary* (see :ref:"

"`typesmapping`). Dictionaries are sometimes found in other languages as "

"\"associative memories\" or \"associative arrays\". Unlike sequences, which "

"are indexed by a range of numbers, dictionaries are indexed by *keys*, which "

"can be any immutable type; strings and numbers can always be keys. Tuples "

"can be used as keys if they contain only strings, numbers, or tuples; if a "

"tuple contains any mutable object either directly or indirectly, it cannot "

"be used as a key. You can't use lists as keys, since lists can be modified "

"in place using index assignments, slice assignments, or methods like :meth:"

"`~list.append` and :meth:`~list.extend`."

msgstr ""

"Python'da yerleşik olarak bulunan bir başka kullanışlı veri türü de "

"*sözlüktür* (bkz :ref:`typesmapping`). Sözlükler bazen diğer dillerde "

"\"ilişkisel bellekler\" veya \"ilişkisel diziler\" olarak bulunur. Bir sayı "

"aralığı ile indekslenen dizilerin aksine, sözlükler herhangi bir değişmez "

"tip olabilen *anahtarlar* ile indekslenir, ki dizgiler ve sayılar her zaman "

"birer anahtar olabilir. Veri grupları yalnızca dizgi, sayı ya da veri grubu "

"içeriyorsa anahtar olarak kullanılabilir. Ancak bir veri grubu doğrudan ya "

"da dolaylı olarak değişebilir herhangi bir nesne içeriyorsa anahtar olarak "

"kullanılamaz. Listeler; dizin atamaları, dilim atamaları veya :meth:`append` "

"ve :meth:`extend` gibi yöntemler kullanılarak yerinde değiştirilebildiğinden "

"listeleri anahtar olarak kullanamazsınız."

#: tutorial/datastructures.rst:507

msgid ""

"It is best to think of a dictionary as a set of *key: value* pairs, with the "

"requirement that the keys are unique (within one dictionary). A pair of "

"braces creates an empty dictionary: ``{}``. Placing a comma-separated list "

"of key:value pairs within the braces adds initial key:value pairs to the "

"dictionary; this is also the way dictionaries are written on output."

msgstr ""

"Bir sözlüğü *anahtar: değer* çiftleri olarak düşünmek en iyisidir. Bir "

"sözlük içerisindeki her anahtarın benzersiz olması gerektiğini ise "

"unutmayın. Bir çift parantez boş bir sözlük oluşturur: ``{}``. Anahtar:değer "

"çiftlerinin virgülle ayrılmış bir listesini parantezler içine yerleştirmek "

"sözlüğe ilk anahtar:değer çiftlerini ekler; sözlükler çıktıda da aynı bu "

"şekilde görünürler."

#: tutorial/datastructures.rst:513

msgid ""

"The main operations on a dictionary are storing a value with some key and "

"extracting the value given the key. It is also possible to delete a key:"

"value pair with ``del``. If you store using a key that is already in use, "

"the old value associated with that key is forgotten. It is an error to "

"extract a value using a non-existent key."

msgstr ""

"Bir sözlük üzerindeki ana işlemler, bir değeri bir anahtarla depolamak ve "

"anahtarı verilen değeri geri çıkarmaktır. Ayrıca ``del`` ile bir anahtar:"

"değer çiftini silmek de mümkündür. Zaten bir değeri kullanımda olan bir "

"anahtar kullanarak saklarsanız, bu anahtarla ilişkili eski değer unutulur. "

"Var olmayan bir anahtar kullanarak değer çıkarmak bir hatadır."

#: tutorial/datastructures.rst:519

msgid ""

"Performing ``list(d)`` on a dictionary returns a list of all the keys used "

"in the dictionary, in insertion order (if you want it sorted, just use "

"``sorted(d)`` instead). To check whether a single key is in the dictionary, "

"use the :keyword:`in` keyword."

msgstr ""

"Bir sözlük üzerinde ``list(d)`` işlemini gerçekleştirmek, sözlükte "

"kullanılan tüm anahtarların bir listesini eklenme sırasına göre döndürür "

"(başka bir düzenle sıralanmasını istiyorsanız, bunun yerine ``sorted(d)`` "

"kullanın). Tek bir anahtarın sözlükte olup olmadığını kontrol etmek için :"

"keyword:`in` anahtar sözcüğünü kullanın."

#: tutorial/datastructures.rst:524

msgid "Here is a small example using a dictionary::"

msgstr "İşte sözlük kullanılan bir örnek::"

#: tutorial/datastructures.rst:545

msgid ""

"The :func:`dict` constructor builds dictionaries directly from sequences of "

"key-value pairs::"

msgstr ""

":func:`dict` yapıcısı, doğrudan anahtar-değer dizilerinden sözlükler "

"oluşturur::"

#: tutorial/datastructures.rst:551

msgid ""

"In addition, dict comprehensions can be used to create dictionaries from "

"arbitrary key and value expressions::"

msgstr ""

"Buna ek olarak, sözlük kavramaları rastgele anahtar ve değer ifadelerinden "

"sözlükler oluşturmak için de kullanılabilir::"

#: tutorial/datastructures.rst:557

msgid ""

"When the keys are simple strings, it is sometimes easier to specify pairs "

"using keyword arguments::"

msgstr ""

"Anahtarlar basit dizgiler olduğunda, anahtar sözcük argümanlarını kullanarak "

"çiftleri belirtmek bazen daha kolaydır::"

#: tutorial/datastructures.rst:567

msgid "Looping Techniques"

msgstr "Döngü Teknikleri"

#: tutorial/datastructures.rst:569

#, fuzzy

msgid ""

"When looping through dictionaries, the key and corresponding value can be "

"retrieved at the same time using the :meth:`~dict.items` method. ::"

msgstr ""

"Sözlükler arasında döngü yaparken, :meth:`items` yöntemi kullanılarak "

"anahtar ve karşılık gelen değer aynı anda alınabilir. ::"

#: tutorial/datastructures.rst:579

msgid ""

"When looping through a sequence, the position index and corresponding value "

"can be retrieved at the same time using the :func:`enumerate` function. ::"

msgstr ""

"Bir dizi boyunca döngü yaparken, :func:`enumerate` fonksiyonu kullanılarak "

"konum indeksi ve karşılık gelen değer aynı anda alınabilir. ::"

#: tutorial/datastructures.rst:589

msgid ""

"To loop over two or more sequences at the same time, the entries can be "

"paired with the :func:`zip` function. ::"

msgstr ""

"Aynı anda iki veya daha fazla dizi üzerinde döngü yapmak için, girdiler :"

"func:`zip` fonksiyonu ile eşleştirilebilir. ::"

#: tutorial/datastructures.rst:601

msgid ""

"To loop over a sequence in reverse, first specify the sequence in a forward "

"direction and then call the :func:`reversed` function. ::"

msgstr ""

"Bir dizi üzerinde ters yönde döngü yapmak için, önce diziyi ileri yönde "

"belirtin ve ardından :func:`reversed` fonksiyonunu çağırın. ::"

#: tutorial/datastructures.rst:613

msgid ""

"To loop over a sequence in sorted order, use the :func:`sorted` function "

"which returns a new sorted list while leaving the source unaltered. ::"

msgstr ""

"Bir dizi üzerinde sıralı olarak döngü yapmak için, listenin kaynağını "

"değiştirmeksizin yeni bir sıralı liste döndüren :func:`sorted` fonksiyonunu "

"kullanın. ::"

#: tutorial/datastructures.rst:627

msgid ""

"Using :func:`set` on a sequence eliminates duplicate elements. The use of :"

"func:`sorted` in combination with :func:`set` over a sequence is an "

"idiomatic way to loop over unique elements of the sequence in sorted "

"order. ::"

msgstr ""

"Bir dizi üzerinde :func:`set` kullanmak yinelenen öğeleri ortadan kaldırır. "

"Bir dizi üzerinde :func:`set` ile birlikte :func:`sorted` kullanımı, dizinin "

"benzersiz öğeleri üzerinde sıralı olarak döngü oluşturmanın deyimsel bir "

"yoludur. ::"

#: tutorial/datastructures.rst:640

msgid ""

"It is sometimes tempting to change a list while you are looping over it; "

"however, it is often simpler and safer to create a new list instead. ::"

msgstr ""

"Bazen bir liste üzerinde döngü yaparken değiştirmek cazip gelebilir; ancak "

"bunun yerine yeni bir liste oluşturmak genellikle daha basit ve daha "

"güvenlidir. ::"

#: tutorial/datastructures.rst:657

msgid "More on Conditions"

msgstr "Koşullar Üzerine"

#: tutorial/datastructures.rst:659

msgid ""

"The conditions used in ``while`` and ``if`` statements can contain any "

"operators, not just comparisons."

msgstr ""

"``while`` ve ``if`` deyimlerinde kullanılan koşullar sadece karşılaştırma "

"değil, herhangi bir operatör içerebilir."

#: tutorial/datastructures.rst:663

msgid ""

"The comparison operators ``in`` and ``not in`` are membership tests that "

"determine whether a value is in (or not in) a container. The operators "

"``is`` and ``is not`` compare whether two objects are really the same "

"object. All comparison operators have the same priority, which is lower "

"than that of all numerical operators."

msgstr ""

"Karşılaştırma operatörleri ``in`` ve ``not in`` bir değerin bir dizide olup "

"olmadığını kontrol eder. ``is`` ve ``is not`` operatörleri iki nesnenin "

"gerçekten aynı nesne olup olmadığını karşılaştırır. Tüm karşılaştırma "

"operatörleri aynı önceliğe sahiptir, bu öncelik ise tüm sayısal "

"operatörlerden daha düşüktür."

#: tutorial/datastructures.rst:669

msgid ""

"Comparisons can be chained. For example, ``a < b == c`` tests whether ``a`` "

"is less than ``b`` and moreover ``b`` equals ``c``."

msgstr ""

"Karşılaştırmalar art arda zincirlenebilir. Örneğin, ``a < b == c`` ifadesi "

"``a`` değerinin ``b`` değerinden küçük olup olmadığını test ederken aynı "

"zamanda ``b`` değerinin ``c`` değerine eşit olup olmadığını test eder."

#: tutorial/datastructures.rst:672

msgid ""

"Comparisons may be combined using the Boolean operators ``and`` and ``or``, "

"and the outcome of a comparison (or of any other Boolean expression) may be "

"negated with ``not``. These have lower priorities than comparison "

"operators; between them, ``not`` has the highest priority and ``or`` the "

"lowest, so that ``A and not B or C`` is equivalent to ``(A and (not B)) or "

"C``. As always, parentheses can be used to express the desired composition."

msgstr ""

"Karşılaştırmalar ``and`` ve ``or`` Boolean operatörleri kullanılarak "

"birleştirilebilir ve bir karşılaştırmanın (veya başka bir Boolean "

"ifadesinin) sonucu ``not`` ile olumsuzlanabilir. Bunlar karşılaştırma "

"operatörlerinden daha düşük önceliklere sahiptir; aralarında, ``not`` en "

"yüksek önceliğe ve ``or`` en düşük önceliğe sahiptir, böylece ``A ve B değil "

"veya C``, ``(A ve (B değil)) veya C`` ile eş değerdir. Her zaman olduğu "

"gibi, istenen bileşimi ifade etmek için parantezler kullanılabilir."

#: tutorial/datastructures.rst:679

msgid ""

"The Boolean operators ``and`` and ``or`` are so-called *short-circuit* "

"operators: their arguments are evaluated from left to right, and evaluation "

"stops as soon as the outcome is determined. For example, if ``A`` and ``C`` "

"are true but ``B`` is false, ``A and B and C`` does not evaluate the "

"expression ``C``. When used as a general value and not as a Boolean, the "

"return value of a short-circuit operator is the last evaluated argument."

msgstr ""

"Boolean operatörleri ``and`` ve ``or`` *kısa devre* operatörleri olarak "

"adlandırılır: argümanları soldan sağa doğru değerlendirilir ve sonuç "

"belirlenir belirlenmez değerlendirme durur. Örneğin, ``A`` ve ``C`` doğru "

"ancak ``B`` yanlış ise, ``A ve B ve C`` ``C`` ifadesini değerlendirmez. "

"Boolean olarak değil de genel bir değer olarak kullanıldığında, kısa devre "

"işlecinin dönüş değeri son değerlendirilen bağımsız değişkendir."

#: tutorial/datastructures.rst:686

msgid ""

"It is possible to assign the result of a comparison or other Boolean "

"expression to a variable. For example, ::"

msgstr ""

"Bir değişkene, bir karşılaştırmanın sonucunu veya başka bir Boolean "

"ifadesini atamak mümkündür. Örneğin::"

#: tutorial/datastructures.rst:694

msgid ""

"Note that in Python, unlike C, assignment inside expressions must be done "

"explicitly with the :ref:`walrus operator <why-can-t-i-use-an-assignment-in-"

"an-expression>` ``:=``. This avoids a common class of problems encountered "

"in C programs: typing ``=`` in an expression when ``==`` was intended."

msgstr ""

"Python'da, C'den farklı olarak, ifadelerin içindeki atamanın :ref:`walrus "

"operatörü <why-can-t-i-use-an-assignment-in-an-expression>` ``=`` ile açıkça "

"yapılması gerektiğini unutmayın. Bu, C programlarında karşılaşılan yaygın "

"bir sorunu önler: ``==`` yazmak isterken ``=`` yazmak."

#: tutorial/datastructures.rst:704

msgid "Comparing Sequences and Other Types"

msgstr "Diziler ile Diğer Veri Tiplerinin Karşılaştırılması"

#: tutorial/datastructures.rst:705

msgid ""

"Sequence objects typically may be compared to other objects with the same "

"sequence type. The comparison uses *lexicographical* ordering: first the "

"first two items are compared, and if they differ this determines the outcome "

"of the comparison; if they are equal, the next two items are compared, and "

"so on, until either sequence is exhausted. If two items to be compared are "

"themselves sequences of the same type, the lexicographical comparison is "

"carried out recursively. If all items of two sequences compare equal, the "

"sequences are considered equal. If one sequence is an initial sub-sequence "

"of the other, the shorter sequence is the smaller (lesser) one. "

"Lexicographical ordering for strings uses the Unicode code point number to "

"order individual characters. Some examples of comparisons between sequences "

"of the same type::"

msgstr ""

"Dizi nesneleri tipik olarak aynı dizi türüne sahip diğer nesnelerle "

"karşılaştırılabilir. Karşılaştırmada *sözlüksel* sıralama kullanılır: önce "

"ilk iki öğe karşılaştırılır ve farklılarsa bu karşılaştırmanın sonucunu "

"belirler; eşitlerse, sonraki iki öğe karşılaştırılır ve her iki dizi de "

"tükenene kadar böyle devam eder. Karşılaştırılacak iki öğenin kendileri de "

"aynı türden diziler ise, sözlükbilimsel karşılaştırma özyinelemeli olarak "

"gerçekleştirilir. İki dizinin tüm öğeleri eşit çıkarsa, diziler eşit kabul "

"edilir. Eğer dizilerden biri diğerinin alt dizisi ise, daha kısa olan dizi "

"daha küçük (küçük) olandır. Dizgiler için sözlükbilimsel sıralama, tek tek "

"karakterleri sıralamak için Unicode kod noktası numarasını kullanır. Aynı "

"türdeki diziler arasındaki karşılaştırmalara bazı örnekler::"

#: tutorial/datastructures.rst:725

msgid ""

"Note that comparing objects of different types with ``<`` or ``>`` is legal "

"provided that the objects have appropriate comparison methods. For example, "

"mixed numeric types are compared according to their numeric value, so 0 "

"equals 0.0, etc. Otherwise, rather than providing an arbitrary ordering, "

"the interpreter will raise a :exc:`TypeError` exception."

msgstr ""

"Nesnelerin uygun karşılaştırma yöntemlerine sahip olması koşuluyla, farklı "

"türlerdeki nesnelerin ``<`` veya ``>`` ile karşılaştırılabileceğini "

"unutmayın. Örneğin, karışık sayısal türler sayısal değerlerine göre "

"karşılaştırılır, bu nedenle 0 eşittir 0.0, vb. Bu türler uygun yöntemlere "

"sahip değillerse, yorumlayıcı rastgele bir sıralama döndürmek yerine :exc:"

"`TypeError` hatası verir."

#: tutorial/datastructures.rst:733

msgid "Footnotes"

msgstr "Dipnotlar"

#: tutorial/datastructures.rst:734

msgid ""

"Other languages may return the mutated object, which allows method chaining, "

"such as ``d->insert(\"a\")->remove(\"b\")->sort();``."

msgstr ""

"Diğer diller, ``d->insert(\"a\")->remove(\"b\")->sort();`` gibi yöntem "

"zincirlemesine izin veren değiştirilmiş nesneyi döndürebilir."