Sume Every 10 element in the list and Divided of Sum

[quest_]

Hello
I have this list
b = [0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,01,0,1,0,1,0,1,0,1,0,1,0,1]

And I want to sum every 10 element in the list after that I want to divide first 10 element with first sum, devide second then element with the second time...

I can find the sum every 10 element with this code

b= [sum(randomlist[i:i+10]) for i in range(0, len(randomlist), 10)]

But after that I really don't know how can I divide them
For instance for the example,sum of first 10 element is 5 and so the element should change like that:
b = [0,0.2,0,0.2,0,0.2,0,0.2,0,0.2010101010101010101010101010101] and so on..

Thanks for helps

[perfringo]

There are some ambiguity for me:

- sum every 10 element in the list - does this mean that sum on ten-item chunks is needed? What should happen if the number of items in list is not divisible by 10?
- divide first 10 element with first sum - what does it mean?

[quest_]

There are some ambiguity for me:

- sum every 10 element in the list - does this mean that sum on ten-item chunks is needed? What should happen if the number of items in list is not divisible by 10?
- divide first 10 element with first sum - what does it mean?

Hello,
Thanks for the answer!
1) do not worry number of elements in my list will be always divided by 10
Suppose that I have 30 elements in my array
2) once we find the sum of every 10 element, suppose that the first sum will be 20, second sum will be 10, and third some will be 12 then first 10 elements will be divided by 20 and second ten elements will be divided by 10 and third ten element will be divided by 12
You can look at the example, I explained it in my question

[deanhystad]

A generator that will do this

def divbysum(items, step=10):
    s=1
    for i, value in enumerate(items):
        if i % step == 0:
            s = sum(items[i:i+step])
        yield value/s

source = list(range(20))
result = [x for x in divbysum(source, 5)]
print(result)

[quest_]

A generator that will do this

def divbysum(items, step=10):
    s=1
    for i, value in enumerate(items):
        if i % step == 0:
            s = sum(items[i:i+step])
        yield value/s

source = list(range(20))
result = [x for x in divbysum(source, 5)]
print(result)

Thank you very much for the answer.
I have a question
Why do we have 5 in this line

result = [x for x in divbysum(source, 5)]

[deanhystad]

Because I wanted to test with summing different sized slices and the last test I did was 5 numbers at a time.

[quest_]

Because I wanted to test with summing different sized slices and the last test I did was 5 numbers at a time.

Thank you very much now I run and see
It is a great answer

[perfringo]

do not worry number of elements in my list will be always divided by 10

I am not the one who should be worrying .

So, I do not worry and ignore items which don't fit into group of 10 items (i.e. if there is 31 items only 30 are considered and last one will be ignored).

My approach would be to create grouper generator function in a such way that it ignores items at the end not fitting into groupsize (don't worry, be happy):

def grouper(iterable, groupsize):
    args = [iter(iterable)] * groupsize
    yield from zip(*args)

Now I can call it with needed groupsize and perform calculations on groups as I see fit. I can create another helper function to perform some magic needed:

def group_magic(group):
    return [item / sum(group) for item in group]

Now I am ready to do some group_magic:

[group_magic(group) for group in grouper(b, 10)]

Of course, if one wants to hide magic from user, it all can be put into one function:

def do_magic(iterable, groupsize):
    def grouper(iterable, groupsize):
        args = [iter(iterable)] * groupsize
        yield from zip(*args)
    def group_magic(group):
        yield from (item / sum(group) for item in group)
    return [[*group_magic(group)] for group in grouper(iterable, groupsize)]

print(do_magic(b, 10)) ->
[[0.0, 0.2, 0.0, 0.2, 0.0, 0.2, 0.0, 0.2, 0.0, 0.2], 
[0.0, 0.2, 0.0, 0.2, 0.0, 0.2, 0.0, 0.2, 0.0, 0.2], 
[0.0, 0.2, 0.0, 0.2, 0.0, 0.2, 0.0, 0.2, 0.0, 0.2], 
[0.0, 0.2, 0.0, 0.2, 0.0, 0.2, 0.0, 0.2, 0.0, 0.2]]

Then I can look at this code and say 'nah, i don't actually need those inner functions. It's too obvious what is going on, let's do some obfuscation' and write this (it returns the same as do_magic):

def do_magic_2(iterable, groupsize):
    groups = zip(*[iter(iterable)] * groupsize)
    operations = ((item / sum(group) for item in group) for group in groups)
    return [[*operation] for operation in operations]