Sudoku 2.1

import time as t

#zum reset hier ne leere zeile für copy+paste:[[],[],[],[],[],[],[],[],[]]


line1=[[1],[0],[0],[5],[7],[0],[3],[0],[0]]
line2=[[0],[0],[0],[0],[0],[0],[5],[7],[0]]
line3=[[6],[0],[0],[0],[9],[0],[0],[0],[8]]
line4=[[0],[0],[0],[0],[0],[0],[0],[4],[1]]
line5=[[0],[0],[0],[6],[0],[3],[0],[0],[0]]
line6=[[7],[2],[8],[0],[0],[0],[0],[0],[0]]
line7=[[0],[9],[0],[2],[0],[6],[0],[0],[0]]
line8=[[0],[0],[0],[0],[0],[1],[2],[0],[3]]
line9=[[3],[5],[2],[0],[0],[0],[9],[0],[0]]

sudoku=[line1,line2,line3,line4,line5,line6,line7,line8,line9]




def printSudoku(sudoku):
    n="\n"
    s="|"
    line="|---|---|---||---|---|---||---|---|---|"
    smoothLine="---------------------------------------"
    output=smoothLine+n
    for i in range(len(sudoku)):
        for j in range(len(sudoku[i])):
            if j%3==0:
                output=output+s
            output=output+" "+str(sudoku[i][j][0])+" "+s
#            for k in range(len(sudoku[i][j])):
#                output=output+str(sudoku[i][j][k])
        if (i+1)%3==0:
            output=output+n+smoothLine+n
        else:
            output=output+n+line+n
    print(output)
    return()




def checkSquare(square):
    if len(square)==1 and square!=[0]:
        done=True

    else:
        done=False

    return(done)



def listSubtract(subtract,list1):
    result=list1
    for a in subtract:
        if a in list1:
            result.remove(a)

    return (result)

def checkForEquals(square1,square2):
    overlap=[]
    for a in square1:
        for b in square2:
            if a==b:
                overlap.append(a)
#    print(overlap)
    return(overlap)



def checkGuesses(row):
    notAdd=[]
    for a in range(9):
        if checkSquare(row[a]):
            notAdd=notAdd+(row[a])
#            print(notAdd)
    for b in range(9):
        if len(row[b])!=1 or row[b]==[0]:
            if row[b]==[0]:
               possible=[1,2,3,4,5,6,7,8,9]
            else:
                possible=row[b]
#            print(possible)
            possible=listSubtract(notAdd,possible)
            row[b]=possible
#        print(row[b])
    notOverlap=[]
    for c in range(9):
        if not checkSquare(row[c]):
            for d in range(9):
                if d!=c:
                    if not checkSquare(row[d]):
                        if notOverlap==[]:
                            notOverlap=listSubtract(row[d],row[c])
                        else:
                            notOverlap=listSubtract(row[d],notOverlap)
                    #notOverlap ist die liste mit zahlen, die nur in einem Feld (row[c]) möglich sind
            print(notOverlap)
        else:
            print("square is done")
        if len(notOverlap)==1:
            row[c]=notOverlap
    return()





#"row"kann jede liste, die neun Felder umfasst und in der die zahlen von eins bis neun vorkommen sollen sein (also Zeilen, Spalten oder Blöcke).
#notAdd ist die liste die die in dieser Reihe unmöglichen Zahlen enthält
#possible ist die Liste die alle möglichen zahlen eines feldes speichert
def checkRow(row):
    notAdd=[]
    for a in range(9):
        if checkSquare(row[a]):
            notAdd=notAdd+(row[a])
#            print(notAdd)
    for b in range(9):
        if len(row[b])!=1 or row[b]==[0]:
            if row[b]==[0]:
               possible=[1,2,3,4,5,6,7,8,9]
            else:
                possible=row[b]
#            print(possible)
            possible=listSubtract(notAdd,possible)
            row[b]=possible
#        print(row[b])
    t.sleep(0.05)
    return()


def checkForComplete(sudoku):
    completeness=0
    for x in range(len(sudoku)):
        for y in range(len(sudoku[x])):
            if checkSquare(sudoku[x][y]):
                completeness=completeness+1
    return(completeness)


printSudoku(sudoku)

counter=0
while checkForComplete(sudoku)<81:

#checkt zeilen
    for g in range(9):
        checkRow(sudoku[g])
        #checkRow(sudoku[g])
#        print("Zeilen")
#        printSudoku(sudoku)
#checkt spalten
    for f in range(9):
        spalte=[]
        for e in range(9):
            spalte.append(sudoku[e][f])
        checkRow(spalte)
        #checkRow(spalte)
#        print("spalten")
#        printSudoku(sudoku)
#checkt blöcke
    for o in range(3):
        for p in range(3):
#o und p sind koordinaten des aktuellen blocks
            block=[]
            for c in range(3):
                for d in range(3):
                    block.append(sudoku[3*o+c][3*p+d])
            checkRow(block)
            #checkRow(block)
#            print("Block")
#            printSudoku(sudoku)
    t.sleep(1)
    counter=counter+1
    print(counter)
    printSudoku(sudoku)
printSudoku(sudoku)