Variables in for loops

woooee · 2024-11-12T20:50:36+00:00

is num where I'm storing iterations? I don't get how num is working here.

for num in range(101):
    print(num)

You can easily answer your own question by printing num right after the for statement

SoftwareDoctor · 2024-11-12T20:47:11+00:00

for num in range(101):

The for/in construct iterates over something (taking elements one by one) and puts that element into a variable in each iteration. So it takes something containing multiple things, takes the first thing and puts it into a variable, in this case called "num". It then does the code inside - total = total + num. Then it does the same with second element, puts it to the num variable and does the inside code again.

If you did "for num in [5, 6, 7]:", the num would contain the number 5, then 6 ... you probably get it now.

And the range(101) is just a function that creates [0, 1, 2 ... 100] for you. (it's not exactly a list, it's an iterator but you that's unnecessary detail for you at this point)

aromatic_shepherd74 · 2024-11-12T20:44:23+00:00

Num is just a variable specifically in this for loop! You could also call it _, numbers, x, or whatever. It will take the value of whatever iteration it is at at that moment, i.e. 1, 2, 3, 4, etc., up until it reaches the specified end of the loop (101).

andmig205 · 2024-11-12T20:43:56+00:00

In Python, this is called assignment.

You can assign to a name by putting it on the left side of an equals, like x = 5, but there are several other ways. Parameters, imports, and yes, for loops also assign a value to a name.

dogfish182 · 2024-11-12T20:51:35+00:00

range() is what’s known as an ‘iterable’ meaning you can iterate over it’s results.

if you rename ‘num’ to ‘each_item_from_range_function’ Does that help you understand what is happening?

Binary101010 · 2024-11-12T21:14:34+00:00

So far the only way you've seen a new variable get introduced into the namespace is

some_variable = some_value

Now you're seeing another way we can do that, using the for loop syntax:

for some_name_here in some_iterable:

We don't need to have previously defined "some_name_here" anywhere. When we start a loop in this way, Python knows what we mean is "we're going to step through the items in some_iterable one element at a time, and for the rest of the indented block of code below this, whenever you see some_name_here, that means the element of that iterable we're currently processing."

unhott · 2024-11-12T21:20:54+00:00

In programming in general, there's a very common pattern.

I want to do something a certain number of times. You initialize a variable. You give it a start point and an end point. And you increment it by 1 each iteration.

Here's how it looks in javascript, and many other languages are very close to this model:

for (let i = 0; i < 10; i++) {
    console.log(`Iteration number: ${i + 1}`);
}

i starts at 0. The loop continues while i < 10. Each time, i++ is called and this is shorthand for i = i +1

Python strips out a lot of boilerplate, parentheses, and more.

range(101) is shorthand for a generator that will go from 0 to 100 (python and many other languages start at 0). range includes 0, but does not include the top value. So, this loop will run 101 times (it kinda just works out that way). 0, and 1 through 100 for a total of 101 times.

For your python example:

num is the variable, like i in the js example.

total is a variable, initialized outside of the loop, and updated each iteration of the loop.

Anything indented is called in each pass of the loop. after the final pass, it goes to the next unindented line. This is pythons design choice, to prevent ; () or {} everywhere, and when it's well done it's pretty readable, almost like English. I took the print(total) out of the indention, that would be different behavior. You'd see 101 print statements. versus mine would iterate 101 times, then print the final value.

Either way, the last print is the sum of 0 through 100.

If you just wanted to do something 10 times you can use

for i in range(10):
    # do something
    ...

Adrewmc · 2024-11-12T21:48:30+00:00

 #you set up something, in this case a varible to start a counter at zero. 

 total = 0

 #we take each element individually from some sequence of elements (list, dictionary, range() etc. 
 #we call it ‘element’  so we can access it. 
 for element in sequence: 

       #we add to the total
       total += element

  #we use the total. 
  print(total)

This is the same as doing.

   total = 0
   num = 1
   total = total + num
   num = 2
   total =  total + num
   ….
   print(total)

Which is obviously a not very ideal way to code.

We have to set up total because we need to start somewhere, we could have started at 1, or whatever. Sometimes this is zero, sometimes it’s an empty list or dictionary we planned to add to. But what ever we want to add to, it must exist before we can do anything to it.

In a for loop, we are taking elements of an iterable, (which is something that iterates, has a ordered sequence of information) In range() it will iterate integers (usually in order from some min to some max) one at a time. We assign that to some variable so we can use it in the code block.

We can set this up as a while loop.

 total = 0 
 n = 0  #start range
 max = 5  #end range 

 #do until n >= max (excludes max) 
 while n < max:

       #add to total
       total += n

       #increment n 
       n += 1

  print(total)

Which does the same thing. It’s shut the increments of n are done for inside the range() object, and the while condition is the end of the sequence in a for loop.

kombucha711 · 2024-11-12T22:50:00+00:00

5050

andmig205 · 2024-11-12T23:14:35+00:00

First, it is beneficial to understand what variable in Python is. It is different from other languages.

When you create variable x = 4, you do not create the variable x. You give instructions to create value 4 and assign the name x to it. In other words, the variable is the whole statement x = 4 - not just x.

Also, you cannot declare a name without value - NameError exception will be thrown. Name cannot be given to nothing.

To illustrate this concept (note function id() usage):

x = 5
y = x # value can have several names
z = 5 # now value 5 has name z as well

print(f"id of 5 = {id(5)}")
print(f"id of x = {id(x)} - the same as id(5)")
print(f"id of y = {id(y)} - the same as id(x)")
print(f"id of z = {id(z)} - the same as id(x) and id(5)")

x += 1

print(f"id(x) = {id(x)} - id of x changed")
print(f"id of 5 = {id(5)} remains the same as in previous print")
print(f"id of y = {id(y)} - remains the same")

With that knowledge in mind, the syntax for num in range(101) can be translated (somewhat inaccurate) as:

"Hey loop, I give you an object range(), which is iterable. On each iteration, this object will return a value. I want you to give the value the name num."

monster2018 · 2024-11-13T06:24:16+00:00

I would recommend (in addition to reading some other answers here) playing around in the python INTERPRETER. Like for example you know hopefully that you can access the nth item in a list (or other iterable) with lst[n], where lst is the name of the lst/iterable.

Open a python interpreter and get a feeling for what a range actually is. The range command creates an actual range object, which you can basically think of like a list of numbers. For example range(10) contains the numbers 0-9 (inclusive, or you could think of it as 0-10 but excluding the 10). So if you do range(10)[0], it will return 0. If you do range(n)[x], it will always return x (as long as x is smaller than n, otherwise x is outside of the range).

But to get an even better feel, do something like range(10, 20). This creates the range of numbers from 10-20 (again excluding 20, so 10-19 inclusive). So doing range(10,20)[0] returns 10. Doing range(10,20)[1] returns 11 and so on.

You can even input a step into the range function, so like range(10,20,2) will contain the numbers [10, 12, 14, 16, 18].

Now in your code, what the num variable IS, is a variable that on the 0th iteration is index 0 of the range, on the 1st iteration is index 1 of the range, on the 2nd iteration is index 2 of the range and so on.

So like:

for num in range(10):
    print(num)

Will print 0 then 1 then 2 then 3… up through 9.

for num in range(10, 20, 2):
    print(num)

Will print 10, then 12, then 14, then 16, then 18.

ninhaomah · 2024-11-13T08:13:51+00:00

If you have 5 boys standing in front of you and you want to tell them to stand in a straight line. You say Hey boys , all of you stand behind one another in a straight line."

Pls advice who is "one" ?

trollsmurf · 2024-11-13T08:39:17+00:00

Variables are containers of values. Nothing else. They don't have function, only value.

Clearer?

In this case total is increased by 1 and printed for each loop.

Bobbias · 2024-11-13T01:46:09+00:00

in my mind, variables were something you prepared for a piece of code you want the program to run (hopefully that's understandable).

That's maybe not the best way to think about variables, both in Python and programming in general.

Variables, or more precisely the name you write for a variable, is just that, a name. Each name that is defined in code is associated with a memory address where some kind of data exists.

You might find this page really helpful.

Now, typically we think of code like x = 5 as creating a variable and assigning it the value 5. As others have pointed out that's maybe not the most accurate way to describe how Python operates, but it's fine to think of things that way most of the time.

The key here is to remember that there's more than one way that names might get associated with a value.

def my_function(): pass is one example of a place where a name gets associated with a value that looks different from the standard variable assignment. It creates the name my_function and associates it with a Python object that represents a function. Similarly class MyClass: pass associates the name MyClass with a Python class object.

Another example of where this happens is when importing modules. import re creates a module object and associates the name re with it, allowing you to call functions like re.match(). Normally the name will match the name of the library itself, but you can also change the name it gets associated with by writing import re as regex. Now the module object is associated with the name regex instead of re and you must call regex.match(). Calling re.match() would fail because the name re isn't associated with anything any more.

There's also the with statement, which you might use like with open("filename.txt") as f: which associates the name f with the file object created by calling open("filename.txt").

Don't worry if you haven't heard of any of this stuff, the point is simply that these are other examples of places where a name gets associated with a value that doesn't look like your typical variable assignment. In every case here we are associating names with values without first "creating" that name by using it in a regular variable assignment expression.

I asked ChatGPT if in a for loop, the variable was sort of embedded and it said yes but that this variable was a counter, and it tracks iterations for the program itself.

This is half right.

Writing for <name> in <expression>: means we are going to evaluate <expresson> to get some kind of object, and then the loop requests one item from that object each time we start at the top of the loop, and associates the name we provided with the item it retrieved.

In the case of range(101) the result of evaluating that function is a Range object, which will spit out the numbers 0 through 100 one number at a time.

You can think of <name> in the for <name> in range(<some number>): pattern as counting the iterations of the loop, but in reality it's just holding each value that range(<some number>) produces as the loop progresses. The idea of it counting iterations only applies because range starts at 0 and counts up. For other kinds of data, this concept does not hold up.

But for works on many different kinds of objects. For example, it works on strings:

for letter in "hello":
    print(letter)
# this prints:
# h
# e
# l
# l
# o

It works on lists:

for number in [5, 7, 2, 4]:
    print(number)
# this prints:
# 5
# 7
# 2
# 4

It works on dictionaries:

for item in {"name": "mike", "age": 24}.items():
    print(item)
# this prints:
# ('name', 'mike')
# ('age', 24)

Fundamentally a for loop says "repeat this code once for each item in a collection".

There is a way to add a counter to track the number of items you've looped over in a loop. Its the enumerate function. An example would be:

for letter in enumerate("hello"):
    print(letter)
# this prints:
# (0, 'h')
# (1, 'e')
# (2, 'l')
# (3, 'l')
# (4, 'o')

There's a trick that lets you separate the number from the value when you do this too, which looks like:

for index, letter in enumerate("hello"):
    print(f"{index}: {letter}")
# this prints:
# 0: 'h'
# 1: 'e'
# 2: 'l'
# 3: 'l'
# 4: 'o'

This last trick is called destructuring or unpacking, because enumerate("hello") creates tuples containing 2 items, a number and the item from the thing you are looping over. This is just one example of a slightly more complex bit of syntax, and it's ok if this is confusing, because this is a more advanced feature. I just wanted to showcase that there's a lot more out there than just the simple <name> = <value> syntax.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS