Как сложить элементы списка в python
Перейти к содержимому

Как сложить элементы списка в python

  • автор:

Разбор: задача про массив и сумму чисел

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

Задание

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

Ещё у нас есть какое-то целое число — оно не в массиве, а само по себе, отдельной переменной.

Нужно вывести индексы тех двух элементов, которые в сумме дают то самое отдельное число. Например, если в массиве у нас (2, 4, 5, 1, 8), а число — 5, то ответом будет пара 1 и 3, потому что на этих местах стоят числа 4 и 1 (и дают в сумме 5). Помните, что нумерация массивов почти во всех языках программирования начинается с нуля.

Решение простым перебором

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

  1. В первом цикле перебираем все элементы от первого до предпоследнего.
  2. Внутрь вкладываем второй, но делаем это так, чтобы не пересекаться по индексам с первым циклом. Для этого смотрим на переменную, с которой работает первый цикл, и начинаем со следующей — и до последнего элемента.
  3. Внутри второго цикла складываем элементы массива с нашими индексами и смотрим, получился нужный результат или нет.
  4. Если получился — выводим результат и останавливаемся.
  5. Если не получился — идём на новый виток цикла.
  6. Если мы прошли весь массив, но так ничего и не нашли — выводим сообщение о том, что такой пары нет.
# массив с числами nums = [2, 4, 5, 1, 8] # сумма target = 5 # функция, которая найдёт ответ def twoSum(nums, target): # сообщение по умолчанию answer = 'В массиве нет такой пары чисел' # запускаем первый цикл for i in range(len(nums) - 1): # запускаем второй цикл for j in range(i + 1, len(nums)): # если получили нужный результат — if target == nums[i] + nums[j]: # меняем ответ и добавляем в него индексы элементов answer = 'Ответ: ' + str(i) + ' и ' + str(j) # выводим результат работы функции return answer # запускаем код print(twoSum(nums, target))

Разбор: задача про массив и сумму чисел

Решение с дополнительным словарём

Если хотите показать, что вы умеете нестандартно мыслить — используйте приём с дополнительным словарём, в котором данные хранятся попарно: ключ и значение. С ним можно убрать один вложенный цикл и сократить количество вычислений. Работает приём так: мы создаём дополнительный словарь, в котором будем хранить результаты просмотра исходного массива. Но создаём его с одной особенностью: мы будем заполнять его не по порядку, а указывая в качестве ключей значения элементов исходного массива. Например, если в исходном массиве у элемента с индексом 2 значение равно 15, то мы в новом словаре создаём элемент с ключом 15 и кладём туда двойку:

Разбор: задача про массив и сумму чисел

Это даст нам быстрый доступ к индексам уже проверенных элементов — мы просто указываем значение элемента и сразу получаем его индекс в исходном массиве.

Остальная логика выглядит так:

  1. Перебираем исходный массив и на каждом шаге считаем разницу между нужным значением и очередным элементом.
  2. Если разница есть в словаре с просмотренными элементами — выводим оба индекса.
  3. Если разницы в словаре нет — добавляем только что просмотренный элемент в словарь.

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

# массив с числами nums = [2, 4, 5, 1, 8] # сумма target = 5 # функция, которая найдёт ответ def twoSum(nums, target): # сообщение по умолчанию answer = 'В массиве нет такой пары чисел' # дополнительный словарь с уже проверенными элементами hashmap = <> # перебираем исходный массив for i in range(len(nums)): # находим разницу между нужным значением и очередным элементом complement = target - nums[i] # если такое значение нам уже попадалось раньше — if complement in hashmap: # получаем индекс того значения и выводим ответ answer = 'Ответ: ' + str(hashmap[complement]) + ' и ' + str(i) # если не попадалось — запоминаем индекс по значению элемента hashmap[nums[i]] = i # выводим результат работы функции return answer # запускаем код print(twoSum(nums, target))

Разбор: задача про массив и сумму чисел

Что дальше

Есть ещё третий способ решения этой задачи — попробуйте найти его сами и почувствовать себя на собеседовании. И подпишитесь, чтобы не пропустить новые статьи с разборами.

Сумма элементов списка * на индекс

Условие: Необходимо написать функцию, которая вернёт сумму всех элементов списка, умноженных на свой индекс. Для пустого списка возвращаем 0.

index_multiplier([1, 2, 3, 4, 5]) ➞ 40.

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

""" вариант с встроенной функцией sum""" def index_multiplier(lst): return sum(j*i for i, j in enumerate(lst))
""" sum + list comprehension """ def index_multiplier(lst): return sum([v*i for i,v in enumerate(lst)])
""" Просто циклами """ def index_multiplier(lst): sum = 0 for i in range (len(lst)): sum += i*lst[i] return sum

Вариант решения от нашего подписчика @baalique:

index_multiplier = lambda seq: sum(i * v for i, v in enumerate(seq))

Как сложить элементы двух списков?

Если важно сохранить начальные списки, то попробуем по другому:

# заполнение переменных a = [1, 2, 3, 4] b = [1, 2, 3] # обработка c = map(sum, zip(a + [0,]*(len(b)-len(a)), b + [0,]*(len(a)-len(b)))) # вывод результата print(list(c)) 

Вариант 3:

В Python 3.8 появился «морж» — оператор := Если важно не повторить функционал:

# заполнение переменных a = [1, 2, 3, 4] b = [1, 2, 3] # обработка c = map(sum, zip(a + [0, ] * (x := len(b) - len(a)), b + [0, ] * -x)) # вывод результата print(list(c)) Результат: > [2, 4, 6, 4] 

Отслеживать
ответ дан 19 мар 2021 в 13:02
121 6 6 бронзовых знаков
Вариант забавный, но 1) он меняет исходные списки, 2) повторяет функционал itertools.zip_longest
19 мар 2021 в 13:10
Так то пусть будет, разные ответы это хорошо )
19 мар 2021 в 13:19
согласен, не без недостатков, но как вариант для «по быстрому»
19 мар 2021 в 13:20
добавил варианты без изменения исходных списков и вариант для Python 3.8 без повтора функционала
19 мар 2021 в 13:54

Если вы еще не «прошли ‘from’ ‘import'», то наиболее простой вариант выглядит вот так:

с=list(map(lambda x, y: x + y, a, b)) 
c1 = [x+y for x,y in zip(a,b)] + (a if len(a) >= len(b) else b)[min(len(a), len(b)):] 

При необходимости обернуть это в вызов функции, надеюсь, сможете сделать самостоятельно: на вход a и b, указанные выражения — в качестве параметра в return.

Отслеживать
ответ дан 22 дек 2019 в 14:14
11.8k 2 2 золотых знака 10 10 серебряных знаков 16 16 бронзовых знаков

Спасибо тебе за ответ) мне нужно просто без комприхенш`на может просто через def и внутри def через for буду рад если поможете = )

23 дек 2019 в 8:51

Если у вас списка ВСЕГДА точно будут одной длины, то можно воспользоваться генератор списков и zip:

a = [1, 2, 3] b = [4, 5, 6] c = [x+y for x, y in zip(a, b)] print(c) #[5, 7, 9] 

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

from itertools import zip_longest a = [1, 2, 3] b = [4, 5, 6, 10] c = [x+y for x, y in zip_longest(a, b, fillvalue=0) #fillvalue нужен, если ваши списки разных рамеров и там где не достаёт элементов, добьёт нулями. print(c) #[5, 7, 9, 10] 

Ответ на комментарий:

from itertools import zip_longest def add_list(a, b): c = [x+y for x, y in zip_longest(a, b, fillvalue=0)] return c a = [1, 2, 3] b = [4, 5, 6, 10] summ_list = add_list(a, b) print(summ_list) 

Как преобразовать список в строку в Python

Рассказываем о методе join() и других полезных инструментах для конвертирования Python‑списков в строки.

Иллюстрация: Оля Ежак для Skillbox Media

Иван Стуков

Иван Стуков
Журналист, изучает Python. Любит разбираться в мелочах, общаться с людьми и понимать их.

В Python существует два основных способа сделать из списка строку: с помощью цикла и с помощью метода join(). У обоих есть нюансы, о которых мы сейчас расскажем.

Преобразование с помощью цикла

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

Как это работает: мы создаём пустую строку, потом с помощью цикла переберём каждый элемент списка и на каждой итерации будем добавлять к строке текущий элемент списка.

lst = ['Преобразование','через','цикл'] #Создаём пустую строку string = '' #По очереди добавляем к ней каждый элемент списка for el in lst: string += el print(string) >>> Преобразованиечерезцикл

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

Поэтому, перед тем как добавлять элемент в список, его нужно преобразовать в строку. Делается это с помощью функции str(). Добавим её в наш код.

#Создаём список, в котором есть как строки, так и цифры lst = ['Преобразование','через','цикл', 2] string = '' for el in lst: string += str(el) #Превращаем каждый элемент списка в строку print(string) >>> Преобразованиечерезцикл2

Если нужно установить разделитель между строками, то для него нужно прописать отдельную строчку кода внутри цикла.

lst = ['Преобразование','через','цикл', 3] string = '' for el in lst: #Добавляем к строке элемент списка string += str(el) #Добавляем к строке разделитель — в данном случае пробел string += ' ' print(string) >>> Преобразование через цикл 3

Обратите внимание: раз мы добавляем разделитель на каждой итерации, пробел будет и после цифры 3 нашего последнего элемента. Это легко проверить, если вместо пробела добавлять какой-то другой, видимый символ.

Эту проблему можно решить — ещё больше усложнив код. Например, введя условие, которое проверяет, последний это элемент в списке или нет. Однако гораздо проще и удобнее превратить список в строку, используя встроенный метод join().

Преобразование с помощью метода join()

Метод join(), по сути, делает всё то же самое, что и наш цикл, но лучше, удобнее и занимает всего одну строку. Вот как его применяют:

string.join(lst)

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

Посмотрим, как join() применяется на практике.

lst = ['Преобразование', 'через', 'метод', 'join()'] #Объединяем элементы списка с пустым разделителем print(''.join(lst)) >>> Преобразованиечерезметодjoin() #Устанавливаем пробел в качестве разделителя print(' '.join(lst)) >>> Преобразование через метод join()

Заметили особенность? Разделители ставятся только между элементами, а не после каждого элемента, как было в нашем цикле. join() — умница. Однако и тут есть ахиллесова пята: если в списке встречаются нестроковые элементы, мы получим ошибку. Чтобы этого избежать, надо опять-таки сначала превратить все нестроки в строки. Сделать это можно двумя способами.

Использовать выражение-генератор

Выражение-генератор — это конструкция, которая позволяет провести операцию над каждым элементом списка. Оно возвращает генератор, с которым метод join() обращается точно так же, как и со списками.

lst = [1, 1.2, 'строка', False] print(' '.join(str(el) for el in lst)) >>> 1 1.2 строка False

Конструкция str(el) for el in lst означает, что каждый элемент el в списке lst будет превращён в строку с помощью функции str (стандартной функции Python, которую мы уже использовали, когда работали с циклом).

Использовать функцию map()

Функция map() умеет делать то же самое, что и выражение-генератор, но их синтаксис отличается. В качестве первого аргумента она принимает саму операцию, в качестве второго — список, к элементам которого эта операция применяется.

lst = [1, 1.2, 'строка', False] print(' '.join(map(str, lst))) >>> 1 1.2 строка False

Конструкция map(str, lst) означает, что каждый элемент в списке lst будет превращён в строку с помощью функции str. Обратите внимание, что в качестве аргумента в map() передаётся только название функции, без скобок.

Итоги

Преобразовать список в строку можно с помощью цикла, но для этого есть и более удобный инструмент — метод join().

Если содержит нестроковые элементы, то их для начала придётся превратить в строки — иначе выскочит ошибка. Для этого можно воспользоваться выражением-генератором или функцией map().

Читайте также:

  • Списки в Python: что это такое и как с ними работать
  • Тест. Какой язык создадите вы — Java или Python?
  • Язык Go: что под капотом и зачем программисту учить его как второй

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

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