Python：在對象列表中獲取兩個布爾屬性頻率的最有效方法？

Question

我有一個用戶對象，有兩個布爾屬性，就像這樣：

class User(object): 
    def __init__(self, a, b): 
    self.a = a # Always a bool 
    self.b = b # Always a bool 

我有這些對象的列表，稱爲user_list，我想要得到多少對象有==頻率計數確實，a == False，b == True，b == False。

我最初的方法是使用collections.Counter，但需要通過列表循環兩次：

a_count = collections.Counter(u.a for u in user_list) 
b_count = collections.Counter(u.b for u in user_list) 
print a_count[True], a_count[False], b_count[True], b_count[False] 

我也想過只用4個計數器，但這是醜陋的，不覺得Python的：

a_true_count = 0 
a_false_count = 0 
b_true_count = 0 
b_false_count = 0 
for u in user_list: 
    if u.a: 
    a_true_count += 1 
    else: 
    a_false_count += 1 
    if u.b: 
    b_true_count += 1 
    else: 
    a_false_count += 1 
print a_true_count, a_false_count, b_true_count, b_false_count 

有沒有更高效的方法來做到這一點？輸出可以是任何東西：4個單獨的變量，一個帶有值的字典，一個列表，元組，任何，只要它有4個值。

在此先感謝！

Answer 1

爲什麼不使用兩個計數器，並從user_list的長度中減去找到其他兩個值？

a_false_count = len(user_list) - a_true_count

b_false_count = len(user_list) - b_true_count

明確循環一樣，可能是最有效的解決方案時明智的，但如果你正在尋找的東西多一點簡潔的代碼明智的，你可以嘗試filter()：

a_false_count = len(filter(lambda x: x.a,user_list)) 
b_false_count = len(filter(lambda x: x.b,user_list)) 

Answer 2

我想用collections.Counter是正確的想法，只是做在一個Counter和單迴路一個更通用的方法：

from collections import Counter 

user_list = [User(True, False), User(False, True), User(True, True), User(False, False)] 
user_attr_count = Counter() 

for user in user_list: 
    user_attr_count['a_%s' % user.a] += 1 
    user_attr_count['b_%s' % user.b] += 1 

print user_attr_count 
# Counter({'b_False': 2, 'a_True': 2, 'b_True': 2, 'a_False': 2}) 

Answer 3

你可以使用位掩碼：

def count(user_list,mask): 
    return Counter((u.a<<1 | u.b)&mask for u in user_list) 

a=0b10 
b=0b01 
aANDb=0b11 
print count(user_list,aANDb) 

Answer 4

from collections import Counter 

c = Counter() 
for u in user_list: 
    c['a'] += u.a 
    c['b'] += u.b 

print c['a'], len(user_list) - c['a'], c['b'], len(user_list) - c['b'] 

Answer 5

這裏有一個解決方案，它靠近你有什麼第一次不同的是它僅在列表上循環一次。它創建兩個計數器，遍歷列表，併爲每個用戶更新每個計數器。進行計數的實際步驟如下：

for user in user_list: 
    a_count.update([user.a]) 
    b_count.update([user.b]) 

它使用更新函數來更新每個計數器對象。你可以這樣做，而不是像你在第一個例子中那樣使用一個生成器在一行中創建計數器。整個代碼示例是在這裏：

import collections 

class User(object): 
    def __init__(self, a, b): 
     self.a = a 
     self.b = b 

user_list = [ 
    User(True, False), 
    User(False, True), 
    User(True, True), 
    User(False, False) 
] 

a_count = collections.Counter() 
b_count = collections.Counter() 

for user in user_list: 
    a_count.update([user.a]) 
    b_count.update([user.b]) 


print a_count[True], a_count[False], b_count[True], b_count[False] 

Answer 6

我喜歡用zip和map這個東西：

from collections import Counter 
# for test, import random: 
import random 

# define class 
class User(object): 
    def __init__(self, a, b): 
    self.a = a # Always a bool 
    self.b = b # Always a bool 

# create an arbitrary set 
users = [ User(r % 2 == 0, r % 3 == 0) for r in (random.randint(0,100) for x in xrange(100)) ] 

# and... count 
aCounter, bCounter = map(Counter, zip(*((u.a, u.b) for u in users))) 

更新： map(sum, zip(*tuples))稍高於更快的for循環的樣本規模較小，但對於較大的樣本量，for-loop可以更好地進行縮放。與其他方法一樣，for循環在處理元組列表時並沒有獲得太多的性能提升。可能是因爲它已經非常優秀了。

collections.Counter還是很慢。

import random 
import itertools 
import time 
from collections import Counter 

# define class 
class User(object): 
    def __init__(self, a, b): 
    self.a = a # Always a bool 
    self.b = b # Always a bool 

# create an arbitrary sample 
users = [ User(r % 2 == 0, r % 3 == 0) for r in (random.randint(0,100) for x in xrange(100)) ] 
# create a list of tuples of the arbitrary sample 
users2 = [ (u.a,u.b) for u in users ] 

# useful function-timer decorator   
def timer(times=1): 
    def outer(fn): 
     def wrapper(*args, **kwargs): 
      t0 = time.time() 
      for n in xrange(times): 
       r = fn(*args, **kwargs) 
      dt = time.time() - t0 
      print '{} ran {} times in {} seconds with {:f} ops/sec'.format(fn.__name__, times, dt, times/dt) 
      return r 
     return wrapper 
    return outer 

# now create the timeable functions   
n=10000 
@timer(times=n) 
def time_sum(): 
    return map(sum, zip(*((u.a, u.b) for u in users))) 
@timer(times=n) 
def time_counter(): 
    return map(Counter, zip(*((u.a, u.b) for u in users))) 
@timer(times=n) 
def time_for(): 
    a,b=0,0 
    for u in users: 
     if u.a is True: 
      a += 1 
     if u.b is True: 
      b += 1 
    return a,b 
@timer(times=n) 
def time_itermapzip(): 
    return list(itertools.imap(sum, itertools.izip(*((u.a, u.b) for u in users)))) 

@timer(times=n) 
def time_sum2(): 
    return map(sum, zip(*users2)) 
@timer(times=n) 
def time_counter2(): 
    return map(Counter, zip(*users2)) 
@timer(times=n) 
def time_for2(): 
    a,b=0,0 
    for _a,_b in users2: 
     if _a is True: 
      a += 1 
     if _b is True: 
      b += 1 
    return a,b 
@timer(times=n) 
def time_itermapzip2(): 
    return list(itertools.imap(sum, itertools.izip(*users2))) 

v = time_sum() 
v = time_counter() 
v = time_for() 
v = time_itermapzip() 

v = time_sum2() 
v= time_counter2() 
v = time_for2() 
v = time_itermapzip2() 

# time_sum ran 10000 times in 0.446894168854 seconds with 22376.662523 ops/sec 
# time_counter ran 10000 times in 1.29836297035 seconds with 7702.006471 ops/sec 
# time_for ran 10000 times in 0.267076015472 seconds with 37442.523554 ops/sec 
# time_itermapzip ran 10000 times in 0.459508895874 seconds with 21762.364319 ops/sec 
# time_sum2 ran 10000 times in 0.174293994904 seconds with 57374.323226 ops/sec 
# time_counter2 ran 10000 times in 0.989939928055 seconds with 10101.623055 ops/sec 
# time_for2 ran 10000 times in 0.183295965195 seconds with 54556.574605 ops/sec 
# time_itermapzip2 ran 10000 times in 0.193426847458 seconds with 51699.131384 ops/sec 

print "True a's: {}\t False a's: {}\nTrue b's: {}\t False b's:{}".format(v[0], len(users)-v[0], v[1], len(users)-v[1]) 
# True a's: 53 False a's: 47 
# True b's: 31 False b's:69 
v 
# [53, 31] 

相同的代碼爲1000的樣品尺寸：

# time_sum ran 10000 times in 9.30428719521 seconds with 1074.773359 ops/sec 
# time_counter ran 10000 times in 16.7009849548 seconds with 598.767080 ops/sec 
# time_for ran 10000 times in 2.61371207237 seconds with 3825.976130 ops/sec 
# time_itermapzip ran 10000 times in 9.40824103355 seconds with 1062.897939 ops/sec 
# time_sum2 ran 10000 times in 5.70988488197 seconds with 1751.348794 ops/sec 
# time_counter2 ran 10000 times in 13.4643371105 seconds with 742.702735 ops/sec 
# time_for2 ran 10000 times in 2.49017906189 seconds with 4015.775473 ops/sec 
# time_itermapzip2 ran 10000 times in 6.10926699638 seconds with 1636.857581 ops/sec