positional argument: 'self'

[mcmxl22]

I write the following code and get the following error.

import random

word_list = ['a', 'ranom', 'list', 'of', 'words']

class Word:
    
    def get_word(self):
        words = random.choice(word_list)
        return words


w = Word.get_word()
print(w)

Error:
Traceback (most recent call last):
  File "c:\Users\mcmxl\mystuff\hangman\test_hangman.py", line 13, in <module>
    w = Word.get_word()
TypeError: get_word() missing 1 required positional argument: 'self'

If I change line 13 to w = Word.get_word('') everything works fine. I know there is a way to make it so I don't have to
use the empty string as the self argument. Could someone explain it to me?

[menator01]

remove self and it will work as expected

[mcmxl22]

remove self and it will work as expected

I'm trying to learn how to use classes and functions with the "self" argument. Removing it doesn't teach me anything.

[Yoriz]

Create an instance of Word

word = Word()
w = word.get_word()

print(w)

[menator01]

A link on self
The self parameter is a reference to the current instance of the class, and is used to access variables that belongs to the class.

Another example

#! /usr/bin/env python3

import random as rnd

word_list = ['a', 'random', 'list', 'of', 'words']

class Word:
    def __init__(self):
        self.my_list = None

    def get_word(self):
        word = rnd.choice(self.my_list)
        return word

word = Word() # Initiate class instant
word.my_list = word_list # Assign word list to instance variable
print(word.get_word()) # Print results of get word
print(word.get_word()) # Print another result

Output:
words
list

[snippsat]

A more normal and standard way to do this menator01.

import random

class Word:
    def __init__(self, word_list):
        self.word_list = word_list

    def get_word(self):
        words = random.choice(self.word_list)
        return words

word_list = ['a', 'ranom', 'list', 'of', 'words']
word = Word(word_list)
for w in range(5):
    print(word.get_word())

Output:
words
of
of
ranom
words

[mcmxl22]

A more normal and standard way to do this menator01.

import random

class Word:
    def __init__(self, word_list):
        self.word_list = word_list

    def get_word(self):
        words = random.choice(self.word_list)
        return words

word_list = ['a', 'ranom', 'list', 'of', 'words']
word = Word(word_list)
for w in range(5):
    print(word.get_word())

Output:
words
of
of
ranom
words

This is what I need to study and wrap my head around.

[menator01]

A more normal and standard way to do this menator01.

import random

class Word:
    def __init__(self, word_list):
        self.word_list = word_list

    def get_word(self):
        words = random.choice(self.word_list)
        return words

word_list = ['a', 'ranom', 'list', 'of', 'words']
word = Word(word_list)
for w in range(5):
    print(word.get_word())

Output:
words
of
of
ranom
words

True. My example was to initiate the class without setting the instance variable right away.

[deanhystad]

There are three kinds of methods; instance, class and static.

class DemoClass:
    def instance_method(*args):
        print("Instance method", args)

    @classmethod
    def class_method(*args):
        print("Class method", args)

    @staticmethod
    def static_method(*args):
        print("Static method", args)

instance = DemoClass()

instance.instance_method('Hello')
instance.class_method('Hello')
instance.static_method('Hello')

DemoClass.class_method('Hello')
DemoClass.static_method('Hello')

Output:
Instance method (<__main__.DemoClass object at 0x0000027A7F634F10>, 'Hello')
Class method (<class '__main__.DemoClass'>, 'Hello')
Static method ('Hello',)
Class method (<class '__main__.DemoClass'>, 'Hello')
Static method ('Hello',)

When calling an instance method, the instance is passed as the first argument and 'Hello' appears as the second argument. Essentially Python converts this:

instance.instance_method('Hello')

to this:

getattr(instance.__class__, "instance_method")(instance, 'Hello')

A class method is identified by the "@classmethod" decorator. A class method cannot access any instance variables because the class method is passed a class reference as the first argument instead of an instance of the class. Essentially the class method decorator converts these:

instance.class_method('Hello')
DemoClass.class_method('Hello')

To these:

getattr(instance.__class__, "class_method")(instance.__class__, 'Hello')
getattr(DemoClass, "class_method")(DemoClass, 'Hello')

A static method is a function that resides in the class namespace. Unlike instance methods and class methods, no arguments are added when calling the method. The first argument in the method call is the first argument in the method argument list.

In the original post, the get_word() method references an instance variable, so it has to be an instance method, and must be called using an instance. The instance becomes the first argument to the method and the method must have an instance argument as the fist argument to the method.

def get_word(self):
    return random.choice(self.word_list)