Python как найти список в списке

Given two lists A and B, write a Python program to Check if list A is contained in list B without breaking A’s order. 

Examples:

Input : A = [1, 2], B = [1, 2, 3, 1, 1, 2, 2]
Output : True
Input : A = ['x', 'y', 'z'], B = ['x', 'a', 'y', 'x', 'b', 'z']
Output : False

Approach #1: Naive Approach 

A simple naive approach is to use two for loops and check if the whole list A is contained within list B or not. If such a position is met in list A, then break the loop and return true, otherwise false.

Python3

def removeElements(A, B):

    for i in range(len(B)-len(A)+1):

        for j in range(len(A)):

            if B[i + j] != A[j]:

                break

        else:

            return True

    return False

A = [1, 2]

B = [1, 2, 3, 1, 1, 2, 2]

print(removeElements(A, B))

Time Complexity: O(n*n)
Auxiliary Space: O(1)

Approach #2: Using list comprehension 

A more efficient approach is to use List comprehension. We first initialize ‘n’ with the length of A. Now use a for loop till len(B)-n and check in each iteration if A == B[i:i+n] or not. 

Python3

def removeElements(A, B):

    n = len(A)

    return any(A == B[i:i + n] for i in range(len(B)-n + 1))

A = [1, 2]

B = [1, 2, 3, 1, 1, 2, 2]

print(removeElements(A, B))

Time complexity: O(n^2). where A and B are both of length n,
Auxiliary space: O(n), where n is the length of B.

Approach #3: Using join and map module 

Here we use join to join both lists to strings and then use in operator to check if list A is contained in B or not. 

Python3

def removeElements(A, B):

    return ', '.join(map(str, A)) in ', '.join(map(str, B))

A = ['x', 'y', 'z']

B = ['x', 'a', 'y', 'x', 'b', 'z']

print(removeElements(A, B))

Time complexity: O(m*n) , where m is the length of A and n is the length of B.
Auxiliary space: O(1),where m is length of A and n is the length of B.

Approach #4: Using regular expressions 

To check if a list is contained in another list using the Python re (regular expression) module, you can use the re.findall() function to find all instances of list A within list B as a string. If the number of instances found is greater than 0, it means that list A is contained within list B.

Here is an example of how this can be done:

Python3

import re

def check_list_contained(A, B):

    A_str = ' '.join(map(str, A))

    B_str = ' '.join(map(str, B))

    instances = re.findall(A_str, B_str)

    return len(instances) > 0

A = ['x', 'y', 'z']

B = ['x', 'a', 'y', 'x', 'b', 'z']

print(check_list_contained(A, B))

Time complexity: O(m*n) , where m is length of A and n is length of B.
Auxiliary space: O(1), where m is length of A and n is length of B.

Approach #5: Using Recursive method

Steps:

  1. If list A is empty, return True, as an empty list is always a sublist of any list.
  2. If list B is empty, return False, as an empty list cannot contain any sublist.
  3. If A[0] matches B[0], recursively check the rest of the elements of A and B by calling the is_sublist method with A[1:] and B[1:].
  4. If A[0] does not match B[0], recursively check if A is a sublist of the remaining elements of B by calling the is_sublist method with A and B[1:]
  5. Return True if the previous recursive call returned True, indicating that A is a sublist of B, or False otherwise.

Python3

def is_sublist(A, B):

    if not A:

        return True

    if not B:

        return False

    if A[0] == B[0]:

        return is_sublist(A[1:], B[1:])

    return is_sublist(A, B[1:])

A = [1, 2]

B = [1, 2, 3, 1, 1, 2, 2]

res = is_sublist(A, B)

print(res)

Time complexity: O(n * m), where n is the length of list A and m is the length of list B. This is because the function needs to traverse both lists in the worst-case scenario, and the length of list B may need to be traversed multiple times depending on the position of the matching element of A.

Auxiliary space: O(max(n, m)), where n is the length of list A and m is the length of list B. This is because the function makes recursive calls, and each call adds a new stack frame to the call stack, potentially using up additional memory. However, the maximum depth of the call stack is bounded by the maximum length of A or B, so the space used is proportional to the maximum of the two lengths.

Approach #6: Using Numpy

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

Steps:

  1. Import numpy module and define a function named “check_list_contained” that takes two parameters, “A” and “B”.
  2. Convert “A” and “B” to numpy arrays “A_arr” and “B_arr” respectively.
  3. Loop through “B_arr” using a for loop and range function for index “i” in range of length of “B_arr”.
  4. Check if the subarray of “B_arr” starting from index “i” and of length equal to the length of “A_arr” is equal to “A_arr” using the numpy array_equal() function.
  5. If the above condition is true, then return True, as the list “A” is contained in the list “B”.
  6. If the loop finishes execution without returning True, return False, as the list “A” is not contained in the list “B”.
  7. Test the function by passing two list parameters “A” and “B”.
  8. Print the result of the function call.

Python3

import numpy as np

def check_list_contained(A, B):

    A_arr = np.array(A)

    B_arr = np.array(B)

    for i in range(len(B_arr)):

        if np.array_equal(A_arr, B_arr[i:i+len(A_arr)]):

            return True

    return False

A = [1, 2]

B = [1, 2, 3, 1, 1, 2, 2]

print(check_list_contained(A, B))

A = ['x', 'y', 'z']

B = ['x', 'a', 'y', 'x', 'b', 'z']

print(check_list_contained(A, B))

Output:

True
False

Time complexity: O(n^2), where n is the length of B.
Auxiliary space: O(n), where n is the length of B.

Last Updated :
10 May, 2023

Like Article

Save Article

Источник

Here’s the Pythonic way to do it:

data = [['a','b'], ['a','c'], ['b','d']]
search = 'c'
any(e[1] == search for e in data)

Or… well, I’m not going to claim this is the «one true Pythonic way» to do it because at some point it becomes a little subjective what is Pythonic and what isn’t, or which method is more Pythonic than another. But using any() is definitely more typical Python style than a for loop as in e.g. RichieHindle’s answer,

Of course there is a hidden loop in the implementation of any, although it breaks out of the loop as soon as it finds a match.

Since I was bored I made a timing script to compare performance of the different suggestions, modifying some of them as necessary to make the API the same. Now, we should bear in mind that fastest is not always best, and being fast is definitely not the same thing as being Pythonic. That being said, the results are… strange. Apparently for loops are very fast, which is not what I expected, so I’d take these with a grain of salt without understanding why they’ve come out the way they do.

Anyway, when I used the list defined in the question with three sublists of two elements each, from fastest to slowest I get these results:

  1. RichieHindle’s answer with the for loop, clocking in at 0.22 μs
  2. Terence Honles’ first suggestion which creates a list, at 0.36 μs
  3. Pierre-Luc Bedard’s answer (last code block), at 0.43 μs
  4. Essentially tied between Markus’s answer and the for loop from the original question, at 0.48 μs
  5. Coady’s answer using operator.itemgetter(), at 0.53 μs
  6. Close enough to count as a tie between Alex Martelli’s answer with ifilter() and Anon’s answer, at 0.67 μs (Alex’s is consistently about half a microsecond faster)
  7. Another close-enough tie between jojo’s answer, mine, Brandon E Taylor’s (which is identical to mine), and Terence Honles’ second suggestion using any(), all coming in at 0.81-0.82 μs
  8. And then user27221’s answer using nested list comprehensions, at 0.95 μs

Obviously the actual timings are not meaningful on anyone else’s hardware, but the differences between them should give some idea of how close the different methods are.

When I use a longer list, things change a bit. I started with the list in the question, with three sublists, and appended another 197 sublists, for a total of 200 sublists each of length two. Using this longer list, here are the results:

  1. RichieHindle’s answer, at the same 0.22 μs as with the shorter list
  2. Coady’s answer using operator.itemgetter(), again at 0.53 μs
  3. Terence Honles’ first suggestion which creates a list, at 0.36 μs
  4. Another virtual tie between Alex Martelli’s answer with ifilter() and Anon’s answer, at 0.67 μs
  5. Again a close-enough tie between my answer, Brandon E Taylor’s identical method, and Terence Honles’ second suggestion using any(), all coming in at 0.81-0.82 μs

Those are the ones that keep their original timing when the list is extended. The rest, which don’t, are

  1. The for loop from the original question, at 1.24 μs
  2. Terence Honles’ first suggestion which creates a list, at 7.49 μs
  3. Pierre-Luc Bedard’s answer (last code block), at 8.12 μs
  4. Markus’s answer, at 10.27 μs
  5. jojo’s answer, at 19.87 μs
  6. And finally user27221’s answer using nested list comprehensions, at 60.59 μs
Источник

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

Есть два списка:
l_1 = [‘val_1’, ‘val_2’, ‘val_3’, ‘val_4’,]
l_2 = [‘val_3’, ‘val_11’, ‘val_32’, ‘val_6’,]
необходимо вывести True (выполнить условие), если любой из элементов l_1 встречается в l_2
как это реализовать без for или set&?


  • Вопрос задан

    18 июн. 2022

  • 415 просмотров 

l_1_element_in_l_2: bool = any(map(lambda element: element in l_2, l_1))

Пригласить эксперта

как это реализовать без for или set&?

За while не говорилось

l_1 = ['val_1', 'val_2', 'val_3', 'val_4',]
l_2 = ['val_3', 'val_11', 'val_32', 'val_6',]

def compare(list1, list2):
    i = 0
    while i<len(list1):
        if l_1[i] in l_2:
            return True
        i += 1
    return False

compare(l_1, l_2)
# True

Для ситуации, когда «чёрный список» длинный, но статичный, а элементы можно сравнивать, может иметь смысл отсортировать списки и двигаться по обоим. Если списки отсортированы заранее, то сложность будет O(M+N), вместо O(M*N). Если не отсортированы, то всё будет определяться скоростью сортировки.

black_list = list('1234567890h')
black_list.sort()
tested_list = list('dabeghfc')
tested_list.sort()
black_last, tested_last = len(black_list)-1, len(tested_list)-1
black_idx, tested_idx = 0, 0
black_item, tested_item = black_list[black_idx], tested_list[tested_idx]
while True:
    if black_item < tested_item and black_idx < black_last:
        # элемент в чёрном списке меньше - идём вперёд по чёрному списку, если есть куда
        black_idx += 1
        black_item = black_list[black_idx]
    elif black_item > tested_item and tested_idx < tested_last:
        # элемент в чёрном списке больше - идём вперёд по тестирумому списку, если есть куда
        tested_idx += 1
        tested_item = tested_list[tested_idx]
    else:  # либо элементы равны (есть вхождение), либо один из списков закончился
        break
print('Есть вхождение!' if black_item == tested_item else 'Нет вхождения')

Можно и без циклов вообще

a = ['a', 'b', 'c'] 
b = ['c', 'd', 'e'] 
seta = set(a)
setb = set(b)
setab = set(a+b) 
if len(seta)+len(setb) != len(setab):
    print('Есть совпадение')
else:
    print('Совпадений нет')


  • Показать ещё
    Загружается…

29 мая 2023, в 15:00

5000 руб./за проект

29 мая 2023, в 14:58

40000 руб./за проект

29 мая 2023, в 14:42

10000 руб./за проект

Минуточку внимания

Источник

Получение индекса для строк: str.index (), str.rindex() и str.find(), str.rfind()

String также имеет index метод , но и более продвинутые варианты и дополнительное str.find.Для обоих из них есть дополнительный обратный метод.

astring = 'Hello on StackOverflow'
astring.index('o')  # 4
astring.rindex('o') # 20

astring.find('o')   # 4
astring.rfind('o')  # 20

Разница между index / rindex и find / rfind это то , что происходит , если подстрока не найдена в строке:

astring.index('q') # ValueError: substring not found
astring.find('q')  # -1

Все эти методы позволяют начальный и конечный индексы:

astring.index('o', 5)    # 6
astring.index('o', 6)    # 6 - start is inclusive
astring.index('o', 5, 7) # 6
astring.index('o', 5, 6) #  - end is not inclusive

ValueError: подстрока не найдена

astring.rindex('o', 20) # 20 
astring.rindex('o', 19) # 20 - still from left to right

astring.rindex('o', 4, 7) # 6

В поисках элемента

Все встроенные в коллекции в Python реализовать способ проверить членство элемента с использованием in. Список

alist = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
5 in alist   # True
10 in alist  # False

Кортеж

atuple =('0', '1', '2', '3', '4')
4 in atuple    # False
'4' in atuple  # True

строка

astring = 'i am a string'
'a' in astring   # True
'am' in astring  # True
'I' in astring   # False

Задавать

aset = {(10, 10), (20, 20), (30, 30)}
(10, 10) in aset  # True
10 in aset        # False

Dict

dict немного особенный: нормальный in проверяет только ключи. Если вы хотите , чтобы искать в значении , которые необходимо указать. То же самое , если вы хотите найти пар ключ-значение.

adict = {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
1 in adict                 # True   - implicitly searches in keys
'a' in adict               # False
2 in adict.keys()          # True   - explicitly searches in keys
'a' in adict.values()      # True   - explicitly searches in values
(0, 'a') in adict.items()  # True   - explicitly searches key/value pairs

Получение списка индексов и кортежей: list.index(), tuple.index()

list и tuple имеют index -метода получить позицию элемента:

alist = [10, 16, 26, 5, 2, 19, 105, 26]
# search for 16 in the list
alist.index(16) # 1
alist[1]        # 16

alist.index(15)

Ошибка значения: 15 отсутствует в списке

Но возвращает только позицию первого найденного элемента:

atuple = (10, 16, 26, 5, 2, 19, 105, 26)
atuple.index(26)   # 2
atuple[2]          # 26
atuple[7]          # 26 - is also 26!

Поиск ключа(ей) по значению в dict

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

def getKeysForValue(dictionary, value):
    foundkeys = []
    for keys in dictionary:
        if dictionary[key] == value:
            foundkeys.append(key)
    return foundkeys

Это также может быть записано как эквивалентное понимание списка:

def getKeysForValueComp(dictionary, value): 
    return [key for key in dictionary if dictionary[key] == value]

Если вам нужен только один найденный ключ:

def getOneKeyForValue(dictionary, value):
    return next(key for key in dictionary if dictionary[key] == value)

Первые две функции возвращает list всех keys , которые имеют определенное значение:

adict = {'a': 10, 'b': 20, 'c': 10}
getKeysForValue(adict, 10)     # ['c', 'a'] - order is random could as well be ['a', 'c']
getKeysForValueComp(adict, 10) # ['c', 'a'] - dito
getKeysForValueComp(adict, 20) # ['b']
getKeysForValueComp(adict, 25) # []

Другой вернет только один ключ:

getOneKeyForValue(adict, 10)   # 'c'  - depending on the circumstances this could also be 'a'
getOneKeyForValue(adict, 20)   # 'b'

и поднять StopIteration — Exception , если значение не в dict :

getOneKeyForValue(adict, 25)

StopIteration

Получение индекса для отсортированных последовательностей: bisect.bisect_left()

Отсортированные последовательности позволяют использовать более быстрый поиск алгоритмов: bisect.bisect_left() [1]:

import bisect

def index_sorted(sorted_seq, value):
    """Locate the leftmost value exactly equal to x or raise a ValueError"""
    i = bisect.bisect_left(sorted_seq, value)
    if i != len(sorted_seq) and sorted_seq[i] == value:
        return i
    raise ValueError

alist = [i for i in range(1, 100000, 3)] # Sorted list from 1 to 100000 with step 3
index_sorted(alist, 97285) # 32428
index_sorted(alist, 4)     # 1
index_sorted(alist, 97286)

ValueError

Для очень больших отсортированных последовательностей выигрыш в скорости может быть достаточно высоким. В случае первого поиска примерно в 500 раз быстрее:

%timeit index_sorted(alist, 97285)
# 100000 loops, best of 3: 3 µs per loop
%timeit alist.index(97285)
# 1000 loops, best of 3: 1.58 ms per loop

Хотя это немного медленнее, если элемент является одним из самых первых:

%timeit index_sorted(alist, 4)
# 100000 loops, best of 3: 2.98 µs per loop
%timeit alist.index(4)
# 1000000 loops, best of 3: 580 ns per loop

Поиск вложенных последовательностей

Поиск во вложенных последовательностях , как в list из tuple требует такого подхода , как поиск ключей для значений в dict , но нуждается в пользовательских функциях.

Индекс самой внешней последовательности, если значение было найдено в последовательности:

def outer_index(nested_sequence, value):
    return next(index for index, inner in enumerate(nested_sequence) 
                      for item in inner 
                      if item == value)

alist_of_tuples = [(4, 5, 6), (3, 1, 'a'), (7, 0, 4.3)]
outer_index(alist_of_tuples, 'a')  # 1
outer_index(alist_of_tuples, 4.3)  # 2

или индекс внешней и внутренней последовательности:

def outer_inner_index(nested_sequence, value):
    return next((oindex, iindex) for oindex, inner in enumerate(nested_sequence) 
                                 for iindex, item in enumerate(inner) 
                                 if item == value)

outer_inner_index(alist_of_tuples, 'a') # (1, 2)
alist_of_tuples[1][2]  # 'a'

outer_inner_index(alist_of_tuples, 7)   # (2, 0)
alist_of_tuples[2][0]  # 7

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

Поиск в пользовательских классах: __contains__ и __iter__

Для того, чтобы разрешить использование in пользовательских классах класса должен либо предоставить магический метод __contains__ или, если это невозможно, в __iter__ -метод.

Предположим , у вас есть класс , содержащий list из list s:

class ListList:
    def __init__(self, value):
        self.value = value
        # Create a set of all values for fast access
        self.setofvalues = set(item for sublist in self.value for item in sublist)

    def __iter__(self):
        print('Using __iter__.')
        # A generator over all sublist elements
        return (item for sublist in self.value for item in sublist)

    def __contains__(self, value):
        print('Using __contains__.')
        # Just lookup if the value is in the set
        return value in self.setofvalues

        # Even without the set you could use the iter method for the contains-check:
        # return any(item == value for item in iter(self))

Использование тестирования членства возможно при использовании in :

a = ListList([[1,1,1],[0,1,1],[1,5,1]])
10 in a    # False
# Prints: Using __contains__.
5 in a     # True
# Prints: Using __contains__.

даже после удаления __contains__ метода:

del ListList.__contains__
5 in a     # True
# Prints: Using __iter__.

Примечание: зацикливание in (как for i in a ) всегда будет использовать __iter__ даже если класс реализует __contains__ метод.

Источник

Автор оригинала: David Yeoman.

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

В этой статье мы начнем, где мы все начали, используя для -Опс, прежде чем перейти к более классическому Python Список понимания . Затем мы выйдем за рамки этого, чтобы использовать встроенные функции Python любой () и все () Прежде чем смотреть на умное использование методов, содержащихся в Установить () тип данных.

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

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

Метод 1: Понимание списка

Таким образом, если бы мы начали в кодировке Python, мы бы использовали для цикла для перебрания с двумя списками и возвращать результат. В примерах, которые мы впервые вернемся к True/False на то, есть ли номер в списке C также в списке A. Затем мы возвращаем фактические числа из списка C, которые находятся в списке A.

# Main list
lst_a = [24, 17, 37, 16, 27, 13, 46, 40, 46, 51,
         44, 29, 54, 77, 78, 73, 40, 58, 32, 48,
         45, 55, 51, 59, 68, 34, 83, 65, 57, 50,
         57, 93, 62, 37, 70, 62
	   ]

# SOME items are in lst_a
lst_c = [93, 108, 15, 42, 27, 83]


# Empty list
lst_result = []
# Check True or False items are in both lists
for i in lst_c:
    for j in lst_a:
        if i == j:
            print(True, end=' ')
        else:
            continue
print('n')
# Return values that are in both lists
for i in lst_c:
    for j in lst_a:
        if i == j:
            lst_result.append(i)
        else:
            continue
print(lst_result)
# Result #
True True True 
[93, 27, 83]

Так что это нормально, насколько это идет; Мы ответили на вопрос. Тем не менее, потребовалось шесть строк кода для истинного/ложного запроса и еще одной шести строки кода плюс создание нового списка для определения фактических чисел, которые были общими для обоих списков. Использование понимания списка мы можем улучшить это.

Метод 2: Лямбда

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

# Main list
lst_a = [24, 17, 37, 16, 27, 13, 46, 40, 46, 51,
         44, 29, 54, 77, 78, 73, 40, 58, 32, 48,
         45, 55, 51, 59, 68, 34, 83, 65, 57, 50,
         57, 93, 62, 37, 70, 62
         ]

# SOME items are in lst_a
lst_c = [93, 108, 15, 42, 27, 83]

print(list(filter(lambda i: i in lst_a, lst_c)))
# Result #
[93, 27, 83]

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

 # Main list
lst_a = [24, 17, 37, 16, 27, 13, 46, 40, 46, 51,
         44, 29, 54, 77, 78, 73, 40, 58, 32, 48,
         45, 55, 51, 59, 68, 34, 83, 65, 57, 50,
         57, 93, 62, 37, 70, 62
         ]

# SOME items are in lst_a
lst_c = [93, 108, 15, 42, 27, 83]

print([True for i in lst_a if i in lst_c], 'n')

print([i for i in lst_a if i in lst_c])

# Result #
[True, True, True] 
[27, 83, 93]

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

Способ 3: Python’s Any () и All () встроенные функции

Чтобы избежать написания длинного кода, Python имеет ряд встроенных функций, которые соответствуют нам необходимости понимать, присутствуют ли элементы в одном списке в другом.

Функция любой () Проверяет, есть ли какие-либо из элементов в списке Правда и возвращает соответствующую Правда Отказ   Вот простой пример того, как он работает:

a = [True, False, True, False, True]
print(any(a))
# Result #
True

Это просто, так что давайте применим его к нашему списку примеров. Я снова скриншот все списки, чтобы спасти вас от прокрутки. Поэтому, если мы хотим простую версию/ложную реакцию на наш вопрос относительно того, есть ли какие-либо элементы в одном списке в другом, любой () подходит для нашей потребности.

print(any(x in lst_a for x in lst_b))
print(any(x in lst_a for x in lst_c))
print(any(x in lst_a for x in lst_d))

# Result #
True
True
False

Помните, что lst_b Элементы все в lst_a ; lst_c имеет некоторые из его предметов в lst_a и lst_d не имеет никаких предметов в lst_a Отказ Поэтому возвращение Правда , Правда , Ложь имеет смысл как третий список, lst_d не имеет никаких предметов, дублированных в lst_a.

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

# Main list
lst_a = [24, 17, 37, 16, 27, 13, 46, 40, 46, 51,
         44, 29, 54, 77, 78, 73, 40, 58, 32, 48,
         45, 55, 51, 59, 68, 34, 83, 65, 57, 50,
         57, 93, 62, 37, 70, 62
         ]

# ALL items are in lst_a
lst_b = [59, 37, 32, 40]

# SOME items are in lst_a
lst_c = [93, 108, 15, 42, 27, 83]

# NO items are in lst_a
lst_d = [23, 101, 63, 35]

print(all(x in lst_a for x in lst_b))
print(all(x in lst_a for x in lst_c))
print(all(x in lst_a for x in lst_d))
# Result #
True
False
False

Таким образом, в этом случае единственный список, который имеет все свои предметы, содержащиеся в lst_a это lst_b С Следовательно, Правда Отказ

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

Способ 4: введение типа и методы набора () ()

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

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

• issubset () – возвращает ли другой набор этот набор или нет

• Пересечение () – Возвращает набор, то есть пересечение двух других наборов

И вот код, использующий оба метода на каждом из наших трех сравнений списка.

# Main list
lst_a = [24, 17, 37, 16, 27, 13, 46, 40, 46, 51,
         44, 29, 54, 77, 78, 73, 40, 58, 32, 48,
         45, 55, 51, 59, 68, 34, 83, 65, 57, 50,
         57, 93, 62, 37, 70, 62
         ]

# ALL items are in lst_a
lst_b = [59, 37, 32, 40]

# SOME items are in lst_a
lst_c = [93, 108, 15, 42, 27, 83]

# NO items are in lst_a
lst_d = [23, 101, 63, 35]

print(set(lst_b).issubset(lst_a))
print(set(lst_c).issubset(lst_a))
print(set(lst_d).issubset(lst_a), 'n')

print(list(set(lst_a).intersection(set(lst_b))))
print(list(set(lst_a).intersection(set(lst_c))))
print(list(set(lst_a).intersection(set(lst_d))))

# Result #
True
False
False 

[32, 40, 59, 37]
[27, 83, 93]
[]

Обратите внимание, что в обоих случаях нам нужно Преобразуйте списки в наборы используя set (lst_a) , set (lst_b) Синтаксис показан, прежде чем разрешить метод пересечения выполнять его работу. Если вы хотите, чтобы ответ был возвращен в виде списка, вам нужно будет преобразовать ответ, используя Список () Команда, как показано. Если это не важно для вас, вы сохраните немного кода и верните набор.

Методы 5-7: три бонусных метода

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

• Разница () – возвращает набор, содержащий разницу между двумя или более наборами

• iSdisjoint () – возвращает, имеют ли два набора пересечения или нет

• ОСУПЕРСЕТ () – возвращает, содержит ли один набор другой набор или нет

Как вы можете сказать из описания, они эффективно обратный от того, что мы сделали ранее с Пересечение () и issubset () Отказ

Используя нашими примерами кода, Разница () вернется номера в lst_a. Это не в lst_b С c или d в то время как iSdisjoint () вернется Ложь Если есть пересечение и Правда Если нет (что кажется немного контрактвым, пока вы не задумываете на имя метода), а ОСУПЕРСЕТ () проверим ли наши большие lst_a Содержит меньший lst_b С c или D в целом.

Вот пример трех методов, используемых в наших списках.

# Main List
lst_a = [24, 17, 37, 16, 27, 13, 46, 40, 46, 51,
         44, 29, 54, 77, 78, 73, 40, 58, 32, 48,
         45, 55, 51, 59, 68, 34, 83, 65, 57, 50,
         57, 93, 62, 37, 70, 62
         ]
# ALL items are in lst_a
lst_b = [59, 37, 32, 40]

# SOME items are in lst_a
lst_c = [93, 108, 15, 42, 27, 83]

# NO items are in lst_a
lst_d = [23, 101, 63, 35]

print(set(lst_a).isdisjoint(lst_b))
print(set(lst_a).isdisjoint(lst_c))
print(set(lst_a).isdisjoint(lst_d), 'n')

print(list(set(lst_a).difference(set(lst_b))))
print(list(set(lst_a).difference(set(lst_c))))
print(list(set(lst_a).difference(set(lst_d))), 'n')

print(set(lst_a).issuperset(set(lst_b)))
print(set(lst_a).issuperset(set(lst_c)))
print(set(lst_a).issuperset(set(lst_d)))
# Result #
False
False
True 

[65, 68, 70, 73, 13, 77, 78, 16, 17, 83, 24, 27, 29, 93, 34, 44, 45, 46, 48, 50, 51, 54, 55, 57, 58, 62]

[65, 68, 70, 73, 13, 77, 78, 16, 17, 24, 29, 32, 34, 37, 40, 44, 45, 46, 48, 50, 51, 54, 55, 57, 58, 59, 62]

[65, 68, 70, 73, 13, 77, 78, 16, 17, 83, 24, 27, 29, 93, 32, 34, 37, 40, 44, 45, 46, 48, 50, 51, 54, 55, 57, 58, 59, 62] 

True
False
False

Рискуют трудоустроить точку, помните, что iSdisjoint () вернется Ложь Если какие-либо элементы в одном списке появляются в другом. Это будет возвращаться только Правда Когда два списка полностью разделяются без каких-либо дублирования.

В итоге

Чтобы обобщить то, что мы охватываем сегодня, мы смотрели на представленный вопрос о том, как лучше всего проверить, есть ли элементы в одном списке в другом.

  • Мы начали с базового понимания списка, используя для -лоп, прежде чем проверять, если лямбда выражение было более подходящим. Наконец, мы заключили в однострочное понимание списка, которые вернулись Правда или Ложь О том, был ли элемент каждого списка в другом списке. Мы также использовали однострочное понимание списка для возврата фактических значений дубликатов в виде списка.
  • Затем мы изучили встроенные функции Python любой () и все () Что возвращает True или False в зависимости от того, повторяются ли какие-либо элементы в одном списке в другом.
  • Наконец, мы представили некоторые из методов, используемых в рамках Установить () тип данных. Использование issubset () Мы смогли вернуть True или False на ли элементы списка дублированы в другом списке и используя Пересечение () Мы вернули значения дублированных предметов.
  • Как бонус, мы также представили некоторые другие Установить () Методы, которые позволили нам дальнейшее манипулировать спискими для возврата полезных данных.

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

Чтобы исследовать встроенные функции Python, я предлагаю начать здесь; https://blog.finxter.com/python-built-in-functions/

Для хорошего начала с пониманием списка попробуйте эту статью; https://blog.finxter.com/list-comprehension/

Если вы хотите узнать больше о записи кода одноклассника, вы не можете пройти через эту книгу; https://www.amazon.com/gp/product/B07ZY7XMX8

Я надеюсь, что вам понравилось статью. Спасибо за прочтение!

Оригинал: “https://blog.finxter.com/how-to-check-if-items-in-a-python-list-are-also-in-another/”

Источник

Понравилась статья? Поделить с друзьями:
  • Как найти сумму чисел в восьмеричной системе
  • Как исправить красную строку в тетради
  • Как найти 250 масштаб
  • Как найти производство обуви
  • Как исправить ошибку в егаис по лесу