В Python, Как можно вычесть два групповых, незаказанных списка? Скажите, что мы имеем a = [0,1,2,1,0]
и b = [0, 1, 1]
Я хотел бы сделать что-то как c = a - b
и имейте c
быть [2, 0]
или [0, 2]
порядок не имеет значения для меня. Это должно выдать исключение, если не содержит все элементы в b.
Обратите внимание, что это отличается от наборов! Я не интересуюсь нахождением различия наборов элементов в a и b, я интересуюсь различием между фактическими наборами элементов в a и b.
Я могу сделать это с для цикла, ища первый элемент b в a и затем удалив элемент из b и из a, и т.д. Но это не обращается ко мне, это было бы очень неэффективно (порядок O(n^2)
время), в то время как это не должна быть без проблем для выполнения в этом O(n log n)
время.
Python 2.7 и 3.2 добавит коллекции . Счетчик - это словарь, который сопоставляет элементы с количеством вхождений элемента. Он может быть использован как мультисет.
В соответствии с документами вы должны быть в состоянии сделать что-то подобное (непроверенное, так как у меня не установлена ни одна из версий).
from collections import Counter
a = Counter(0,1,2,1)
b = Counter(0,1,1)
print a - b # ignores items in b missing in a
# check every element in a is in b
# a[key] returns 0 if key not in a, instead of raising an exception
assert all(a[key] > b[key] for key in b)
Edit:
Так как вы застряли с 2.5, вы можете попробовать импортировать его и определить вашу собственную версию, если это не удастся. Таким образом, вы обязательно получите последнюю версию, если она доступна, и вернетесь к рабочей версии, если нет. Вы также выиграете от улучшений скорости, если в будущем будете конвертированы в реализацию на C. Т.е.
, т.е.
try:
from collections import Counter
except ImportError:
class Counter(dict):
...
Вы можете найти текущий источник на Python здесь .
Использование списка понимание:
[i for i in a if not i in b or b.remove(i)]
будет делать трюк. Это будет изменять B в процессе, хотя. Но я согласен с JKP и Dyno Fu, что с использованием петли лучше будет лучше.
Возможно, кто-то может создать лучший пример, который использует список списков, но все же это поцелуй?
Вы хотите Расстояние между границей
:
<table style="border-spacing: 10px;">
или в CSS-блоке где-то:
table {
border-spacing: 10px;
}
см. quirksMode на расстоянии
. Помните, что Расстояние между границей
не работает на IE7 и ниже.
Чтобы доказать точку JKP, что «что-нибудь на одной строке, вероятно, будет умозрительно сложно, чтобы понять», я создал одноклассник. Пожалуйста, не модируйте меня, потому что я понимаю, что это не решение, которое вы должны использовать на самом деле. Это только для демонстрационных целей.
Идея состоит в том, чтобы добавить значения в один за другим, до тех пор, пока общаяжды вы добавили, что значение делает меньше всего, чем общее количество раз, это значение в минусе, количество раз, когда он находится в B :
[ value for counter,value in enumerate(a) if a.count(value) >= b.count(value) + a[counter:].count(value) ]
Ужас! Но, возможно, кто-то может улучшить на нем? Это даже безрезультатно бесплатно?
Редактировать: видишь комментарий devin Jeanpierre об использовании DEVIN Datastructure, я придумал этот онеленер:
sum([ [value]*count for value,count in {value:a.count(value)-b.count(value) for value in set(a)}.items() ], [])
лучше, но все еще нечитаемое.
есть более простое решение для MySQL через двигатель стола СЛИЯНИЯ:
предполагают, что мы имеем стол, названный rus_vacancies
, и нуждаемся в его английском эквиваленте
create table eng_vacancies select * from rus_vacancies;
delete from eng_vacancies;
alter table eng_vacancies ENGINE=MERGE;
alter table eng_vacancies UNION=(rus_vacancies);
теперь, таблица rus_vacancies
равняется таблице eng_vacancies
для любого прочитанного - пишут операции
одно ограничение - у оригинального стола должен быть ENGINE=MyISAM (это может быть легко сделано» , изменяют стол rus_vacancies ENGINE=MyISAM
»)
Вы можете попробовать что-то подобное:
class mylist(list):
def __sub__(self, b):
result = self[:]
b = b[:]
while b:
try:
result.remove(b.pop())
except ValueError:
raise Exception("Not all elements found during subtraction")
return result
a = mylist([0, 1, 2, 1, 0] )
b = mylist([0, 1, 1])
>>> a - b
[2, 0]
Вы должны определить, что [1, 2, 3] - [5, 6] должно выводиться, хотя, я думаю, вы хотите [1, 2, 3] вот почему я не обращаю внимания на StartError.
Изменить:
Теперь я вижу, вы хотели, чтобы исключение, если a
не содержит всех элементов, добавил его, вместо того, чтобы передать StartError.
Я не уверен, в чем возражение против петли for loop: в Python нет мультисетов, поэтому вы не можете использовать встроенный контейнер, чтобы помочь вам.
Мне кажется, что что-нибудь на одной линии (если возможно) будет сложно понять. Вперед к читабельности и KISS. Python - это не C :)
.Python 2.7+ и 3.0 имеют коллекции. Counter (A.k.a. MultiSet). Документация ссылки на рецепт 576611: счетчик класса для Python 2.5:
from operator import itemgetter
from heapq import nlargest
from itertools import repeat, ifilter
class Counter(dict):
'''Dict subclass for counting hashable objects. Sometimes called a bag
or multiset. Elements are stored as dictionary keys and their counts
are stored as dictionary values.
>>> Counter('zyzygy')
Counter({'y': 3, 'z': 2, 'g': 1})
'''
def __init__(self, iterable=None, **kwds):
'''Create a new, empty Counter object. And if given, count elements
from an input iterable. Or, initialize the count from another mapping
of elements to their counts.
>>> c = Counter() # a new, empty counter
>>> c = Counter('gallahad') # a new counter from an iterable
>>> c = Counter({'a': 4, 'b': 2}) # a new counter from a mapping
>>> c = Counter(a=4, b=2) # a new counter from keyword args
'''
self.update(iterable, **kwds)
def __missing__(self, key):
return 0
def most_common(self, n=None):
'''List the n most common elements and their counts from the most
common to the least. If n is None, then list all element counts.
>>> Counter('abracadabra').most_common(3)
[('a', 5), ('r', 2), ('b', 2)]
'''
if n is None:
return sorted(self.iteritems(), key=itemgetter(1), reverse=True)
return nlargest(n, self.iteritems(), key=itemgetter(1))
def elements(self):
'''Iterator over elements repeating each as many times as its count.
>>> c = Counter('ABCABC')
>>> sorted(c.elements())
['A', 'A', 'B', 'B', 'C', 'C']
If an element's count has been set to zero or is a negative number,
elements() will ignore it.
'''
for elem, count in self.iteritems():
for _ in repeat(None, count):
yield elem
# Override dict methods where the meaning changes for Counter objects.
@classmethod
def fromkeys(cls, iterable, v=None):
raise NotImplementedError(
'Counter.fromkeys() is undefined. Use Counter(iterable) instead.')
def update(self, iterable=None, **kwds):
'''Like dict.update() but add counts instead of replacing them.
Source can be an iterable, a dictionary, or another Counter instance.
>>> c = Counter('which')
>>> c.update('witch') # add elements from another iterable
>>> d = Counter('watch')
>>> c.update(d) # add elements from another counter
>>> c['h'] # four 'h' in which, witch, and watch
4
'''
if iterable is not None:
if hasattr(iterable, 'iteritems'):
if self:
self_get = self.get
for elem, count in iterable.iteritems():
self[elem] = self_get(elem, 0) + count
else:
dict.update(self, iterable) # fast path when counter is empty
else:
self_get = self.get
for elem in iterable:
self[elem] = self_get(elem, 0) + 1
if kwds:
self.update(kwds)
def copy(self):
'Like dict.copy() but returns a Counter instance instead of a dict.'
return Counter(self)
def __delitem__(self, elem):
'Like dict.__delitem__() but does not raise KeyError for missing values.'
if elem in self:
dict.__delitem__(self, elem)
def __repr__(self):
if not self:
return '%s()' % self.__class__.__name__
items = ', '.join(map('%r: %r'.__mod__, self.most_common()))
return '%s({%s})' % (self.__class__.__name__, items)
# Multiset-style mathematical operations discussed in:
# Knuth TAOCP Volume II section 4.6.3 exercise 19
# and at http://en.wikipedia.org/wiki/Multiset
#
# Outputs guaranteed to only include positive counts.
#
# To strip negative and zero counts, add-in an empty counter:
# c += Counter()
def __add__(self, other):
'''Add counts from two counters.
>>> Counter('abbb') + Counter('bcc')
Counter({'b': 4, 'c': 2, 'a': 1})
'''
if not isinstance(other, Counter):
return NotImplemented
result = Counter()
for elem in set(self) | set(other):
newcount = self[elem] + other[elem]
if newcount > 0:
result[elem] = newcount
return result
def __sub__(self, other):
''' Subtract count, but keep only results with positive counts.
>>> Counter('abbbc') - Counter('bccd')
Counter({'b': 2, 'a': 1})
'''
if not isinstance(other, Counter):
return NotImplemented
result = Counter()
for elem in set(self) | set(other):
newcount = self[elem] - other[elem]
if newcount > 0:
result[elem] = newcount
return result
def __or__(self, other):
'''Union is the maximum of value in either of the input counters.
>>> Counter('abbb') | Counter('bcc')
Counter({'b': 3, 'c': 2, 'a': 1})
'''
if not isinstance(other, Counter):
return NotImplemented
_max = max
result = Counter()
for elem in set(self) | set(other):
newcount = _max(self[elem], other[elem])
if newcount > 0:
result[elem] = newcount
return result
def __and__(self, other):
''' Intersection is the minimum of corresponding counts.
>>> Counter('abbb') & Counter('bcc')
Counter({'b': 1})
'''
if not isinstance(other, Counter):
return NotImplemented
_min = min
result = Counter()
if len(self) < len(other):
self, other = other, self
for elem in ifilter(self.__contains__, other):
newcount = _min(self[elem], other[elem])
if newcount > 0:
result[elem] = newcount
return result
if __name__ == '__main__':
import doctest
print doctest.testmod()
Тогда вы можете написать
a = Counter([0,1,2,1,0])
b = Counter([0, 1, 1])
c = a - b
print list(c.elements()) # [0, 2]
Я попытался найти более элегантное решение, но лучшее, что я мог сделать, было в основном то же самое что Dyno Fu сказал:
from copy import copy
def subtract_lists(a, b):
"""
>>> a = [0, 1, 2, 1, 0]
>>> b = [0, 1, 1]
>>> subtract_lists(a, b)
[2, 0]
>>> import random
>>> size = 10000
>>> a = [random.randrange(100) for _ in range(size)]
>>> b = [random.randrange(100) for _ in range(size)]
>>> c = subtract_lists(a, b)
>>> assert all((x in a) for x in c)
"""
a = copy(a)
for x in b:
if x in a:
a.remove(x)
return a
Я знаю, что "за" - это не то, что вы хотите, но это просто и ясно:
for x in b:
a.remove(x)
Или если члены b
могут не находиться в a
, тогда используйте:
for x in b:
if x in a:
a.remove(x)
Я бы сделал проще:
a_b = [e for e in a if not e in b ]
...как писал wich, это неправильно - это работает только если элементы уникальны в списках. А если да, то лучше использовать
a_b = list(set(a) - set(b))