Tic Tac Toe in Python 3 Learning to code with python this is what i came up with. But looking at the code i am sure there are ways to improve. I would really appreciate a constructive review and some guidelines.

from itertools import cycle

game = [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]]

player = [1, 2]

current_player = cycle(player)


def diagonal_win():
    if game[0][0] == game[1][1] == game[2][2] != 0:
        print('Winner')

    elif game[0][2] == game[1][1] == game[2][0] != 0:
        print('Winner')


def horizontal_win():
    for row in game:
        if row.count(row[0]) == len(row) and row[0] != 0:
            print('Winner')


def vertical_win():
    for col in range(len(game)):
        see = []
        for row in game:
            see.append(row[col])
        if see.count(see[0]) == len(see) and see[0] != 0:
            print('Winner')


def pick_player(current_player):
    if current_player == 1:
        p1rinput = input('Player 1 Row: ')
        p1cinput = input('Player 1 Column: ')
        if p1rinput.isdigit() and p1cinput.isdigit():
            p1rinput = int(p1rinput)
            p1cinput = int(p1cinput)
            print('Player 1: ')
            if game[p1rinput - 1][p1cinput - 1] == 0:
                game[p1rinput - 1][p1cinput - 1] = 1
            else:
                print('You cheated !!!Skipping turn...')
            return p1rinput, p1cinput

    if current_player == 2:
        p2rinput = input('Player 2 row: ')
        p2cinput = input('Player 2 column: ')
        if p2cinput.isdigit() and p2rinput.isdigit():
            p2cinput = int(p2cinput)
            p2rinput = int(p2rinput)
            print('Player 2: ')

            if game[p2rinput - 1][p2cinput - 1] == 0:
                game[p2rinput - 1][p2cinput - 1] = 2
            else:
                print('You cheated !!!Skipping turn...')

            return p2rinput, p2cinput


def gameplay():
    for items in game:
        print(items)
    while True:
        if vertical_win():
            break
        elif horizontal_win():
            break
        elif diagonal_win():
            break

        else:
            pick_player(next(cycle(current_player)))
            for items in game:
                print(items)


gameplay()
Displaying the grid

Personally, I would move displaying the grid into a separate function, such as display_grid:

def display_grid() -&gt; None:
    for row in game:
        print(row)


This removes the need to keep having to write the loop over and over.

Picking the player

Another personal preference is that I would have the user input both the row and column as the input, and just split what they inputed to get the values. Removes the need to have multiple input calls, and makes the game a little easier to play.

def pick_player(current_player: int) -&gt; (int, int):
    row, col = input(f"Player {current_player} Turn!\nEnter row and column of choice: ").split()
    if row.isdigit() and col.isdigit():
        row, col = int(row), int(col)
        if game[row - 1][col - 1] == 0:
            game[row - 1][col - 1] = current_player
        else:
            print("Position already taken! Skipping turn!")
        return row, col


Checking the board

Instead of having three separate functions to check the board, you should group all the conditionals into one function. Now, I did a bit of fixing and this function, check_win, checks all the ways the game can be won.

def check_win():
    return any([
        game[0][0] == game[1][1] == game[2][2] != 0,
        game[0][2] == game[1][1] == game[2][0] != 0,
        any([row.count(row[0]) == len(row) and row[0] != 0 for row in game]),
        any([len(set([game[i][j] for i in range(3)])) == 1 and game[0][j] != 0 for j in range(3)])
    ])


You can use any to determine if any of the elements in an iterable are True. The last line in this functions does the vertical checking. Spent a good deal trying to make this one line, and it looks pretty good. Basically, the set call removes all duplicates and retains the single values. For example, set([1, 1, 2]) results in {1, 2}.

With this information, if the length of the set is one, and the single value isn't 0, then a winner has been found. That's all that line is doing.