# 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, 2022

# Ivan Prytula, 2023

#

#, fuzzy

msgid ""

msgstr ""

"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 01:50+0000\n"

"Last-Translator: Ivan Prytula, 2023\n"

"Language-Team: Ukrainian (https://app.transifex.com/python-doc/teams/5390/"

"uk/)\n"

"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 "Data Structures"

msgstr "Структури даних"

msgid ""

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

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

msgstr ""

"У цьому розділі більш детально описано деякі речі, про які ви вже вивчили, а "

"також додано деякі нові речі."

msgid "More on Lists"

msgstr "Більше про списки"

msgid ""

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

"list objects:"

msgstr ""

"Тип даних список має ще кілька методів. Ось усі методи об’єктів типу список:"

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

msgstr ""

msgid ""

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

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

msgstr ""

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 ""

"Вставте елемент у задану позицію. Перший аргумент — це індекс елемента, "

"перед яким потрібно вставити, тому ``a.insert(0, x)`` вставляє на початку "

"списку, а ``a.insert(len(a), x)`` еквівалентно ``a.append(x)``."

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 ""

"Видаліть зі списку перший елемент, значення якого дорівнює *x*. Це викликає :"

"exc:`ValueError`, якщо такого елемента немає."

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. It raises an :exc:`IndexError` if the list is empty or the index is "

"outside the list range."

msgstr ""

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

msgstr ""

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 ""

"Повертає індекс від нуля в списку першого елемента, значення якого дорівнює "

"*x*. Викликає :exc:`ValueError`, якщо такого елемента немає."

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 ""

"Необов’язкові аргументи *start* і *end* інтерпретуються так само, як і в "

"нотації фрагментів, і використовуються для обмеження пошуку певною "

"підпослідовністю списку. Повернений індекс обчислюється відносно початку "

"повної послідовності, а не аргументу *start*."

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

msgstr "Повертає кількість разів *x* у списку."

msgid ""

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

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

msgstr ""

"Відсортуйте елементи списку за місцем (аргументи можна використовувати для "

"налаштування сортування, див. :func:`sorted` для їх пояснення)."

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

msgstr "Переверніть елементи списку на місці."

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

msgstr ""

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

msgstr "Приклад, який використовує більшість методів списку::"

msgid ""

">>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', "

"'banana']\n"

">>> fruits.count('apple')\n"

"2\n"

">>> fruits.count('tangerine')\n"

"0\n"

">>> fruits.index('banana')\n"

"3\n"

">>> fruits.index('banana', 4) # Find next banana starting at position 4\n"

"6\n"

">>> fruits.reverse()\n"

">>> fruits\n"

"['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']\n"

">>> fruits.append('grape')\n"

">>> fruits\n"

"['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']\n"

">>> fruits.sort()\n"

">>> fruits\n"

"['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']\n"

">>> fruits.pop()\n"

"'pear'"

msgstr ""

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 ""

"Ви могли помітити, що методи ``insert``, ``remove`` або ``sort``, які лише "

"модифікують список, не мають значення повернення - вони повертають значення "

"за замовчуванням ``None``. [#]_ Це принцип проектування всіх змінюваних "

"структур даних у Python."

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 ""

msgid "Using Lists as Stacks"

msgstr "Використання списків як стеків"

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:`!append`. To retrieve an "

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

"For example::"

msgstr ""

msgid ""

">>> stack = [3, 4, 5]\n"

">>> stack.append(6)\n"

">>> stack.append(7)\n"

">>> stack\n"

"[3, 4, 5, 6, 7]\n"

">>> stack.pop()\n"

"7\n"

">>> stack\n"

"[3, 4, 5, 6]\n"

">>> stack.pop()\n"

"6\n"

">>> stack.pop()\n"

"5\n"

">>> stack\n"

"[3, 4]"

msgstr ""

msgid "Using Lists as Queues"

msgstr "Використання списків як черг"

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 ""

"Також можна використовувати список як чергу, де перший доданий елемент є "

"першим отриманим елементом (\"першим увійшов, першим вийшов\"); однак списки "

"не ефективні для цієї мети. У той час як додавання та висування з кінця "

"списку є швидкими, виконання вставок або висунення з початку списку "

"відбувається повільно (оскільки всі інші елементи мають бути зміщені на "

"одиницю)."

msgid ""

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

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

msgstr ""

"Щоб реалізувати чергу, використовуйте :class:`collections.deque`, який був "

"розроблений для швидкого додавання та висування з обох кінців. Наприклад::"

msgid ""

">>> from collections import deque\n"

">>> queue = deque([\"Eric\", \"John\", \"Michael\"])\n"

">>> queue.append(\"Terry\") # Terry arrives\n"

">>> queue.append(\"Graham\") # Graham arrives\n"

">>> queue.popleft() # The first to arrive now leaves\n"

"'Eric'\n"

">>> queue.popleft() # The second to arrive now leaves\n"

"'John'\n"

">>> queue # Remaining queue in order of arrival\n"

"deque(['Michael', 'Terry', 'Graham'])"

msgstr ""

msgid "List Comprehensions"

msgstr "Розуміння списку"

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 ""

"Розуміння списків забезпечує стислий спосіб створення списків. Загальні "

"застосування полягають у створенні нових списків, де кожен елемент є "

"результатом деяких операцій, застосованих до кожного члена іншої "

"послідовності або ітерації, або створення підпослідовності тих елементів, "

"які задовольняють певну умову."

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

msgstr ""

"Наприклад, припустимо, що ми хочемо створити список квадратів, наприклад:"

msgid ""

">>> squares = []\n"

">>> for x in range(10):\n"

"... squares.append(x**2)\n"

"...\n"

">>> squares\n"

"[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"

msgstr ""

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 ""

"Зауважте, що це створює (або перезаписує) змінну з назвою ``x``, яка все ще "

"існує після завершення циклу. Ми можемо обчислити список квадратів без "

"побічних ефектів за допомогою:"

msgid "squares = list(map(lambda x: x**2, range(10)))"

msgstr ""

msgid "or, equivalently::"

msgstr "або, що еквівалентно::"

msgid "squares = [x**2 for x in range(10)]"

msgstr ""

msgid "which is more concise and readable."

msgstr "який більш стислий і читабельний."

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 ""

"Розуміння списку складається з дужок, які містять вираз, після якого йде "

"речення :keyword:`!for`, потім нуль або більше речень :keyword:`!for` або :"

"keyword:`!if`. Результатом буде новий список, отриманий в результаті "

"обчислення виразу в контексті речень :keyword:`!for` і :keyword:`!if`, які "

"слідують за ним. Наприклад, цей listcomp поєднує елементи двох списків, якщо "

"вони не рівні:"

msgid ""

">>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]\n"

"[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]"

msgstr ""

msgid "and it's equivalent to::"

msgstr "і це еквівалентно::"

msgid ""

">>> combs = []\n"

">>> for x in [1,2,3]:\n"

"... for y in [3,1,4]:\n"

"... if x != y:\n"

"... combs.append((x, y))\n"

"...\n"

">>> combs\n"

"[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]"

msgstr ""

msgid ""

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

"same in both these snippets."

msgstr ""

"Зверніть увагу, що порядок операторів :keyword:`for` і :keyword:`if` "

"однаковий в обох цих фрагментах."

msgid ""

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

"it must be parenthesized. ::"

msgstr ""

"Якщо вираз є кортежем (наприклад, ``(x, y)`` у попередньому прикладі), його "

"потрібно взяти в дужки. ::"

msgid ""

">>> vec = [-4, -2, 0, 2, 4]\n"

">>> # create a new list with the values doubled\n"

">>> [x*2 for x in vec]\n"

"[-8, -4, 0, 4, 8]\n"

">>> # filter the list to exclude negative numbers\n"

">>> [x for x in vec if x >= 0]\n"

"[0, 2, 4]\n"

">>> # apply a function to all the elements\n"

">>> [abs(x) for x in vec]\n"

"[4, 2, 0, 2, 4]\n"

">>> # call a method on each element\n"

">>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']\n"

">>> [weapon.strip() for weapon in freshfruit]\n"

"['banana', 'loganberry', 'passion fruit']\n"

">>> # create a list of 2-tuples like (number, square)\n"

">>> [(x, x**2) for x in range(6)]\n"

"[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]\n"

">>> # the tuple must be parenthesized, otherwise an error is raised\n"

">>> [x, x**2 for x in range(6)]\n"

" File \"<stdin>\", line 1\n"

" [x, x**2 for x in range(6)]\n"

" ^^^^^^^\n"

"SyntaxError: did you forget parentheses around the comprehension target?\n"

">>> # flatten a list using a listcomp with two 'for'\n"

">>> vec = [[1,2,3], [4,5,6], [7,8,9]]\n"

">>> [num for elem in vec for num in elem]\n"

"[1, 2, 3, 4, 5, 6, 7, 8, 9]"

msgstr ""

msgid ""

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

msgstr "Розуміння списків може містити складні вирази та вкладені функції:"

msgid ""

">>> from math import pi\n"

">>> [str(round(pi, i)) for i in range(1, 6)]\n"

"['3.1', '3.14', '3.142', '3.1416', '3.14159']"

msgstr ""

msgid "Nested List Comprehensions"

msgstr "Розуміння вкладених списків"

msgid ""

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

"expression, including another list comprehension."

msgstr ""

"Початковим виразом у розуміння списку може бути будь-який довільний вираз, "

"включаючи інший розуміння списку."

msgid ""

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

"lists of length 4::"

msgstr ""

"Розглянемо наступний приклад матриці 3x4, реалізованої як список із 3 "

"списків довжини 4::"

msgid ""

">>> matrix = [\n"

"... [1, 2, 3, 4],\n"

"... [5, 6, 7, 8],\n"

"... [9, 10, 11, 12],\n"

"... ]"

msgstr ""

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

msgstr "Наступне включення списку транспонує рядки та стовпці:"

msgid ""

">>> [[row[i] for row in matrix] for i in range(4)]\n"

"[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]"

msgstr ""

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 ""

"Як ми побачили у попередньому розділі, внутрішнє включення списку оцінюється "

"в контексті :keyword:`for`, який слідує за ним, тому цей приклад "

"еквівалентний::"

msgid ""

">>> transposed = []\n"

">>> for i in range(4):\n"

"... transposed.append([row[i] for row in matrix])\n"

"...\n"

">>> transposed\n"

"[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]"

msgstr ""

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

msgstr "що, у свою чергу, те саме, що::"

msgid ""

">>> transposed = []\n"

">>> for i in range(4):\n"

"... # the following 3 lines implement the nested listcomp\n"

"... transposed_row = []\n"

"... for row in matrix:\n"

"... transposed_row.append(row[i])\n"

"... transposed.append(transposed_row)\n"

"...\n"

">>> transposed\n"

"[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]"

msgstr ""

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 ""

"У реальному світі вам слід віддавати перевагу вбудованим функціям перед "

"складними операторами потоку. Функція :func:`zip` чудово впорається з цим "

"випадком використання::"

msgid ""

">>> list(zip(*matrix))\n"

"[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]"

msgstr ""

msgid ""

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

msgstr ""

"Перегляньте :ref:`tut-unpacking-arguments`, щоб дізнатися більше про зірочку "

"в цьому рядку."

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

msgstr "Оператор :keyword:`!del`"

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:`!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 ""

msgid ""

">>> a = [-1, 1, 66.25, 333, 333, 1234.5]\n"

">>> del a[0]\n"

">>> a\n"

"[1, 66.25, 333, 333, 1234.5]\n"

">>> del a[2:4]\n"

">>> a\n"

"[1, 66.25, 1234.5]\n"

">>> del a[:]\n"

">>> a\n"

"[]"

msgstr ""

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

msgstr ""

":keyword:`del` також можна використовувати для видалення змінних повністю::"

msgid ">>> del a"

msgstr ""

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 ""

"Посилання на назву ``a`` у подальшому є помилкою (принаймні доти, доки їй не "

"буде присвоєно інше значення). Пізніше ми знайдемо інші способи "

"використання :keyword:`del`."

msgid "Tuples and Sequences"

msgstr "Кортежі та послідовності"

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 ""

"Ми побачили, що списки та рядки мають багато спільних властивостей, таких як "

"операції індексування та нарізки. Це два приклади типів даних *sequence* "

"(див. :ref:`typesseq`). Оскільки Python є мовою, що розвивається, можна "

"додавати інші типи даних послідовності. Існує ще один стандартний тип даних "

"послідовності: *кортеж*."

msgid ""

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

msgstr "Кортеж складається з кількох значень, розділених комами, наприклад::"

msgid ""

">>> t = 12345, 54321, 'hello!'\n"

">>> t[0]\n"

"12345\n"

">>> t\n"

"(12345, 54321, 'hello!')\n"

">>> # Tuples may be nested:\n"

">>> u = t, (1, 2, 3, 4, 5)\n"

">>> u\n"

"((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))\n"

">>> # Tuples are immutable:\n"

">>> t[0] = 88888\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: 'tuple' object does not support item assignment\n"

">>> # but they can contain mutable objects:\n"

">>> v = ([1, 2, 3], [3, 2, 1])\n"

">>> v\n"

"([1, 2, 3], [3, 2, 1])"

msgstr ""

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 ""

"Як ви бачите, на виході кортежі завжди взяті в круглі дужки, так що вкладені "

"кортежі інтерпретуються правильно; вони можуть бути введені з круглими "

"дужками або без них, хоча часто дужки все одно необхідні (якщо кортеж є "

"частиною більшого виразу). Неможливо призначити окремі елементи кортежу, "

"однак можна створити кортежі, які містять змінні об’єкти, наприклад списки."

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 ""

"Хоча кортежі можуть здаватися схожими на списки, вони часто використовуються "

"в різних ситуаціях і для різних цілей. Кортежі є :term:`immutable` і "

"зазвичай містять різнорідну послідовність елементів, доступ до яких "

"здійснюється через розпакування (див. далі в цьому розділі) або індексування "

"(або навіть за атрибутом у випадку :func:`namedtuples <collections."

"namedtuple>`). Списки є :term:`mutable`, і їхні елементи, як правило, є "

"однорідними та доступні за допомогою ітерації по списку."

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 ""

"Особливою проблемою є побудова кортежів, що містять 0 або 1 елемент: "

"синтаксис має деякі додаткові примхи для їх врахування. Порожні кортежі "

"будуються за допомогою порожньої пари круглих дужок; кортеж з одним "

"елементом створюється шляхом коми після значення (недостатньо взяти одне "

"значення в дужки). Негарно, але ефективно. Наприклад::"

msgid ""

">>> empty = ()\n"

">>> singleton = 'hello', # <-- note trailing comma\n"

">>> len(empty)\n"

"0\n"

">>> len(singleton)\n"

"1\n"

">>> singleton\n"

"('hello',)"

msgstr ""

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!'`` є прикладом *упакування кортежів*: "

"значення ``12345``, ``54321`` і ``'hello!''`` упаковуються разом в кортежі. "

"Можлива і зворотна операція:"

msgid ">>> x, y, z = t"

msgstr ""

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 ""

"Це називається, доречно, *розпакуванням послідовності* і працює для будь-"

"якої послідовності в правій частині. Розпакування послідовності вимагає, щоб "

"ліворуч від знака рівності було стільки змінних, скільки елементів у "

"послідовності. Зауважте, що множинне призначення насправді є лише "

"комбінацією упаковки кортежів і розпакування послідовності."

msgid "Sets"

msgstr "Набори"

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 також містить тип даних для *наборів*. Набір — це невпорядкована "

"колекція без повторюваних елементів. Основні способи використання включають "

"тестування членства та усунення повторюваних записів. Об’єкти множини також "

"підтримують математичні операції, такі як об’єднання, перетин, різниця та "

"симетрична різниця."

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 ""

"Для створення наборів можна використовувати фігурні дужки або функцію :func:"

"`set`. Примітка: щоб створити порожній набір, потрібно використовувати "

"``set()``, а не ``{}``; останній створює порожній словник, структуру даних, "

"яку ми обговоримо в наступному розділі."

msgid "Here is a brief demonstration::"

msgstr "Ось коротка демонстрація:"

msgid ""

">>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}\n"

">>> print(basket) # show that duplicates have been "

"removed\n"

"{'orange', 'banana', 'pear', 'apple'}\n"

">>> 'orange' in basket # fast membership testing\n"

"True\n"

">>> 'crabgrass' in basket\n"

"False\n"

"\n"

">>> # Demonstrate set operations on unique letters from two words\n"

">>>\n"

">>> a = set('abracadabra')\n"

">>> b = set('alacazam')\n"

">>> a # unique letters in a\n"

"{'a', 'r', 'b', 'c', 'd'}\n"

">>> a - b # letters in a but not in b\n"

"{'r', 'd', 'b'}\n"

">>> a | b # letters in a or b or both\n"

"{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}\n"

">>> a & b # letters in both a and b\n"

"{'a', 'c'}\n"

">>> a ^ b # letters in a or b but not both\n"

"{'r', 'd', 'b', 'm', 'z', 'l'}"

msgstr ""

msgid ""

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

"are also supported::"

msgstr ""

"Подібно до :ref:`списків розуміння <tut-listcomps>`, також підтримуються "

"набір розуміння::"

msgid ""

">>> a = {x for x in 'abracadabra' if x not in 'abc'}\n"

">>> a\n"

"{'r', 'd'}"

msgstr ""

msgid "Dictionaries"

msgstr "словники"

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:`!"

"append` and :meth:`!extend`."

msgstr ""

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 ""

"Найкраще думати про словник як про набір пар *ключ:значення* з вимогою, щоб "

"ключі були унікальними (в межах одного словника). Пара фігурних дужок "

"створює порожній словник: ``{}``. Розміщення розділених комами списку пар "

"ключ:значення в фігурних дужках додає початкові пари ключ:значення до "

"словника; це також спосіб написання словників на виході."

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 ""

"Основними операціями зі словником є збереження значення з деяким ключем і "

"вилучення значення з заданим ключем. Також можна видалити пару ключ:значення "

"за допомогою ``del``. Якщо ви зберігаєте за допомогою ключа, який уже "

"використовується, старе значення, пов’язане з цим ключем, забувається. "

"Видобування значення за допомогою неіснуючого ключа є помилкою."

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 ""

"Виконання ``list(d)`` для словника повертає список усіх ключів, використаних "

"у словнику, у порядку вставки (якщо ви хочете, щоб він був відсортований, "

"просто використовуйте ``sorted(d)``). Щоб перевірити, чи є один ключ у "

"словнику, використовуйте ключове слово :keyword:`in`."

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

msgstr "Ось невеликий приклад використання словника::"

msgid ""

">>> tel = {'jack': 4098, 'sape': 4139}\n"

">>> tel['guido'] = 4127\n"

">>> tel\n"

"{'jack': 4098, 'sape': 4139, 'guido': 4127}\n"

">>> tel['jack']\n"

"4098\n"

">>> del tel['sape']\n"

">>> tel['irv'] = 4127\n"

">>> tel\n"

"{'jack': 4098, 'guido': 4127, 'irv': 4127}\n"

">>> list(tel)\n"

"['jack', 'guido', 'irv']\n"

">>> sorted(tel)\n"

"['guido', 'irv', 'jack']\n"

">>> 'guido' in tel\n"

"True\n"

">>> 'jack' not in tel\n"

"False"

msgstr ""

msgid ""

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

"key-value pairs::"

msgstr ""

"Конструктор :func:`dict` створює словники безпосередньо з послідовностей пар "

"ключ-значення:"

msgid ""

">>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])\n"

"{'sape': 4139, 'guido': 4127, 'jack': 4098}"

msgstr ""

msgid ""

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

"arbitrary key and value expressions::"

msgstr ""

"Крім того, розуміння dict можна використовувати для створення словників із "

"довільних ключів і виразів значень:"

msgid ""

">>> {x: x**2 for x in (2, 4, 6)}\n"

"{2: 4, 4: 16, 6: 36}"

msgstr ""

msgid ""

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

"using keyword arguments::"

msgstr ""

"Коли ключі є простими рядками, інколи легше вказати пари за допомогою "

"аргументів ключових слів::"

msgid ""

">>> dict(sape=4139, guido=4127, jack=4098)\n"

"{'sape': 4139, 'guido': 4127, 'jack': 4098}"

msgstr ""

msgid "Looping Techniques"

msgstr "Техніка циклу"

msgid ""

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

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

msgstr ""

msgid ""

">>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}\n"

">>> for k, v in knights.items():\n"

"... print(k, v)\n"

"...\n"

"gallahad the pure\n"

"robin the brave"

msgstr ""

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 ""

"Під час циклічного перегляду послідовності індекс позиції та відповідне "

"значення можна отримати одночасно за допомогою функції :func:`enumerate`. ::"

msgid ""

">>> for i, v in enumerate(['tic', 'tac', 'toe']):\n"

"... print(i, v)\n"

"...\n"

"0 tic\n"

"1 tac\n"

"2 toe"

msgstr ""

msgid ""

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

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

msgstr ""

"Щоб перейти до двох або більше послідовностей одночасно, записи можна "

"поєднати з функцією :func:`zip`. ::"

msgid ""

">>> questions = ['name', 'quest', 'favorite color']\n"

">>> answers = ['lancelot', 'the holy grail', 'blue']\n"

">>> for q, a in zip(questions, answers):\n"

"... print('What is your {0}? It is {1}.'.format(q, a))\n"

"...\n"

"What is your name? It is lancelot.\n"

"What is your quest? It is the holy grail.\n"

"What is your favorite color? It is blue."

msgstr ""

msgid ""

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

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

msgstr ""

"Щоб виконати цикл у зворотному напрямку, спочатку вкажіть послідовність у "

"прямому напрямку, а потім викличте функцію :func:`reversed`. ::"

msgid ""

">>> for i in reversed(range(1, 10, 2)):\n"

"... print(i)\n"

"...\n"

"9\n"

"7\n"

"5\n"

"3\n"

"1"

msgstr ""

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 ""

"Щоб перейти до послідовності у відсортованому порядку, використовуйте "

"функцію :func:`sorted`, яка повертає новий відсортований список, залишаючи "

"джерело без змін. ::"

msgid ""

">>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']\n"

">>> for i in sorted(basket):\n"

"... print(i)\n"

"...\n"

"apple\n"

"apple\n"

"banana\n"

"orange\n"

"orange\n"

"pear"

msgstr ""

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 ""

"Використання :func:`set` у послідовності усуває повторювані елементи. "

"Використання :func:`sorted` у поєднанні з :func:`set` над послідовністю є "

"ідіоматичним способом проходження унікальних елементів послідовності в "

"порядку сортування. ::"

msgid ""

">>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']\n"

">>> for f in sorted(set(basket)):\n"

"... print(f)\n"

"...\n"

"apple\n"

"banana\n"

"orange\n"

"pear"

msgstr ""

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 ""

"Іноді виникає спокуса змінити список, поки ви переглядаєте його; однак часто "

"простіше й безпечніше створити новий список. ::"

msgid ""

">>> import math\n"

">>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]\n"

">>> filtered_data = []\n"

">>> for value in raw_data:\n"

"... if not math.isnan(value):\n"

"... filtered_data.append(value)\n"

"...\n"

">>> filtered_data\n"

"[56.2, 51.7, 55.3, 52.5, 47.8]"

msgstr ""

msgid "More on Conditions"

msgstr "Детальніше про умови"

msgid ""

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

"operators, not just comparisons."

msgstr ""

"Умови, які використовуються в операторах while і if, можуть містити будь-які "

"оператори, а не лише порівняння."

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 ""

"Оператори порівняння ``in`` і ``not in`` — це тести на приналежність, які "

"визначають, чи є значення в контейнері (чи ні). Оператори ``is`` і ``is "

"not`` порівнюють, чи дійсно два об’єкти є одним і тим же об’єктом. Усі "

"оператори порівняння мають однаковий пріоритет, який нижчий, ніж у всіх "

"числових операторів."

msgid ""

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

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

msgstr ""

"Порівняння можуть бути ланцюжками. Наприклад, ``a < b == c`` перевіряє, чи "

"``a`` є меншим за ``b`` і, крім того, ``b`` дорівнює ``c``."

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 ""

"Порівняння можна комбінувати за допомогою логічних операторів ``and`` і "

"``or``, а результат порівняння (або будь-якого іншого логічного виразу) "

"можна заперечувати за допомогою ``not``. Вони мають нижчий пріоритет, ніж "

"оператори порівняння; між ними ``not`` має найвищий пріоритет, а ``or`` "

"найнижчий, так що ``A and not B or C`` еквівалентно ``(A and (not B)) or "

"C`` . Як завжди, дужки можна використовувати для вираження бажаної "

"композиції."

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 ""

"Логічні оператори ``and`` і ``or`` є так званими операторами *короткого "

"замикання*: їхні аргументи обчислюються зліва направо, і обчислення "

"припиняється, щойно визначається результат. Наприклад, якщо ``A`` і ``C`` є "

"істинними, ``B`` є хибними, ``A and B and C`` не обчислює вираз ``C``. Якщо "

"використовується як загальне значення, а не як логічне, значення, що "

"повертається оператором короткого замикання, є останнім обчисленим "

"аргументом."

msgid ""

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

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

msgstr ""

"Змінній можна призначити результат порівняння або інший логічний вираз. "

"Наприклад, ::"

msgid ""

">>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'\n"

">>> non_null = string1 or string2 or string3\n"

">>> non_null\n"

"'Trondheim'"

msgstr ""

msgid ""