When to use arguments in my method?

TLDR: You use arguments whenever you want to parametrize your methods, which basically means making your methods output be affected by arguments provided by the user. (This isn't **exactly* what it means, but in this case it's close enough)*

So basically you want to use arguments whenever you want the output of your method to be affected by some sort of input. Let's say for example that you are creating a method that adds two numbers together.

def add():
    return 1 + 2

This is perfectly valid code, but whenever you use this, it will always just add 1 and 2. This is kind of pointless right? So let's change that to use some variables, that way we can change what the numbers are.

a = 1
b = 2
def add():
    return a + b

Okay, this is a bit better, we are using variables now, so we can change the numbers to whatever we want rather than just having them hard coded. But now we've run into another issue. Whoever is using your add method, may not have access to those variables (for example they may be importing your add method and using it in their code), or if they do have access those variables can change throughout the life of the program before the add method is called.

So to solve this, we will make the method use arguments, that way when the method is called the user can specify exactly what they want added together. Let's do that by extracting the variables into arguments.

def add(a, b):
    return a + b

Great! We've done it! Now our method is using arguments!

But! When do we not use arguments? Basically if we know we don't need any sort of input to change the output of our method. To keep it simple, lets say we have a method that simply prints hello;

def say_hello():
   print("Hello.")

In this case, we don't need any sort of input to change what the output of this method is, because we will always just be saying hello!

Hopefully that clears things up for you!

P.S. One more thing to go over! Class methods are a unique exception to the rule above. As whenever we are creating a method in a class, they will implicitly always be using an argument called self, this is something python requires in order for the class method to properly interact with the class and its internal state. For example:

class Person:
   def __init__(self, name):
        self.name = name

   def say_hello(self):
        print(f"{self.name} says hello!")

   def walk(self):
       print("Walks in a general direction")

In this case you can see that we will need the self argument whenever we need to access the internal state of our class (in this case, self.name). But you also notice that we require this self argument even when we don't need it like in the walk method. This is because a class method has the self argument as an implicit parameter. Which means that the method is implied and doesn't need to explicitly set in the method call. For example:

class Person:
   def __init__(self, name):
        self.name = name

   def say_hello(self):
        print(f"{self.name} says hello!")

   def walk(self):
       print("Walks in a general direction")

me = Person("Dane")
person.walk() # Walks in a general direction

See we don't need to actually place any argument in the call because the self is implied, the class itself will fill that in. However, if we were to not add the self parameter when defining the method in the class, we would get an error.

class Person:
   def __init__(self, name):
        self.name = name

   def say_hello(self):
        print(f"{self.name} says hello!")

   def walk(): # notice that we aren't using the self parameter?
       print("Walks in a general direction")

me = Person("Dane")
person.walk() # Would give an argument count error

Again hopefully that clears things up for you, if you need more help or clarification let me know.