DEV Community: XZM27

Wordle with python

XZM27 — Wed, 17 Aug 2022 05:29:57 +0000

Lets create the famous wordle game in python

How the game works:
- learn by playing it yourself: wordle
Prerequisite:
- classes and objects
- pip install clrprint

Basic template
lets create the basic template for the game

import random
from clrprint import *


class Wordle:
    """main game class"""
    def __init__(self: object) -> None:
        """initialize attributes"""
        # word list and current word
        self.words = ["HELLO","WORLD","CRANE","BREAD",
                      "GIVER","GREAT","NEVER"]
        self.current_word = random.choice(self.words)

        self.current_row = 0

        self.letter_found = False

    def run_game(self: object) -> None:
        """main game runner class"""
        while self.current_row < 6 and not self.letter_found:
            pass       


if __name__ == "__main__":
    w_game = Wordle()
    w_game.run_game()

__init__
- Firstly we import random and clrprint. We will use clrprint to give colored outputs in our shell.
- We define the main game class Wordle
- We create a list of words self.words out of which one will be the current word self.current_word
- More words can be added to self.words
- We get the self.current_word using random.choice(self.words)
- We initialize self.current_row. This will help us to keep track when the player has exhausted 6 tries.
- We set self.letter_found = False so that when the letter is found we can stop the game
run_game
- This contains the while loop for the game.
- We run the while loop until the player has exhausted his tries or the player finds the word.
- For the moment we run pass
starting the game
- We create the objeect of Wordle as w_game under if __name__ == "__main__":
- We call the run_game method using w_game.run_game()

Taking user input and incrementing self.current_row
Alright now we need to take the users input.

The user input must have a length of 5
It must be contained in "self.words"
If the input is valid then we increment self.current_row by 1 Lets create a method _check_row to accomplish this and we will call _check_row in the while loop.

--snip--
    def run_game(self: object) -> None:
        """main game runner class"""
        while self.current_row < 6 and not self.letter_found:
            self._check_row()

    def _check_row(self: object) -> None:
        """"handle the try count"""
        print(f"Number of tries: {self.current_row + 1}")
        user_word = input("enter word: ").upper()
        if len(user_word) == 5 and user_word in self.words:
            self.current_row += 1
            self.compare_word(user_word)
        else:
            print("input five letter word which is in word list")

    def compare_word(self: object, user_input: str) -> None:
        """compare user input to current word"""
        pass

--snip--

run_game
- We call the freshly baked _check_row in the while loop
_check_row
- We print the current number of tries of the player
- We take the users input user_word and use .upper() to covert the user input into uppercase
- We check if the input is valid or not
- For a valid input we increment self.current_row by 1
- We need some logic to comapre the user input with our self.current_word. We create a new method for that called compare_wordand leave it with pass for the moment.
- If the user input is invalid we do not incrememnt self.current_row and humbly ask the user to input a five letter word which is in self.words. We can run the game now. For valid inputs the tries will increment and when we reach 6 tries the game will stop. So far so good, but we still need to give the game its backbone logic.

Comparing the user input and urrent word and adding logic

Wordle logic:
- If the letter is not in the actual word: grey
- If the letter is in the actual word and in the correct position: green
- If the letter is in the actual word and not in the correct position: yellow

We can implement this logic easily enumerate(). Also if the player finds the word we want to stop the game.

--snip--
    def compare_word(self: object, user_input: str) -> None:
        """compare user input to current word"""
        if user_input == self.current_word:
                clrprint("You found the letter", clr="red")
                self.letter_found = True

        else:
            for letter_index, letter in enumerate(user_input):
                if letter == self.current_word[letter_index]:
                    clrprint(f"{letter} is in the word and in correct position", clr="green")
                elif letter in self.current_word:
                    clrprint(f"{letter} is in the word but not in correct position", clr="yellow")
                else:
                    print(f"{letter} is not in the word")
--snip--

compare_word(self: object, user_input: str) -> None
- The compare_word method takes an argument user_input which is the user input.
- Firstly we check if the user has found the word.
- If the user finds the word we print a congatulations message and then set self.letter_found to True. This stops the while loop from running and ends the game.
- clrprint allows us to give colored outputs in the shell.
- If the word is not found we implement our logic part.
- In the for loop we iterate through user_input
- enumerate() adds a counter to the iterable and returns it.
- We store two iterating variables- letter_index, letter
- We then check if letter matches self.current_word[letter_index]. This compares the letter in both user input and current word at the same positions.
- If the letter is not found in the same position we check if the letter is in the current word.
- If none of the above holds truthy we output that the letter is not in the word.
- We do this checking for every letter in the user input using the for loop.

SOURCE CODE

import random
from clrprint import *


class Wordle:
    """main game class"""
    def __init__(self: object) -> None:
        """initialize attributes"""
        # word lst and current word
        self.words = ["HELLO","WORLD","CRANE","BREAD","GIVER","GREAT","NEVER"]
        self.current_word = random.choice(self.words)

        self.current_row = 0

        self.letter_found = False

    def run_game(self: object) -> None:
        """main game runner class"""
        while self.current_row < 6 and not self.letter_found:
            self._check_row()

    def _check_row(self: object) -> None:
        """"handle the try count"""
        print(f"Number of tries: {self.current_row + 1}")
        user_word = input("enter word: ").upper()
        if len(user_word) == 5 and user_word in self.words:
            self.current_row += 1
            self.compare_word(user_word)
        else:
            print("input five letter word which is in word list")

    def compare_word(self: object, user_input: str) -> None:
        """compare user input to current word"""
        if user_input == self.current_word:
                clrprint("You found the letter", clr="red")
                self.letter_found = True

        else:
            for letter_index, letter in enumerate(user_input):
                if letter == self.current_word[letter_index]:
                    clrprint(f"{letter} is in the word and in correct position", clr="green")
                elif letter in self.current_word:
                    clrprint(f"{letter} is in the word but not in correct position", clr="yellow")
                else:
                    print(f"{letter} is not in the word")



if __name__ == "__main__":
    w_game = Wordle()
    w_game.run_game()

The game is now ready to be played. Add more words to self.words to make the game more challenging.

From the author:
Please do comment any improvements/ bugs in the game. Thank you for reading and learning :)

Decorators part II

XZM27 — Wed, 10 Aug 2022 06:22:42 +0000

This is a continuation to the previous post decorators in python.
Previously we passed the function display into the decorator function. But what if the display function has some arguments that it takes?

def decorator_function(original_function):
    def wrapper_function():
        #do something before the function
        print("hello from wrapper")
        return original_function()
    return wrapper_function


#this works same as decorator_function(display)
@decorator_function
def display():
    print("hello from display")

display()

Passing arguments into decorators
lets pass down some arguments in display and see what happens.

@decorator_function
def display(name, age):
    print(f"hello from {name}. I am {age} years old.")

display("Dev", 15)

Output

TypeError: wrapper_function() takes 0 positional arguments but 2 were given

It throws an error because right now the wrapper function cannot take any arguments. This can be fixed by using *args and **kwargs.

def decorator_function(original_function):
    def wrapper_function(*args, **kwargs):
        #do something before the function
        print("hello from wrapper")
        return original_function(*args, **kwargs)
    return wrapper_function


#this works same as decorator_function(display)
@decorator_function
def display():
    print(f"hello from {name}. I am {age} years old.")

display("Dev", 15)

*args allows us to pass any number of positional arguments and **kwargs allows us to pass any number of keyword arguments into the wrapper_function. Now we can pass any number of arguments into our decorated function.
Output

hello from wrapper
hello from dev. I am 15 years old

Thank you for reading and learning.

Decorators in python

XZM27 — Tue, 09 Aug 2022 22:12:00 +0000

Decorators: end you everlasting confusion about decorators and its uses

Whenever going through github or any other codebase, we often come across somthing that looks unlike python.

@decorator
def my_function():
    pass

This is known as a decorator in python and is extremely handy and powerful. A decorator is used when we need to change the behaviour of a function without changing the function itself. Makes sense? It will now.
It can be said that almost everything in python is an object. Functions are also objects(first class). Therefore we can assign functions to a variable.

def my_function():
    print("hello dev community")

#we can assign the function without executing to the variable func
func=my_function

Functions are first class objects
They can be assigned to a varibale as shown earlier.
Moreover they can be passed as argument to another function and also nested into another function.

def outer(message):
    def inner():
        print("hi "+ message)
    return inner

hi = outer("dev community")
bye = outer("dev community")

#this executes the inner function.
hi()
bye()

output

hi dev community
bye dev community

Here we have two nested function outer and inner
outer returns inner without executing it. When we assign outer to a variable and execute the variable,it actually executes inner with the specific argument.
This is called a closure. Closures can avoid the use of global values and provides some form of data hiding. It can also provide an object oriented solution to the problem.

Decorators extensively use closures
Rather than taking message as an argument decorators take functions as arguments.Let's create a decorator step-by-step.

def decorator_function(original_function):
    def wrapper_function():
        #do something before the function
        print("hello from wrapper")
        return original_function()
    return wrapper_function

def display():
    print("hello from display")

decor_display = decorator_function(display)
decor_display()

The code looks extremly similar to the closure we created earlier. We are now passing a function through decorated_function.

When we assign decor_display the decorator_function executes and returns wrapper_function. We then execute the wrapper_function stored in decor_display by invoking decor_display in the last line. Now the wrapper_function executes its print statement and the original_function which in our context is display and finally outputs:

hello from wrapper
hello from display

That was a lot to take in for sure.Go through the process again and hopefully the logic will be clear.
Here we successfully managed to changed the behaviour of the display function by printing and extra line before it hello from wrapper. We did not change the display function itself but rather changed its behaviour using our decorator_function.

Python allows us to do this same thing using @decorator_function_name. Rather than assigning decorator_function to a variable we can assign it to any function using @decorator_function before the function.

def decorator_function(original_function):
    def wrapper_function():
        #do something before the function
        print("hello from wrapper")
        return original_function()
    return wrapper_function


#this works same as decorator_function(display)
@decorator_function
def display():
    print("hello from display")

display()

output

hello from wrapper
hello from display

Conclusions
Decorators are a powerful tool and is used in many codebases for various purposes such as logging, performance testing, perform caching, verifying permissions etc. If you find this tutorial useful do comment below. Thank you for reading and learning.

decorators part II->