1

So I understand this simple for loop:

sum = 0
for number in {1,2,3,4}:
    sum = sum + number
    print sum

>>> 
1
3
6
10
>>>

Then here is a neat little code that combines a for loop and a function I found on the interwebs:

def sum_list(l):
    sum = 0
    for number in l:
        sum = sum + number
    return sum

print sum_list([1, 7, 4])

>>> 
12

What I don't understand is how python interprets this code (rather how Python knows to add the 3 arguments 1,7,4 together).

I would really help if you can break it down for me!

To tack on another question for you guys to review:

sum = 0
for number in {1,2,3,4}:
    sum = sum + number
    return sum

Spits out an error. print sum will list the results as 1,3,6,10

Error says: Syntaxerror: 'return' outside of function

[EDIT] @sshashank124

For example: This code spits out 3 answers. It prints out:

sum = 0
for number in {1,7,4}:
    sum = sum + number
    print sum

>>> 
1
8
12 
>>>

But this: 

def sum_list(l):
    sum= 0
    for number in l:
        sum = sum + number
    print sum
print sum_list([1, 7, 4])

>>> 
12
none

Spits out only 1 answer, 12. My question is why that occurs.

Improve this question

4 Answers 4

Reset to default
2 
for number in l:

This iterates over the l, and number will have each and every element of l on every iteration. You can check that like this

for number in l:
    print number
# 1
# 7
# 4

You are adding those numbers to the sum variable. You can check that like this

sum = 0
for number in l:
    sum = sum + number
    print sum
# 1
# 8
# 12

I believe you are doing this for educational purpose. If you actually wanted to find the sum of an iterable, then you can use the builtin sum function, like this

sum([1, 7, 4])
Improve this answer
Sign up to request clarification or add additional context in comments.

15 Comments

I was about to ask. Why Python spits out one answer:12 instead of three answers: 1,8,12
@user3386440 Because, you are returning after adding all the numbers together. So, only one number will be returned and printed :)
If I replace return with print, it will give me: 12 none, so still one integer.
It will immediately print the answer. However, if you do 'sum = sum_list([x, y, z])' Then you can reference that variable in later code.
@user3386440 Please include the print statement in the for loop itself, like in my answer.
|
1

It knows to add them together, because you tell it to do that.

Let me rewrite the code a bit to show what's happening. Rewrite one, adding 1,7,4 and then 2,8,5, but adding more numbers requires more lines:

sum = 0
sum = sum + 1
sum = sum + 7
sum = sum + 4
print sum

sum = 0
sum = sum + 2
sum = sum + 8
sum = sum + 5
print sum

Rewrite two - using a loop. Two lines shorter, but it can now handle lists of more items - adding four, five, even ten numbers, without adding more lines of code, just by making the lists longer:

sum = 0
for number in [1,7,4]:
    sum = sum + number
print sum

sum = 0
for number in [2,8,5]:
    sum = sum + number
print sum

Rewrite three - moving the lists out of the loop. The code got longer again, but something interesting happened - see how the loop code is now identical both times:

myList = [1,7,4]
sum = 0
for number in myList:
    sum = sum + number
print sum

myList = [2,8,5]
sum = 0
for number in myList:
    sum = sum + number
print sum

Rewrite four - now it's identical, why does it have to be there twice? Can't we ... write it once, and use it twice? That way if we need to change it, we only have to change it in one place. Yes - make it a function and call the function:

def sum_list():
    sum = 0
    for number in myList:
        sum = sum + number
    print sum

myList = [1,7,4]
sum_list()

myList = [2,8,5]
sum_list()

Rewrite five - what's happening above works fine, because you called everything 'myList' it all works. But if you write bigger programs like that it gets messy fast - one myList could be several pages of code away from another, we'll tend to forget that something pages and pages away could be affecting things. So we humans can keep track of what's going on, we need to clearly and explicitly give the function something to work on, and not have it just reaching far away and pulling things out of the rest of the code.

def sum_list(working_list):       # working_list is whatever the function gets
    sum = 0                       # by a different name
    for number in working_list:
        sum = sum + number
    print sum

myList1 = [1,7,4]
sum_list(myList1)

myList2 = [2,8,5]
sum_list(myList2)

See in the above code, I've called them myList1 and myList2 - yet whatever you give to the function, the function sees it called 'working_list'. The names don't have to match.

But because sum_list has it's own name for whatever you give it, you don't have to have a name for what you give it. You can just give it a list directly without a name:

def sum_list(working_list):
    sum = 0                
    for number in working_list:
        sum = sum + number
    print sum

sum_list([1,7,4])

sum_list([2,8,5])

The next move is, once you're feeding things into sum_list, sum_list is looking away and writing to the screen. We can't have that. For the sake of humans tracking what's happening, that's a bad idea - you want to give functions some work to do and have them give you back an answer. That way you know you can use them anytime you need, without worrying about them printing to the screen unexpectedly. That's where 'return' comes in:

def sum_list(working_list):
    sum = 0                
    for number in working_list:
        sum = sum + number
    return sum

result = sum_list([1,7,4])
print result

result = sum_list([2,8,5])
print result

Now sum_list is a self contained adder, it does nothing else. You can trust it. It's not reading from names all over your code, it's only reading explicitly what you gave to it. It's not writing to the screen at surprise times, or anything. You give it a list, you get a result, it's isolated, limited, controlled, predictable, easy to work with, easy to reuse. And like the list names, if all you do is get the result and print it, you don't need to give that a name either:

def sum_list(working_list):
    sum = 0                
    for number in working_list:
        sum = sum + number
    return sum

print sum_list([1,7,4])
print sum_list([2,8,5])

Edit: I hope that explains several of your questions.

  1. What that code is doing
  2. Why it prints one answer instead of three - because you are giving it one thing (a list).
  3. Why it makes no sense to use return on its own - because you have to call a function and then return from the function, and you can bring something back with you or you can go somewhere and bring nothing back (function with no return). But you can't bring something back if you don't go anywhere first.
Improve this answer

3 Comments

WOW, thanks for putting in all that effort. It's going to take some time to go through this, but I'm REALLY looking forward to it. Thanks again!
I noticed that the print sum inside the loop and outside the loop changes the outcome. If its inside, it lists (1,5,12). If its outside the loop, it just gives the answer: 12. Why is that?
@user3386440 because you're noodling around inside the machinery before it's finished. The code inside the loop happens once for every number in the list. Three numbers, it happens three times. So it adds something into sum and prints it. Next time it adds something to sum and prints it - the sum of the first two items in the list. Next time it adds something again and prints it - the sum of the first three items. When you put print outside, it does all the summing of all the numbers behind the scenes and you just get to see afterwards - or rather, you tell it to show you after it's finished.
1

In Python you will realise that when you initialise a variable you don't need to assign a type to it, you can just initialise anything in there. in this case l was interoperated as an object, or an array to be specific.

as for the loop.

for number in l:

is like a for each statement, it goes through each of the elements. and stores it in number, then iterates after the block is executed, moving on to the next l.

Hope that helped? (if i understand your question.

Improve this answer

Comments

1

The for number in l: line takes each of the elements in [1,7,4] and adds them to the sum variable which represents the total sum of the elements in the list.

This is what it looks like:

Take first element of l: 1 Add to sum --> sum is now 1

Take second element of l: 7 Add to sum --> sum is now 8

Take third element of l: 4 Add to sum --> sum is now 12

Return sum --> sum is 12

Might I suggest that sum([1,7,4]), the builtin python method would also work.

Improve this answer

10 Comments

Thanks that clarifies. But if you supplant the Return with Print it will still give you a 12 none. Meanwhile, in the first example I gave at the top, it will list out the sums {1,8,12) instead of giving an aggregate sum.
@user3386440, I'm afraid I don't understand what you mean. Can you please provide a line of code in reference
@user3386440, For the first set of code, you are printing each line out and are using {}. Use []
absolutely. How do I add in a line of code in comments without breaking formatting? Should I just add it to the OP?
@user3386440, Yes you might as well add it to your question as [EDIT] @sshashank124 or something like that
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.