Python сравнение массивов: Как сравнивать списки в Python

Порядок элементов исходного списка не важен, поскольку списки сортируются перед сравнением.

Примечание: Можно сортировать только списки, в которых элементы имеют одинаковый тип данных.

Пример sort()

В следующем примере показано, как с помощью метода sort() сортировать и сравнивать списки:

l1 = [10, 20, 30, 40, 50] 
l2 = [20, 30, 50, 40, 70] 
l3 = [50, 10, 30, 20, 40] 

l1.sort() 
l2.sort() 
l3.sort() 

if l1 == l2: 
    print ("The lists l1 and l2 are the same") 
else: 
    print ("The lists l1 and l2 are not the same") 

if l1 == l3: 
    print ("The lists l1 and l3 are the same") 
else:
    print ("The lists l1 and l3 are not the same")

Получим следующий вывод:

The lists l1 and l3 are the same
The lists l1 and l2 are not the same

Код предыдущего примера сортирует каждый список, сравнивает l1 с l3 и выводит результат, а затем сравнивает l1 с l2 и выводит результат.

Пример функции sorted()

В следующем примере показано, как с помощью функции sorted() сортировать и сравнить списки:

l1 = [10, 20, 30, 40, 50]
l2 = [20, 30, 50, 40, 70]
l3 = [50, 10, 30, 20, 40]

l1_sorted = sorted(l1)
l2_sorted = sorted(l2)
l3_sorted = sorted(l3)

if l1_sorted == l2_sorted:
    print ("The lists l1 and l2 are the same")
else:
    print ("The lists l1 and l2 are not the same")

if l1_sorted == l3_sorted:
    print ("The lists l1 and l3 are the same")
else:
    print ("The lists l1 and l3 are not the same")

Вывод будет следующим:

The lists l1 and l3 are the same
The lists l1 and l2 are not the same

Сравнение списков с помощью функций reduce() и map()

Сравнить элементы двух списков можно с помощью функции map() вместе с функцией functools. reduce(). При их комбинации map() применяет заданную функцию к каждому элементу, а функция reduce() обеспечивает последовательное применение функции.

Функция map() принимает в качестве аргументов функцию и итератор. Затем map() применяет заданную функцию к каждому элементу итерации,а затем возвращает объект map (итератор) в качестве результата.

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

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

Порядок элементов списка важен для reduce() и map(). Списки с одинаковыми элементами в разном порядке не считаются одинаковыми.

В следующем примере показано, как проверить списки на равенство с помощью функций reduce() и map():

import functools

l1 = [10, 20, 30, 40, 50]
l2 = [20, 30, 50, 40, 70]
l3 = [10, 20, 30, 40, 50]

if functools.reduce(lambda x, y : x and y, map(lambda p, q: p == q,l1,l2), True):
    print ("The lists l1 and l2 are the same")
else:
    print ("The lists l1 and l2 are not the same")

if functools.reduce(lambda x, y : x and y, map(lambda p, q: p == q,l1,l3), True):
    print ("The lists l1 and l3 are the same")
else:
    print ("The lists l1 and l3 are not the same")

Получим следующий вывод:

The lists l1 and l2 are not the same
The lists l1 and l3 are the same

В предыдущем примере код сравнивает l1 с l2, а затем сравнивает l1 с l3.

Сравнение списков с помощью функции set() 

С помощью функции set() можно создать объекты set на основе заданных списков, а затем проверить эти наборы на равенство с помощью оператора ==.

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

Примечание. Дублирующиеся элементы списка появляются в наборе только один раз.

Следующий пример демонстрирует, как создавать наборы из списков и сравнивать их:

l1 = [10, 20, 30, 40, 50]
l2 = [50, 10, 30, 20, 40]

a = set(l1)
b = set(l2)

if a == b:
    print("Lists l1 and l2 are equal")
else:
    print("Lists l1 and l2 are not equal")

Получаем вывод:

Lists l1 and l2 are equal

Код в предыдущем примере создает наборы a и b из списков l1 и l2, затем сравнивает их и выводит результат.

Сравнение списков с помощью класса collections.Counter() 

С помощью класса collections.Counter() можно сравнивать списки. Функция counter() подсчитывает частоту элементов в списке и сохраняет данные в виде словаря в формате value:frequency. Если два списка выдают два одинаковых словаря, можно сделать вывод, что списки одинаковы.

Порядок элементов исходного списка не важен при сравнении с помощью класса Counter.

Следующий пример демонстрирует, как создать объекты Counter из заданных списков и сравнить их:

import collections

l1 = [10, 20, 30, 40, 50]
l2 = [20, 30, 50, 40, 70]
l3 = [50, 20, 30, 40, 10]

if collections.Counter(l1) == collections.Counter(l2):
    print ("The lists l1 and l2 are the same")
else:
    print ("The lists l1 and l2 are not the same")

if collections.Counter(l1) == collections.Counter(l3):
    print ("The lists l1 and l3 are the same")
else:
    print ("The lists l1 and l3 are not the same")

Вывод будет следующим:

The lists l1 and l2 are not the same
The lists l1 and l3 are the same

Код в предыдущем примере создаст объекты Counter для списков l1 и l2, сравнит их и выведет результат. Код повторяется для списков l1 и l3.

Сравнение с помощью генератора списков

Читайте также: Генераторы списков в Python 3

При сравнении списков с помощью генераторов порядок элементов исходного списка не важен.

Следующий пример показывает, как сравнить списки с помощью генератора:

l1 = [10, 20, 30, 40, 50]
l2 = [50, 75, 30, 20, 40]
l3 = [50, 20, 30, 40, 10]

res = [x for x in l1 + l2 if x not in l1 or x not in l2]

print(res)
if not res:
    print("Lists l1 and l2 are equal")
else:
    print("Lists l1 and l2 are not equal")

res2 = [x for x in l1 + l3 if x not in l1 or x not in l3]

print(res2)
if not res2:
    print("Lists l1 and l3 are equal")
else:
    print("Lists l1 and l3 are not equal")

Код в предыдущем примере устанавливает элемент-указатель x в списки l1 и l2, а затем проверяет, присутствует ли в списках элемент, на который указывает элемент-указатель. Если результат res — пустой список, то можно сделать вывод, что списки равны, поскольку нет элементов, которые присутствуют только в одном из списков.

Вывод будет следующим:

[10, 75]
Lists l1 and l2 are not equal

Подводим итоги

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

Как сравнить два списка в Python: 5 методов и примеры

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

Сравнение – это метод проверки элементов данных одного списка на предмет равенства с элементами данных другого списка.

Содержание

1. Методы сравнения двух списков
2. 1. Функции Python reduce() и map()
3. 2. Метод Python collection.counter()
4. 3. Метод Python sort() и оператор ==
5. 4. Метод Python set() и оператор ==
6. 5. Понимание пользовательского списка

Методы сравнения двух списков

• Функции reduce() и map().
• Функция collection.counter().
• sort() вместе с оператором ==.
• set() вместе с оператором ==.
• Функция difference().

1. Функции Python reduce() и map()

Мы можем использовать функцию map() вместе с функцией functools.reduce() для сравнения элементов данных двух списков.

Метод map() принимает в качестве аргументов функцию и итерацию, например список, кортеж, строку и т.д.

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

Метод functools.reduce() применяет переданную функцию к каждому элементу итерируемого ввода рекурсивным образом.

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

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

Пример:

import functools 


l1 = [10, 20, 30, 40, 50] 
l2 = [10, 20, 30, 50, 40, 70] 
l3 = [10, 20, 30, 40, 50] 

if functools. reduce(lambda x, y : x and y, map(lambda p, q: p == q,l1,l2), True): 
    print ("The lists l1 and l2 are the same") 
else: 
    print ("The lists l1 and l2 are not the same") 

if functools.reduce(lambda x, y : x and y, map(lambda p, q: p == q,l1,l3), True): 
    print ("The lists l1 and l3 are the same") 
else: 
    print ("The lists l1 and l3 are not the same") 

Выход:

The lists l1 and l2 are not the same
The lists l1 and l3 are the same

2. Метод Python collection.counter()

Метод collection.counter() можно использовать для эффективного сравнения списков. Функция counter() подсчитывает частоту элементов в списке и сохраняет данные в виде словаря в формате <значение>: <частота>.

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

Примечание. Порядок в списке не влияет на метод counter().

Пример:

import collections 


l1 = [10, 20, 30, 40, 50] 
l2 = [10, 20, 30, 50, 40, 70] 
l3 = [10, 20, 30, 40, 50] 

if collections. Counter(l1) == collections.Counter(l2):
    print ("The lists l1 and l2 are the same") 
else: 
    print ("The lists l1 and l2 are not the same") 

if collections.Counter(l1) == collections.Counter(l3):
    print ("The lists l1 and l3 are the same") 
else: 
    print ("The lists l1 and l3 are not the same") 

Выход:

The lists l1 and l2 are not the same
The lists l1 and l3 are the same

3. Метод Python sort() и оператор ==

Мы можем объединить метод sort() с оператором == для сравнения двух списков.

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

Примечание. Порядок в списке не влияет на этот метод, потому что мы будем сортировать списки перед сравнением.

Кроме того, оператор == используется для сравнения списка элемент за элементом.

Пример:

import collections 


l1 = [10, 20, 30, 40, 50] 
l2 = [10, 20, 30, 50, 40, 70] 
l3 = [50, 10, 30, 20, 40] 

l1.sort() 
l2.sort() 
l3.sort() 

if l1 == l3: 
    print ("The lists l1 and l3 are the same") 
else: 
    print ("The lists l1 and l3 are not the same") 


if l1 == l2: 
    print ("The lists l1 and l2 are the same") 
else: 
    print ("The lists l1 and l2 are not the same") 

Выход:

The lists l1 and l3 are the same
The lists l1 and l2 are not the same

4. Метод Python set() и оператор ==

Метод set() манипулирует элементами данных итерации до отсортированного набора элементов данных, не принимая во внимание порядок элементов.

Кроме того, оператор == используется для поэлементного сравнения элементов данных списка.

Пример:

l1 = [10, 20, 30, 40, 50] 
l3 = [50, 10, 30, 20, 40] 

a = set(l1)
b = set(l3)

if a == b:
    print("Lists l1 and l3 are equal")
else:
    print("Lists l1 and l3 are not equal")

Выход:

Lists l1 and l3 are equal

5.

Мы можем использовать List в Python для сравнения двух списков.

Пример:

l1 = [10, 20, 30, 40, 50] 
l3 = [50, 75, 30, 20, 40, 69] 

res = [x for x in l1 + l3 if x not in l1 or x not in l3]

print(res)
if not res:
    print("Lists l1 and l3 are equal")
else:
    print("Lists l1 and l3 are not equal")

 

В приведенном выше коде мы устанавливаем элемент указателя «x» на список l1 и l3. Далее мы проверяем, присутствует ли элемент, на который указывает элемент-указатель, в списках.

Выход:

[10, 75, 69]
Lists l1 and l3 are not equal

Python Сравнение массивов | Gkindex

Мы можем использовать операторы отношения >, >=, <, <=, == и != для сравнения массивов одинакового размера. Эти операторы сравнивают соответствующие элементы массивов и возвращают другой массив со значениями логического типа. Это означает, что результирующий массив содержит элементы, которые являются True или False.

из импорта numpy *
а = массив ([1,2,3,0])
б = массив ([0,2,3,1])
с = а == б
print('Результат a==b:', c)
с = а > б
print('Результат a>b:', c)
с = а <= б
print('Результат a<=b:', c)
                         

Используйте numpy.where() For If Else Condi...

Пожалуйста, включите JavaScript

The any() Функцию можно использовать для определения , если какой-либо элемент массива имеет значение True.

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

Программа на Python, чтобы знать эффекты функций any() и all().

из импорта numpy *
а = массив ([1,2,3,0])
б = массив ([0,2,3,1])
с = а > б
print('Результат a>b:', c)
print('Проверить, истинен ли хотя бы один элемент:', any(c))
print('Проверить, все ли элементы истинны:', all(c))
если(любой(а>б)):
print('a содержит как минимум на один элемент больше, чем b')

Функции logical_and(), logical_or() и logical_not() полезны для получения логического массива в результате сравнения составного условия.

из импорта numpy *
а = массив ([1,2,3], целое число)
б = массив ([0,2,3], целое число)
с = логическое_и(а>0, а<4)
печать (с)
c = логическое_или (b>=0, b==1)
печать (с)
с = логическое_не(б)
печать (с)

Функция where() может использоваться для создания нового массива в зависимости от того, является ли заданное условие истинным или ложным. Синтаксис функции where():

массив = где (условие, выражение1, выражение2)

Если 'условие' истинно, выполняется 'выражение1' и результат сохраняется в массиве, иначе выполняется «выражение2», и его результат сохраняется в массиве. Например,

a = массив([10, 21, 30, 41, 50], целое)

с = где (а% 2 == 0, а, 0)

Новый массив 'c' содержит элементы из 'a' на основании условия a%2==0. Это условие применяется к каждому элементу массива «а», и если оно истинно, элемент «a» сохраняется в «c», иначе «0» сохраняется в c. Следовательно, массив 'c' выглядит так:

[10 0 30 0 50].

из импорта numpy *
а = массив ([10, 20, 30, 40, 50], целое число)
b = массив ([1, 21, 3, 40, 51], целое число)
с = где (а>б, а, б)
печать (с)

Функция ненулевая() полезно знать позиции элементов, которые не равны нулю. Эта функция возвращает массив, содержащий индексы элементов массива, не равные нулю. Например,

а = массив ([1, 2, 0, -1, 0, 6], целое число)

В предыдущем массиве ненулевыми элементами являются: 1, 2, -1 и 6. Их позиции или индексы: 0, 1, 3, 5. Эти индексы могут быть извлечены в другой массив 'c' как:

c = nonzero(a)

из импорта numpy *
а = массив ([1, 2, 0, -1, 0, 6], целое число)
с = ненулевое (а)
#отображать индексы
для я в с:
  печать (я)
# отображать ненулевые значения
печать (а [с])

Как сравнить два списка в python?

спросил 12 лет, 10 месяцев назад

Изменено 2 года, 5 месяцев назад

Просмотрено 251 тысяч раз

Как сравнить два списка в python?

 date = "Чт, 16 сентября, 13:14:15 CDT 2010"
sdate = "Чт, 16 сентября, 14:14:15 CDT 2010"
dateArr = [] dateArr = date.split()
sdateArr = [] sdateArr = sdate.split()
 

Теперь я хочу сравнить эти два списка. Я думаю, что split возвращает список. Мы можем сделать простое сравнение в Java, например dateArr[i] == sdateArr[i] , но как мы можем сделать это в Python?

• питон
• список

Вы всегда можете сделать просто:

 a=[1,2,3]
б=['а','б']
с=[1,2,3,4]
д=[1,2,3]
a==b # возвращает ложь
a==c # возвращает ложь
a==d # возвращает Истина
 

 а = ['a1','b2','c3']
б = ['a1','b2','c3']
с = ['b2','a1','c3']
# если вам важен порядок
а == б # Верно
а == с # Ложь
# если вас не волнует порядок и дубликаты
set(a) == set(b) # Истинно
set(a) == set(c) # Истинно
 

Создавая наборы a , b и c , вы удаляете дубликаты, и порядок не учитывается. Сравнение наборов также намного быстрее и эффективнее, чем сравнение списков.

Если вы имеете в виду списки, попробуйте == :

 l1 = [1,2,3]
л2 = [1,2,3,4]
l1 == l2 # Ложь
 

Если вы имеете в виду массив :

 l1 = массив ('l', [1, 2, 3])
l2 = массив ('d', [1. 0, 2.0, 3.0])
l1 == l2 # Верно
l2 = массив ('d', [1.0, 2.0, 3.0, 4.0])
l1 == l2 # Ложь
 

Если вы хотите сравнить строки (согласно вашему комментарию):

 date_string = u'Thu Sep 16 13:14:15 CDT 2010'
date_string2 = u'Thu Sep 16 14:14:15 CDT 2010'
date_string == date_string2 # Ложь
 

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

 >>> dateList = "Чт, 16 сентября, 13:14:15 CDT 2010".split()
>>> sdateList = "Чт, 16 сентября, 14:14:15 CDT 2010".split()
>>> dateList == sdataList
ЛОЖЬ
 

Метод split строки возвращает список. Список в Python сильно отличается от массива. == в этом случае выполняет поэлементное сравнение двух списков и возвращает результат, если все их элементы равны, а количество и порядок элементов совпадают. Прочтите документацию.

 для i в arr1:
    если я в обр2:
        вернуть 1
    вернуть 0
обр1=[1,2,5]
обр2=[2,4,15]
q=checkarrayequalornot(arr1,arr2)
распечатать (к)
>>0
 

Из вашего поста я понял, что вы хотите сравнивать даты, а не массивы.