Python - explain function parameters

Question

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.

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.

Answer 2

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.

Answer 3

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.

Answer 4

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])