Как найти последовательность в списке питон

I am trying to find if some sequences of numbers are in a list. If so, this tuple should be removed from the list. Numbers must be contiguous to one another.

Example:

list of tuples:

list_1 =  [(), (1,), (3,), (2,), (4,), (1, 3), (1, 2), (1, 4), (3, 2), (3, 4), (2, 4), (1, 3, 2), (1, 3, 4), (1, 2, 4), (3, 2, 4), (1, 3, 2, 4)]

and a second list:

list_2 = [1,3,2,4]

In this case the elements (1, 3), (3, 2), (2, 4), (1, 3, 2), (3, 2, 4), (1, 3, 2, 4), (1, 3, 4), (1, 2, 4) in list_1 should be removed, because they contain numbers (not necessarily all of them!)that are contiguous in list_2.

I want to check if the elements in list

I tried something like this:

for i in range(len(lista)):
    teste = []
    for j in range(len(lista[i])):
        for k in stuff:
            if len(lista[i]) >= 2:
                if lista[i][j] == k:
                    teste.append(k)
                    if len(teste) == 2:
                        lista.remove(lista[i])
                        teste=[]

            else:
                pass

With this output:

if len(lista[i]) >= 2:
IndexError: list index out of range

I was trying to check a number, append it to a list check the next one and if it was appended too i would remove the corresponding tuple.

Введение

В ходе статьи рассмотрим 5 способов поиска элемента в списке Python.

Поиск методом count

Метод count() возвращает вхождение указанного элемента в последовательность. Создадим список разных цветов, чтобы в нём производить поиск:

colors = ['black', 'yellow', 'grey', 'brown']

Зададим условие, что если в списке colors присутствует элемент ‘yellow’, то в консоль будет выведено сообщение, что элемент присутствует. Если же условие не сработало, то сработает else, и будет выведена надпись, что элемента отсутствует в списке:

colors = ['black', 'yellow', 'grey', 'brown']

if colors.count('yellow'):
    print('Элемент присутствует в списке!')
else:
    print('Элемент отсутствует в списке!')

# Вывод: Элемент присутствует в списке!

Поиск при помощи цикла for

Создадим цикл, в котором будем перебирать элементы из списка colors. Внутри цикла зададим условие, что если во время итерации color приняла значение ‘yellow’, то элемент присутствует:

colors = ['black', 'yellow', 'grey', 'brown']

for color in colors:
    if color == 'yellow':
         print('Элемент присутствует в списке!')

# Вывод: Элемент присутствует в списке!

Поиск с использованием оператора in

Оператор in предназначен для проверки наличия элемента в последовательности, и возвращает либо True, либо False.

Зададим условие, в котором если ‘yellow’ присутствует в списке, то выводится соответствующее сообщение:

colors = ['black', 'yellow', 'grey', 'brown']

if 'yellow' in colors:
    print('Элемент присутствует в списке!')
else:
    print('Элемент отсутствует в списке!')

# Вывод: Элемент присутствует в списке!

В одну строку

Также можно найти элемент в списке при помощи оператора in всего в одну строку:

colors = ['black', 'yellow', 'grey', 'brown']

print('Элемент присутствует в списке!') if 'yellow' in colors else print('Элемент отсутствует в списке!')

# Вывод: Элемент присутствует в списке!

Или можно ещё вот так:

colors = ['black', 'yellow', 'grey', 'brown']

if 'yellow' in colors: print('Элемент присутствует в списке!')

# Вывод: Элемент присутствует в списке!

Поиск с помощью лямбда функции

В переменную filtering будет сохранён итоговый результат. Обернём результат в список (list()), т.к. метода filter() возвращает объект filter. Отфильтруем все элементы списка, и оставим только искомый, если он конечно присутствует:

colors = ['black', 'yellow', 'grey', 'brown']

filtering = list(filter(lambda x: 'yellow' in x, colors))

Итак, если искомый элемент находился в списке, то он сохранился в переменную filtering. Создадим условие, что если переменная filtering не пустая, то выведем сообщение о присутствии элемента в списке. Иначе – отсутствии:

colors = ['black', 'yellow', 'grey', 'brown']

filtering = list(filter(lambda x: 'yellow' in x, colors))

if filtering:
    print('Элемент присутствует в списке!')
else:
    print('Элемент отсутствует в списке!')

# Вывод: Элемент присутствует в списке!

Поиск с помощью функции any()

Функция any принимает в качестве аргумента итерабельный объект, и возвращает True, если хотя бы один элемент равен True, иначе будет возвращено False.

Создадим условие, что если функция any() вернёт True, то элемент присутствует:

colors = ['black', 'yellow', 'grey', 'brown']

if any(color in 'yellow' for color in colors):
    print('Элемент присутствует в списке!')
else:
    print('Элемент отсутствует в списке!')

# Вывод: Элемент присутствует в списке!

Внутри функции any() при помощи цикла производится проверка присутствия элемента в списке.

Заключение

В ходе статьи мы с Вами разобрали целых 5 способов поиска элемента в списке Python. Надеюсь Вам понравилась статья, желаю удачи и успехов! 🙂

Найти элемент в списке можно как по значению, так и по индексу.

Рис. (1). Пример (7)

Задачи нахождения в списке элемента, удовлетворяющего каким-то условиям, разнообразны.

Рассмотрим нахождение минимального и максимального элементов.
В Python есть встроенные функции, которые ищут максимум и минимум последовательности.

Рис. (2). Функции min и max

Попробуем реализовать этот алгоритм самостоятельно.

Рис. (3). Пример (8)

В этой статье вы узнаете о последовательностях в Python и базовых операциях над ними. 

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

На любой элемент последовательности можно ссылаться, используя его индекс, например, s[0] и s[1].

Индексы последовательности начинаются с 0, а не с 1. Поэтому первый элемент — s[0], а второй — s[1]. Если последовательность s состоит из n элементов, то последним элементом будет s[n-1].

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

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

Последовательность может быть однородной или неоднородной. В однородной последовательности все элементы имеют одинаковый тип. Например, строки — это однородные последовательности, поскольку каждый элемент строки — символ — один и тот же тип.

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

Примечание. C точки зрения хранения и операций однородные типы последовательностей более эффективны, чем неоднородные.

Последовательности и итерируемые объекты: разница

Итерируемый объект (iterable) — это коллекция объектов, в которой можно получить каждый элемент по очереди. Поэтому любая последовательность является итерируемой. Например, список — итерируемый объект.

Однако итерируемый объект может не быть последовательностью. Например, множество является итерируемым объектом, но не является последовательностью.

Примечание. Итерируемые объекты — более общий тип, чем последовательности.

Стандартные методы последовательностей

Ниже описаны некоторые встроенные в Python методы последовательностей:

1) Количество элементов последовательности

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

len(последовательность)

Пример

cities = ['Санкт-Петербург', 'Новосибирск', 'Москва']
print(len(cities))

Вывод

3

2) Проверка вхождения элемента в последовательность

Чтобы проверить, находится ли элемент в последовательности, можно использовать оператор in:

элемент in последовательность

Пример 1

Проверим, есть ли 'Новосибирск' в последовательности cities.

cities = ['Санкт-Петербург', 'Новосибирск', 'Москва']
print('Новосибирск' in cities)

Вывод

True

Чтобы проверить, отсутсвует ли элемент в последовательности, используется оператор not in.

Пример 2

Проверим, отсутсвует ли 'Новосибирск' в последовательности cities.

cities = ['Санкт-Петербург', 'Новосибирск', 'Москва']
print('Новосибирск' not in cities)

Вывод

False

3) Поиска индекса элемента в последовательности

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

последовательность.index(элемент)

Пример 1

numbers = [1, 4, 5, 3, 5, 7, 8, 5]
print(numbers.index(5))

Вывод

2

Индекс первого появления числа 5 в списке numbers — 2. Если числа в последовательности нет, Python сообщит об ошибке:

numbers = [1, 4, 5, 3, 5, 7, 8, 5]
print(numbers.index(10))

Вывод

ValueError: 10 is not in list

Чтобы найти индекс вхождения элемента после определенного индекса, можно использовать метод index() в таком виде:

последовательность.index(элемент, индекс)

Пример 2

В следующем примере возвращается индекс первого вхождения числа 5 после третьего индекса:

numbers = [1, 4, 5, 3, 5, 7, 8, 5]
print(numbers.index(5, 3))

Вывод

4

Чтобы найти индекс вхождения элемента между двумя определенными индексами, можно использовать метод index() в такой форме:

последовательность.index(элемент, i, j)

Поиск элемента будет осуществляться между i и j.

Пример 3 

numbers = [1, 4, 5, 3, 5, 7, 8, 5]
print(numbers.index(5, 3, 5))

Вывод

4

4) Слайсинг последовательности

Чтобы получить срез от индекса i до индекса j (не включая его), используйте следующий синтаксис:

последовательность[i:j]

Пример 1

numbers = [1, 4, 5, 3, 5, 7, 8, 5]
print(numbers[2:6])

Вывод

[5, 3, 5, 7]

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

Расширенный слайсинг позволяет получить срез последовательности от индекса i до j (не включая его) с шагом k:

последовательность[i:j:k]

Пример 2

numbers = [1, 4, 5, 3, 5, 7, 8, 5]
print(numbers[2:6:2])

Вывод

[5, 5]

5) Получение максимального и минимального значений из последовательности

Если задан порядок между элементами в последовательности, можно использовать встроенные функции min() и max() для нахождения минимального и максимального элементов:

numbers = [1, 4, 5, 3, 5, 7, 8, 5]

print(min(numbers))  # Вывод: 1
print(max(numbers))  # Вывод: 8

6) Объединение (конкатенация) последовательностей

Чтобы объединить две последовательности в одну, используется оператор +:

последовательность3 = последовательность1 + последовательность2

Пример

east = ['Владивосток', 'Якутск']
west = ['Санкт-Петербург', 'Москва']

cities = east + west
print(cities)

Вывод

['Владивосток', 'Якутск', 'Санкт-Петербург', 'Москва']

Неизменяемые последовательно объединять безопасно. В следующем примере мы доблавяем один элемент к списку west. И это не влияет на последовательность cities:

west.append('Благовещенск')

print(west)
print(cities)

Вывод

['Владивосток', 'Якутск', 'Благовещенск']

['Владивосток', 'Якутск', 'Санкт-Петербург', 'Москва']

Однако когда вы работаете с изменяемыми последовательностями, стоит быть внимательными. . В следующем примере показано, как объединить список самого с собой.

city = [['Санкт-Петербург', 900_000]]
cities = city + city

print(cities)

Вывод

[[‘Санкт-Петербург’, 1000000], [‘Санкт-Петербург’, 1000000]]

Поскольку список является изменяемой последовательностью, адреса памяти первого и второго элементов из списка citites одинаковы:

print(id(cities[0]) == id(cities[1]))  # Вывод: True

Кроме того, при изменении значения из исходного списка изменяется и объединенный список:

city[0][1] = 1_000_000
print(cities)

Соберем все вместе:

city = [['Санкт-Петербург', 900_000]]
cities = city + city

print(cities)
print(id(cities[0]) == id(cities[1]))  # Вывод: True

city[0][1] = 1_000_000
print(cities)

Вывод

[['Санкт-Петербург', 900000], ['Санкт-Петербург', 900000]]
True
[['Санкт-Петербург', 1000000], ['Санкт-Петербург', 1000000]]

7) Повторение последовательности

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

В следующем примере строка повторяется 3 раза:

s = 'ха'
print(s*3)

Вывод

хахаха