Das deutsche Python-Forum

Code: Alles auswählen

'''
Created on 07.12.2011

@author: Roland-User
'''
# -*- coding: iso-8859-1 -*-

DIRECTIONS = RIGHT, LEFT, UP, DOWN = [(1,0),(-1,0),(0,-1),(0,1)]
DIRECTION_TO_STR = { RIGHT: 'rechts', LEFT: 'links', UP: 'oben', DOWN: 'unten' }
FINISH_CHAR="F"
FREE_CHAR=" "
VISITED_CHAR="."

def suggest_dir(pos,env):
    (x,y)=pos
    result=list()
    for direction in DIRECTIONS:
        (x_new,y_new)=direction
        field=env[x+x_new][y+y_new]
        if(field==FINISH_CHAR):
            return [direction]
        if (field==FREE_CHAR):
            result.append(direction)
    return result

class maze:
    
    def __init__(self,Input_Filename):
        self.Input_File=open(Input_Filename,'r')
        self.maze_File=self.Input_File.readlines()
        self.maze_Rows=[]
        self.correct=False
        for i in xrange(len(self.maze_File)):
            if i+1 < len(self.maze_File):
                self.storage=self.maze_File[i]
                self.storage=self.storage[:len(self.storage)-1]
                self.maze_File[i]=self.storage
        for i in xrange(len(self.maze_File)):
            storage=[]
            for j in xrange(len(self.maze_File[i])):
                storage.append(self.maze_File[i][j])
            self.maze_Rows.append(storage)
        self.Input_File.close()
        print self.maze_Rows
        print len(self.maze_Rows)
    '__getitem__ gibt einfach maze_Rows an der Stelle (x,y) aus'
    def __getitem__(self,(x,y)):
        return self.maze_Rows[y][x]
    'Die Funktion __setitem__ erlaubt es, bestimmte Zellen innerhalb des Labyrinths mit eigenen Daten zu fuellen'
    def __setitem__(self,(x,y),input_args):
        try:
            self.maze_Rows[y][x]=input_args
        except IndexError:
            print "Der angegebene Index ist ausserhalb des Labyrinths"
        except:
            print "Ein Fehler ist aufgetreten"
    'Diese Funktion ist fuer das korrekte funktionieren des Befehls "print <Klasse>" zustaendig'
    def __str__(self):
        return '\n'.join(' '.join(line) for line in self.maze_Rows)
    'getStart gibt den Ort des Startpunktes zurueck'
    def getStart(self):
        for i in xrange(len(self.maze_Rows)):
            for j in xrange(len(self.maze_Rows[i])):
                if(self.__getitem__((j, i))=='S'):
                    return i,j
                else:
                    pass
        return False
    'getFinish gibt den Ort des Zielpunktes zurueck'
    def getFinish(self):
        for i in xrange(len(self.maze_Rows)):
            for j in xrange(len(self.maze_Rows[i])):
                if(self.__getitem__((j,i))=='F'):
                    return i,j
                else:
                    pass
        return False        
    def solve_maze(self,pos):
        print self.__str__()
        if (self.getFinish() and self.getStart()) or self.correct:
            self.correct=True
            (x,y)=pos
            suggested_dir=suggest_dir(pos,self.maze_Rows)
            #print suggest_dir(pos,self.maze_Rows)
            if (x, y) == self.getFinish():
                    print self.__str__()
                    print 'Maze solved'
            else:
                suggested_dir=suggest_dir(pos,self.maze_Rows)
                if not suggested_dir:
                    print "Sackgasse"
                    print pos
                    self.maze_Rows[pos[0]][pos[1]]=VISITED_CHAR
                    return 1
                else:
                    for direction in suggested_dir:
                        (x_delta,y_delta)=direction
                        self.maze_Rows[x][y]=VISITED_CHAR
                        self.solve_maze((x+x_delta,y+y_delta))
        else:
            print "Das Labyrinth ist nicht loesbar, da wichtige Punkte fehlen. Bitte geben Sie ein gueltiges Labyrinth an und starten Sie"
            print "dann das Skript erneut"
                    
        
        

Code: Alles auswählen

import time

DIRECTIONS = RIGHT, LEFT, UP, DOWN = [(1,0),(-1,0),(0,-1),(0,1)]
FINISH_CHAR="F"
FREE_CHAR=" "
VISITED_CHAR="."
BLOCK_CHAR="*"

def suggest_dir(pos,env):                           #"""Die Funktion suggest_dir prueft, in welche Richtungen ein Laufen moeglich ist"""
    (x,y)=pos
    result=list()
    for direction in DIRECTIONS:
        (x_new,y_new)=direction
        field=env[x+x_new][y+y_new]
        if(field==FINISH_CHAR):
            return [direction]
        if (field==FREE_CHAR):
            result.append(direction)
    return result

class maze:                                         #"""Klasse Maze"""
    
    def __init__(self,Input_Filename):              #"""Konstruktor der Klasse Maze, liest das Labyrinth ein"""
        try:
            self.Input_File=open(Input_Filename,'r')
        except IOError:
            print "File does not exist"
        self.maze_Rows=[]
        self.correct=False
        self.LabSolved=False
        self.convert_data(self.Input_File)
        self.recursion_deep=0
        
        
    def convert_data(self,maze_File):               #"""convert_data wandelt den eingelesenen String in eine mehrdimensionale Liste um"""
        self.maze_Rows=[list(row.strip()) for row in maze_File]
    
    def __getitem__(self,(x,y)):                    #"""__getitem__ liefert den Wert des Labyrinths an der Stelle x,y zurueck"""
        return self.maze_Rows[y][x]
    
    def __setitem__(self,(x,y),input_args):         #"""Mit __setitem__ kann man den Wert des Labyrinths an der Stelle (x,y) auf den Wert input_args setzen"""
        try:
            self.maze_Rows[y][x]=input_args
        except IndexError:
            print "Der angegebene Index ist ausserhalb des Labyrinths"
        except:
            print "Ein Fehler ist aufgetreten"
    
    def __str__(self):                              #"""Diese Funktion ist fuer das korrekte funktionieren des Befehls "print <Klasse>" zustaendig"""
        maze_clear=self.maze_Rows
        for i,row in enumerate(maze_clear):
            for j,position in enumerate(row):
                if(position==BLOCK_CHAR):
                    maze_clear[i][j]=" "
                else:
                    pass
        return '\n'.join(' '.join(line) for line in maze_clear)
    
    def getPosition(self, key):                     #"""getPosition gibt den Ort eines beliebigen Wertes zurueck"""
        for i,row in enumerate(self.maze_Rows):
            for j,position in enumerate(row):
                if(position==key):
                    return i,j
                else:
                    pass
        return False
    
    def getFinish(self):                            #"""getFinish gibt den Ort des Zielpunktes zurueck"""
        return self.getPosition("F")
    
    def getStart(self):                             #"""getStart gibt den Ort des Startpunktes zurueck"""
        return self.getPosition("S")
           
    def solve_maze(self,pos):                       #"""solve_maze loest das uebergebene Labyrinth"""
        print self.recursion_deep
        #time.sleep(0.5)
        if pos:
            (x,y)=pos
        else:
            pos=self.getStart()
        if pos==self.getFinish():
            print self.__str__()
            print "Maze solved"
            self.LabSolved=True
        if (self.getFinish() and self.getStart()) or self.correct:
            if not self.LabSolved:
                self.correct=True
                suggested_dir=suggest_dir(pos,self.maze_Rows)
                if not suggested_dir:
                    if(self.recursion_deep==1):
                        print "Labyrinth kann nicht geloest werden"
                        return False
                    else:
                        self.maze_Rows[pos[0]][pos[1]]=BLOCK_CHAR
                        #print "Sackgasse"
                        #print pos
                        #self.maze_Rows[pos[0]][pos[1]]=FREE_CHAR
                else:
                    for direction in suggested_dir:
                        (x_delta, y_delta)=direction
                        self.maze_Rows[x][y]=VISITED_CHAR
                        print self.__str__()
                        self.recursion_deep=self.recursion_deep+1
                        value=self.solve_maze((x+x_delta,y+y_delta))
                        if value:
                            return True
                        self.maze_Rows[x][y]=FREE_CHAR
                self.recursion_deep=self.recursion_deep-1
                return False
            else:
                return True
        else:
            print "Das Labyrinth ist nicht loesbar, da wichtige Punkte fehlen. Bitte geben Sie ein gueltiges Labyrinth an und starten Sie"
            print "dann das Skript erneut"
        return False
        

Code: Alles auswählen

def suggest_dir(pos,env):
    """Die Funktion suggest_dir prueft, in welche Richtungen ein Laufen
    moeglich ist
    """
    (x,y)=pos
    # ...

Code: Alles auswählen

except:
   print "Fehler"
   sys.exit()

Code: Alles auswählen

>>> try:
...     4 / 0
... except:
...     print("Fehler")
...
Fehler

Code: Alles auswählen

>>> 4 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

Code: Alles auswählen

>>> try:
...     4 / 0
... except ZeroDivisionError:
...     print("Ihre Eingabe hat dazu geführt, dass durch '0' geteilt werden soll
. Dies ist mathematisch nicht möglich. Bitte wählen Sie nur Zahlen ungleich '0'.")

Code: Alles auswählen

>>> def divide(divident, divisor):
...     if divisor:
...             return divident / divisor
...