Use a generator expression:

sum(c.a for c in c_list)

You can do this using a defaultdict:

from collections import defaultdict
indexed_sums = defaultdict(int)
for o in xbs:
    indexed_sums[(o.W, o.X, o.Y)] += o.Z

For instance, if you start with (using your class definition of xb):

xbs = [xb(1, 2, 3, 4, 5),
       xb(1, 2, 3, 4, 5),
       xb(1, 2, 3, 4, 5),
       xb(1, 4, 3, 4, 5),
       xb(1, 4, 3, 4, 3),
       xb(1, 2, 3, 9, 3)]

You end up with:

print dict(indexed_sums)
# {(4, 3, 4): 8, (2, 3, 4): 15, (2, 3, 9): 3}

Thus, you could get the sum for W, X, Y being 2, 3, 4 as:

indexed_sums[(2, 3, 4)]
# 15

Note that the defaultdict is doing very little work here (it's just a dictionary of counts that starts at 0 by default): the main thing is that you are indexing the (o.W, o.X, o.Y) tuples in a dictionary. You could have done the same thing without defaultdict as:

indexed_sums = {}
for o in xbs:
    if (o.W, o.X, o.Y) not in indexed_sums:
        indexed_sums[(o.W, o.X, o.Y)] = 0
    indexed_sums[(o.W, o.X, o.Y)] += o.Z

The defaultdict is just saving you two lines.

sum needs somewhere to start; by default, it starts at 0. So the first operation it attempts is 0 + MyClass(value=1), which you haven't told it how to do!

You therefore have two choices, either:

1. Specify the start (e.g. sum(c, MyClass())); or
2. Tell MyClass how to deal with adding integers to instances.

The latter could look like:

class MyClass(object):

    ...

    def __add__(self, other):
        try:
            return MyClass(self.value + other.value)  # handle things with value attributes
        except AttributeError:
            return MyClass(self.value + other)  # but also things without

    ...

which lets you skip the explicit start:

>>> sum([MyClass(1), MyClass(2)]).value
3

Use itertools.groupby after sorting it with operator.attrgetter('name') as key.

from itertools import groupby
from operator import attrgetter
print({k: sum(o.value for o in g) for k, g in groupby(sorted(listOfObj, key=attrgetter('name')), attrgetter('name'))})

You can use the inspect module to extract a list of all arguments required to initialise a class instance.

Then iterate those arguments with a list comprehension:

import inspect

class Foo():
    def __init__(self, a1, a2, a3):
        self.a1 = a1
        self.a2 = a2
        self.a3 = a3
        pass

# get list of arguments, ignore the first which is self
args = inspect.getfullargspec(Foo.__init__).args[1:]

l = [Foo(a1=1, a2=2, a3=3), Foo(a1=1, a2=2, a3=3), Foo(a1=1, a2=2, a3=3)]

# use list comprehension to sum by attribute
sums = [sum([getattr(x, i) for x in l]) for i in args]

# [3, 6, 9]

The defaultdict approach is probably better, assuming c.Y is hashable, but here's another way:

from itertools import groupby
from operator import attrgetter
get_y = attrgetter('Y')
tuples = [(y, sum(c.Z for c in cs_with_y) for y, cs_with_y in 
           groupby(sorted(cs, key=get_y), get_y)]

To be a little more concrete about the differences:

• This approach requires making a sorted copy of cs, which takes O(n log n) time and O(n) extra space. Alternatively, you can do cs.sort(key=get_y) to sort cs in-place, which doesn't need extra space but does modify the list cs. Note that groupby returns an iterator so there's not any extra overhead there. If the c.Y values aren't hashable, though, this does work, whereas the defaultdict approach will throw a TypeError.

  But watch out -- in recent Pythons it'll raise TypeError if there are any complex numbers in there, and maybe in other cases. It might be possible to make this work with an appropriate key function -- key=lambda e: (e.real, e.imag) if isinstance(e, complex) else e seems to be working for anything I've tried against it right now, though of course custom classes that override the __lt__ operator to raise an exception are still no go. Maybe you could define a more complicated key function that tests for this, and so on.

  Of course, all we care about here is that equal things are next to each other, not so much that it's actually sorted, and you could write an O(n^2) function to do that rather than sort if you so desired. Or a function that's O(num_hashable + num_nonhashable^2). Or you could write an O(n^2) / O(num_hashable + num_nonhashable^2) version of groupby that does the two together.

• sblom's answer works for hashable c.Y attributes, with minimal extra space (because it computes the sums directly).

• philhag's answer is basically the same as sblom's, but uses more auxiliary memory by making a list of each of the cs -- effectively doing what groupby does, but with hashing instead of assuming it's sorted and with actual lists instead of iterators.

So, if you know your c.Y attribute is hashable and only need the sums, use sblom's; if you know it's hashable but want them grouped for something else as well, use philhag's; if they might not be hashable, use this one (with extra worrying as noted if they might be complex or a custom type that overrides __lt__).

as the input is:

my_list = [
             {
               'brand': 'Totoya',
               'quantity': 10
             },
             {
               'brand': 'Honda',
               'quantity': 20
             },
             {
               'brand': 'Hyundai',
               'quantity': 30
             }
           ]

You can loop over it as this:

counter = 0
for i in my_list:
    counter += i['quantity']
print(counter)

or in oneliner:

print(sum(i['quantity'] for i in my_list))

I'm going to assume that your CSV file is in fact a CSV file. Comma is the delimiter and the quotechar is the single quote char '.

Counting the number of times that (zero-based) column 3 occurs for each store in column 0 requires grouping the data by column 0. One way to do that is with a dictionary. A collections.defaultdict is a type of dictionary that makes it easy to collect lists of values with a common key. Once you have that you can produce counts of the "Blue" items, or "Red", or whatever else you might have.

import csv
from collections import defaultdict

d = defaultdict(list) 
with open('count.csv') as f:
    for row in csv.reader(f, quotechar="'"):
        d[row[0]].append(row[3])

    for k in sorted(d):
        print('{},{}'.format(k, d[k].count('Blue')))

Output

Store A,2
Store B,2
Store C,3

In Python, it's generally better to loop directly over the items in a list, rather than looping indirectly using indices. It's easier to read, and more efficient not to muck around with indices that you don't really need.

To get a total for each mini_carpet you can do this:

for mini in carpet:
    nr_total = sum(package.nr_buys for package in mini)
    # Do something with nr_total

To get a single grand total, do a double for loop in the generator expression:

nr_total = sum(package.nr_buys for mini in carpet for package in mini)

To utilize sum built-in function in Python for member variables of objects, you need to make a sequence (e.g, tuple or list) of the member variables of the objects. The following snippet shows how to make a list of objects' member variables. The code you posted omits the comprehension expression. I hope it will be helpful :)

class ActivityCenter:

    def __init__(self, costpool, costsum, costdriver, cdunits):
        self.costpool = costpool
        self.costsum = costsum
        self.costdriver = costdriver
        self.cdunits = cdunits

"""
Create some objects

objs = []
for i in range(num_obj):
    objs.append(ActivityCenter(<some value>,<...>,<...>,<...>))

Or use objects to make a list
"""
cp1 = ActivityCenter("Material Handling", 480000, 160000, "Pounds")
cp2 = ActivityCenter("Production orders", 90000, 200, "Num of POs")
cp3 = ActivityCenter("Marketing", 120000, 1000, "Num of events")

objs = [cp1, cp2, cp3]

total_cost = sum([obj.costsum for obj in objs])  # List comprehension
print("Total cost: ", total_cost)

First off - sum doesn't need a list - you can use a generator expression instead:

atotal = sum(x.acounter for x in someList)

You could write a helper function to do the search of the list once but look up each attribute in turn per item, eg:

def multisum(iterable, *attributes, **kwargs):
    sums = dict.fromkeys(attributes, kwargs.get('start', 0))
    for it in iterable:
        for attr in attributes:
            sums[attr] += getattr(it, attr)
    return sums

counts = multisum(someList, 'acounter', 'bcounter')
# {'bcounter': 45, 'acounter': 45}