How to replace list values

class Classy(object):
    def __init__(self, ):
        self.items = []
        

    def addItem(self, name):
        self.add_item = name
        self.items.append(self.add_item)

        for i in range(len(self.add_item[0])):
            
            if self.items[i] == "bowtie":
                self.items[i] = 4
                return print("Item Added")
            
            if self.items[i] == "tophat":
                self.items[i] = 2
                return print("Item Added") 
                       
            if self.items[i] == "monocle":
                self.items[i] = 5
                return print("Item Added")
            
        return print("NO item added")
            
            
    def getClassiness(self):
        total_classiness = 0
        for item in self.items:
            if item == 4:
                total_classiness += 4

            elif item == 2:
                total_classiness += 2

            elif item == 5:
                total_classiness += 5

        return total_classiness
            
                
me = Classy()

# Should be 0
print(me.getClassiness())

me.addItem("tophat")
# Should be 2
print(me.getClassiness())

me.addItem("bowtie")
me.addItem("jacket")
me.addItem("monocle")
# Should be 11
print(me.getClassiness())

me.addItem("bowtie")
# Should be 11
print(me.getClassiness())

The requirements is that classy items must be stored in a string as input, then string is added to
the list, and that there is a method that calculates the classiness.

The output of the current code is:

0 
Item Added
2
NO item added
NO item added
NO item added
2
NO item added
2

Currently, in my debugging, I can see that it adds the value 'tophat' and then it replaces it with the value 2
but when it comes to the 'bowtie' or 'monocle' it adds them to the list and then doesn't replace the values
I would like to know why it doesn't change the value any other time the method is called

Problem

When you do for i in range(len(self.add_item[0])): you are enumerating i from 0 to the length of the first character of the string stored in self.add_item, which will always be 1. So i will start at 0 and end before 1 every time (So i will only ever be 0).

So the first item "tophat" works because when you add tophat to the list with append it looks like this: ["tophat"] (the list only contains "tophat" at index 0). So the item at self.items[i] (i.e. self.items[0] is tophat, so if self.items[i] == "tophat": will evaluate to true.

The next line in the if block replaces the value of "tophat" with 2 in the list. So for every subsequent call to addItem all the if statements that compare self.items[i] are really just comparing the new first value (2) to the other strings ("bowtie", "tophat", etc).

Here is what is going on in the code itself

First call

me.addItem("tophat")
# self.items becomes ["tophat"]
# self.items[i] (where i is 0) equals "tophat"
# self.items[i] becomes 2
# self.items is now ["tophat"]
> "Item Added"

Second call

me.addItem("bowtie")
# self.items becomes [2, "bowtie"]
# self.items[i] (where i is 0) does not equal any of the strings, since self.items[0] is 2
# self.items is still [2, "bowtie"]
> "NO item added"

Third call

me.addItem("jacket")
# self.items becomes [2, "bowtie", "jacket"]
# self.items[i] (where i is 0) does not equal any of the strings, since self.items[0] is 2
# self.items is still [2, "bowtie", "jacket"]
> "NO item added"

... and so on for each subsequent call to addItem.

Solution

What I think you intended to do is check if the most recently added item is equal to one of your classy strings. If you get rid of the for loop and just check the last item (using self.items[-1]) you will be able to just replace the new item with its classyness value.

def addItem(self, name):
    self.add_item = name
    self.items.append(self.add_item)

        
    if self.items[-1] == "bowtie":
        self.items[-1] = 4
        return print("Item Added")
    
    if self.items[-1] == "tophat":
        self.items[-1] = 2
        return print("Item Added") 
                
    if self.items[-1] == "monocle":
        self.items[-1] = 5
        return print("Item Added")
        
    return print("NO item added")

The result using this method would be

0
Item Added   
2
Item Added   
NO item added
Item Added   
11
Item Added   
15

Solution Continued

To further simplify the code, I put together a different version that produces the same results while also reducing the chances of confusing errors later down the line.

class Classy(object):

    def __init__(self):
        self.items = []
        self.classy_items = {
            "tophat": 2,
            "bowtie": 4,
            "monocle": 5
        }
        
    def addItem(self, name):
        if name in self.classy_items.keys():
            self.items.append(self.classy_items[name])
            print("Item added")
        else:
            print("NO item added")
            
    def getClassiness(self):
        return sum(self.items)

classy_items stores all the classy items and their classyness values in a key-value pair dictionary.

addItem checks if the new item exists in in classy_items and adds its value to the list if so. This fixes two things that were happening unnecessarily

1. Previously the item was added to the list regardless of if it was classy or not, and then changed to its classyness value only if it was classy. Now it only adds the value of classy items.

• items before: [2, 4, "jacket", 5, 4]
• items now: [2, 4, 5, 4]

2. Removed the return print(...) statements. This was unnecessary and not a good practice.
3. Calculated the total claassyness with a simple sum(...) function which just sums the list.

• This is now possible because it is not adding any unused strings to the list.
• It also removes the need for redundant if statements.