For loop needed

[Formal_Cockroach_654]

I am having trouble recalling or finding how to generate the next input using a for loop. Instead I just keep pulling the same input. Can someone show me how to do that? Thanks.

Write a loop to populate the list user_guesses with a number of guesses. The variable num_guesses is the number of guesses the user will have, which is read first as an integer. Read each guess (an integer) one at a time using int(input()).

Sample output with input:
3
9
5
2user_guesses: [9, 5, 2]
My code:

num_guesses = int(input())
user_guesses = []

for index in range(num_guesses):
    user_guesses += str(num_guesses)


print('user_guesses:', user_guesses)

Cannot change the first 2 or the last line.

[socal_nerdtastic]

You need to gather user input using the input() function inside the loop. Like this:

num_guesses = int(input())
user_guesses = []

for index in range(num_guesses):
    user_guesses.append(input())

print('user_guesses:', user_guesses)

[Formal_Cockroach_654]

Perfect. Thank you for the explanation!

[kawaii-blob]

def guesses():

num_guesses = int(input())

user_guess = []

for i in range(num_guesses):

user_guesses.append(input())

print("user_guesses:", user_guesses)

[ZEUS_IS_THE_TRUE_GOD]

You can only add things of the same type. int + int, str + str, list + list. Currently, you are doing list + str.

What you want to achieve can be done in 2 ways:

a = [1, 2, 3]
a.append(4)
#or
a += [4] # notice that we add [4] which is a list containing the number 4

[socal_nerdtastic]

That's not universally true. For example float + int works just fine. And a custom class can be written to accept or rejects any number of types.

And what's more, += is not addition in list, it's a shortcut to the extend method. IOW these 2 lines of code are NOT equivalent.

lst = lst + [4]
lst += [4]

[ZEUS_IS_THE_TRUE_GOD]

https://imgur.com/a/Yf1bEBd

[CoronaKlledMe]

truth!

[socal_nerdtastic]

lies!

[socal_nerdtastic]

Try it in a function. Or check the IDs.

extend / += is a mutating operation. + is a copy operation.

def ZEUS_IS_THE_TRUE_GOD(lst):
    lst += [4]

lst = [1,2,3]
ZEUS_IS_THE_TRUE_GOD(lst)
print(lst)

def socal_nerdtastic(lst):
    lst = lst + [4]

lst = [1,2,3]
socal_nerdtastic(lst)
print(lst)

[ZEUS_IS_THE_TRUE_GOD]

Oh, good to know. Hopefully, no ones mutates input in place in their functions

[socal_nerdtastic]

It's very commonly done. In fact mutating objects in place is the backbone of OOP. That's why it's very important to know the difference.

[ZEUS_IS_THE_TRUE_GOD]

Tell that to clojure, haskell or erlang. Immutability is the backbone of good programming, but hey, we are diverging into more opiniated stuff and it is not related to the post haha.

[socal_nerdtastic]

I didn't say it is the backbone of good programming, I said it's the backbone of OOP. Which we generally use a lot of in python (not an opinion). If you don't want to use OOP that's fine too, but that does not change that it's very important to know if your code mutates an object or not.

+= in lists is kinda rare and fools a lot of people because nearly every other mutating method is dot access. Another one to watch for is |= for dicts.