Python 如果函数在匹配来自不同列表的两个用户ID时执行函数？

我正在寻找一些帮助来添加到我当前的代码中，我有两个用户名列表，列表如下所示：

Fishermen A:

George
Tom
Joel
Tom
Lance


Fishermen B:

George
Tom
Tom

我想能够做的基本上是，如果一个用户名出现在Fisherman a列表和Fisherman B列表中，那么计算它出现在这两个列表中的次数。因此，在本例中，代码将列出Tom 4次和George 2次，否则什么也不做。我是一个相对新手与编码，所以任何意见和帮助将不胜感激

看起来像是以下人员的工作：

fishermanA = ['George', 'Tom', 'Joel', 'Tom', 'Lance']
fishermanB = ['George', 'Tom', 'Tom']
a_set = set(fishermanA)
b_set = set(fishermanB)
inter = a_set.intersection(b_set)
for i in inter:
    print(i, fishermanA.count(i) + fishermanB.count(i))


Output:
('George', 2)
('Tom', 4)

看起来像是一份工作：

这个怎么样：

from collections import defaultdict

fmenA = [
    "George",
    "Tom",
    "Joel",
    "Tom",
    "Lance",
]

fmenB = [
    "George",
    "Tom",
    "Tom",
]

countsA = defaultdict(int)
countsB = defaultdict(int) 

for name in fmenA:
    countsA[name] += 1

for name in fmenB:
    countsB[name] += 1

print {
         name: countsA[name] + countsB[name] 
         for name in countsA if name in countsB
      }


--output:--
{'George': 2, 'Tom': 4}



#The following data is highly skewed against count()

print len(string.printable)   #-->100

fmenA = list(string.printable)[:10]
fmenB = list(string.printable)[:10]
--------------------------------------
2.14819002151   defaultdict
1.860476017     count()
3.48084497452   Counter_arshajii
5.76169896126   Counter_jpmc26



fmenA = list(string.printable)[:20]
fmenB = list(string.printable)[:20]
--------------------------------------
3.87321305275    defaultdict
4.63102507591    count()
5.21796107292    Counter_arshajii
8.44607114792    Counter_jpmc26


fmenA = list(string.printable)[:40]
fmenB = list(string.printable)[:40]
--------------------------------------
7.59739494324         defaultdict
13.643941879272461    count()
9.3110909462          Counter_arshajii
15.3523819447         Counter_jpmc26



fmenA = list(string.printable)
fmenB = list(string.printable)
-------------------------------
18.7256119251    defaultdict
80.9080910683    count()
22.0006680489    Counter_arshajii
37.6448471546    Counter_jpmc26



import timeit

setup ="""
from collections import defaultdict
from collections import Counter
import string

fmenA = list(string.printable) 
fmenB = list(string.printable) 
"""

s1 = """
countsA = defaultdict(int)
countsB = defaultdict(int) 

for name in fmenA:
    countsA[name] += 1

for name in fmenB:
    countsB[name] += 1

{
    name: (countsA[name] + countsB[name]) 
    for name in countsA if name in countsB
}

"""

s2 = """
a_set = set(fmenA)
b_set = set(fmenB)
inter = a_set.intersection(b_set)

{
    name: fmenA.count(name) + fmenB.count(name) 
    for name in inter
}
"""

s3 = """
Counter(filter((set(fmenA) & set(fmenB)).__contains__, fmenA + fmenB))
"""

s4 = """
a = Counter(fmenA)
b = Counter(fmenB)
{k: a[k] + b[k] for k in a if a[k] > 0 and b[k] > 0}
"""

t = timeit.Timer(stmt=s1, setup=setup)
print(t.timeit(number=100000))
t = timeit.Timer(stmt=s2, setup=setup)
print(t.timeit(number=100000))
t = timeit.Timer(stmt=s3, setup=setup)
print(t.timeit(number=100000))
t = timeit.Timer(stmt=s4, setup=setup)
print(t.timeit(number=100000))

这个怎么样：

from collections import defaultdict

fmenA = [
    "George",
    "Tom",
    "Joel",
    "Tom",
    "Lance",
]

fmenB = [
    "George",
    "Tom",
    "Tom",
]

countsA = defaultdict(int)
countsB = defaultdict(int) 

for name in fmenA:
    countsA[name] += 1

for name in fmenB:
    countsB[name] += 1

print {
         name: countsA[name] + countsB[name] 
         for name in countsA if name in countsB
      }


--output:--
{'George': 2, 'Tom': 4}



#The following data is highly skewed against count()

print len(string.printable)   #-->100

fmenA = list(string.printable)[:10]
fmenB = list(string.printable)[:10]
--------------------------------------
2.14819002151   defaultdict
1.860476017     count()
3.48084497452   Counter_arshajii
5.76169896126   Counter_jpmc26



fmenA = list(string.printable)[:20]
fmenB = list(string.printable)[:20]
--------------------------------------
3.87321305275    defaultdict
4.63102507591    count()
5.21796107292    Counter_arshajii
8.44607114792    Counter_jpmc26


fmenA = list(string.printable)[:40]
fmenB = list(string.printable)[:40]
--------------------------------------
7.59739494324         defaultdict
13.643941879272461    count()
9.3110909462          Counter_arshajii
15.3523819447         Counter_jpmc26



fmenA = list(string.printable)
fmenB = list(string.printable)
-------------------------------
18.7256119251    defaultdict
80.9080910683    count()
22.0006680489    Counter_arshajii
37.6448471546    Counter_jpmc26



import timeit

setup ="""
from collections import defaultdict
from collections import Counter
import string

fmenA = list(string.printable) 
fmenB = list(string.printable) 
"""

s1 = """
countsA = defaultdict(int)
countsB = defaultdict(int) 

for name in fmenA:
    countsA[name] += 1

for name in fmenB:
    countsB[name] += 1

{
    name: (countsA[name] + countsB[name]) 
    for name in countsA if name in countsB
}

"""

s2 = """
a_set = set(fmenA)
b_set = set(fmenB)
inter = a_set.intersection(b_set)

{
    name: fmenA.count(name) + fmenB.count(name) 
    for name in inter
}
"""

s3 = """
Counter(filter((set(fmenA) & set(fmenB)).__contains__, fmenA + fmenB))
"""

s4 = """
a = Counter(fmenA)
b = Counter(fmenB)
{k: a[k] + b[k] for k in a if a[k] > 0 and b[k] > 0}
"""

t = timeit.Timer(stmt=s1, setup=setup)
print(t.timeit(number=100000))
t = timeit.Timer(stmt=s2, setup=setup)
print(t.timeit(number=100000))
t = timeit.Timer(stmt=s3, setup=setup)
print(t.timeit(number=100000))
t = timeit.Timer(stmt=s4, setup=setup)
print(t.timeit(number=100000))

---

我同意arshaji的观点，即

计数器

是一条可行之路，但在我看来，创建额外的

集合

并直接访问魔法方法是不必要的

>>> from collections import Counter
>>> l1 = ['George', 'Tom', 'Joel', 'Tom', 'Lance']
>>> l2 = ['George', 'Tom', 'Tom']
>>> a = Counter(l1)
>>> b = Counter(l2)
>>> counts = {k: a[k] + b[k] for k in a if a[k] > 0 and b[k] > 0}
>>> counts
{'George': 2, 'Tom': 4}
>>> for k in counts:
...     print str(k) + ': ' + str(counts[k])
...
George: 2
Tom: 4

请注意，我们只在一个

计数器中迭代键是可以的。键必须在两个列表中，我们才能关心它，因此如果它在两个列表中，它将在我们迭代的
计数器中

与Ankur Ankan的解决方案相比，它的优点是对于大型列表的效率。Ankur Ankan的解决方案对每个公共元素的两个完整列表进行迭代。
计数器仅在每个列表上迭代一次，然后在一个
计数器上迭代一次。对于大型列表和大量公共元素，性能差异将非常大。对于小列表，性能的影响可以忽略不计。
我同意arshaji的观点，即
计数器是一种可行的方法，但在我看来，创建额外的
集合和直接访问神奇方法是不必要的

>>> from collections import Counter
>>> l1 = ['George', 'Tom', 'Joel', 'Tom', 'Lance']
>>> l2 = ['George', 'Tom', 'Tom']
>>> a = Counter(l1)
>>> b = Counter(l2)
>>> counts = {k: a[k] + b[k] for k in a if a[k] > 0 and b[k] > 0}
>>> counts
{'George': 2, 'Tom': 4}
>>> for k in counts:
...     print str(k) + ': ' + str(counts[k])
...
George: 2
Tom: 4

请注意，我们只在一个
计数器中迭代键是可以的。键必须在两个列表中，我们才能关心它，因此如果它在两个列表中，它将在我们迭代的
计数器中

与Ankur Ankan的解决方案相比，它的优点是对于大型列表的效率。Ankur Ankan的解决方案对每个公共元素的两个完整列表进行迭代。
计数器仅在每个列表上迭代一次，然后在一个
计数器上迭代一次。对于大型列表和大量公共元素，性能差异将非常大。对于小列表，性能影响可以忽略不计。
答案是汤姆4和乔治2吗？请准确显示您希望输出的内容。Soory伙计们，是的，汤姆4和乔治2:）答案是汤姆4和乔治2吗？请准确显示您希望输出的内容。Soory伙计们，是的，汤姆4和乔治2:）“与Ankur Ankan的解决方案相比，该解决方案的优势在于对大型列表的效率。“这两种计数器解决方案的效率都非常低，我的测试表明，无论列表大小如何，您的计数器解决方案都是最慢的。我使用原始列表，原始列表乘以1000。你介意发布你的测试吗？嗯。我的印象是，
计数器
是按
O（n）
的顺序生成的，并查看
O（1）
（哈希表），但如果你的测试显示不是这样，我想我的假设是错误的。如果我们将
计数器
s转换为
dict
s:
a=dict（计数器（l1））
，会发生什么情况？我们还应该尝试一对包含大量不同公共元素的列表，因为这也会对性能产生重大影响（因此是“每个公共元素”部分）。对于两个列表[“Tom”]和[“Tom”，“Tom”]，当列表变大时（2->20000），您的解决方案的性能不会明显优于另一个计数器解决方案，但反方案都是可悲的——我给了你免费的进口产品。count（）解决方案的速度快了20倍。对于最大的列表，defaultdict的速度是它的两倍。defaultdict在大小范围内的速度实际上是它的3-4倍；我说我的假设肯定是错误的，我提出了两条建议。根据您的测试，我不确定我的解决方案的性能顺序是什么，但Ankur Ankan的解决方案最多应该有顺序
O（（n+c）（a+b））
，其中
n
是不同的公共元素数，
a
和
b
是列表长度，
c
是常数（乘以列表长度）以说明生成交集的原因。（
c
可能是1或2。）您没有增加影响最大的
n
。“与Ankur Ankan的解决方案相比，Ankur Ankan的优势在于大列表的效率。”这两种计数器的效率都非常低，我的测试表明，对于任何列表大小，您的计数器都是最慢的。我使用了原始列表，原始列表乘以1000。您介意发布您的测试吗？嗯。我的印象是，
计数器
是按顺序
O（n）生成的
并查看
O（1）
（哈希表），但如果您的测试显示不是这样，我想我的假设是错误的。如果我们将
计数器
s转换为
dict
s:
a=dict（计数器（l1））会发生什么
？我们还应该尝试一对包含大量不同公共元素的列表，因为这也会对性能产生重大影响（因此是“每个公共元素”部分）。对于两个列表[“Tom”]和[“Tom”，“Tom”]，随着列表变大（2->20000），您的解决方案的性能不会明显优于另一个计数器解决方案，但反方案都很糟糕——我给了你免费的进口品解决方案快了20倍。对于最大的列表，defaultdict的速度是它的两倍。defaultdict实际上在大小范围内是它的3-4倍。我不清楚你想表达的是什么观点；我说的是我的假设一定是错的，并提出了两个建议。根据你的测试，我不确定我的sol的性能顺序是什么答案是肯定的，但Ankur Ankan的解决方案最多应该有顺序
O（（n+c）（a+b））
，其中
n
是distin的数量