Как применить функцию ко всем элементам списка пайтон

• Модуль csv - чтение и запись CSV файлов
• Создаём сайт на Django, используя хорошие практики. Часть 1: создаём проект
• Онлайн-обучение Python: сравнение популярных программ

• Книги о Python
• GUI (графический интерфейс пользователя)
• Курсы Python
• Модули
• Новости мира Python
• NumPy
• Обработка данных
• Основы программирования
• Примеры программ
• Типы данных в Python
• Видео
• Python для Web
• Работа для Python-программистов

• Сделай свой вклад в развитие сайта!
• Самоучитель Python
• Карта сайта
• Отзывы на книги по Python
• Реклама на сайте

Python: List (Списки)

Список – это структура данных, которая содержит упорядоченный набор элементов, т.е. хранит последовательность элементов. Изменяемые списки создаются через квадратные скобки. Элементы могут повторяться и меняться. Доступ к отдельному элементу тоже через квадратные скобки. Отсчёт с 0.

Узнать все методы списка можно через команду.

 help(list) 

Рассмотрим некоторые примеры.

 cats = ["Барсик", "Мурзик", "Васька"] print(cats) # все элементы списка print(cats[1]) # один указанный элемент numbers = [0, 1, 2, 3, 4, 5] print(numbers) print(numbers[4]) // список из строки mylist = list('Барсик') print(mylist) 

В списке могут быть разные типы. Поместим в список числа и строки.

 mix = ["one", 3, "two", "three", 9, 3] print(mix[1]) print(mix[2]) 

Можно создать пустой список.

 empty = [] print(empty) # [] 

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

 numbers = [0, 1, 2, 3, 4, 5] print(numbers[-1]) #5 print(numbers[-2]) #4 print(numbers[-3]) #3 

Развернуть список можно через reverse().

 reversed = [1, 2, 3, 4, 4] reversed.reverse() print (reversed) # [4, 4, 3, 2, 1] kitten = list("Барсик") kitten.reverse() print(kitten) # ['к', 'и', 'с', 'р', 'а', 'Б'] 

Сортировать можно через sort().

 mylist = [8, 2, 11, 4, 3] mylist.sort() print (mylist) 

Можем заменить существующие элементы списка.

 numbers = [0, 1, 2, 3, 4, 5] numbers[0] = 10 numbers[5] = 22 print(numbers[-1]) print(numbers[0]) 

Добавить новый элемент в конец списка можно через append().

 numbers = [0, 1, 2, 3, 4, 5] numbers.append(99) print(numbers[-1]) 

Можно вставить элемент в нужную позицию через insert(), указав индекс.

 numbers = [0, 1, 2, 3, 4, 5] numbers = [0, 1, 2, 3, 4, 5] numbers.insert(1, 33) print(numbers[1]) print(numbers) # [0, 33, 1, 2, 3, 4, 5] 

Удалить элемент по указанному индексу можно через remove().

 numbers = [0, 1, 2, 3, 4, 5] numbers.remove(5) print(numbers) # [0, 1, 2, 3, 4] 

Метод pop() также позволяет удалить элемент по индексу, но при этом возвращает значение удалённого элемента. Если индекс не указан, то удаляется последний элемент.

 numbers = [6, 3, 9, 5, 1, 5] poped = numbers.pop(2) print(poped) # 9 poped = numbers.pop() print(poped) # 5 

Есть ещё способ удаления по индексу через инструкцию del.

Когда удаляется элемент с индексом 1, элемент, имевший индекс 2, становится элементом с индексом 1, элемент, имевший индекс 3, приобретает индекс 2 и так далее. Соответственно, количество индексов при удалении элемента уменьшается.

Можно запускать команду del numbers[1] снова и снова, удаляя по одному элементу списка. Главное, это вовремя остановиться, чтобы не получить ошибку при удалении несуществующего индекса.

Длину списка можно узнать через len().

 numbers = [6, 8, 2, 5, 1, 5] print(len(numbers)) # 6 

Узнать количество одинаковых элементов в списке можно через count().

 kitten = list('котёнок') print(kitten.count('к')) # 2 

Список можно расширить другим списком через extend(). Новые элементы добавляются в конец первого списка.

 oneList = [6, 8, 2, 5, 1, 5] secondList = [0, 1, 4] oneList.extend(secondList) print(oneList) # [6, 8, 2, 5, 1, 5, 0, 1, 4] 

Два списка можно сложить и получить третий список.

 firstList = [6, 8, 2, 5, 1, 5] secondList = [0, 1, 4] bigList = firstList + secondList print(bigList) # [6, 8, 2, 5, 1, 5, 0, 1, 4] 

Пройтись по всем элементам списка можно через цикл for.

 numbers = [1, 2, 3] for element in numbers: print(element) 

Фильтрация списка через filter() с лямбдой

Мы можем фильтровать элементы списка по заданному условию, используя класс filter и лямбда-выражения.

Допустим, у нас есть список чисел от 1 до 10 и мы хотим оставить числа меньше 5. Применяем к списку функцию filter(), в котором указываем лямбда-выражение - берётся каждый элемент списка и проверяется условие. Если число меньше 5, то условие выполняется и число попадает в объект класса filter. Затем мы создаём новый список, куда помещаем созданный объект и на выходе получаем финальный результат - отфильтрованный список.

 sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] filterObj = filter(lambda x: x < 5, sourceList) print(type(filterObj)) # filteredList = list(filterObj) print(filteredList) # [1, 2, 3, 4] 

Существует другой громоздкий вариант через цикл for, который не стал приводить здесь.

Вместо лямбда-выражения можно использовать именную функцию. Создадим именную функцию под именем isGreater и зададим условие - числа должны быть больше 5.

 def isGreater(x): return x > 5 sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] filteredList = list(filter(isGreater, sourceList)) print(str(filteredList)) 

Проекция на список через map() с лямбдой

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

 sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] mapObj = map(lambda x: x + 9, sourceList) print(type(mapObj)) # mappedList = list(mapObj) print(mappedList) # [10, 11, 12, 13, 14, 15, 16, 17, 18, 19] 

Вырезка последовательности

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

 item[START:STOP:STEP] 

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

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

 sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] print(sourceList[1:4]) # со второго до четвёртого print(sourceList[5:]) # с шестого элемента до конца print(sourceList[1:-1]) # со второго до предпоследнего print(sourceList[:]) # все элементы 
[2, 3, 4] [6, 7, 8, 9, 10] [2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 

Можно указать шаг вырезки в третьем аргументе (по умолчанию шаг вырезки равен 1):

 sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] print(sourceList[1:8:2]) # [2, 4, 6, 8] 

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

 sourceList = [1, 2, 3, 4, 5] sourceList[1:3] = [7, 7, 7] # добавим три новых элемента вместо второго и третьего элемента print(sourceList) # [1, 7, 7, 7, 4, 5] del sourceList[:-3] # удаляем первые элементы списка до третьего элемента с конца print(sourceList) # [7, 4, 5] 

Как применить функцию ко всем элементам списка (произвольной вложенности)

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

['1','2', ['1',['2','4',['5','6']]],'7','8'] 

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

[1, 4, [1, [4, 16, [25, 36]]], 49, 64] 

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

Отслеживать
задан 27 дек 2016 в 22:43
MaxU - stand with Ukraine MaxU - stand with Ukraine
149k 12 12 золотых знаков 59 59 серебряных знаков 132 132 бронзовых знака

4 ответа 4

Сортировка: Сброс на вариант по умолчанию

Чтобы поместу изменить, не создавая новые списки (поиск в глубину—depth-first search (DFS)):

def apply_nested(func, lst, isatom=lambda item: not isinstance(item, list)): for i, item in enumerate(lst): if isatom(item): lst[i] = func(item) else: apply_nested(func, item, isatom) 

Здесь isatom() предикат определяет, что является неразрывным элементом (атомом) для заданного алгоритма: apply_nested(func, lst) вызывает func функцию для каждого атома в (глубоковложенном) списке lst . Похожее решение: flatten_gen() .

def apply_nested(func, lst, isatom=lambda item: not isinstance(item, list)): stack = [lst] while stack: lst = stack.pop() for i, item in enumerate(lst): if isatom(item): lst[i] = func(item) else: stack.append(item) 

>>> nested = ['1','2', ['1',['2','4',['5','6']]],'7','8'] >>> apply_nested(lambda atom: int(atom)**2, nested) >>> nested [1, 4, [1, [4, 16, [25, 36]]], 49, 64] 

Аналогично, можно определить функции, которые возвращают новые значения, не изменяя ввода (DFS):

def map_nested(func, lst, isatom=lambda item: not isinstance(item, list)): return [func(item) if isatom(item) else map_nested(func, item, isatom) for item in lst] 

def map_nested(func, lst, isatom=lambda item: not isinstance(item, list)): result = [] stack = [(lst, result)] while stack: lst, new_lst = stack.pop() for item in lst: if isatom(item): new_lst.append(func(item)) else: # item is a sublist (collection) sublist = [] new_lst.append(sublist) stack.append((item, sublist)) return result 

>>> map_nested(lambda atom: int(atom)**2, nested)) [1, 4, [1, [4, 16, [25, 36]]], 49, 64] 

Отслеживать
ответ дан 28 дек 2016 в 18:34
52.2k 11 11 золотых знаков 108 108 серебряных знаков 312 312 бронзовых знаков

Сложно что-то выдумать - в вашем решении уже вроде все есть. Однако, можно попробовать внести пару (ненужных?) изменений + функция в одну строку. Большую функцию тоже можно при желании разместить в 1 строку, однако это уже будет чересчур:

import timeit def map_nested(lst, func=lambda x: x, forbidden_types=(str, int)): container_type = type(lst) if hasattr(lst, '__iter__') and type(lst) not in forbidden_types: return container_type(map_nested(item, func) for item in lst) else: try: return func(lst) except: return lst def map_nested_1line(lst, func=lambda x: x): return [map_nested_1line(item, func) for item in lst] if type(lst) is list else func(lst) 

UPDATE: Утро вечера мудренее и подумав я родил нерекурсивный вариант этой функции. Нерекурсивный хорош тем, что не упадет на длинных и сильно вложенных списках на ОС с ограничением на длину рекурсии. Плох тем, что очень медленный. Суть нерекурсивного решения в том, что в специальный массив заносится порядок входа и выхода во вложенные списки. Находим вложенный массив - заносим указатель на него + индекс в спец. хранилище. Выходим из него - указатель и индекс извлекаем.

# Also non-recursive. Yay! def map_nested_inplace(lst, func=lambda x: x, forbidden_types=(str, int)): # forbidden_types не используется processed_elements = 0 # assert type(lst) is list # blah-blah current_container = lst containers_repo = [[current_container, 0]] # До тех пор, пока не были обработаны все списки и под-списки while len(containers_repo) != 0: while True: try: # Следующий элемент в текущем списке. # Может быть как числом, так и новым под-списком next_one = current_container[containers_repo[-1][1]] break # Исключение означает, что под-список кончился. # Т.к. он кончился, то убираем его из хранилища # и пробуем извлечь следующий элемент except IndexError: containers_repo.pop() if len(containers_repo) == 0: break current_container = containers_repo[-1][0] if len(containers_repo) != 0: if type(next_one) is list: # Это под-список, а не число. # Заносим под-список в хранилище и # на следующей итерации открываем уже его containers_repo[-1][1] += 1 current_container = next_one containers_repo.append([current_container, 0]) else: current_container[containers_repo[-1][1]] = func(current_container[containers_repo[-1][1]]) containers_repo[-1][1] += 1 # ради небольшой проверки processed_elements += 1 # set также работает, но непохоже, чтобы он сохранял порядок lst = ['1', 'an error', ('1', ['2', '4', (5, '6')]), '7', 8] lst_simple = ['1', '2', ['1', ['2', '4', ['5', '6']]], '7', '8'] lst_another_simple = ['1', '2', ['1', ['2', '4', ['5', '6']], ['6', '6', '6'], ['8', '8']], '7', ['11'], '8'] print(map_nested(lst, lambda x: int(x)**2)) print(map_nested_1line(lst_simple, lambda x: int(x)**2)) print(map_nested_1line([], lambda x: int(x)**2)) map_nested_inplace(lst_another_simple, lambda x: int(x)**2) print(lst_another_simple) 

Также немного тестирования:

import random test_array = [] container_tree = [test_array] current_container = container_tree[-1] TOTAL_AMOUNT = 10000 NEW_LEVEL_PROBABILITY = 0.5 for i in range(TOTAL_AMOUNT): if random.random() >= NEW_LEVEL_PROBABILITY: current_container.append([]) container_tree.append(current_container[-1]) current_container = current_container[-1] elif len(container_tree) > 1: current_container = container_tree[-2] current_container.append(str(random.randint(0, 20))) # Для работоспособности рекурсивных методов # Впрочем, без старта новго потока с threading.stack_size() все равно не будет работать :( import sys if sys.getrecursionlimit() < len(container_tree) * 2: sys.setrecursionlimit(len(container_tree) * 2) setup_statement = """from __main__ import test_array, """ # Не используется lambda x**2, потому что # в inplace квадраты будут накатываться до тех пор, # пока хватит памяти - список для каждого прохода должен генерироваться заново print(timeit.timeit("map_nested_inplace(test_array)", setup=setup_statement + "map_nested_inplace", number=100)) print(timeit.timeit("map_nested_1line(test_array)", setup=setup_statement + "map_nested_1line", number=100)) print(timeit.timeit("map_nested(test_array)", setup=setup_statement + "map_nested", number=100)) >>> 1.8096923486838081 # Без рекурсии >>> 0.9477624593712808 # Однострочник >>> 1.827232542223693 # Большая функция