Как переметить нулевые значения в конец списка?
Есть список с числами, среди элементов списка есть нули. Подскажите как переместить нулевые значения в конец этого же списка или нового с помощью list comprehension и/или срезов?
- Вопрос задан более года назад
- 534 просмотра
3 комментария
Простой 3 комментария
Что мешает отсортировать на месте?

lt = [0,1,8,3,0,4,5,0,0] for i in lt: if i == 0: lt = lt[:lt.index(i)]+lt[lt.index(i)+1:]+[i] print(lt)
nihi1ist @nihi1ist Автор вопроса
mkone112, порядок символов отличных от нуля должен остаться прежним.
Решения вопроса 2

original_list = [0,1,8,3,0,4,5,0,0] #исходный список new_list = [x for x in original_list if x != 0] #только ненулевые элементы how_many_zeros = len(original_list) - len(new_list) #сколько нулей потеряли? new_list.extend( [0] * how_many_zeros ) # добавляем нужное количество нулей в конец
Ответ написан более года назад
Нравится 1 1 комментарий
nihi1ist @nihi1ist Автор вопроса
Уже сделал немного по другому. Отсортировал в 2 списка (цифры и нули). А затем через extend() расширил список.
Как переметить нулевые значения в конец списка?
lst = [0,1,8,3,0,4,5,0,0] lst.sort(key=lambda i: bool(i), reverse=True)
print(lst) [1, 8, 3, 4, 5, 0, 0, 0, 0]
Ответ написан более года назад
Комментировать
Нравится 1 Комментировать
Ответы на вопрос 0
Ваш ответ на вопрос
Войдите, чтобы написать ответ

- Python
- +1 ещё
Почему при большом количестве строк async выдает ошибку?
- 1 подписчик
- 2 часа назад
- 19 просмотров
Вставить элемент в конец списка Python
В этом посте мы обсудим, как вставить элемент в конец списка в Python.
1. Использование list.append(x) функция
Вы можете добавлять новые элементы в конец списка, используя append() функция:
if __name__ == ‘__main__’ :
l = [ ‘A’ , ‘B’ , ‘C’ ]
l . append ( x )
print ( l ) # prints [‘A’, ‘B’, ‘C’, ‘D’]
2. Использование list.insert(i, x) функция
Вы также можете использовать список insert() функция, которая вставляет элемент в указанную позицию.
if __name__ == ‘__main__’ :
l = [ ‘A’ , ‘B’ , ‘C’ ]
l . insert ( len ( l ) , x )
print ( l ) # prints [‘A’, ‘B’, ‘C’, ‘D’]
3. Использование итерируемого оператора распаковки
Другим правдоподобным способом вставки в конце является использование * итерируемый оператор распаковки. Эта функция была представлена в Python 3.5 после принятия PEP 448 — Дополнительные обобщения распаковки.
if __name__ == ‘__main__’ :
l = [ ‘A’ , ‘B’ , ‘C’ ]
print ( l ) # prints [‘A’, ‘B’, ‘C’, ‘D’]
4. Создание нового списка
Другой подход состоит в том, чтобы сначала преобразовать данный элемент в список, а затем объединить его с существующим списком. Обратите внимание, что это решение медленнее, чем все вышеперечисленные решения, поскольку оно создает новый список.
if __name__ == ‘__main__’ :
l = [ ‘A’ , ‘B’ , ‘C’ ]
l += [ x ] # или используйте нарезку: l[len(l):] = [x]
print ( l ) # prints [‘A’, ‘B’, ‘C’, ‘D’]
Вот и все, что касается вставки элемента в конец списка в Python.
Оценить этот пост
Средний рейтинг 5 /5. Подсчет голосов: 2
Голосов пока нет! Будьте первым, кто оценит этот пост.
Сожалеем, что этот пост не оказался для вас полезным!
Расскажите, как мы можем улучшить этот пост?
Спасибо за чтение.
Пожалуйста, используйте наш онлайн-компилятор размещать код в комментариях, используя C, C++, Java, Python, JavaScript, C#, PHP и многие другие популярные языки программирования.
Как мы? Порекомендуйте нас своим друзьям и помогите нам расти. Удачного кодирования 🙂
Подписывайся
0 Комментарии
Встроенные отзывы
Просмотреть все комментарии
Загрузить больше комментариев
Просматривать
Подпишитесь на новые публикации
- Все проблемы
- Практика DSA
- 100 самых популярных задач
- 50 лучших классических задач
- Лучшие алгоритмы
- Компилятор С/С++
- Компилятор Java
- Компилятор Python
- Компилятор JavaScript
- компилятор PHP
- Компилятор C#
- Свяжитесь с нами
- Политика конфиденциальности
- условия обслуживания
- Подпишитесь на новые публикации
Techie Delight © 2023 Все права защищены.
Этот веб-сайт использует файлы cookie. Используя этот сайт, вы соглашаетесь с использованием файлов cookie, нашей политикой, условиями авторского права и другими условиями. Читайте наши Политика конфиденциальности. Понятно
Списки, кортежи и словари
Для работы с наборами данных Python предоставляет такие встроенные типы как списки, кортежи и словари.
Список (list) представляет тип данных, который хранит набор или последовательность элементов. Во многих языках программирования есть аналогичная структура данных, которая называется массив.
Создание списка
Для создания списка применяются квадратные скобки [] , внутри которых через запятую перечисляются элементы списка. Например, определим список чисел:
numbers = [1, 2, 3, 4, 5]
Подобным образом можно определять списки с данными других типов, например, определим список строк:
people = ["Tom", "Sam", "Bob"]
Также для создания списка можно использовать функцию-конструктор list() :
numbers1 = [] numbers2 = list()
Оба этих определения списка аналогичны — они создают пустой список.
Список необязательно должен содержать только однотипные объекты. Мы можем поместить в один и тот же список одновременно строки, числа, объекты других типов данных:
objects = [1, 2.6, "Hello", True]
Для проверки элементов списка можно использовать стандартную функцию print, которая выводит содержимое списка в удобочитаемом виде:
numbers = [1, 2, 3, 4, 5] people = ["Tom", "Sam", "Bob"] print(numbers) # [1, 2, 3, 4, 5] print(people) # ["Tom", "Sam", "Bob"]
Конструктор list может принимать набор значений, на основе которых создается список:
numbers1 = [1, 2, 3, 4, 5] numbers2 = list(numbers1) print(numbers2) # [1, 2, 3, 4, 5] letters = list("Hello") print(letters) # ['H', 'e', 'l', 'l', 'o']
Если необходимо создать список, в котором повторяется одно и то же значение несколько раз, то можно использовать символ звездочки *, то есть фактически применить операцию умножения к уже существующему списку:
numbers = [5] * 6 # 6 раз повторяем 5 print(numbers) # [5, 5, 5, 5, 5, 5] people = ["Tom"] * 3 # 3 раза повторяем "Tom" print(people) # ["Tom", "Tom", "Tom"] students = ["Bob", "Sam"] * 2 # 2 раза повторяем "Bob", "Sam" print(students) # ["Bob", "Sam", "Bob", "Sam"]
Обращение к элементам списка
Для обращения к элементам списка надо использовать индексы, которые представляют номер элемента в списка. Индексы начинаются с нуля. То есть первый элемент будет иметь индекс 0, второй элемент — индекс 1 и так далее. Для обращения к элементам с конца можно использовать отрицательные индексы, начиная с -1. То есть у последнего элемента будет индекс -1, у предпоследнего — -2 и так далее.
people = ["Tom", "Sam", "Bob"] # получение элементов с начала списка print(people[0]) # Tom print(people[1]) # Sam print(people[2]) # Bob # получение элементов с конца списка print(people[-2]) # Sam print(people[-1]) # Bob print(people[-3]) # Tom
Для изменения элемента списка достаточно присвоить ему новое значение:
people = ["Tom", "Sam", "Bob"] people[1] = "Mike" # изменение второго элемента print(people[1]) # Mike print(people) # ["Tom", "Mike", "Bob"]
Разложение списка
Python позволяет разложить список на отдельные элементы:
people = ["Tom", "Bob", "Sam"] tom, bob, sam = people print(tom) # Tom print(bob) # Bob print(sam) # Sam
В данном случае переменным tom, bob и sam последовательно присваиваются элементы из списка people. Однако следует учитывать, что количество переменных должно быть равно числу элементов присваиваемого списка.
Перебор элементов
Для перебора элементов можно использовать как цикл for, так и цикл while.
Перебор с помощью цикла for :
people = ["Tom", "Sam", "Bob"] for person in people: print(person)
Здесь будет производиться перебор списка people, и каждый его элемент будет помещаться в переменную person.
Перебор также можно сделать с помощью цикла while :
people = ["Tom", "Sam", "Bob"] i = 0 while i < len(people): print(people[i]) # применяем индекс для получения элемента i += 1
Для перебора с помощью функции len() получаем длину списка. С помощью счетчика i выводит по элементу, пока значение счетчика не станет равно длине списка.
Сравнение списков
Два списка считаются равными, если они содержат один и тот же набор элементов:
numbers1 = [1, 2, 3, 4, 5] numbers2 = list([1, 2, 3, 4, 5]) if numbers1 == numbers2: print("numbers1 equal to numbers2") else: print("numbers1 is not equal to numbers2")
В данном случае оба списка будут равны.
Получение части списка
Если необходимо получить какую-то определенную часть списка, то мы можем применять специальный синтаксис, который может принимать следующие формы:
- list[:end] : через параметр end передается индекс элемента, до которого нужно копировать список
- list[start:end] : параметр start указывает на индекс элемента, начиная с которого надо скопировать элементы
- list[start:end:step] : параметр step указывает на шаг, через который будут копироваться элементы из списка. По умолчанию этот параметр равен 1.
people = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"] slice_people1 = people[:3] # с 0 по 3 print(slice_people1) # ["Tom", "Bob", "Alice"] slice_people2 = people[1:3] # с 1 по 3 print(slice_people2) # ["Bob", "Alice"] slice_people3 = people[1:6:2] # с 1 по 6 с шагом 2 print(slice_people3) # ["Bob", "Sam", "Bill"]
Можно использовать отрицательные индексы, тогда отсчет будет идти с конца, например, -1 - предпоследний, -2 - третий сконца и так далее.
people = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"] slice_people1 = people[:-1] # с предпоследнего по нулевой print(slice_people1) # ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"] slice_people2 = people[-3:-1] # с третьего с конца по предпоследний print(slice_people2) # [ "Sam", "Tim"]
Методы и функции по работе со списками
Для управления элементами списки имеют целый ряд методов. Некоторые из них:
- append(item) : добавляет элемент item в конец списка
- insert(index, item) : добавляет элемент item в список по индексу index
- extend(items) : добавляет набор элементов items в конец списка
- remove(item) : удаляет элемент item. Удаляется только первое вхождение элемента. Если элемент не найден, генерирует исключение ValueError
- clear() : удаление всех элементов из списка
- index(item) : возвращает индекс элемента item. Если элемент не найден, генерирует исключение ValueError
- pop([index]) : удаляет и возвращает элемент по индексу index. Если индекс не передан, то просто удаляет последний элемент.
- count(item) : возвращает количество вхождений элемента item в список
- sort([key]) : сортирует элементы. По умолчанию сортирует по возрастанию. Но с помощью параметра key мы можем передать функцию сортировки.
- reverse() : расставляет все элементы в списке в обратном порядке
- copy() : копирует список
Кроме того, Python предоставляет ряд встроенных функций для работы со списками:
- len(list) : возвращает длину списка
- sorted(list, [key]) : возвращает отсортированный список
- min(list) : возвращает наименьший элемент списка
- max(list) : возвращает наибольший элемент списка
Добавление и удаление элементов
Для добавления элемента применяются методы append() , extend и insert , а для удаления - методы remove() , pop() и clear() .
people = ["Tom", "Bob"] # добавляем в конец списка people.append("Alice") # ["Tom", "Bob", "Alice"] # добавляем на вторую позицию people.insert(1, "Bill") # ["Tom", "Bill", "Bob", "Alice"] # добавляем набор элементов ["Mike", "Sam"] people.extend(["Mike", "Sam"]) # ["Tom", "Bill", "Bob", "Alice", "Mike", "Sam"] # получаем индекс элемента index_of_tom = people.index("Tom") # удаляем по этому индексу removed_item = people.pop(index_of_tom) # ["Bill", "Bob", "Alice", "Mike", "Sam"] # удаляем последний элемент last_item = people.pop() # ["Bill", "Bob", "Alice", "Mike"] # удаляем элемент "Alice" people.remove("Alice") # ["Bill", "Bob", "Mike"] print(people) # ["Bill", "Bob", "Mike"] # удаляем все элементы people.clear() print(people) # []
Проверка наличия элемента
Если определенный элемент не найден, то методы remove и index генерируют исключение. Чтобы избежать подобной ситуации, перед операцией с элементом можно проверять его наличие с помощью ключевого слова in :
people = ["Tom", "Bob", "Alice", "Sam"] if "Alice" in people: people.remove("Alice") print(people) # ["Tom", "Bob", "Sam"]
Выражение if "Alice" in people возвращает True, если элемент "Alice" имеется в списке people. Поэтому конструкция if "Alice" in people может выполнить последующий блок инструкций в зависимости от наличия элемента в списке.
Удаление с помощью del
Python также поддерживает еще один способ удаления элементов списка - с помощью оператора del . В качестве параметра этому оператору передается удаляемый элемент или набор элементов:
people = ["Tom", "Bob", "Alice", "Sam", "Bill", "Kate", "Mike"] del people[1] # удаляем второй элемент print(people) # ["Tom", "Alice", "Sam", "Bill", "Kate", "Mike"] del people[:3] # удаляем по четвертый элемент не включая print(people) # ["Bill", "Kate", "Mike"] del people[1:] # удаляем со второго элемента print(people) # ["Bill"]
Изменение подсписка
Для изменения подсписка - набора элементов в списке можно использовать вышерассмотренный синтаксис [start:end] :
nums = [10, 20, 30, 40, 50] nums[1:4]=[11, 22] print(nums) # [10, 11, 22, 50]
Здесь выражение nums[1:4] фактически обращается к подсписку [20, 30, 40] . Присвоение этому подсписку списка [11, 22] позволяет заменить элемента с 1 по 4 индекс не включая на элементы [11, 22] . И после изменения получим список [10, 11, 22, 50]
Подсчет вхождений
Если необходимо узнать, сколько раз в списке присутствует тот или иной элемент, то можно применить метод count() :
people = ["Tom", "Bob", "Alice", "Tom", "Bill", "Tom"] people_count = people.count("Tom") print(people_count) # 3
Сортировка
Для сортировки по возрастанию применяется метод sort() :
people = ["Tom", "Bob", "Alice", "Sam", "Bill"] people.sort() print(people) # ["Alice", "Bill", "Bob", "Sam", "Tom"]
Если необходимо отсортировать данные в обратном порядке, то мы можем после сортировки применить метод reverse() :
people = ["Tom", "Bob", "Alice", "Sam", "Bill"] people.sort() people.reverse() print(people) # ["Tom", "Sam", "Bob", "Bill", "Alice"]
При сортировке фактически сравниваются два объекта, и который из них "меньше", ставится перед тем, который "больше". Понятия "больше" и "меньше" довольно условны. И если для чисел все просто - числа расставляются в порядке возрастания, то для строк и других объектов ситуация сложнее. В частности, строки оцениваются по первым символам. Если первые символы равны, оцениваются вторые символы и так далее. При чем цифровой символ считается "меньше", чем алфавитный заглавный символ, а заглавный символ считается меньше, чем строчный.
Таким образом, если в списке сочетаются строки с верхним и нижним регистром, то мы можем получить не совсем корректные результаты, так как для нас строка "bob" должна стоять до строки "Tom". И чтобы изменить стандартное поведение сортировки, мы можем передать в метод sort() в качестве параметра функцию:
people = ["Tom", "bob", "alice", "Sam", "Bill"] people.sort() # стандартная сортировка print(people) # ["Bill", "Sam", "Tom", "alice", "bob"] people.sort(key=str.lower) # сортировка без учета регистра print(people) # ["alice", "Bill", "bob", "Sam", "Tom"]
Кроме метода sort мы можем использовать встроенную функцию sorted , которая имеет две формы:
- sorted(list) : сортирует список list
- sorted(list, key) : сортирует список list, применяя к элементам функцию key
people = ["Tom", "bob", "alice", "Sam", "Bill"] sorted_people = sorted(people, key=str.lower) print(sorted_people) # ["alice", "Bill", "bob", "Sam", "Tom"]
При использовании этой функции следует учитывать, что эта функция не изменяет сортируемый список, а все отсортированные элементы она помещает в новый список, который возвращается в качестве результата.
Минимальное и максимальное значения
Встроенный функции Python min() и max() позволяют найти минимальное и максимальное значения соответственно:
numbers = [9, 21, 12, 1, 3, 15, 18] print(min(numbers)) # 1 print(max(numbers)) # 21
Копирование списков
При копировании списков следует учитывать, что списки представляют изменяемый (mutable) тип, поэтому если обе переменных будут указывать на один и тот же список, то изменение одной переменной, затронет и другую переменную:
people1 = ["Tom", "Bob", "Alice"] people2 = people1 people2.append("Sam") # добавляем элемент во второй список # people1 и people2 указывают на один и тот же список print(people1) # ["Tom", "Bob", "Alice", "Sam"] print(people2) # ["Tom", "Bob", "Alice", "Sam"]
Это так называемое "поверхностное копирование" (shallow copy). И, как правило, такое поведение нежелательное. И чтобы происходило копирование элементов, но при этом переменные указывали на разные списки, необходимо выполнить глубокое копирование (deep copy). Для этого можно использовать метод copy() :
people1 = ["Tom", "Bob", "Alice"] people2 = people1.copy() # копируем элементы из people1 в people2 people2.append("Sam") # добавляем элемент ТОЛЬКО во второй список # people1 и people2 указывают на разные списки print(people1) # ["Tom", "Bob", "Alice"] print(people2) # ["Tom", "Bob", "Alice", "Sam"]
Соединение списков
Для объединения списков применяется операция сложения (+):
people1 = ["Tom", "Bob", "Alice"] people2 = ["Tom", "Sam", "Tim", "Bill"] people3 = people1 + people2 print(people3) # ["Tom", "Bob", "Alice", "Tom", "Sam", "Tim", "Bill"]
Списки списков
Списки кроме стандартных данных типа строк, чисел, также могут содержать другие списки. Подобные списки можно ассоциировать с таблицами, где вложенные списки выполняют роль строк. Например:
people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] print(people[0]) # ["Tom", 29] print(people[0][0]) # Tom print(people[0][1]) # 29
Чтобы обратиться к элементу вложенного списка, необходимо использовать пару индексов: people[0][1] - обращение ко второму элементу первого вложенного списка.
Добавление, удаление и изменение общего списка, а также вложенных списков аналогично тому, как это делается с обычными (одномерными) списками:
people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] # создание вложенного списка person = list() person.append("Bill") person.append(41) # добавление вложенного списка people.append(person) print(people[-1]) # ["Bill", 41] # добавление во вложенный список people[-1].append("+79876543210") print(people[-1]) # ["Bill", 41, "+79876543210"] # удаление последнего элемента из вложенного списка people[-1].pop() print(people[-1]) # ["Bill", 41] # удаление всего последнего вложенного списка people.pop(-1) # изменение первого элемента people[0] = ["Sam", 18] print(people) # [ ["Sam", 18], ["Alice", 33], ["Bob", 27]]
Перебор вложенных списков:
people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] for person in people: for item in person: print(item, end=" | ")
Tom | 29 | Alice | 33 | Bob | 27 |
Python. Урок 7. Работа со списками (list)
![]()
Одна из ключевых особенностей Python, благодаря которой он является таким популярным – это простота. Особенно подкупает простота работы с различными структурами данных – списками, кортежами, словарями и множествами. Сегодня мы рассмотрим работу со списками.
Что такое список (list) в Python?
Список (list) – это структура данных для хранения объектов различных типов. Если вы использовали другие языки программирования, то вам должно быть знакомо понятие массива. Так вот, список очень похож на массив, только, как было уже сказано выше, в нем можно хранить объекты различных типов. Размер списка не статичен, его можно изменять. Список по своей природе является изменяемым типом данных. Про типы данных можно подробно прочитать здесь . Переменная, определяемая как список, содержит ссылку на структуру в памяти, которая в свою очередь хранит ссылки на какие-либо другие объекты или структуры.
Как списки хранятся в памяти?
Как уже было сказано выше, список является изменяемым типом данных. При его создании в памяти резервируется область, которую можно условно назвать некоторым “контейнером”, в котором хранятся ссылки на другие элементы данных в памяти. В отличии от таких типов данных как число или строка, содержимое “контейнера” списка можно менять. Для того, чтобы лучше визуально представлять себе этот процесс взгляните на картинку ниже. Изначально был создан список содержащий ссылки на объекты 1 и 2, после операции a[1] = 3, вторая ссылка в списке стала указывать на объект 3.

Более подробно эти вопросы обсуждались в уроке 3 (Типы и модель данных).
Создание, изменение, удаление списков и работа с его элементами
Создать список можно одним из следующих способов.
>>> a = [] >>> type(a) >>> b = list() >>> type(b)
Также можно создать список с заранее заданным набором данных.
>>> a = [1, 2, 3] >>> type(a)
Если у вас уже есть список и вы хотите создать его копию, то можно воспользоваться следующим способом:
>>> a = [1, 3, 5, 7] >>> b = a[:] >>> print(a) [1, 3, 5, 7] >>> print(b) [1, 3, 5, 7]
или сделать это так:
>>> a = [1, 3, 5, 7] >>> b = list(a) >>> print(a) [1, 3, 5, 7] >>> print(b) [1, 3, 5, 7]
В случае, если вы выполните простое присвоение списков друг другу, то переменной b будет присвоена ссылка на тот же элемент данных в памяти, на который ссылается a, а не копия списка а. Т.е. если вы будете изменять список a, то и b тоже будет меняться.
>>> a = [1, 3, 5, 7] >>> b = a >>> print(a) [1, 3, 5, 7] >>> print(b) [1, 3, 5, 7] >>> a[1] = 10 >>> print(a) [1, 10, 5, 7] >>> print(b) [1, 10, 5, 7]
Добавление элемента в список осуществляется с помощью метода append().
>>> a = [] >>> a.append(3) >>> a.append("hello") >>> print(a) [3, 'hello']
Для удаления элемента из списка, в случае, если вы знаете его значение, используйте метод remove(x), при этом будет удалена первая ссылка на данный элемент.
>>> b = [2, 3, 5] >>> print(b) [2, 3, 5] >>> b.remove(3) >>> print(b) [2, 5]
Если необходимо удалить элемент по его индексу, воспользуйтесь командой del имя_списка[индекс].
>>> c = [3, 5, 1, 9, 6] >>> print(c) [3, 5, 1, 9, 6] >>> del c[2] >>> print(c) [3, 5, 9, 6]
Изменить значение элемента списка, зная его индекс, можно напрямую к нему обратившись.
>>> d = [2, 4, 9] >>> print(d) [2, 4, 9] >>> d[1] = 17 >>> print(d) [2, 17, 9]
Очистить список можно просто заново его проинициализировав, так как будто вы его вновь создаете. Для получения доступа к элементу списка укажите индекс этого элемента в квадратных скобках.
>>> a = [3, 5, 7, 10, 3, 2, 6, 0] >>> a[2] 7
Можно использовать отрицательные индексы, в таком случае счет будет идти с конца, например для доступа к последнему элементу списка можно использовать вот такую команду:
>>> a[-1] 0
Для получения из списка некоторого подсписка в определенном диапазоне индексов, укажите начальный и конечный индекс в квадратных скобках, разделив их двоеточием.
>>> a[1:4] [5, 7, 10]
Методы списков
list.append(x)
Добавляет элемент в конец списка. Ту же операцию можно сделать так a[len(a):] = [x].
>>> a = [1, 2] >>> a.append(3) >>> print(a) [1, 2, 3]
list.extend(L)
Расширяет существующий список за счет добавления всех элементов из списка L. Эквивалентно команде a[len(a):] = L.
>>> a = [1, 2] >>> b = [3, 4] >>> a.extend(b) >>> print(a) [1, 2, 3, 4]
list.insert(i, x)
Вставить элемент x в позицию i. Первый аргумент – индекс элемента после которого будет вставлен элемент x.
>>> a = [1, 2] >>> a.insert(0, 5) >>> print(a) [5, 1, 2] >>> a.insert(len(a), 9) >>> print(a) [5, 1, 2, 9]
list.remove(x)
Удаляет первое вхождение элемента x из списка.
>>> a = [1, 2, 3] >>> a.remove(1) >>> print(a) [2, 3]
Удаляет элемент из позиции i и возвращает его. Если использовать метод без аргумента, то будет удален последний элемент из списка.
>>> a = [1, 2, 3, 4, 5] >>> print(a.pop(2)) 3 >>> print(a.pop()) 5 >>> print(a) [1, 2, 4]
list.clear()
Удаляет все элементы из списка. Эквивалентно del a[:].
>>> a = [1, 2, 3, 4, 5] >>> print(a) [1, 2, 3, 4, 5] >>> a.clear() >>> print(a) []
list.index(x[, start[, end]])
Возвращает индекс элемента.
>>> a = [1, 2, 3, 4, 5] >>> a.index(4) 3
list.count(x)
Возвращает количество вхождений элемента x в список.
>>> a=[1, 2, 2, 3, 3] >>> print(a.count(2)) 2
list.sort(key=None, reverse=False)
Сортирует элементы в списке по возрастанию. Для сортировки в обратном порядке используйте флаг reverse=True. Дополнительные возможности открывает параметр key, за более подробной информацией обратитесь к документации.
>>> a = [1, 4, 2, 8, 1] >>> a.sort() >>> print(a) [1, 1, 2, 4, 8]
list.reverse()
Изменяет порядок расположения элементов в списке на обратный.
>>> a = [1, 3, 5, 7] >>> a.reverse() >>> print(a) [7, 5, 3, 1]
list.copy()
Возвращает копию списка. Эквивалентно a[:].
>>> a = [1, 7, 9] >>> b = a.copy() >>> print(a) [1, 7, 9] >>> print(b) [1, 7, 9] >>> b[0] = 8 >>> print(a) [1, 7, 9] >>> print(b) [8, 7, 9]
List Comprehensions
List Comprehensions чаще всего на русский язык переводят как абстракция списков или списковое включение, является частью синтаксиса языка, которая предоставляет простой способ построения списков. Проще всего работу list comprehensions показать на примере. Допустим вам необходимо создать список целых чисел от 0 до n, где n предварительно задается. Классический способ решения данной задачи выглядел бы так:
>>> n = int(input()) 7 >>> a=[] >>> for i in range(n): a.append(i) >>> print(a) [0, 1, 2, 3, 4, 5, 6]
Использование list comprehensions позволяет сделать это значительно проще:
>>> n = int(input()) 7 >>> a = [i for i in range(n)] >>> print(a) [0, 1, 2, 3, 4, 5, 6]
или вообще вот так, в случае если вам не нужно больше использовать n:
>>> a = [i for i in range(int(input()))] 7 >>> print(a) [0, 1, 2, 3, 4, 5, 6]
List Comprehensions как обработчик списков
В языке Python есть две очень мощные функции для работы с коллекциями: map и filter . Они позволяют использовать функциональный стиль программирования, не прибегая к помощи циклов, для работы с такими типами как list , tuple , set , dict и т.п. Списковое включение позволяет обойтись без этих функций. Приведем несколько примеров для того, чтобы понять о чем идет речь.
Пример с заменой функции map .
Пусть у нас есть список и нужно получить на базе него новый, который содержит элементы первого, возведенные в квадрат. Решим эту задачу с использованием циклов:
>>> a = [1, 2, 3, 4, 5, 6, 7] >>> b = [] >>> for i in a: b.append(i**2) >>> print('a = <>\nb = <>'.format(a, b)) a = [1, 2, 3, 4, 5, 6, 7] b = [1, 4, 9, 16, 25, 36, 49]
Та же задача, решенная с использованием map , будет выглядеть так:
>>> a = [1, 2, 3, 4, 5, 6, 7] >>> b = list(map(lambda x: x**2, a)) >>> print('a = <>\nb = <>'.format(a, b)) a = [1, 2, 3, 4, 5, 6, 7] b = [1, 4, 9, 16, 25, 36, 49]
В данном случае применена lambda -функция, о том, что это такое и как ее использовать можете прочитать здесь.
Через списковое включение эта задача будет решена так:
>>> a = [1, 2, 3, 4, 5, 6, 7] >>> b = [i**2 for i in a] >>> print('a = <>\nb = <>'.format(a, b)) a = [1, 2, 3, 4, 5, 6, 7] b = [1, 4, 9, 16, 25, 36, 49]
Пример с заменой функции filter .
Построим на базе существующего списка новый, состоящий только из четных чисел:
>>> a = [1, 2, 3, 4, 5, 6, 7] >>> b = [] >>> for i in a: if i%2 == 0: b.append(i) >>> print('a = <>\nb = <>'.format(a, b)) a = [1, 2, 3, 4, 5, 6, 7] b = [2, 4, 6]
Решим эту задачу с использованием filter :
>>> a = [1, 2, 3, 4, 5, 6, 7] >>> b = list(filter(lambda x: x % 2 == 0, a)) >>> print('a = <>\nb = <>'.format(a, b)) a = [1, 2, 3, 4, 5, 6, 7] b = [2, 4, 6]
Решение через списковое включение:
>>> a = [1, 2, 3, 4, 5, 6, 7] >>> b = [i for i in a if i % 2 == 0] >>> print('a = <>\nb = <>'.format(a, b)) a = [1, 2, 3, 4, 5, 6, 7] b = [2, 4, 6]
Слайсы / Срезы
Слайсы (срезы) являются очень мощной составляющей Python , которая позволяет быстро и лаконично решать задачи выборки элементов из списка. Выше уже был пример использования слайсов, здесь разберем более подробно работу с ними. Создадим список для экспериментов:
>>> a = [i for i in range(10)]
Слайс задается тройкой чисел, разделенных запятой: start:stop:step . Start – позиция с которой нужно начать выборку, stop – конечная позиция, step – шаг. При этом необходимо помнить, что выборка не включает элемент определяемый stop .
>>> # Получить копию списка >>> a[:] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> # Получить первые пять элементов списка >>> a[0:5] [0, 1, 2, 3, 4] >>> # Получить элементы с 3-го по 7-ой >>> a[2:7] [2, 3, 4, 5, 6] >>> # Взять из списка элементы с шагом 2 >>> a[::2] [0, 2, 4, 6, 8] >>> # Взять из списка элементы со 2-го по 8-ой с шагом 2 >>> a[1:8:2] [1, 3, 5, 7]
Слайсы можно сконструировать заранее, а потом уже использовать по мере необходимости. Это возможно сделать, в виду того, что слайс – это объект класса slice . Ниже приведен пример, демонстрирующий эту функциональность:
>>> s = slice(0, 5, 1) >>> a[s] [0, 1, 2, 3, 4] >>> s = slice(1, 8, 2) >>> a[s] [1, 3, 5, 7]
Типо “List Comprehensions”… в генераторном режиме
Есть ещё одни способ создания списков, который похож на списковое включение, но результатом работы является не объект класса list , а генератор. Подробно про генераторы написано в “ Уроке 15. Итераторы и генераторы“.
Предварительно импортируем модуль sys , он нам понадобится:
>>> import sys
Создадим список, используя списковое включение :
>>> a = [i for i in range(10)]
проверим тип переменной a:
>>> type(a)
и посмотрим сколько она занимает памяти в байтах:
>>> sys.getsizeof(a) 192
Для создания объекта-генератора, используется синтаксис такой же как и для спискового включения, только вместо квадратных скобок используются круглые:
>>> b = (i for i in range(10)) >>> type(b) >>> sys.getsizeof(b) 120
Обратите внимание, что тип этого объекта ‘generator’ , и в памяти он занимает места меньше, чем список, это объясняется тем, что в первом случае в памяти хранится весь набор чисел от 0 до 9, а во втором функция, которая будет нам генерировать числа от 0 до 9. Для наших примеров разница в размере не существенна, рассмотрим вариант с 10000 элементами:
>>> c = [i for i in range(10000)] >>> sys.getsizeof(c) 87624 >>> d = (i for i in range(10000)) >>> sys.getsizeof(d) 120
Сейчас уже разница существенна, как вы уже поняли, размер генератора в данном случае не будет зависеть от количества чисел, которые он должен создать.
Если вы решаете задачу обхода списка, то принципиальной разницы между списком и генератором не будет:
>>> for val in a: print(val, end=' ') 0 1 2 3 4 5 6 7 8 9 >>> for val in b: print(val, end=' ') 0 1 2 3 4 5 6 7 8 9
Но с генератором нельзя работать также как и со списком: нельзя обратиться к элементу по индексу и т.п.
P.S.
Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.
Раздел: Python Уроки по Python Метки: Python, Уроки Python
Python. Урок 7. Работа со списками (list) : 53 комментария
- навруз 17.12.2017 там ошибка
Изменить значение элемента списка, зная его индекс, можно напрямую к нему обратившись. >>> d = [2, 4, 9]
>>> print(d)
[2, 4, 9]
>>> d[1] = 17 индекс указан первый, следовательно должен измениться первый элемент.
>>> print(d)
[2, 17, 9] а тут изменен второй элемент. Вывод должен выглядеть так [17, 4, 9] Если я не
ошибаюсь)))
- writer 18.12.2017 В Python элементы списка нумеруются с нуля. Поэтому в списке [2, 4, 9], элемент с индексом 1 – это 4, и если мы сделаем присваивание d[1] = 17, то поменяем средний элемент в списке, так как это показано в примере!
Удачи!
- навруз 20.12.2017 ой спасибо за обьяснение)) изивиняюсь за ложные обвинения и невнимательность)))
- writer 20.12.2017 Пожалуйста! Спасибо вам за интерес к блогу)))