Printing Command Line Unicode Chess Board
numpy
In this case there is no need to use. For an 8 by 8 board, filled with strings, there is no advantage to using it, apart from the possibility to index row and column at the same time
enums
You have a few properties wich would be best presented as an enum. The color and the type of the piece
import enum


class Color(enum.Enum):
    WHITE = 0
    BLACK = 1


class Piece(enum.Enum):
    EMPTY = enum.auto()
    PAWN = enum.auto()
    ROOK = enum.auto()
    KNIGHT = enum.auto()
    BISHOP = enum.auto()
    KING = enum.auto()
    QUEEN = enum.auto()

tuple
You have a chrs dictionary with keys that contain both the color and the piece. A better approach here would be to use tuples as keys
chrs = {
    (Color.WHITE, Piece.EMPTY): &quot;\u25FB&quot;,
    (Color.WHITE, Piece.PAWN): &quot;\u265F&quot;,
    (Color.WHITE, Piece.ROOK): &quot;\u265C&quot;,
    (Color.WHITE, Piece.KNIGHT): &quot;\u265E&quot;,
    (Color.WHITE, Piece.BISHOP): &quot;\u265D&quot;,
    (Color.WHITE, Piece.KING): &quot;\u265A&quot;,
    (Color.WHITE, Piece.QUEEN): &quot;\u265B&quot;,
    (Color.BLACK, Piece.EMPTY): &quot;\u25FC&quot;,
    (Color.BLACK, Piece.PAWN): &quot;\u2659&quot;,
    (Color.BLACK, Piece.ROOK): &quot;\u2656&quot;,
    (Color.BLACK, Piece.KNIGHT): &quot;\u2658&quot;,
    (Color.BLACK, Piece.BISHOP): &quot;\u2657&quot;,
    (Color.BLACK, Piece.KING): &quot;\u2654&quot;,
    (Color.BLACK, Piece.QUEEN): &quot;\u2655&quot;,
}

board
You keep a black and a white board. Better would be to keep one board, and just flip it at the time of presentation.
def board_begin():
    return (
        [
            [
                (Color.WHITE, Piece.ROOK),
                (Color.WHITE, Piece.KNIGHT),
                (Color.WHITE, Piece.BISHOP),
                (Color.WHITE, Piece.QUEEN),
                (Color.WHITE, Piece.KING),
                (Color.WHITE, Piece.BISHOP),
                (Color.WHITE, Piece.KNIGHT),
                (Color.WHITE, Piece.ROOK),
            ],
            [(Color.WHITE, Piece.PAWN) for _ in range(8)],
            *[[None] * 8 for _ in range(4)],
            [(Color.BLACK, Piece.PAWN) for _ in range(8)],
            [
                (Color.BLACK, Piece.ROOK),
                (Color.BLACK, Piece.KNIGHT),
                (Color.BLACK, Piece.BISHOP),
                (Color.BLACK, Piece.QUEEN),
                (Color.BLACK, Piece.KING),
                (Color.BLACK, Piece.BISHOP),
                (Color.BLACK, Piece.KNIGHT),
                (Color.BLACK, Piece.ROOK),
            ],
        ]
    )

Here I use None to represent an empty tile, and replace it by a white or black tile at the time of display.
flip board
If you use numpy to keep your board, you can np.flip, or a simple routine like this:
def flip(board):
    return [
        row[::-1] for row in reversed(board)
    ]

display the board
Here a simple routine, which takes a boolean flag on whether to flip it:
def display_board(board, flip_board=False):
    for i, row in enumerate(board if not flip_board else flip(board)):
        row_strings = [
            chrs.get(tile, chrs[(Color((i + j) % 2), Piece.EMPTY)])
            for j, tile in enumerate(row)
        ]
        print(&quot;&quot;.join(row_strings))

using dict.get to replace the empty tiles by the correct squares

board = board_begin()


[[(&lt;Color.WHITE: 0&gt;, &lt;Piece.ROOK: 3&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.KNIGHT: 4&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.BISHOP: 5&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.QUEEN: 7&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.KING: 6&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.BISHOP: 5&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.KNIGHT: 4&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.ROOK: 3&gt;)],
       [(&lt;Color.WHITE: 0&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.WHITE: 0&gt;, &lt;Piece.PAWN: 2&gt;)],
       [None, None, None, None, None, None, None, None],
       [None, None, None, None, None, None, None, None],
       [None, None, None, None, None, None, None, None],
       [None, None, None, None, None, None, None, None],
       [(&lt;Color.BLACK: 1&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.PAWN: 2&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.PAWN: 2&gt;)],
       [(&lt;Color.BLACK: 1&gt;, &lt;Piece.ROOK: 3&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.KNIGHT: 4&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.BISHOP: 5&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.QUEEN: 7&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.KING: 6&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.BISHOP: 5&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.KNIGHT: 4&gt;),
        (&lt;Color.BLACK: 1&gt;, &lt;Piece.ROOK: 3&gt;)]]


display_board(board, flip_board=False)


♜♞♝♛♚♝♞♜
♟♟♟♟♟♟♟♟
◻◼◻◼◻◼◻◼
◼◻◼◻◼◻◼◻
◻◼◻◼◻◼◻◼
◼◻◼◻◼◻◼◻
♙♙♙♙♙♙♙♙
♖♘♗♕♔♗♘♖


display_board(board, flip_board=True)


♖♘♗♔♕♗♘♖
♙♙♙♙♙♙♙♙
◻◼◻◼◻◼◻◼
◼◻◼◻◼◻◼◻
◻◼◻◼◻◼◻◼
◼◻◼◻◼◻◼◻
♟♟♟♟♟♟♟♟
♜♞♝♚♛♝♞♜


Board class
If you want to incorporate moves etc, it might pay to make a Class of the board, with it's own display, __getitem__ and move routines