python-docs-uk/howto/sorting.po at 3.8 · python/python-docs-uk

543 lines (468 loc) · 22.9 KB
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# Translators:
# Dmytro Kazanzhy, 2023
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-04-11 14:19+0000\n"
"PO-Revision-Date: 2021-06-28 00:53+0000\n"
"Last-Translator: Dmytro Kazanzhy, 2023\n"
"Language-Team: Ukrainian (https://app.transifex.com/python-doc/teams/5390/"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: uk\n"
"Plural-Forms: nplurals=4; plural=(n % 1 == 0 && n % 10 == 1 && n % 100 != "
"11 ? 0 : n % 1 == 0 && n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 12 || n % "
"100 > 14) ? 1 : n % 1 == 0 && (n % 10 ==0 || (n % 10 >=5 && n % 10 <=9) || "
"(n % 100 >=11 && n % 100 <=14 )) ? 2: 3);\n"
msgid "Sorting Techniques"
msgid "Author"
msgstr "Автор"
msgid "Andrew Dalke and Raymond Hettinger"
msgstr "Andrew Dalke та Raymond Hettinger"
"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 мають вбудований метод :meth:`list.sort`, який змінює список "
"на місці. Існує також вбудована функція :func:`sorted`, яка створює новий "
"відсортований список із ітерованого."
"In this document, we explore the various techniques for sorting data using "
"У цьому документі ми досліджуємо різні техніки сортування даних за допомогою "
msgid "Sorting Basics"
msgstr "Основи сортування"
"A simple ascending sort is very easy: just call the :func:`sorted` function. "
"It returns a new sorted list:"
"Просте сортування за зростанням дуже просте: просто викличте функцію :func:"
"`sorted`. Він повертає новий відсортований список:"
">>> sorted([5, 2, 3, 1, 4])\n"
"[1, 2, 3, 4, 5]"
"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."
"Ви також можете використовувати метод :meth:`list.sort`. Він змінює список "
"на місці (і повертає ``None``, щоб уникнути плутанини). Зазвичай це менш "
"зручно, ніж :func:`sorted`, але якщо вам не потрібен оригінальний список, це "
"трохи ефективніше."
">>> a = [5, 2, 3, 1, 4]\n"
">>> a.sort()\n"
"[1, 2, 3, 4, 5]"
"Another difference is that the :meth:`list.sort` method is only defined for "
"lists. In contrast, the :func:`sorted` function accepts any iterable."
"Ще одна відмінність полягає в тому, що метод :meth:`list.sort` визначено "
"лише для списків. На відміну від цього, функція :func:`sorted` приймає будь-"
"яку ітерацію."
">>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})\n"
"[1, 2, 3, 4, 5]"
msgid "Key Functions"
msgstr "Ключові функції"
"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."
"І :meth:`list.sort`, і :func:`sorted` мають параметр *key* для вказівки "
"функції (або іншого виклику), яка буде викликана для кожного елемента списку "
"перед проведенням порівнянь."
msgid "For example, here's a case-insensitive string comparison:"
msgstr "Наприклад, ось порівняння рядків без урахування регістру:"
">>> sorted(\"This is a test string from Andrew\".split(), key=str.casefold)\n"
"['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']"
"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* має бути функцією (або іншою можливістю виклику), "
"яка приймає один аргумент і повертає ключ для використання в цілях "
"сортування. Ця техніка є швидкою, оскільки ключова функція викликається "
"рівно один раз для кожного вхідного запису."
"A common pattern is to sort complex objects using some of the object's "
"indices as keys. For example:"
"Загальним шаблоном є сортування складних об’єктів за допомогою деяких "
"індексів об’єктів як ключів. Наприклад:"
">>> 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)]"
"The same technique works for objects with named attributes. For example:"
"Така ж техніка працює для об’єктів з іменованими атрибутами. Наприклад:"
">>> 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)]"
"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`."
msgid "Operator Module Functions and Partial Function Evaluation"
"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."
msgid "Using those functions, the above examples become simpler and faster:"
"Використовуючи ці функції, наведені вище приклади стають простішими та "
"швидшими:"
">>> 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)]"
"The operator module functions allow multiple levels of sorting. For example, "
"to sort by *grade* then by *age*:"
"Функції модуля оператора дозволяють сортувати кілька рівнів. Наприклад, щоб "
"відсортувати за *класом*, а потім за *віком*:"
">>> 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)]"
"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."
">>> 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']"
msgid "Ascending and Descending"
msgstr "Висхідний і спадний"
"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:"
"І :meth:`list.sort`, і :func:`sorted` приймають параметр *reverse* із "
"логічним значенням. Це використовується для позначення сортування за "
"спаданням. Наприклад, щоб отримати дані про студентів у зворотному порядку "
">>> 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)]"
msgid "Sort Stability and Complex Sorts"
msgstr "Стійкість сортування та складні сорти"
"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."
"Сортування гарантовано буде `стабільним <https://en.wikipedia.org/wiki/"
"Sorting_algorithm#Stability>`_\\. Це означає, що коли кілька записів мають "
"однаковий ключ, їхній початковий порядок зберігається."
">>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]\n"
">>> sorted(data, key=itemgetter(0))\n"
"[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]"
"Notice how the two records for *blue* retain their original order so that "
"``('blue', 1)`` is guaranteed to precede ``('blue', 2)``."
"Зверніть увагу, як два записи для *blue* зберігають свій початковий порядок, "
"тому ``('blue', 1)`` гарантовано передує ``('blue', 2)``."
"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*:"
"Ця чудова властивість дозволяє вам створювати складні сорти за допомогою "
"серії кроків сортування. Наприклад, щоб відсортувати дані студента за "
"зменшенням *оцінки*, а потім за зростанням *віку*, спочатку виконайте "
"сортування за *віком*, а потім знову за допомогою *оцінки*:"
">>> 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)]"
"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."
"Це можна абстрагувати у функцію-обгортку, яка може брати список і кортежі "
"полів і впорядковувати їх, щоб сортувати їх за кілька проходів."
">>> 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)]"
"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."
"Алгоритм `Timsort <https://en.wikipedia.org/wiki/Timsort>`_, що "
"використовується в Python, ефективно виконує багаторазове сортування, "
"оскільки він може використовувати будь-яке впорядкування, яке вже є в наборі "
msgid "Decorate-Sort-Undecorate"
msgid "This idiom is called Decorate-Sort-Undecorate after its three steps:"
msgstr "Ця ідіома називається Decorate-Sort-Undecorate після трьох кроків:"
"First, the initial list is decorated with new values that control the sort "
"По-перше, початковий список прикрашається новими значеннями, які контролюють "
"порядок сортування."
msgid "Second, the decorated list is sorted."
msgstr "По-друге, оформлений список сортується."
"Finally, the decorations are removed, creating a list that contains only the "
"initial values in the new order."
"Нарешті, декорації видаляються, створюючи список, який містить лише "
"початкові значення в новому порядку."
"For example, to sort the student data by *grade* using the DSU approach:"
"Наприклад, щоб відсортувати дані студента за *класом* за допомогою підходу "
">>> 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)]"
"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."
"Ця ідіома працює, тому що кортежі порівнюються лексикографічно; порівнюються "
"перші предмети; якщо вони однакові, то порівнюються другі елементи і так "
"It is not strictly necessary in all cases to include the index *i* in the "
"decorated list, but including it gives two benefits:"
"Не обов’язково в усіх випадках включати індекс *i* в оформлений список, але "
"це дає дві переваги:"
"The sort is stable -- if two items have the same key, their order will be "
"preserved in the sorted list."
"Сортування є стабільним — якщо два елементи мають однаковий ключ, їхній "
"порядок буде збережено у відсортованому списку."
"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."
"Оригінальні елементи не обов’язково мають бути порівнянними, тому що порядок "
"оформлених кортежів визначатиметься щонайбільше першими двома елементами. "
"Так, наприклад, вихідний список може містити комплексні числа, які неможливо "
"відсортувати безпосередньо."
"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."
"Інша назва цієї ідіоми — `перетворення Шварца <https://en.wikipedia.org/wiki/"
"Schwartzian_transform>`_\\, на честь Рендала Л. Шварца, який популяризував "
"її серед програмістів на Perl."
"Now that Python sorting provides key-functions, this technique is not often "
"Тепер, коли сортування Python надає ключові функції, ця техніка не часто "
"потрібна."
msgid "Comparison Functions"
"Unlike key functions that return an absolute value for sorting, a comparison "
"function computes the relative ordering for two inputs."
"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."
"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."
"To accommodate those situations, Python provides :class:`functools."
"cmp_to_key` to wrap the comparison function to make it usable as a key "
"function::"
msgid "sorted(words, key=cmp_to_key(strcoll))  # locale-aware sort order"
msgid "Odds and Ends"
msgstr "Обривки"
"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."
"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* усе ще підтримує стабільність сортування (щоб записи з "
"однаковими ключами зберігали вихідний порядок). Цікаво, що цей ефект можна "
"моделювати без параметра, використовуючи двічі вбудовану функцію :func:"
"`reversed`:"
">>> 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)]"
"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:"
">>> Student.__lt__ = lambda self, other: self.age < other.age\n"
">>> sorted(student_objects)\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
"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."
"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:"
"Ключові функції не повинні безпосередньо залежати від об’єктів, які "
"сортуються. Ключова функція також може отримувати доступ до зовнішніх "
"ресурсів. Наприклад, якщо оцінки студентів зберігаються в словнику, їх можна "
"використовувати для сортування окремого списку імен студентів:"
">>> students = ['dave', 'john', 'jane']\n"
">>> newgrades = {'john': 'F', 'jane':'A', 'dave': 'C'}\n"
">>> sorted(students, key=newgrades.__getitem__)\n"
"['jane', 'dave', 'john']"
msgid "Partial Sorts"
"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:"
":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."
":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."
":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."
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
