Python tkinter Snake

Question

I have made a little Snake game with Python tkinter. It's my first Python program with one GUI. What can I improve?

from tkinter import *
import random


boardWidth = 30
boardHeight = 30
tilesize = 10

class Snake():

    def __init__(self):

        self.snakeX = [20, 20, 20]
        self.snakeY = [20, 21, 22]
        self.snakeLength = 3
        self.key = "w"
        self.points = 0

    def move(self): # move and change direction with wasd

        for i in range(self.snakeLength - 1, 0, -1):
                self.snakeX[i] = self.snakeX[i-1]
                self.snakeY[i] = self.snakeY[i-1]

        if self.key == "w":
            self.snakeY[0] = self.snakeY[0] - 1

        elif self.key == "s":
            self.snakeY[0] = self.snakeY[0] + 1

        elif self.key == "a":
            self.snakeX[0] = self.snakeX[0] - 1

        elif self.key == "d":
            self.snakeX[0] = self.snakeX[0] + 1

        self.eatApple()

    def eatApple(self):

        if self.snakeX[0] == apple.getAppleX() and self.snakeY[0] == apple.getAppleY():

            self.snakeLength = self.snakeLength + 1

            x = self.snakeX[len(self.snakeX)-1] # Snake grows
            y = self.snakeY[len(self.snakeY) - 1]
            self.snakeX.append(x+1)
            self.snakeY.append(y)

            self.points = self.points + 1
            apple.createNewApple()

    def checkGameOver(self):

        for i in range(1, self.snakeLength, 1):

            if self.snakeY[0] == self.snakeY[i] and self.snakeX[0] == self.snakeX[i]:
                return True # Snake eat itself

        if self.snakeX[0] < 1 or self.snakeX[0] >= boardWidth-1 or self.snakeY[0] < 1 or self.snakeY[0] >= boardHeight-1:
            return True # Snake out of Bounds

        return False

    def getKey(self, event):

        if event.char == "w" or event.char == "d" or event.char == "s" or event.char == "a" or event.char == " ":
            self.key = event.char

    def getSnakeX(self, index):
        return self.snakeX[index]

    def getSnakeY(self, index):
        return self.snakeY[index]

    def getSnakeLength(self):
        return self.snakeLength

    def getPoints(self):
        return self.points


class Apple:

    def __init__(self):
        self.appleX = random.randint(1, boardWidth - 2)
        self.appleY = random.randint(1, boardHeight - 2)

    def getAppleX(self):
        return self.appleX

    def getAppleY(self):
        return self.appleY

    def createNewApple(self):
        self.appleX = random.randint(1, boardWidth - 2)
        self.appleY = random.randint(1, boardHeight - 2)

class GameLoop:

    def repaint(self):

        canvas.after(200, self.repaint)
        canvas.delete(ALL)

        if snake.checkGameOver() == False:

            snake.move()
            snake.checkGameOver()

            canvas.create_rectangle(snake.getSnakeX(0) * tilesize, snake.getSnakeY(0) * tilesize,
                                    snake.getSnakeX(0) * tilesize + tilesize,
                                    snake.getSnakeY(0) * tilesize + tilesize, fill="red")  # Head

            for i in range(1, snake.getSnakeLength(), 1):
                canvas.create_rectangle(snake.getSnakeX(i) * tilesize, snake.getSnakeY(i) * tilesize,
                                        snake.getSnakeX(i) * tilesize + tilesize,
                                        snake.getSnakeY(i) * tilesize + tilesize, fill="blue")  # Body

            canvas.create_rectangle(apple.getAppleX() * tilesize, apple.getAppleY() * tilesize,
                                    apple.getAppleX() * tilesize + tilesize,
                                    apple.getAppleY() * tilesize + tilesize, fill="green")  # Apple

        else:   # GameOver Message
            canvas.delete(ALL)
            canvas.create_text(150, 100, fill="darkblue", font="Times 20 italic bold", text="GameOver!")
            canvas.create_text(150, 150, fill="darkblue", font="Times 20 italic bold",
                                   text="Points:" + str(snake.getPoints()))


snake = Snake()
apple = Apple()
root = Tk()

canvas = Canvas(root, width=300, height=300)
canvas.configure(background="yellow")
canvas.pack()

gameLoop = GameLoop()
gameLoop.repaint()

root.title("Snake")
root.bind('<KeyPress>', snake.getKey)
root.mainloop()

Answer 1

Review

Naming conventions

In Python, methods and variables should be named the following way: https://stackoverflow.com/questions/159720/what-is-the-naming-convention-in-python-for-variable-and-function-names So in your case, it would be:

• self.snakeLength > self.snake_length
• def eatApple(self) > def eat_apple(self)

Choose better names for variables

Snake.snakeX seems to be a little bit too much. Why don't you

• Snake.snakeX > Snake.x
• Snake.snakeLength > Snake.length
• Apple.appleX > Apple.x

Use class constants instead of global variables

Usually you want to have as few golbal variables / constants as possible. Instead of boardWidth = 30 you can create a cosntant and move it to some class, like BOARD_WIDTH = 30 (see example).

Wrap the main code

Create a new class which wraps the code your script runs. You could, for exapmple, use the Tk class (see example)

Use main

If someone wants to import your code, he will instatnly run the whole script, creating a Tkinter widget, running the gameloop infinitely. Instead, wrap it with a if __name__ == "__main__": statement.

Prevent the snake of moving backwards

In your implementation it is possible to do a 180° turn, which kills your snake instantly. You could always save the last move, e.g. "w", which blocks all incoming "s", so only "w", "a" and "d" are valid for the next move (see example).

Reduce visibility

You can reduce the visibility of class members by placing __ in front of them. For example

• self.apple > self.__apple

Looks ugly, but this way these fields can't be accessed from outside your class.

Use @property

Instead of defining getters manually, use propteries (see example). More information: https://www.smallsurething.com/private-methods-and-attributes-in-python/

Code improvements

Instead of event.char == "w" or event.char == "d" or event.char == "s" or event.char == "a" you can define a list of all keys KEYS = ["w", "a", "s", "d"] and then do event.char in Snake.KEYS

Do not write if snake.checkGameOver() == False, instead do if not snake.checkGameOver()

You might use type hinting

Since python 3.5 there is typehinting (see example). More information: https://blog.jetbrains.com/pycharm/2015/11/python-3-5-type-hinting-in-pycharm-5/

Code example

snake.py

from tkinter import *
import random
from typing import List


class Apple:

    def __init__(self):
        self.__x = random.randint(1, App.BOARD_WIDTH - 2)
        self.__y = random.randint(1, App.BOARD_HEIGHT - 2)

    def create_new_apple(self) -> None:
        self.__x = random.randint(1, App.BOARD_WIDTH - 2)
        self.__y = random.randint(1, App.BOARD_HEIGHT - 2)

    @property
    def x(self) -> int:
        return self.__x

    @property
    def y(self) -> int:
        return self.__y
        

class Snake:

    KEYS = ["w", "a", "s", "d"]
    MAP_KEY_OPP = {"w": "s", "a": "d", "s": "w", "d": "a"}

    def __init__(self, apple):
        self.__apple = apple
        self.__x = [20, 20, 20]
        self.__y = [20, 21, 22]
        self.__length = 3
        self.__key_current = "w"
        self.__key_last = self.__key_current
        self.__points = 0

    def move(self) -> None:  # move and change direction with wasd

        self.__key_last = self.__key_current

        for i in range(self.length - 1, 0, -1):
            self.__x[i] = self.__x[i - 1]
            self.__y[i] = self.__y[i - 1]

        if self.__key_current == "w":
            self.__y[0] = self.__y[0] - 1

        elif self.__key_current == "s":
            self.__y[0] = self.__y[0] + 1

        elif self.__key_current == "a":
            self.__x[0] = self.__x[0] - 1

        elif self.__key_current == "d":
            self.__x[0] = self.__x[0] + 1

        self.eat_apple()

    def eat_apple(self) -> None:

        if self.__x[0] == self.__apple.x and self.__y[0] == self.__apple.y:

            self.__length = self.__length + 1

            x = self.__x[len(self.__x) - 1]  # snake grows
            y = self.__y[len(self.__y) - 1]
            self.__x.append(x + 1)
            self.__y.append(y)

            self.__points = self.__points + 1
            self.__apple.create_new_apple()

    @property
    def gameover(self) -> bool:

        for i in range(1, self.length, 1):

            if self.__y[0] == self.__y[i] and self.__x[0] == self.__x[i]:
                return True  # snake ate itself

        if self.__x[0] < 1 or self.__x[0] >= App.BOARD_WIDTH - 1 or self.__y[0] < 1 or self.__y[0] >= App.BOARD_HEIGHT - 1:
            return True  # snake out of bounds

        return False

    def set_key_event(self, event: Event) -> None:

        if event.char in Snake.KEYS and event.char != Snake.MAP_KEY_OPP[self.__key_last]:
            self.__key_current = event.char

    @property
    def x(self) -> List[int]:
        return self.__x.copy()

    @property
    def y(self) -> List[int]:
        return self.__y.copy()

    @property
    def length(self) -> int:
        return self.__length

    @property
    def points(self) -> int:
        return self.__points


class App(Tk):

    BOARD_WIDTH = 30
    BOARD_HEIGHT = 30
    TILE_SIZE = 10

    COLOR_BACKGROUND = "yellow"
    COLOR_SNAKE_HEAD = "red"
    COLOR_SNAKE_BODY = "blue"
    COLOR_APPLE = "green"
    COLOR_FONT = "darkblue"
    FONT = "Times 20 italic bold"
    FONT_DISTANCE = 25

    TEXT_TITLE = "Snake"
    TEXT_GAMEOVER = "GameOver!"
    TEXT_POINTS = "Points: "

    TICK_RATE = 200  # in ms
    
    def __init__(self, screenName=None, baseName=None, className='Tk', useTk=1, sync=0, use=None):
        Tk.__init__(self, screenName, baseName, className, useTk, sync, use)
        
        self.__apple = Apple()
        self.__snake = Snake(self.__apple)

        self.__canvas = Canvas(self, width=App.BOARD_WIDTH * App.TILE_SIZE, height=App.BOARD_HEIGHT * App.TILE_SIZE)
        self.__canvas.pack()
        self.__canvas.configure(background=App.COLOR_BACKGROUND)
    
        self.title(App.TEXT_TITLE)
        self.bind('<KeyPress>', self.__snake.set_key_event)

    def mainloop(self, n=0):
        self.__gameloop()
        Tk.mainloop(self, n)

    def __gameloop(self):

        self.after(App.TICK_RATE, self.__gameloop)
        self.__canvas.delete(ALL)

        if not self.__snake.gameover:

            self.__snake.move()

            x = self.__snake.x
            y = self.__snake.y

            self.__canvas.create_rectangle(
                x[0] * App.TILE_SIZE,
                y[0] * App.TILE_SIZE,
                x[0] * App.TILE_SIZE + App.TILE_SIZE,
                y[0] * App.TILE_SIZE + App.TILE_SIZE,
                fill=App.COLOR_SNAKE_HEAD
            )  # Head

            for i in range(1, self.__snake.length, 1):
                self.__canvas.create_rectangle(
                    x[i] * App.TILE_SIZE,
                    y[i] * App.TILE_SIZE,
                    x[i] * App.TILE_SIZE + App.TILE_SIZE,
                    y[i] * App.TILE_SIZE + App.TILE_SIZE,
                    fill=App.COLOR_SNAKE_BODY
                )  # Body

            self.__canvas.create_rectangle(
                self.__apple.x * App.TILE_SIZE,
                self.__apple.y * App.TILE_SIZE,
                self.__apple.x * App.TILE_SIZE + App.TILE_SIZE,
                self.__apple.y * App.TILE_SIZE + App.TILE_SIZE,
                fill=App.COLOR_APPLE
            )  # Apple

        else:  # GameOver Message
            x = App.BOARD_WIDTH * App.TILE_SIZE / 2  # x coordinate of screen center
            y = App.BOARD_HEIGHT * App.TILE_SIZE / 2  # y coordinate of screen center
            self.__canvas.create_text(x, y - App.FONT_DISTANCE, fill=App.COLOR_FONT, font=App.FONT,
                                      text=App.TEXT_GAMEOVER)
            self.__canvas.create_text(x, y + App.FONT_DISTANCE, fill=App.COLOR_FONT, font=App.FONT,
                                      text=App.TEXT_POINTS + str(self.__snake.points))
    

if __name__ == "__main__":
    App().mainloop()

---

As always, no warranty. As there are many different styles for programming python, these are some suggestions for you, how you COULD impove your code. Many things I mentioned are optional, not necessary.