magic numbers

I see the value 3 (and 9) in your code when it refers to the board size. It is best to prevent such magic number, and either replace them with variables, or with constants

BOARD_SIZE = 3

num_to_coord

you can use divmod to calculate the quotient and remainder of a modulo division in 1 step, so num_to_coord gets reduced to:

def num_to_coord(num):
    """calculates the coordinate of a 1-indexed position number

    Examples
    --------
    >>> num_to_coord(1)
    (0, 0)
    >>> num_to_coord(3)
    (0, 2)
    >>> num_to_coord(4)
    (1, 0)
    """
    return divmod(num - 1, BOARD_SIZE)

The effect is a 90° rotation of the board

multi-line strings

Python has multiline string literals, so your welcome ca

def intro():
    welcome_message = """
    Welcome to Tic Tac Toe
    ______________________
    You can pick location by identifying the position on the board. (There are 9 positions)
    The player who plays first will be using 'x' and the second player will be using 'o'.
    """
    print(welcome_message)
    intro_board = """
    |1|2|3|
    |4|5|6|
    |7|8|9|"""
    print(intro_board)

State

to separate state and representation, I would use an enum.Enum to keep the state of a board position

import enum
class Position(enum.Enum):
    EMPTY = " "
    PLAYER_1 = "x"
    PLAYER_2 = "o"

then later on, you can define the game_board as game_board = [[Position.EMPTY] * BOARD_SIZE for _ in range(BOARD_SIZE)]

This allows you to check whether there are still open positions in this way:

def check_board_open(the_game_board):
    """checks whether there are still open positions in the board"""
    return any(Position.EMPTY in row for row in the_game_board)

instead of having to keep a count of how many moves have been done

and drawing the board becomes:

def format_row(row, separator="|"):
    return (
        separator
        + separator.join(position.value for position in row)
        + separator
    )


def draw_board(the_game_board, separator="|"):
    return "\n".join(format_row(row, separator) for row in the_game_board)

In your code, you also put changed the board in the method to draw the board, which is a serious violation of the separation of concerns.

taken_positions

you define taken_positions as a list, but the order is unimportant, and the main goal is check for containment. A set is a more suited collection for this purpose.

check_position

def check_position(the_position, the_taken_positions):
    if the_position in the_taken_positions:
        return True
    if the_position not in the_taken_positions:
        return False

can be simplified to

def check_position(the_position, the_taken_positions):
    return the_position in the_taken_positions

and then dropped altogether to make it inline

user input

You trust your user to input a valid number. This can be made more robust, and integrate the check whether the position is empty

class GameEnd(Exception):
    pass


def get_empty_position(the_game_board):
    max_position = BOARD_SIZE ** 2
    while True:
        user_input = input(f"Enter a position [1-{max_position}]: (q to quit)")
        if user_input.lower() == "q":
            raise GameEnd()
        try:
            position = int(user_input)
            if not 0 < position <= max_position:
                continue
            x, y = num_to_coord(position)
            if the_game_board[x][y] != Position.EMPTY:
                print("Position taken! Try again.")
                continue
            return x, y
        except ValueError:
            pass

This keeps asking for input until a valid, empty position is given, or "q". If the user wants to end the game, this raises a GameEnd exception.

You also don't need the taken_positions, since checking whether the position is taken is done here immediately, and directly compared to the game board instead of a second data structure.

Win situations

@feelsbadman is correct that you can decouple the different rows, columns and diagonals to check for a win condition, but I think the way he implements it can be improved. For tips on looping, check the great talk: "Looping like a Pro" (video on Youtube)

Instead of looping over the indices, you can loop over the rows or columns, and then see whether there is a sole player in that row or column.

To see whether there is a winner in a row, columns or diagonal, you can use this:

def get_winner(row):
    row_set = set(row)
    if len(row_set) == 1 and Position.EMPTY not in row_set:
        return row_set.pop()

This returns the winner if there is one, or None if there isn't

def check_win_horizontal(the_game_board):
    for row in the_game_board:
        winner = get_winner(row)
        if winner:
            return winner
    return None

to check vertical, you can transpose the board with zip(*the_game_board) so a separate vertical method is unnecessary.

For the diagonal, you can define 2 diagonals:

diagonal1 = {the_game_board[i][i] for i in range(BOARD_SIZE)}
diagonal2 = {the_game_board[i][-(i + 1)] for i in range(BOARD_SIZE)}

and then check them like this:

def check_win_diagonal(the_game_board):
    diagonal1 = {the_game_board[i][i] for i in range(BOARD_SIZE)}
    diagonal2 = {the_game_board[i][-(i + 1)] for i in range(BOARD_SIZE)}
    winner = get_winner(diagonal1) or get_winner(diagonal2)
    return winner

The general method to check whether there is a winner then simply is:

def check_win(the_game_board):
    return (
        check_win_horizontal(the_game_board)
        or check_win_horizontal(zip(*the_game_board))
        or check_win_diagonal(the_game_board)
    )

change_symbol

can be simplified to

def change_symbol(the_symbol):
    symbols = {"x": "o", "o": "x"}
    return symbols[the_symbol]

But this can also be done differently:

In the main method, you define the players as a itertools.cycle of (Position.PLAYER_1, Position.PLAYER_2). To get the next player, you just do player = next(players)

changing the board is then as simple as

    x, y = get_empty_position(game_board)
    game_board[x][y] = player 

main

def main():
    game_board = [[Position.EMPTY] * BOARD_SIZE for _ in range(BOARD_SIZE)]
    players = cycle((Position.PLAYER_1, Position.PLAYER_2))
    intro()
    while check_board_open(game_board):
        player = next(players)
        print(f"Player {player.value} to move")
        x, y = get_empty_position(game_board)
        game_board[x][y] = player
        print(draw_board(game_board))
        winner = check_win(game_board)
        if winner:
            return winner

main guard

Best put the code that should be run as a script behind a if __name__ == "__main__": guard, so you can import this file with a minimum of side effects

def ask_retry():
    user_input = input("press ENTER to continue, q, then ENTER to quit")
    return not user_input.lower() in {"q", "quit"}

if __name__ == "__main__":
    retry = True
    while retry:
        try:
            winner = main()
            message =  f"{winner.name} won!" if winner else "WOW! You guys are good! DRAW!!!"
            print(message)
            retry = ask_retry()
        except GameEnd:
            print("Thanks for playing! Exiting")
            retry = False

testing

By separating the methods like this, you can easily test them with unit tests. For code like this, which is 140 lines long, you can easily test it by hand, but if you want to incorporate changes later, like varying board sizes, a working, complete test suite will be a great help in spotting bugs.