Improving and optimizing Tic-Tac-Toe game written in Python 3
#!/usr/bin/env python3

import random

board = [0]*9


Having global variables that change is considered a bad idea. You'd be better off putting this variable and the methods inside a class.

def resetBoard():
    for index, i in enumerate(board):
        board[index] = 0


You could also do board[:] = [0] * 9

def printBoard():
    counter = 0


In python you rarely need to keep track of counters like this

    s = ""


In python, you should avoid building strings by adding different pieces together

    print("|-----|-----|-----|")
    for index, i in enumerate(board):
        s += "|  "
        if(board[index] == 0):


The point of enumerate is that i is the value in board. Use it rather then refetching it here.

            s += str(index)
        if(board[index] == 1):
            s+= "x"
        if(board[index] == 2):
            s += "o"
        s += "  "


By building the string this way its hard to follow exactly what the string is.

        counter += 1
        if(counter == 3):


Instead of making the counter use `if index % 3 == 2:' Also you don't need the parens

            s += "|"
            print(s)
            print("|-----|-----|-----|")
            s = ""
            counter = 0


Your whole algorithm here is rendered more complicated because you are iterating over cells rather the rows. Your algorithm would be much more natural with rows

def getPlayers():
    return input("1 or 2 Players?")


Shouldn't this return an int, not a string?

def moveSquare(xOro, ai):


variable names are recommended to follow x_or_o as a naming convetion

    square = 0
    flag = 0


If this is a boolean flag, use False not 0

    while(board[square] != 0 or flag == 0):


No need for the parens around the while expression

        if(ai == 0):


Again use True/False for boolean flags. No need for parens

            if(xOro == 1):
                square = eval(input("Choose a square to place X: "))
            if(xOro == 2):
                square = eval(input("Choose a square to place O: "))


Avoid magic numbers like 1 and 2 to denote X and O. In this case, I'd probably pass 'x' or 'o' strings.

        if(ai == 1):


Use an else:

            square = random.randint(0, 8)
        flag = 1


Flag is really terrible variable name because I don't know what it means. Boolean flags are usually an ugly solution

    board[square] = xOro
    print("\n\n")

def checkForWin():
    if(board[0] == board[1] and board[1] == board[2] and board[2] != 0):
        return 1


Don't use magic numbers like that. Instead create some global constants to return or something

    if(board[3] == board[4] and board[4] == board[5] and board[5] != 0):
        return 1
    if(board[6] == board[7] and board[7] == board[8] and board[8] != 0):
        return 1
    if(board[0] == board[3] and board[3] == board[6] and board[6] != 0):
        return 1
    if(board[1] == board[4] and board[4] == board[7] and board[7] != 0):
        return 1
    if(board[2] == board[5] and board[5] == board[8] and board[8] != 0):
        return 1
    if(board[0] == board[4] and board[4] == board[8] and board[8] != 0):
        return 1
    if(board[2] == board[4] and board[4] == board[6] and board[6] != 0):
        return 1


A lot duplication here. 

    for index, i in enumerate(board):
        if(i  == 0):
            break
        if(index == 8):
            return 2
    return 0

def gameOver():
    return eval(input("\nPress 0 and then ENTER to play again!"))


Eval is a bit dangerous because the user can put in anything they want.

# Main


You should your main logic in a function

random.seed()
quit = 0
while(quit == 0):


Make quite a boolean variable

    players = 0
    win = 0
    while(players != 1 and players != 2):
        players = eval(getPlayers())
    resetBoard()
    game = 0 #game = 1 when game is finished


Game becoming 1 when the game is finished seems backwards

    while(game == 0): #game loop
        printBoard()
        moveSquare(1, 0)
        game = checkForWin()
        if(game &gt; 0):
            win = game
            break


Not much point checking game == 0 above if you are just going to break anyways

        printBoard()
        if(players == 1):
            moveSquare(2, 1)
        if(players == 2):
            moveSquare(2, 0)
        game = checkForWin()
        if(game &gt; 0):
            win = game + 1
            break


See how the two parts of the loop are very similar? Suggests that you should get rid of the duplication.

    if(win == 1):
        print("\nX Wins!")
    if(win == 2):
        print("\nO Wins!")
    if(win == 3):
        print("\n The game is a draw!")
    quit = gameOver()


Having gameOver() return whether or not you should quit seems confusing. The name doesn't suggest that

exit()


Not much point in calling quit, the program is about to terminate anyways

And just to demonstrate how I'd do this:

#!/usr/bin/env python3
import random

WINNING_LINES = [
    [0, 1, 2],
    [3, 4, 5],
    [5, 6, 7],

    [0, 3, 5],
    [1, 4, 6],
    [2, 5, 7],

    [0, 4, 7],
    [2, 4, 5]
]

STALEMATE = '!'

class TicTacToe(object):
    def __init__(self):
        self.board = [' '] * 9

    def print(self):
        # make a copy of the board
        cells = self.board[:] 

        # put a digit in every blank cell
        for index, cell in enumerate(cells):
            if cell == ' ':
                cells[index] = str(index)

        # put spaces around the cells
        cells = [' %s ' % cell for cell in cells]

        # print the actual board
        print('|---|---|---|')
        for start in range(0, 9, 3):
            row = cells[start:start+3]
            print('|', '|'.join(row), '|', sep = '')
            print('|---|---|---|')

    def move_square(self, player, ai):
        square = -1
        while square &lt; 0 or square &gt;= 9 or self.board[square] != ' ':
            if ai:
                square = random.randrange(9)
            else:
                question = "Choose a square to place {}:".format(player.upper())
                square_text = input(question)
                print(square_text)
                try:
                    square = int(square_text)
                except ValueError:
                    # user didn't enter a number
                    square = -1
        self.board[square] = player
        print("\n\n")

    def status(self):
        # check for a win
        for a, b, c in WINNING_LINES:
            if self.board[a] == self.board[b] and self.board[b] == self.board[c] and self.board[a] != ' ':
                return self.board[a]

        if not any(cell == ' ' for cell in self.board):
            return STALEMATE
        return ' '

def get_players():
    while True:
        text = input("1 or 2 players")
        try:
            value = int(text)
        except ValueError:
            pass
        else:
            if 0 &lt; value &lt; 3:
                return value




def play_again():
    return input("\nPress 0 and then ENTER to play again!") == '0'

GAME_OVER_MESSAGES = {
    'X' : 'X wins!',
    'O' : 'O wins!',
    '!' : 'The game is a draw!'
}

def main():

    while True:

        # create a list to denote whether
        # a player is AI
        ai_players = [False, False]
        if get_players() == 1:
            ai_players[1] = True


        tic_tac_toe = TicTacToe()
        player_turn = 0
        player_codes = 'XY'
        while tic_tac_toe.status() == ' ':
            tic_tac_toe.print()
            tic_tac_toe.move_square(player_codes[player_turn], ai_players[player_turn])
            player_turn = (player_turn + 1) % 2

        print(GAME_OVER_MESSAGES[tic_tac_toe.status()])

        if not play_again():
            break


if __name__ == '__main__':
    main()