python-docs-tr/howto/sorting.po at 3.12 · python/python-docs-tr

659 lines (580 loc) · 24.1 KB
# Python Documentation Turkish Translation
# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
"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: 2023-04-19 21:42+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"
"X-Generator: Poedit 3.1\n"
#: howto/sorting.rst:4
msgid "Sorting Techniques"
msgstr "Sıralama Temelleri"
#: howto/sorting.rst:0
msgid "Author"
msgstr "Yazar"
#: howto/sorting.rst:6
msgid "Andrew Dalke and Raymond Hettinger"
msgstr "Andrew Dalke and Raymond Hettinger"
#: howto/sorting.rst:9
"Python lists have a built-in :meth:`list.sort` method that modifies the list "
"in-place.  There is also a :func:`sorted` built-in function that builds a "
"new sorted list from an iterable."
"Python listeleri, listeyi yerinde değiştiren yerleşik bir :meth:`list.sort` "
"yöntemine sahiptir.  Ayrıca, bir yinelenebilirden yeni bir sıralanmış liste "
"oluşturan bir :func:`sorted` yerleşik işlevi de vardır."
#: howto/sorting.rst:13
"In this document, we explore the various techniques for sorting data using "
"Bu belgede, Python kullanarak verileri sıralamak için çeşitli teknikleri "
"keşfediyor olacağız."
#: howto/sorting.rst:17
msgid "Sorting Basics"
msgstr "Sıralama Temelleri"
#: howto/sorting.rst:19
"A simple ascending sort is very easy: just call the :func:`sorted` function. "
"It returns a new sorted list:"
"Basit bir artan sıralama yaratmak çok kolaydır: :func:`sorted` fonksiyonunu "
"çağırmanız yeterlidir. Bu fonksiyon, yeni bir sıralanmış liste döndürür:"
#: howto/sorting.rst:22
">>> sorted([5, 2, 3, 1, 4])\n"
"[1, 2, 3, 4, 5]"
#: howto/sorting.rst:27
"You can also use the :meth:`list.sort` method. It modifies the list in-place "
"(and returns ``None`` to avoid confusion). Usually it's less convenient "
"than :func:`sorted` - but if you don't need the original list, it's slightly "
"more efficient."
"Ayrıca :meth:`list.sort` yöntemini de kullanabilirsiniz. Listeyi yerinde "
"modifiye eder (ve karışıklığı önlemek için ``None`` döndürür). Genellikle :"
"func:`sorted` yönteminden daha az kullanışlıdır - ancak orijinal listeye "
"ihtiyacınız yoksa, biraz daha verimlidir."
#: howto/sorting.rst:32
">>> a = [5, 2, 3, 1, 4]\n"
">>> a.sort()\n"
"[1, 2, 3, 4, 5]"
#: howto/sorting.rst:39
"Another difference is that the :meth:`list.sort` method is only defined for "
"lists. In contrast, the :func:`sorted` function accepts any iterable."
"Diğer bir fark ise :meth:`list.sort` metodunun sadece listeler için "
"tanımlanmış olmasıdır. Buna karşılık, :func:`sorted` fonksiyonu herhangi bir "
"yinelenebiliri kabul eder."
#: howto/sorting.rst:42
">>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})\n"
"[1, 2, 3, 4, 5]"
#: howto/sorting.rst:48
msgid "Key Functions"
msgstr "Anahtar Fonksiyonları"
#: howto/sorting.rst:50
"Both :meth:`list.sort` and :func:`sorted` have a *key* parameter to specify "
"a function (or other callable) to be called on each list element prior to "
"making comparisons."
"Hem :meth:`list.sort` hem de :func:`sorted`, karşılaştırma yapmadan önce "
"listenin her öğesi üzerinde çağrılacak bir işlevi (veya başka bir "
"çağrılabiliri) özellikle belirtmek için bir *key* parametresine sahiptir."
#: howto/sorting.rst:54
msgid "For example, here's a case-insensitive string comparison:"
"Örneğin, büyük/küçük harfe duyarlı olmayan bir dize karşılaştırması bu "
"şekilde yapılmaktadır:"
#: howto/sorting.rst:56
">>> sorted(\"This is a test string from Andrew\".split(), key=str.casefold)\n"
"['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']"
#: howto/sorting.rst:61
"The value of the *key* parameter should be a function (or other callable) "
"that takes a single argument and returns a key to use for sorting purposes. "
"This technique is fast because the key function is called exactly once for "
"each input record."
"*key* (anahtar) parametresinin değeri, tek bir argüman alan ve sıralama "
"amacıyla kullanılacak bir anahtarı döndürecek bir fonksiyon (veya başka bir "
"çağrılabilir) olmalıdır. Bu teknik, hızlı çalışır çünkü anahtar işlevi her "
"girdi (input) kaydı için tam olarak bir kez çağrılır."
#: howto/sorting.rst:66
"A common pattern is to sort complex objects using some of the object's "
"indices as keys. For example:"
"Yaygın bir model, nesnenin bazı indislerini anahtar olarak kullanarak "
"karmaşık nesneleri sıralamaktır. Örneğin:"
#: howto/sorting.rst:69
">>> student_tuples = [\n"
"...     ('john', 'A', 15),\n"
"...     ('jane', 'B', 12),\n"
"...     ('dave', 'B', 10),\n"
">>> sorted(student_tuples, key=lambda student: student[2])   # sort by age\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
#: howto/sorting.rst:79
"The same technique works for objects with named attributes. For example:"
"Aynı teknik, adlandırılmış niteliklere sahip nesneler için de geçerlidir. "
#: howto/sorting.rst:81
">>> class Student:\n"
"...     def __init__(self, name, grade, age):\n"
"...         self.name = name\n"
"...         self.grade = grade\n"
"...         self.age = age\n"
"...     def __repr__(self):\n"
"...         return repr((self.name, self.grade, self.age))\n"
">>> student_objects = [\n"
"...     Student('john', 'A', 15),\n"
"...     Student('jane', 'B', 12),\n"
"...     Student('dave', 'B', 10),\n"
">>> sorted(student_objects, key=lambda student: student.age)   # sort by "
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
#: howto/sorting.rst:99
"Objects with named attributes can be made by a regular class as shown above, "
"or they can be instances of :class:`~dataclasses.dataclass` or a :term:"
"`named tuple`."
#: howto/sorting.rst:104
msgid "Operator Module Functions and Partial Function Evaluation"
msgstr "Operatör Modülü İşlevleri"
#: howto/sorting.rst:106
"The :term:`key function` patterns shown above are very common, so Python "
"provides convenience functions to make accessor functions easier and faster. "
"The :mod:`operator` module has :func:`~operator.itemgetter`, :func:"
"`~operator.attrgetter`, and a :func:`~operator.methodcaller` function."
"Yukarıda gösterilen anahtar-fonksiyon kalıpları çok yaygındır. Bu nedenle "
"Python, erişim fonksiyonlarını daha kolay ve hızlı hale getirmek için bazı "
"kolaylık fonksiyonları sağlar. :mod:`operator` modülü :func:`~operator."
"itemgetter`, :func:`~operator.attrgetter` ve bir :func:`~operator."
"methodcaller` fonksiyonuna sahiptir."
#: howto/sorting.rst:111
msgid "Using those functions, the above examples become simpler and faster:"
"Bu fonksiyonların kullanımı sonucunda, yukarıdaki örnekler daha basit ve "
"hızlı hale gelir:"
#: howto/sorting.rst:113
">>> from operator import itemgetter, attrgetter\n"
">>> sorted(student_tuples, key=itemgetter(2))\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]\n"
">>> sorted(student_objects, key=attrgetter('age'))\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
#: howto/sorting.rst:123
"The operator module functions allow multiple levels of sorting. For example, "
"to sort by *grade* then by *age*:"
"Operatör modülü fonksiyonları birden fazla seviyede sıralama yapılmasına "
"izin verir. Örneğin, *sınıf* ve ardından *yaş*'a göre sıralamak için:"
#: howto/sorting.rst:126
">>> sorted(student_tuples, key=itemgetter(1,2))\n"
"[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]\n"
">>> sorted(student_objects, key=attrgetter('grade', 'age'))\n"
"[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]"
#: howto/sorting.rst:134
"The :mod:`functools` module provides another helpful tool for making key-"
"functions.  The :func:`~functools.partial` function can reduce the `arity "
"<https://en.wikipedia.org/wiki/Arity>`_ of a multi-argument function making "
"it suitable for use as a key-function."
#: howto/sorting.rst:139
">>> from functools import partial\n"
">>> from unicodedata import normalize\n"
">>> names = 'Zoë Åbjørn Núñez Élana Zeke Abe Nubia Eloise'.split()\n"
">>> sorted(names, key=partial(normalize, 'NFD'))\n"
"['Abe', 'Åbjørn', 'Eloise', 'Élana', 'Nubia', 'Núñez', 'Zeke', 'Zoë']\n"
">>> sorted(names, key=partial(normalize, 'NFC'))\n"
"['Abe', 'Eloise', 'Nubia', 'Núñez', 'Zeke', 'Zoë', 'Åbjørn', 'Élana']"
#: howto/sorting.rst:153
msgid "Ascending and Descending"
msgstr "Yükselen ve Alçalan"
#: howto/sorting.rst:155
"Both :meth:`list.sort` and :func:`sorted` accept a *reverse* parameter with "
"a boolean value. This is used to flag descending sorts. For example, to get "
"the student data in reverse *age* order:"
"Hem :meth:`list.sort` hem de :func:`sorted` boolean değerli bir *reverse* "
"parametresi kabul eder. Bu, azalan sıralamaları işaretlemek için kullanılır. "
"Örneğin, öğrenci verilerini ters olarak *yaş* sırasına göre elde etmek için:"
#: howto/sorting.rst:159
">>> sorted(student_tuples, key=itemgetter(2), reverse=True)\n"
"[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]\n"
">>> sorted(student_objects, key=attrgetter('age'), reverse=True)\n"
"[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]"
#: howto/sorting.rst:168
msgid "Sort Stability and Complex Sorts"
msgstr "Sıralama Kararlılığı ve Karmaşık Sıralamalar"
#: howto/sorting.rst:170
"Sorts are guaranteed to be `stable <https://en.wikipedia.org/wiki/"
"Sorting_algorithm#Stability>`_\\. That means that when multiple records have "
"the same key, their original order is preserved."
"Sıralamaların `kararlı <https://en.wikipedia.org/wiki/"
"Sorting_algorithm#Stability>`_\\ olması kesindir. Bunun anlamı ise, birden "
"fazla kayıt aynı anahtara sahip olduğunda, orijinal sıralamanın "
"korunacağıdır."
#: howto/sorting.rst:174
">>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]\n"
">>> sorted(data, key=itemgetter(0))\n"
"[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]"
#: howto/sorting.rst:180
"Notice how the two records for *blue* retain their original order so that "
"``('blue', 1)`` is guaranteed to precede ``('blue', 2)``."
"*blue* için iki kaydın orijinal sıralarını nasıl koruduğuna dikkat edin, "
"böylece ``('blue', 1)`` kaydının ``('blue', 2)`` kaydından önce gelmesi "
"garanti edilir."
#: howto/sorting.rst:183
"This wonderful property lets you build complex sorts in a series of sorting "
"steps. For example, to sort the student data by descending *grade* and then "
"ascending *age*, do the *age* sort first and then sort again using *grade*:"
"Bu harika özellik, birkaç sıralama adımı sonucunda karmaşık sıralamalar "
"oluşturmanıza olanak tanır. Örneğin, öğrenci verilerini azalan *sınıf* ve "
"ardından artan *yaş* ile sıralamak için, önce *yaş* sıralamasını yapın ve "
"ardından *sınıf* kullanarak tekrar sıralayın:"
#: howto/sorting.rst:187
">>> s = sorted(student_objects, key=attrgetter('age'))     # sort on "
"secondary key\n"
">>> sorted(s, key=attrgetter('grade'), reverse=True)       # now sort on "
"primary key, descending\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
#: howto/sorting.rst:193
"This can be abstracted out into a wrapper function that can take a list and "
"tuples of field and order to sort them on multiple passes."
"Bu, bir listeyi ve alan çiftlerini alıp bunları birden fazla geçişte "
"sıralayabilen bir sarmalayıcı fonksiyon oluşturacak şekilde soyutlanabilir."
#: howto/sorting.rst:196
">>> def multisort(xs, specs):\n"
"...     for key, reverse in reversed(specs):\n"
"...         xs.sort(key=attrgetter(key), reverse=reverse)\n"
"...     return xs\n"
">>> multisort(list(student_objects), (('grade', True), ('age', False)))\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
#: howto/sorting.rst:206
"The `Timsort <https://en.wikipedia.org/wiki/Timsort>`_ algorithm used in "
"Python does multiple sorts efficiently because it can take advantage of any "
"ordering already present in a dataset."
"Python'da kullanılan `Timsort <https://en.wikipedia.org/wiki/Timsort>`_ "
"algoritması, bir veri kümesinde zaten mevcut olan herhangi bir sıralamadan "
"yararlanabildiği için çoklu sıralamayı verimli bir şekilde yapar."
#: howto/sorting.rst:211
msgid "Decorate-Sort-Undecorate"
msgstr "Süsle-Sırala-Boz"
#: howto/sorting.rst:213
msgid "This idiom is called Decorate-Sort-Undecorate after its three steps:"
"Süsle-Sırala-Boz deyimi, içerdiği üç adımdan ilham alınarak oluşturulmuştur:"
#: howto/sorting.rst:215
"First, the initial list is decorated with new values that control the sort "
"İlk olarak, ilk liste sıralama düzenini kontrol eden yeni değerlerle "
"süslenir (dekore edilir)."
#: howto/sorting.rst:217
msgid "Second, the decorated list is sorted."
msgstr "İkinci olarak, dekore edilmiş liste sıralanır."
#: howto/sorting.rst:219
"Finally, the decorations are removed, creating a list that contains only the "
"initial values in the new order."
"Son olarak, süslemeler kaldırılır ve yeni sırada yalnızca ilk değerleri "
"içeren bir liste oluşturulur."
#: howto/sorting.rst:222
"For example, to sort the student data by *grade* using the DSU approach:"
"Örneğin, DSU yaklaşımını kullanarak öğrenci verilerini *sınıf* bazında "
"sıralamak için:"
#: howto/sorting.rst:224
">>> decorated = [(student.grade, i, student) for i, student in "
"enumerate(student_objects)]\n"
">>> decorated.sort()\n"
">>> [student for grade, i, student in decorated]               # undecorate\n"
"[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]"
#: howto/sorting.rst:231
"This idiom works because tuples are compared lexicographically; the first "
"items are compared; if they are the same then the second items are compared, "
"and so on."
"Bu deyim, veri çiftleri leksikografik (sözlükbilimsel) olarak "
"karşılaştırıldığı için işe yarar: İlk öğeler karşılaştırılır, aynılarsa "
"ikinci öğeler karşılaştırılır ve bu böyle devam eder."
#: howto/sorting.rst:235
"It is not strictly necessary in all cases to include the index *i* in the "
"decorated list, but including it gives two benefits:"
"*i* indeksini dekore edilmiş listeye dahil etmek her durumda gerekli "
"değildir, ancak dahil etmek iki fayda sağlar:"
#: howto/sorting.rst:238
"The sort is stable -- if two items have the same key, their order will be "
"preserved in the sorted list."
"Sıralama sabittir -- iki öğe aynı anahtara sahipse, sıralanmış listede "
"sıraları korunacaktır."
#: howto/sorting.rst:241
"The original items do not have to be comparable because the ordering of the "
"decorated tuples will be determined by at most the first two items. So for "
"example the original list could contain complex numbers which cannot be "
"sorted directly."
"Orijinal öğelerin karşılaştırılabilir olması gerekmez çünkü dekore edilmiş "
"çiftlerin sıralaması en fazla ilk iki öğe tarafından belirlenecektir. "
"Örneğin orijinal liste doğrudan sıralanamayan karmaşık sayılar içerebilir."
#: howto/sorting.rst:246
"Another name for this idiom is `Schwartzian transform <https://en.wikipedia."
"org/wiki/Schwartzian_transform>`_\\, after Randal L. Schwartz, who "
"popularized it among Perl programmers."
"Bu deyimin bir diğer adı da, deyimi Perl programcıları arasında popüler hale "
"getiren Randal L. Schwartz'a atfen `Schwartzian transform <https://en."
"wikipedia.org/wiki/Schwartzian_transform>`_\\'dur."
#: howto/sorting.rst:250
"Now that Python sorting provides key-functions, this technique is not often "
"Artık Python sıralama anahtar fonksiyonları sağladığından, bu tekniğe pek "
"sık ihtiyaç duyulmamaktadır."
#: howto/sorting.rst:253
msgid "Comparison Functions"
msgstr "Karşılaştırma Fonksiyonları"
#: howto/sorting.rst:255
"Unlike key functions that return an absolute value for sorting, a comparison "
"function computes the relative ordering for two inputs."
"Sıralama için mutlak bir değer döndüren anahtar işlevlerinin aksine, "
"karşılaştırma işlevi iki girdi için göreceli bir sıralamayı hesaplar."
#: howto/sorting.rst:258
"For example, a `balance scale <https://upload.wikimedia.org/wikipedia/"
"commons/1/17/Balance_à_tabac_1850.JPG>`_ compares two samples giving a "
"relative ordering: lighter, equal, or heavier. Likewise, a comparison "
"function such as ``cmp(a, b)`` will return a negative value for less-than, "
"zero if the inputs are equal, or a positive value for greater-than."
"Örneğin, bir `balance scale <https://upload.wikimedia.org/wikipedia/"
"commons/1/17/Balance_à_tabac_1850.JPG>`_ iki örneği karşılaştırarak göreceli "
"bir sıralama verir: daha hafif, eşit veya daha ağır. Benzer şekilde, "
"``cmp(a, b)`` karşılaştırma fonksiyonu; girdiler eşitse sıfır, küçükse "
"negatif, büyükse pozitif bir değer döndürür."
#: howto/sorting.rst:265
"It is common to encounter comparison functions when translating algorithms "
"from other languages.  Also, some libraries provide comparison functions as "
"part of their API.  For example, :func:`locale.strcoll` is a comparison "
"function."
"Algoritmaları diğer dillerden çevirirken karşılaştırma fonksiyonlarıyla "
"karşılaşmak yaygındır.  Ayrıca, bazı kütüphaneler API'lerinin bir parçası "
"olarak karşılaştırma fonksiyonları sağlar.  Örneğin, :func:`locale.strcoll` "
"bir karşılaştırma fonksiyonudur."
#: howto/sorting.rst:269
"To accommodate those situations, Python provides :class:`functools."
"cmp_to_key` to wrap the comparison function to make it usable as a key "
"function::"
"Bu durumlara uyum sağlamak için Python, karşılaştırma fonksiyonunu bir "
"anahtar fonksiyon olarak kullanılabilir hale getirmek için :class:`functools."
"cmp_to_key` aracını sağlar::"
#: howto/sorting.rst:273
msgid "sorted(words, key=cmp_to_key(strcoll))  # locale-aware sort order"
#: howto/sorting.rst:276
msgid "Odds and Ends"
msgstr "Tuhaflıklar ve Sonlar"
#: howto/sorting.rst:278
"For locale aware sorting, use :func:`locale.strxfrm` for a key function or :"
"func:`locale.strcoll` for a comparison function.  This is necessary because "
"\"alphabetical\" sort orderings can vary across cultures even if the "
"underlying alphabet is the same."
"Yerel ayarlara duyarlı sıralama yapmak istiyorsanız, anahtar işlevleri için :"
"func:`locale.strxfrm` ve karşılaştırma işlevleri için :func:`locale.strcoll` "
"kullanabilirsiniz. Bu gereklidir çünkü \"alfabetik\" sıralamalar, temel "
"alfabe aynı olsa bile kültürler arasında farklılık gösterebilir."
#: howto/sorting.rst:283
"The *reverse* parameter still maintains sort stability (so that records with "
"equal keys retain the original order). Interestingly, that effect can be "
"simulated without the parameter by using the builtin :func:`reversed` "
"function twice:"
"*reverse* parametresi sıralamalardaki kararlığı aynı şekilde korur (böylece "
"eşit anahtarlara sahip kayıtlar orijinal sırasını korumuş olur). İlginç bir "
"şekilde bu etki, parametre olmadan yerleşik :func:`reversed` fonksiyonu iki "
"kez kullanılarak da simüle edilebilir:"
#: howto/sorting.rst:288
">>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]\n"
">>> standard_way = sorted(data, key=itemgetter(0), reverse=True)\n"
">>> double_reversed = list(reversed(sorted(reversed(data), "
"key=itemgetter(0))))\n"
">>> assert standard_way == double_reversed\n"
">>> standard_way\n"
"[('red', 1), ('red', 2), ('blue', 1), ('blue', 2)]"
#: howto/sorting.rst:297
"The sort routines use ``<`` when making comparisons between two objects. So, "
"it is easy to add a standard sort order to a class by defining an :meth:"
"`~object.__lt__` method:"
"Sıralama rutinleri, iki nesne arasında karşılaştırma yaparken ``<`` "
"kullanır. Bu nedenle, bir :meth:`__lt__` yöntemi tanımlayarak, bir sınıfa "
"standart bir sıralama düzeni eklemek kolaydır:"
#: howto/sorting.rst:301
">>> Student.__lt__ = lambda self, other: self.age < other.age\n"
">>> sorted(student_objects)\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
#: howto/sorting.rst:307
"However, note that ``<`` can fall back to using :meth:`~object.__gt__` if :"
"meth:`~object.__lt__` is not implemented (see :func:`object.__lt__` for "
"details on the mechanics).  To avoid surprises, :pep:`8` recommends that all "
"six comparison methods be implemented. The :func:`~functools.total_ordering` "
"decorator is provided to make that task easier."
#: howto/sorting.rst:314
"Key functions need not depend directly on the objects being sorted. A key "
"function can also access external resources. For instance, if the student "
"grades are stored in a dictionary, they can be used to sort a separate list "
"of student names:"
"Anahtar işlevlerinin doğrudan sıralanan nesnelere bağlı olması gerekmez. Bir "
"anahtar işlevi, harici kaynaklara da erişebilir. Örneğin, öğrenci notları "
"bir sözlükte saklanıyorsa, öğrenci adlarından oluşan ayrı bir listenin "
"sıralanmasında da kullanılabilirler:"
#: howto/sorting.rst:319
">>> students = ['dave', 'john', 'jane']\n"
">>> newgrades = {'john': 'F', 'jane':'A', 'dave': 'C'}\n"
">>> sorted(students, key=newgrades.__getitem__)\n"
"['jane', 'dave', 'john']"
#: howto/sorting.rst:327
msgid "Partial Sorts"
#: howto/sorting.rst:329
"Some applications require only some of the data to be ordered.  The standard "
"library provides several tools that do less work than a full sort:"
#: howto/sorting.rst:332
":func:`min` and :func:`max` return the smallest and largest values, "
"respectively.  These functions make a single pass over the input data and "
"require almost no auxiliary memory."
#: howto/sorting.rst:336
":func:`heapq.nsmallest` and :func:`heapq.nlargest` return the *n* smallest "
"and largest values, respectively.  These functions make a single pass over "
"the data keeping only *n* elements in memory at a time.  For values of *n* "
"that are small relative to the number of inputs, these functions make far "
"fewer comparisons than a full sort."
#: howto/sorting.rst:342
":func:`heapq.heappush` and :func:`heapq.heappop` create and maintain a "
"partially sorted arrangement of data that keeps the smallest element at "
"position ``0``.  These functions are suitable for implementing priority "
"queues which are commonly used for task scheduling."
#~ msgid "Sorting HOW TO"
#~ msgstr "Sıralama NASIL YAPILIR"
#~ msgid "Release"
#~ msgstr "Yayın Versiyonu"
#~ msgid "0.1"
#~ msgstr "0.1"
#~ msgid ""
#~ "However, note that ``<`` can fall back to using :meth:`~object.__gt__` "
#~ "if :meth:`~object.__lt__` is not implemented (see :func:`object.__lt__`)."
#~ msgstr ""
#~ "Ancak, :meth:`__lt__` uygulanmamışsa, ``<``'ın :meth:`__gt__` kullanımına "
#~ "geri dönebileceğini unutmayın (bkz. :func:`object.__lt__`)."
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

FilesExpand file tree

sorting.po

Latest commit

History

sorting.po

File metadata and controls
