Как найти сумму кортежа

Как найти сумму кортежа

Sometimes, while programming, we have a problem in which we might need to perform summation among tuple elements. This is an essential utility as we come across summation operations many times and tuples are immutable and hence required to be dealt with. Let’s discuss certain ways in which this task can be performed. 

Method #1: Using list() + sum() 

The above functions can be combined to perform this task. We can employ sum() to accumulate the result of summation logic. The list() function is used to perform interconversions. 

Approach:

  1. Define a function named “summation” that takes a tuple “test_tup” as input.
  2. Convert the tuple “test_tup” to a list named “test”.
  3. Initialize a variable “count” to zero.
  4. Using a “for” loop, iterate over the elements of “test” and add each element to “count”.
  5. Return the value of “count”.
  6. Initialize a tuple “test_tup” with the values (5, 20, 3, 7, 6, 8).
  7. Call the “summation” function with “test_tup” as the argument and print the result.

Python3

def summation(test_tup):

    test = list(test_tup)

    count = 0

    for i in test:

        count += i

    return count

test_tup = (5, 20, 3, 7, 6, 8)

print(summation(test_tup))

Output : 

The original tuple is : (7, 8, 9, 1, 10, 7)
The summation of tuple elements are : 42

Time complexity: O(n)
Auxiliary space: O(n) – due to the creation of a new list from the tuple.

Method #2: Using map() + sum() + list() 

The combination of the above functions can be used to perform this task. In this, we first convert the tuple to list, flatten it’s each list element using map(), perform summation of each using sum() and again employ sum() for the overall summation of the resultant list. 

Follow the below steps to implement the above idea:

  1. The tuple test_tup is initialized with three inner lists containing integer values.
  2. The original tuple is printed using the print() function along with a message string.
  3. The sum() function is used to calculate the sum of all the elements of the tuple test_tup.
  4. The map() function is applied to test_tup with sum function as its argument to sum the elements of each inner list.
  5. The result of the map() function is converted to a list using the list() function.
  6. The result of step 5 is then passed as an argument to the sum() function to add up all the sums of inner lists and get the total sum of all elements in the tuple.
  7. The result of step 6 is stored in the variable res.
  8. The result is printed using the print() function along with a message string.

Below is the implementation of the above approach:

Python3

test_tup = ([7, 8], [9, 1], [10, 7])

print("The original tuple is : " + str(test_tup))

res = sum(list(map(sum, list(test_tup))))

print("The summation of tuple elements are : " + str(res))

Output : 

The original tuple is : (7, 8, 9, 1, 10, 7)
The summation of tuple elements are : 42

Time complexity: O(n^2) where n is the size of the tuple. 
Auxiliary space: O(n) where n is the size of the tuple. 

Method #3: Using for loop

Python3

test_tup = (7, 8, 9, 1, 10, 7)

print("The original tuple is : " + str(test_tup))

res = 0

for i in test_tup:

    res += i

print("The summation of tuple elements are : " + str(res))

Output

The original tuple is : (7, 8, 9, 1, 10, 7)
The summation of tuple elements are : 42

Time complexity: O(n) where n is the number of elements in the tuple. 
Auxiliary space: O(1) because it uses a constant amount of extra space to store the variable “res” which is used to accumulate the summation of the elements in the tuple.

Method #4: Using reduce() + operator.add()

The reduce() function can be used to iterate through the tuple and the operator.add() function can be used for the summation of elements.

Python3

import operator

from functools import reduce

def summation(test_tup):

  return reduce(operator.add, test_tup)

test_tup = (5, 20, 3, 7, 6, 8)

print(summation(test_tup))

Time Complexity: O(n) where n is the number of elements in the tuple.
Auxiliary Space: O(1) as no extra space is required.

Method 5: Using the numpy library

Note: Install numpy module using command “pip install numpy”

To find the sum of the elements in a tuple, we could convert the tuple to a numpy array and then use the numpy.sum() function.

Python3

import numpy as np

test_tup = (7, 8, 9, 1, 10, 7)

test_array = np.array(test_tup)

print("The original tuple is : " + str(test_tup))

res = np.sum(test_array)

print("The summation of tuple elements are : " + str(res))

Output:

The original tuple is : (7, 8, 9, 1, 10, 7)
The summation of tuple elements are : 42

Time complexity: O(n), where n is the number of elements in the tuple. This is because the numpy.sum() function also needs to iterate over all n elements in the array to find the sum.
Auxiliary space: O(n), as it requires the creation of a numpy array to store all n elements of the tuple.

Method 6: Using a list comprehension:

Use a list comprehension to convert the tuple to a list and sum up the elements.

Python3

def summation(test_tup):

    test = [x for x in test_tup]

    return sum(test)

test_tup = (5, 20, 3, 7, 6, 8)

print(summation(test_tup))

Time complexity: O(n), where n is the number of elements in the tuple. 
Auxiliary space: O(n)

Method 7: Using a generator expression and the built-in sum() function

Step-by-step approach:

  • Define a function summation2() that takes a tuple test_tup as its argument.
  • Use a generator expression to convert test_tup to an iterable that can be passed to the sum() function. A generator expression is similar to a list comprehension but does not create a list in memory, instead, it generates values on-the-fly as they are needed.
  • Pass the generator expression to the sum() function to find the sum of the elements in test_tup.
  • Return the sum.

Below is the implementation of the above approach:

Python3

def summation2(test_tup):

    if len(test_tup) == 0:

        raise ValueError("Input tuple is empty")

    if not all(isinstance(x, int) for x in test_tup):

        raise TypeError("Input tuple must contain only integers")

    iterable = (x for x in test_tup)

    total_sum = sum(iterable)

    return total_sum

test_tup = (5, 20, 3, 7, 6, 8)

print(summation2(test_tup))

Time complexity: O(n)
Auxiliary space: O(1) – only a single variable total_sum is used.

Method 8: Using the math library

  1. Import the math library.
  2. Initialize the tuple test_tup with the given elements.
  3. Create a variable res and assign it the value returned by the math.fsum() function, which calculates the sum of all the elements in the tuple.
  4. Print the value of res to display the result.

Python3

import math

test_tup = (7, 8, 9, 1, 10, 7)

res = math.fsum(test_tup)

print("The summation of tuple elements are : " + str(res))

Output

The summation of tuple elements are : 42.0

Time Complexity: O(n), where n is the number of elements in the tuple.
Auxiliary Space: O(1), as we are only using a constant amount of extra space to store the result.

Last Updated :
08 May, 2023

Like Article

Save Article

Источник

Кортежи очень похожи на списки, но имеют одно важное отличие — они неизменяемые. В остальном, они также могут состоять из данных разных типов и использовать индексы, которые определяют конкретный порядок элементов.

Индекс начинается с нуля, как и в случае списков, а отрицательный индекс — с -1. Этот индекс указывает на последний элемент кортежа.

Где используется?

Кортежи — распространенная структура данных для хранения последовательностей в Python.

  • .index() — используется для вывода индекса элемента.
  • .count() — используется для подсчета количества элементов в кортеже.
  • sum() — складывает все элементы кортежа.
  • min() — показывает элемент кортежа с наименьшим значением.
  • max() — показывает элемент кортежа с максимальным значением.
  • len() — показывает количество элементов кортежа.

Рекомендации по работе с кортежами

  1. Кортежи создаются с помощью круглых скобок: ();
  2. Элементы внутри кортежей разделяются запятыми;
  3. Важно соблюдать особенности синтаксиса, характерные для каждого отдельного типа данных в кортеже — кавычки для строк, числа и булевые значения без кавычек и так далее.

Дальше — кортеж, включающий элементы разных типов:



>>> p_tup = ("Лондон", "Пекин", 44, True)

>>> print(p_tup)

('Лондон', 'Пекин', 44, True)

Доступ к элементам: получить элементы кортежа можно с помощью соответствующего индекса в квадратных скобках.

Например, для получения элемента «Лондон» нужно использовать следующий индекс: p_tup[0]

А для 44: p_tup[2]

Последний элемент следующего кортежа — булево True. Доступ к нему мы получаем с помощью функции print.



>>> p_tup = ("Лондон", "Пекин", 44, True)

>>> print(p_tup[3])

True

Пример получения первого элемента кортежа.



>>> p_tup = ("Лондон", "Пекин", 44, True)

>>> print(p_tup[0])

'Лондон'

Советы:

  1. Обратное индексирование: по аналогии с элементами списка элементы кортежа также можно получить с помощью обратного индексирования. Оно начинается с -1. Это значение указывает на последний элемент.
    Так, для получения последнего элемент p_tup нужно писать p_tup[-1]. p_tup[-2] вернет второй элемент с конца и так далее.
  2. Главное отличие кортежей от списков — они неизменяемые. Кортежам нельзя добавлять или удалять элементы.
    Поэтому эта структура используется, когда известно, что элементы не будут меняться в процессе работы программы.


>>> p_tup = ("Лондон", "Пекин", 44, True)

>>> print(p_tup[-1])

True

Функция .index()

.index() — полезный метод, используемый для получения индекса конкретного элемента в кортеже.

Посмотрим на примере.



>>> p_tup = ("Лондон", "Пекин", 44, True)

>>> print(p_tup.index("Лондон"))

0

Функция .count()

Метод .count() подходит для определения количества вхождений определенного элемента в кортеже.

В примере ниже можно увидеть, что считается количество вхождений числа 101 в списке p_cup. Результат — 2.



>>> p_tup = (5, 101, 42, 3, 101)

>>> print(p_tup.count(101))

2

Функция sum()

Функция sum() возвращает общую сумму чисел внутри кортежа.



>>> lucky_numbers = (5, 55, 4, 3, 101, 42)

>>> print(sum(lucky_numbers))

210

Функция min()

Функция min() вернет элемент с самым маленьким значением в кортеже.



>>> lucky_numbers = (5, 55, 4, 3, 101, 42)

>>> print(min(lucky_numbers))

5

Функция max()

Функция max() вернет элемент с максимальным значением в кортеже.



>>> lucky_numbers = (5, 55, 4, 3, 101, 42)

>>> print(max(lucky_numbers))

101

Задачи к уроку

Попробуйте решить задачи к этому уроку для закрепления знаний.

1. Создайте кортеж с цифрами от 0 до 9 и посчитайте сумму.

# данный код
numbers =
print(sum(numbers))
# требуемый вывод:
# 45

2. Введите статистику частотности букв в кортеже.

# данный код
long_word = (
    'т', 'т', 'а', 'и', 'и', 'а', 'и', 
    'и', 'и', 'т', 'т', 'а', 'и', 'и',
    'и', 'и', 'и', 'т', 'и'
)

print("Количество 'т':", )
print("Количество 'a':", )
print("Количество 'и':", )
# требуемый вывод:
# Колличество 'т': 5
# Колличество 'а': 3
# Колличество 'и': 11
  1. Допишите скрипт для расчета средней температуры.
    Постарайтесь посчитать количество дней на основе week_temp. Так наш скрипт сможет работать с данными за любой период.
# данный код
week_temp = (26, 29, 34, 32, 28, 26, 23)
sum_temp =
days =
mean_temp = sum_temp / days
print(int(mean_temp))
# требуемый вывод:
# 28

Файл со всем заданиями: https://gitlab.com/PythonRu/python-dlya-nachinayushih/-/blob/master/lesson_7.py.

Тест по кортежам

Пройдите тест к этому уроку для проверки знаний. В тесте 5 вопросов, количество попыток неограниченно.

Выберете верное утверждение. Одно.

Можно удалить элемент из кортежа

Можно добавить элемент в кортеж

Можно удалить элемент, но нельзя добавить новый

Когда точно нужно использовать кортеж? Выберите один ответ.

До нас данные записывали в кортеж

Мы записываем данные, которые нельзя менять

Мы записываем данные, которые меняются раз в год

Мы записываем данные, которые будут обновляться

Что выведет этот код:

sample = (10, 20, 30)
sample.append(60)
print(sample)

Какая функция создаст пустой кортеж?

Такой функции в python нет

Как получить последний элемент этого кортежа:

lake = ("Python", 51, False, "22")

Если нашли ошибку, опечатку или знаете как улучшить этот урок, пишите на почту. Ее можно найти внизу сайта.

Источник

Кортежи tuple в Python предназначены, как и списки, для хранения последовательностей, состоящих из данных любого типа. Однако, в отличие от списков, кортежи относятся к неизменяемым типам данных. По этой причине в них часто хранят информацию, которую необходимо защитить от случайного изменения – например, конфигурационные данные.

Кортеж в Питоне: свойства и особенности

1. Кортежи не поддерживают добавление и удаление элементов, но допускают расширение и дополнение для тех элементов, которые относятся к изменяемым типам (списки, словари), а также любые операции с элементами элементов:

        >>> numbers = ([1, 2, 3, 4], [5, 4, 5])
>>> numbers[1].extend([3, 5, 9])
>>> numbers[0].append([7, 7, 8])
>>> numbers[1][1] += 5
>>> print(numbers)
([1, 2, 3, 4, [7, 7, 8]], [5, 9, 5, 3, 5, 9])

2. Кортежи поддерживают неограниченный уровень вложенности:

        numbers = ((4, 5, 8, (5, 1, (5, 3))), (7, 2, (4, 5, (3, 1, 1))))

3. Кортежи работают немного быстрее, чем списки – это связано с особенностями хранения tuple в памяти:

        >>> from timeit import timeit
>>> times = 1000000
>>> t1 = timeit("list(['груша', 'виноград','яблоко', 'банан', 'апельсин'])", number=times)
>>> t2 = timeit("tuple(('груша', 'виноград','яблоко', 'банан', 'апельсин'))", number=times)
>>> diff = "{:.0%}".format((t2 - t1)/t1)
>>> print(f'Время копирования списка {times} раз: {t1}')
Время копирования списка 1000000 раз: 0.5761922669999961
>>> print(f'Время копирования кортежа {times} раз: {t2}')
Время копирования кортежа 1000000 раз: 0.22475764600000048
>>> print(f'Разница: {diff}')
Разница: -61%

4. Кортежи занимают меньше места в памяти:

        >>> from sys import getsizeof
>>> numbers1 = ((1, 2, 3, 4), (5, 4, 5))
>>> numbers2 = [[1, 2, 3, 4], [5, 4, 5]]
>>> print(getsizeof(numbers1))
36
>>> print(getsizeof(numbers2))
44

5. Кортежи поддерживают конкатенацию + и повторение * n:

        >>> num1 = (1, 2, 3)
>>> num2 = (4, 5, 6)
>>> print(num1 + num2)
(1, 2, 3, 4, 5, 6)
>>> print(num1 * 3)
(1, 2, 3, 1, 2, 3, 1, 2, 3)

6. Элементы tuple можно использовать в качестве значений переменных; этот прием называют распаковкой кортежа:

        >>> seasons = ('весна', 'лето', 'осень', 'зима')
>>> s1, s2, s3, s4 = seasons
>>> print(s1, s3)
весна осень

Создание tuple в Питоне

Пустой кортеж можно создать двумя способами – с помощью круглых скобок () и с использованием функции tuple():

        my_tuple = ()
my_tuple2 = tuple()

При создании кортежа с одним элементом после этого элемента необходимо ставить запятую, иначе Python не определяет конструкцию как кортеж:

        >>> my_tuple = (5)
>>> print(type(my_tuple))
<class 'int'>
>>> my_tuple = (5,)
>>> print(type(my_tuple))
<class 'tuple'>

Создать кортеж с несколькими элементами можно следующими способами.

Способ 1: Перечисление элементов

Как и в случае со списками и словарями, кортеж с данными можно создать вручную. Кортеж может содержать данные различных типов:

        info = ('Егор', 'разработчик', 350000, 28)

Элементы кортежа необязательно перечислять в круглых скобках – когда Python получает более одного значения для переменной, создание (“упаковка”) кортежа происходит автоматически:

        >>> letters = 'a', 'b', 'c', 'd'
>>> print(letters)
('a', 'b', 'c', 'd')

Способ 2: Преобразование других типов данных

С помощью встроенной функции tuple() можно создать кортеж из списка, строки или множества:

        >>> my_lst = [4, 6, 2, 8]
>>> print(tuple(my_lst))
(4, 6, 2, 8)
>>> my_str = 'Я изучаю Python'
>>> print(tuple(my_str))
('Я', ' ', 'и', 'з', 'у', 'ч', 'а', 'ю', ' ', 'P', 'y', 't', 'h', 'o', 'n')
>>> my_set = {2, 5, 6, 7}
>>> print(tuple(my_set))
(2, 5, 6, 7)

Однако при подобном преобразовании словаря в кортеж останутся только ключи:

        >>> my_dict = {'яблоки': 52, 'апельсины': 35}
>>> print(tuple(my_dict))
('яблоки', 'апельсины')

Число напрямую преобразовать в кортеж нельзя:

        >>> num = 178394
>>> print(tuple(num))
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: 'int' object is not iterable

Но если конвертировать число в строку, преобразование пройдет без ошибок:

        >>> num = 31232534
>>> print(tuple(str(num)))
('3', '1', '2', '3', '2', '5', '3', '4')

В ходе преобразования строки в кортеж с помощью одной лишь функции tuple() строка разбивается на отдельные символы. Если нужно разбить строку по одному разделителю, подойдет метод partition():

        >>> st = 'Я изучаю***Python'
>>> print(st.partition('***'))
('Я изучаю', '***', 'Python')

Чтобы разбить строку по всем разделителям, вместе с tuple() используют split():

        >>> st = tuple(input().split())
Код на языке Python
>>> print(st)
('Код', 'на', 'языке', 'Python')

Способ 3: Генератор кортежей

Генераторы кортежей, в отличие от списков и словарей, не слишком удобно использовать для решения практических задач:

        >>> my_tuple = (i for i in range(5))
>>> print(my_tuple)
<generator object <genexpr> at 0x023B5830>

Но если генератор кортежа все-таки необходимо использовать, это можно сделать двумя способами:

1. Распаковать сгенерированный объект при выводе:

        >>> numbers = (i for i in range(10))
>>> print(*numbers)
0 1 2 3 4 5 6 7 8 9

2. Либо использовать в генераторе функцию tuple():

        >>> my_tuple = tuple(i ** 2 for i in range(1, 12, 2))
>>> print(my_tuple)
(1, 9, 25, 49, 81, 121)

Способ 4: Распаковка строк и списков

Оператор распаковки * и запятая после имени переменной автоматически превращают строки и списки в кортежи:

        >>> st = 'Я изучаю Python'
>>> sp = ['Python', 'HTML5', 'CSS', 'JavaScript']
>>> tuple1 = (*st,)
>>> tuple2 = (*sp,)
>>> print(tuple1)
('Я', ' ', 'и', 'з', 'у', 'ч', 'а', 'ю', ' ', 'P', 'y', 't', 'h', 'o', 'n')
>>> print(tuple2)
('Python', 'HTML5', 'CSS', 'JavaScript')

Кортежи поддерживают большинство методов списков, за исключением удаления элементов и присваивания им новых значений:

        >>> my_tuple = (4, 5, 6)
>>> del my_tuple[1]
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion
>>> my_tuple[2] = 9
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Индексация и срезы

Индексация и срезы в кортежах работают так же, как и в списках:

        >>> my_tuple = ('банан', 'груша', 'манго')
>>> print(my_tuple[0], my_tuple[-1])
банан манго
>>> print(my_tuple[1:])
('груша', 'манго')
>>> print(my_tuple[::-1])
('манго', 'груша', 'банан')

Для возвращения индексa элемента используется index():

        >>> nutr = ('белки', 'жиры', 'углеводы')
>>> print(nutr.index('белки'))
0

Длина, сумма, минимальный и максимальный элементы

Эти методы тоже аналогичны списочным:

        >>> my_tuple = ('карандаш', 'ручка', 'шар')
>>> print(len(my_tuple))
3
>>> print(min(my_tuple, key=len))
шар
>>> print(max(my_tuple, key=len))
карандаш
>>> nums = (4, 5, 2, 1, 6)
>>> print(sum(nums))
18

Принадлежность

С помощью операторов in и not in можно убедиться в наличии (отсутствии) определенного значения в кортеже:

        >>> nums = (1, 3, 5, 6, 7, 8)
>>> (5 in nums)
True
>>> (25 not in nums)
True

Подсчет элементов

Для подсчета числа вхождений какого-либо значения в кортеже используется count():

        >>> cities = ('Москва', 'Ростов', 'Москва', 'Рязань', 'Саратов', 'Москва')
>>> print(cities.count('Москва'))
3

Сортировка

Кортежи поддерживают сортировку, однако результатом будет список:

        >>> nums = (4, 1, 7, 2, 0, 9, 5)
>>> print(sorted(nums))
[0, 1, 2, 4, 5, 7, 9]

Если результат должен сохраняться в виде кортежа, нужно использовать tuple():

        >>> nums = (4, 1, 7, 2, 0, 9, 5)
>>> print(tuple(sorted(nums, reverse=True)))
(9, 7, 5, 4, 2, 1, 0)

Преобразование кортежей в другие типы данных

Кортеж можно преобразовать в строку:

        >>> letters = ('P', 'y', 't', 'h', 'o', 'n')
>>> print('*'.join(letters))
P*y*t*h*o*n

В список:

        >>> sp = (2, 7, 5, 8, 1)
>>> print(list(sp))
[2, 7, 5, 8, 1]

В словарь (если кортеж вложенный и состоит из пар значений):

        >>> info = (('фрукты', 5), ('овощи', 15), ('конфеты', 3))
>>> print(dict(info))
{'фрукты': 5, 'овощи': 15, 'конфеты': 3}

Во множество:

        >>> numbers = (3, 2, 1, 6, 7, 2, 2, 9)
>>> print(set(numbers))
{1, 2, 3, 6, 7, 9}

Сравнение кортежей

Как и списки, кортежи с однородными данными можно сравнивать между собой с помощью операторов >, >=, <, <=, ==, !=. Если элементы кортежей принадлежат к разным типам данных, поддерживаются только операторы == и !=.

        >>> tuple1 = (1, 2, 3)
>>> tuple2 = (4, 5, 6)
>>> print(tuple1 < tuple2)
True
>>> print(tuple1 != tuple2)
True

Практика

Задание 1

Напишите программу, которая:

  • Создает кортежи из положительных и отрицательных целых чисел на основе полученной от пользователя строки.
  • Выводит количество положительных и отрицательных чисел в этих кортежах.

Пример ввода:

        45 -6 -9 43 23 5 2 -9 -1 6 3

Вывод:

        Кортеж (45, 43, 23, 5, 2, 6, 3) состоит из 7 положительных чисел
Кортеж (-6, -9, -9, -1) состоит из 4 положительных чисел

Решение:

        numbers = tuple(map(int, input().split()))
pos = tuple(i for i in numbers if i > 0)
neg = tuple(i for i in numbers if i < 0)
print(f'Кортеж {pos} состоит из {len(pos)} положительных чисел')
print(f'Кортеж {neg} состоит из {len(neg)} положительных чисел')

Задание 2

Напишите программу, которая:

  • Создает кортеж из полученной от пользователя строки, состоящей из вещественных чисел, разделенных пробелами.
  • Выводит минимальный и максимальный элементы кортежа, а также их сумму.

Пример ввода:

        3.45 6.78 8.99 1.45 4.32 19.04 0.55

Вывод:

        Минимальное число: 0.55
Максимальное число: 19.04
Сумма min и max: 19.59

Решение:

        my_tuple = tuple(map(float, input().split()))
print(f'Минимальное число: {min(my_tuple)}')
print(f'Максимальное число: {max(my_tuple)}')
print(f'Сумма min и max: {((min(my_tuple) + max(my_tuple))):.2f}')

Задание 3

Имеется кортеж списков, в которых перечислены названия фруктов и калорийность:

        fruit = (['яблоки', 46], ['персики', 49], ['лимоны', 36], ['виноград', 190])

Калорийность винограда указана ошибочно. Напишите программу, которая исправит калорийность на 75, и добавит в третий элемент кортежа новое значение ['айва', 42]. Результат должен выглядеть так:

        fruit = (['яблоки', 46], ['персики', 49], ['лимоны', 36, 'айва', 42], ['виноград', 75])

Решение:

        fruit = (['яблоки', 46], ['персики', 49], ['лимоны', 36], ['виноград', 190])
fruit[3][1] = 75
fruit[2].extend(['айва', 42])
print(fruit)

Задание 4

Имеется вложенный кортеж:

        numbers = ((5, 4, 5, 4), (3, 3, 4, 6), (8, 9, 5, 4), (12, 4, 5, 1), (9, 3, 5, 1))

Напишите программу, которая формирует новый кортеж, состоящий из средних арифметических значений элементов numbers. Результат выводится в следующем виде:

        4.5 4.0 6.5 5.5 4.5

Решение:

        numbers = ((5, 4, 5, 4), (3, 3, 4, 6), (8, 9, 5, 4), (12, 4, 5, 1), (9, 3, 5, 1))
avg = tuple(sum(i)/len(i) for i in numbers)
print(*avg)

Задание 5

Имеется вложенный кортеж:

        nested_tuple = ((12, 3, 1), (5, 11), (15, 7, 8, 9), (10, 6, 4))

Напишите программу для преобразования nested_tuple в обычный кортеж, упорядоченный по возрастанию:

        (1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15)

Решение:

        nested_tuple = ((12, 3, 1), (5, 11), (15, 7, 8, 9), (10, 6, 4))
res = []
flat_list = [res.extend(i) for i in nested_tuple]
print(tuple(sorted(res)))

Задание 6

Напишите программу для сортировки вложенного кортежа по третьему элементу. Исходный кортеж:

        (('красный', 33, 55), ('зеленый', 17, 44), ('синий', 12, 3), ('черный', 2, 5))

Результат:

        (('черный', 2, 5), ('синий', 12, 3), ('зеленый', 17, 44), ('красный', 33, 55))

В качестве ключа сортировки следует использовать конструкцию key=lambda x: x[2] – это анонимная функция. В последующих статьях мы будем подробно разбирать применение анонимных функций.

Решение:

        nested_tuple = (('красный', 33, 55), ('зеленый', 17, 44), ('синий', 12, 3), ('черный', 2, 5))
nested_tuple = tuple(sorted(list(nested_tuple), key=lambda x: x[2]))
print(nested_tuple)

Задание 7

Напишите программу, которая:

  • принимает на вход строку, состоящую из цифр или символов, разделенных пробелами;
  • создает из строки кортеж;
  • проверяет, состоит ли кортеж из одинаковых элементов;
  • выводит True или False в зависимости от результатов проверки.

Для проверки соответствия всех элементов одному условию в Python используется встроенная функция all():

        all(i == my_tuple[0] for i in my_tuple)

Пример ввода:

        35 35 35 35 35

Вывод:

        True

Решение:

        my_tuple = tuple(input().split())
print(all(i == my_tuple[0] for i in my_tuple))

Задание 8

Напишите программу, которая на основе исходного кортежа создает новый кортеж, из которого исключены все пользователи с номерами телефонов с региональным кодом +56.

Исходный кортеж:

        info = (('Евгений Романов', 25, '+56(983)354-67-21'),
    	('Марина Дятлова', 22, '+56(190)251-45-79'),
    	('Кирилл Кудрявцев', 34, '+7(890)456-12-42'),
    	('Сергей Дятлов', 24, '+56(190)156-42-99'),
    	('Юлия Степанова', 21, '+16(398)355-33-09'),
    	('Тимофей Иванов', 34, '+7(918)222-52-77'))

Ожидаемый результат:

        (('Кирилл Кудрявцев', 34, '+7(890)456-12-42'), ('Юлия Степанова', 21, '+16(398)355-33-09'), ('Тимофей Иванов', 34, '+7(918)222-52-77'))

Решение:

        info = (('Евгений Романов', 25, '+56(983)354-67-21'),
    	('Марина Дятлова', 22, '+56(190)251-45-79'),
    	('Кирилл Кудрявцев', 34, '+7(890)456-12-42'),
    	('Сергей Дятлов', 24, '+56(190)156-42-99'),
    	('Юлия Степанова', 21, '+16(398)355-33-09'),
    	('Тимофей Иванов', 34, '+7(918)222-52-77'))
new_info = tuple([i for i in info if not i[2].startswith('+56')])
print(new_info)

Задание 9

Имеется кортеж списков:

        numbers = ([4, 5], [4, 5], [1, 6], [7, 3], [3, 3], [2, 4], [9, 5], [1, 1])

Напишите программу, которая добавит цифру 5 в конец каждого списка.

Ожидаемый результат:

        numbers = ([4, 5, 5], [4, 5, 5], [1, 6, 5], [7, 3, 5], [3, 3, 5], [2, 4, 5], [9, 5, 5], [1, 1, 5])

Решение:

        numbers = ([4, 5], [4, 5], [1, 6], [7, 3], [3, 3], [2, 4], [9, 5], [1, 1])
add = [i.extend([5]) for i in numbers]
print(numbers)

Задание 10

Напишите программу, которая:

  • получает на вход целое число n – количество точек на плоскости;
  • получает n строк с координатами x, y;
  • определяет точку, наиболее удаленную от начала координат.

Пример ввода:

        5
4 8
1 2
7 4
7 8
3 2

Вывод:

        7 8

Решение:

        n = int(input())
points = [tuple(map(int, input().split())) for i in range(n)]
mx = max(points, key=lambda x: x[0] ** 2 + x[1] ** 2)
print(*mx)

Подведем итоги

Кортежи во многом похожи на списки. Выбор в пользу кортежей стоит делать тогда, когда необходимо защитить данные от случайного изменения. Кроме того, многие операции с кортежами выполняются быстрее и занимают меньше памяти. В следующей статье будем изучать множества.

Содержание самоучителя

  1. Особенности, сферы применения, установка, онлайн IDE
  2. Все, что нужно для изучения Python с нуля – книги, сайты, каналы и курсы
  3. Типы данных: преобразование и базовые операции
  4. Методы работы со строками
  5. Методы работы со списками и списковыми включениями
  6. Методы работы со словарями и генераторами словарей
  7. Методы работы с кортежами
  8. Методы работы со множествами
  9. Особенности цикла for
  10. Условный цикл while
  11. Функции с позиционными и именованными аргументами
  12. Анонимные функции
  13. Рекурсивные функции
  14. Функции высшего порядка, замыкания и декораторы
  15. Методы работы с файлами и файловой системой
  16. Регулярные выражения
  17. Основы скрапинга и парсинга
  18. Основы ООП: инкапсуляция и наследование
  19. Основы ООП – абстракция и полиморфизм
  20. Графический интерфейс на Tkinter
Источник

Кортеж – это один из четырех встроенных типов данных в Python, используемых для хранения коллекций данных. Операции с кортежем – это те операции, которые могут выполняться с элементами в структуре данных кортежа. Давайте посмотрим на некоторые из наиболее широко используемых операций с кортежами в Python.

1. Подсчет вхождений элемента в кортеж

count () используется для подсчета общего количества вхождений элемента в кортеж. Если элемент не найден в кортеже, функция возвращает 0.

 tup1 = ( 1, 4, 7, 3, 6, 4, 1, 8, 4 )
 # counts number of times 4 occurs in the tuple
 print( tup1.count(4) )
 # prints
 3

2. Определение позиции элемента в кортеже

Вы можете использовать метод index (), чтобы найти индекс / позицию элемента в кортеже. Если в кортеже более одного вхождения элемента, функция возвращает индекс первого вхождения.

 tup1 = ( 1, 4, 7, 3, 6, 4, 1, 8, 4)
 print( tup1.index(4) )
 # prints
 1

Примечание:

Если вы попытаетесь найти индекс элемента, которого нет в кортеже, функция выдаст ValueError как:

ValueError: tuple.index (x): x не в кортеже

3. Как объединить две или более кортежей

Вы можете объединить два или более кортежа с помощью оператора + .

 tup1 = ( 1, 2, 3 )
 tup2 = ( 4, 5, 6 )
 tup3 = tup1 + tup2
 print( tup3 )
 # prints
 (1, 2, 3, 4, 5, 6)

4. Как преобразовать строку в кортеж

Вы можете использовать конструктор tuple () для преобразования строки в кортеж, передав строку в качестве параметра конструктору tuple ().

 tup1 = tuple( "MAKEUSEOF" )
 print( tup1 )
 # prints
 ('M', 'A', 'K', 'E', 'U', 'S', 'E', 'O', 'F')

5. Как преобразовать список в кортеж

Мы можем использовать три подхода для преобразования списка в кортеж.

Подход 1: использование конструктора tuple ()

Конструктор tuple () используется для преобразования списка в кортеж путем передачи списка в качестве параметра конструктору tuple ().

 list1 = [1, 2, 3, 4, 5, 6]
 tup1 = tuple(list1)
 print(tup1)
 # prints
 (1, 2, 3, 4, 5, 6)

Подход 2: использование конструктора цикла внутри tuple ()

Это небольшая вариация вышеупомянутого подхода. Мы запускаем цикл ( используя понимание списка ) внутри конструктора tuple () для создания кортежа.

 list1 = [ 1, 2, 3, 4, 5, 6 ]
 tup1 = tuple( element for element in list1 )
 print( tup1 )
 # prints
 (1, 2, 3, 4, 5, 6)

Подход 3. Использование (* listName,)

Это распаковывает список внутри литерала кортежа из-за наличия единственной запятой ( , ). Это самый быстрый из трех подходов.

 list1 = [1, 2, 3, 4, 5, 6]
 tup1 = (*list1,)
 print(tup1)
 # prints
 (1, 2, 3, 4, 5, 6)

6. Как умножать кортежи

Вы можете умножить содержимое кортежа любое количество раз, используя оператор * .

 tup1 = ( 1, 2, 3 )
 tup2 = tup1 * 3
 print( tup2 )
 # prints
 (1, 2, 3, 1, 2, 3, 1, 2, 3)

7. Как найти общее количество элементов в кортеже

Функция len () – одна из наиболее часто используемых встроенных функций в Python. Он используется для определения общего количества элементов в объекте. Вы можете использовать функцию len () с кортежем для подсчета общего количества элементов в кортеже.

 tup1 = ( 1, 2, 3 )
 print( len( tup1 ) )
 # prints
 3

8. Как найти минимальный элемент в кортеже

Функция min () используется для поиска элемента с наименьшим значением в заданном кортеже.

 tup1 = ( 1, 2, 3 )
 print("Minimum element in the tuple is: ")
 print( min( tup1 ) )
 # prints
 Minimum element in the tuple is:
 1

9. Как найти максимальный элемент в кортеже

Функция max () используется для поиска элемента с наибольшим значением в заданном кортеже.

 tup1 = ( 1, 2, 3 )
 print("Maximum element in the tuple is: ")
 print( max( tup1 ) )
 # prints
 Maximum element in the tuple is:
 3

10. Как найти сумму всех элементов в кортеже

Функция sum () используется для вычисления арифметической суммы всех элементов в кортеже.

 tup1 = ( 1, 2, 3 )
 print("Sum of elements : ")
 print( sum( tup1 ) )
 # prints
 Sum of elements :
 6

11. Операция any () над кортежами

Если один или несколько элементов кортежа имеют логическое значение True, функция any () возвращает True, в противном случае возвращает False .

 tup1 = ( False, False, False, True )
 print( any( tup1 ) )
 # prints
 True

12. Операция all () над кортежами

Вы можете использовать функцию all (), чтобы проверить, все ли элементы кортежа имеют логическое значение True. Даже если какой-либо элемент кортежа имеет логическое значение False, функция возвращает False.

 tup1 = ( True, True, True, False, True )
 print( all( tup1 ) )
 # prints
 False

13. Операция sorted () над кортежами

Вы можете использовать функцию sorted (), чтобы вернуть отсортированный список в порядке возрастания.

 tup1 = ( 6, 1, 8, 3, 7, 2 )
 print( sorted(tup1) )
 print( type(sorted( tup1 )) )
 # prints
 [1, 2, 3, 6, 7, 8]
 <class 'list'>
 # Note that the return type is list

14. Как перемешать кортеж

Поскольку кортежи неизменяемы, их нельзя перемешивать напрямую. Нам нужно использовать списки для перемешивания кортежа. Перемешать кортеж с помощью преобразования типов можно в три этапа:

Шаг 1: приведение кортежа к списку

Шаг 2. Перемешайте список

Шаг 3: приведение списка к кортежу

 import random
 old_tuple = ( 45, 46, 47, 48, 49 )
 # Printing tuple
 print("Old tuple:")
 print(old_tuple)
 # Typecasting tuple to list
 list1 = list(old_tuple)
 # Shuffling list
 random.shuffle(list1)
 # Typecasting list back to tuple
 new_tuple = tuple(list1)
 # Printing new shuffled tuple
 print("New shuffled tuple:")
 print(new_tuple)
 # prints
 Old tuple:
 (45, 46, 47, 48, 49)
 New shuffled tuple:
 (45, 49, 46, 47, 48)

Примечание. Поскольку кортеж перемешивается случайным образом, вы можете получить другой результат.

15. Как преобразовать список кортежей в список списков

Используя понимание списка, мы можем преобразовать список кортежей в список списков.

 list1 = [ ('A', 'B'), ('C', 'D'), ('E', 'F') ]
 print("List of tuples:")
 print( list1 )
 # List Comprehension
 result = [ list(element) for element in list1 ]
 print("List of lists:")
 print(result)
 # prints
 List of tuples:
 [('A', 'B'), ('C', 'D'), ('E', 'F')]
 List of lists:
 [['A', 'B'], ['C', 'D'], ['E', 'F']]

16. Как преобразовать список кортежей в список строк

Используя метод понимания списка и join (), мы можем преобразовать список кортежей в список строк.

 list1 = [ ('M', 'A', 'K', 'E'), ('U', 'S', 'E'), ('O', 'F') ]
 print("List of tuples:")
 print( list1 )
 # List Comprehension with join() method
 result = [ ''.join(element) for element in list1 ]
 print("List of strings:")
 print(result)
 # prints
 List of tuples:
 [('M', 'A', 'K', 'E'), ('U', 'S', 'E'), ('O', 'F')]
 List of strings:
 ['MAKE', 'USE', 'OF']

Используя технику нарезки, мы можем перевернуть кортеж. Во время этого процесса создается новая копия кортежа.

 old_tuple = ('M', 'A', 'K', 'E', 'U', 'S', 'E', 'O', 'F')
 print("Old tuple:")
 print(old_tuple)
 # Reversing tuple using slicing
 new_tuple = old_tuple[::-1]
 print("New tuple:")
 print(new_tuple)
 # prints
 Old tuple:
 ('M', 'A', 'K', 'E', 'U', 'S', 'E', 'O', 'F')
 New tuple:
 ('F', 'O', 'E', 'S', 'U', 'E', 'K', 'A', 'M')

Изучение питонического пути

Используя операции с кортежами в Python, вы можете выполнить задачу с минимальным количеством строк кода. Проявите творческий подход и исследуйте потенциал кортежей, чтобы изучить Python более питоническим способом.

Источник

Is there anyway to get tuple operations in Python to work like this:

>>> a = (1,2,3)
>>> b = (3,2,1)
>>> a + b
(4,4,4)

instead of:

>>> a = (1,2,3)
>>> b = (3,2,1)
>>> a + b
(1,2,3,3,2,1)

I know it works like that because the __add__ and __mul__ methods are defined to work like that. So the only way would be to redefine them?

Ciro Santilli OurBigBook.com's user avatar

asked Jan 31, 2009 at 0:51

Rodrigo's user avatar

Using all built-ins..

tuple(map(sum, zip(a, b)))

answered Jan 31, 2009 at 2:49

Kenan Banks's user avatar

Kenan BanksKenan Banks

206k34 gold badges154 silver badges171 bronze badges

4

import operator
tuple(map(operator.add, a, b))

8

This solution doesn’t require an import:

tuple(map(lambda x, y: x + y, tuple1, tuple2))

Andy Hayden's user avatar

Andy Hayden

355k101 gold badges619 silver badges535 bronze badges

answered Oct 3, 2012 at 6:20

Boaz Shvartzman's user avatar

1

Sort of combined the first two answers, with a tweak to ironfroggy’s code so that it returns a tuple:

import operator

class stuple(tuple):
    def __add__(self, other):
        return self.__class__(map(operator.add, self, other))
        # obviously leaving out checking lengths

>>> a = stuple([1,2,3])
>>> b = stuple([3,2,1])
>>> a + b
(4, 4, 4)

Note: using self.__class__ instead of stuple to ease subclassing.

tzot's user avatar

tzot

91.8k29 gold badges140 silver badges203 bronze badges

answered Jan 31, 2009 at 1:10

Dana's user avatar

DanaDana

31.8k17 gold badges62 silver badges73 bronze badges

0

Generator comprehension could be used instead of map. Built-in map function is not obsolete but it’s less readable for most people than list/generator/dict comprehension, so I’d recommend not to use map function in general.

tuple(p+q for p, q in zip(a, b))

answered Jan 14, 2016 at 20:22

Jaehyun Yeom's user avatar

simple solution without class definition that returns tuple

import operator
tuple(map(operator.add,a,b))

answered Jun 24, 2010 at 16:10

DemonEye's user avatar

DemonEyeDemonEye

611 silver badge1 bronze badge

All generator solution. Not sure on performance (itertools is fast, though)

import itertools
tuple(x+y for x, y in itertools.izip(a,b))

answered Sep 26, 2012 at 21:25

Mike's user avatar

MikeMike

8892 gold badges12 silver badges15 bronze badges

even simpler and without using map, you can do that

>>> tuple(sum(i) for i in zip((1, 2, 3), (3, 2, 1)))
(4, 4, 4)

answered Jun 12, 2016 at 23:17

LetsPlayYahtzee's user avatar

LetsPlayYahtzeeLetsPlayYahtzee

7,07111 gold badges40 silver badges64 bronze badges

Yes. But you can’t redefine built-in types. You have to subclass them:

class MyTuple(tuple):
    def __add__(self, other):
         if len(self) != len(other):
             raise ValueError("tuple lengths don't match")
         return MyTuple(x + y for (x, y) in zip(self, other))

answered Jan 31, 2009 at 0:55

Doug's user avatar

DougDoug

8,6901 gold badge27 silver badges37 bronze badges

1

I currently subclass the “tuple” class to overload +,- and *. I find it makes the code beautiful and writing the code easier.

class tupleN(tuple):
    def __add__(self, other):
        if len(self) != len(other):
             return NotImplemented
        else:
             return tupleN(x+y for x,y in zip(self,other))
    def __sub__(self, other):
        if len(self) != len(other):
             return NotImplemented
        else:
             return tupleN(x-y for x,y in zip(self,other))
    def __mul__(self, other):
        if len(self) != len(other):
             return NotImplemented
        else:
             return tupleN(x*y for x,y in zip(self,other))


t1 = tupleN((1,3,3))
t2 = tupleN((1,3,4))
print(t1 + t2, t1 - t2, t1 * t2, t1 + t1 - t1 - t1)
(2, 6, 7) (0, 0, -1) (1, 9, 12) (0, 0, 0)

answered Jun 25, 2019 at 18:06

user2012588's user avatar

Here is another handy solution if you are already using numpy.
It is compact and the addition operation can be replaced by any numpy expression.

import numpy as np
tuple(np.array(a) + b)

answered Dec 17, 2020 at 16:23

Hugues's user avatar

HuguesHugues

2,7851 gold badge26 silver badges37 bronze badges

I keep coming back to this question, and I don’t particularly like any of the answers as they are all answering the question for the general case, and I’m normally looking for the answer to a special case: I’m normally using a fixed tuple count, e.g. for n-dimensions.

   # eg adding a dx/dy to an xy point.
   # if I have a point xy and another point dxdy
   x, y = xy
   dx, dy = dxdy
   return x+dx, y+dy

while I normally shudder at unnecessary variables, the reason why I am unpacking a tuple is normally because I am working on the elements as individuals, and that is what is happening with tuple addition as requested above.

answered Dec 28, 2021 at 22:32

Konchog's user avatar

KonchogKonchog

1,90219 silver badges22 bronze badges

In case someone need to average a list of tuples: 

import operator 
from functools import reduce
tuple(reduce(lambda x, y: tuple(map(operator.add, x, y)),list_of_tuples))

answered Jan 20, 2018 at 4:32

ytutow's user avatar

ytutowytutow

2851 gold badge4 silver badges13 bronze badges

Источник

Добавить комментарий