如何在Python中打印板子？

Question

我試圖在Python上編寫稱爲三元組三元組的遊戲，但是我有一個板子輸出的問題，它必須像這樣每個方塊，其中每個數字代表一個基點，有9個方塊，三個爲每一行。

| 1 | 1 | 9 | 

|2@3|1*6|7*2| 

| 4 | 1 | 2 | 

我覺得做一個列表，每一行，並開始與數字電路板的每一個基點，例如，「0」，如果它是北方或類似的東西，所以當我有數字來代替的卡片，我確切知道每個基點的位置，有什麼建議？

在此先感謝

Answer 1

這裏有一個簡單的方法來得到你正在尋找的格式：

def format_row(row): 
    return '|' + '|'.join('{0:^3s}'.format(x) for x in row) + '|' 

def format_board(board): 
    # for a single list with 9 elements uncomment the following line: 
    # return '\n\n'.join(format_row(row) for row in zip(*[iter(board)]*3)) 
    # for a 3x3 list: 
    return '\n\n'.join(format_row(row) for row in board) 

例子：

>>> print format_board([['1', '1', '9'], ['2@3', '1*6', '7*2'], ['4', '1', '2']]) 
| 1 | 1 | 9 | 

|2@3|1*6|7*2| 

| 4 | 1 | 2 | 

Answer 2

可以代表三列出了該板：

["1", "1", "9"] 
["2@3", "1*6", "7*2"] 
["4", "1", "2"] 

或一起在一個列表：

board = [["1", "1", "9"], ["2@3", "1*6", "7*2"], ["4", "1", "2"]] 

現在你需要寫兩個函數：

• 函數t帽子拿着這份清單，並用|之間的線打印你的紙板。
• 計算上述列表並確定板中每個單元的正確值的函數。

你不需要處理數字或其他任何東西，這都是做這兩件事的問題。

Answer 3

我看着卡三重三合會（我記得現在的遊戲，樂趣東西），我不明白你的主板上的@或*的含義。如果你想表現它，那麼這裏是一些代碼，會顯示數字：

def cardString(card): 
    if (card): 
     return '{west},{north},{south},{east}'.format(**card) 
    else: 
     return '-,-,-,-' 

def printBoard(board): 
    for row in board: 
     print('{}|{}|{}'.format(cardString(row[0]), cardString(row[1]), cardString(row[2]))) 

cardMoogle = {'north':9, 'east':3, 'west':2, 'south':9} 
cardNull = {'north':'-', 'east':'-', 'west':'-', 'south':'-'} 
# I'm sure there's a better way to do this list, but I'm new to Python. 
board = [cardNull]*3 
board = [list(board), list(board), list(board)] 
board[0][0] = cardMoogle 

printBoard(board) 

是，在所有有用嗎？

Answer 4

這可能是矯枉過正，但下面的矩陣類可自動創建自己的表示：如果你需要一種方法來設定，添加或乘矩陣

class Matrix: 

    def __init__(self, rows, columns): 
     self.__data = tuple([None] * columns for row in range(rows)) 
     self.__rows, self.__columns = rows, columns 

    def __repr__(self): 
     table = Matrix(self.rows, self.columns) 
     rows, columns = [0] * self.rows, [0] * self.columns 
     for (row, column), value in self: 
      lines = tuple(repr(value).replace('\r\n', '\n') 
          .replace('\r', '\n').split('\n')) 
      table[row, column] = self.__yield(lines) 
      rows[row] = max(rows[row], len(lines)) 
      columns[column] = max(columns[column], max(map(len, lines))) 
     return ('\n' + '+'.join('-' * column for column in columns) + '\n') \ 
       .join('\n'.join('|'.join(next(table[row, column]) 
       .ljust(columns[column]) for column in range(table.columns)) 
       for line in range(rows[row])) for row in range(table.rows)) 

    def __len__(self): 
     return self.rows * self.columns 

    def __getitem__(self, key): 
     row, column = key 
     return self.__data[row][column] 

    def __setitem__(self, key, value): 
     row, column = key 
     self.__data[row][column] = value 

    def __delitem__(self, key): 
     self[key] = None 

    def __iter__(self): 
     for row in range(self.rows): 
      for column in range(self.columns): 
       key = row, column 
       yield key, self[key] 

    def __reversed__(self): 
     for row in range(self.rows - 1, -1, -1): 
      for column in range(self.columns - 1, -1, -1): 
       key = row, column 
       yield key, self[key] 

    def __contains__(self, item): 
     for row in self.__data: 
      if item in row: 
       return True 
     return False 

    def freeze(self): 
     self.__data = tuple(map(tuple, self.__data)) 

    def thaw(self): 
     self.__data = tuple(map(list, self.__data)) 

    @property 
    def rows(self): 
     return self.__rows 

    @property 
    def columns(self): 
     return self.__columns 

    @staticmethod 
    def __yield(lines): 
     for line in lines: 
      yield line 
     while True: 
      yield '' 

，這些功能作爲你操作的補充：

def set_matrix(matrix, array): 
    for y, row in enumerate(array): 
     for x, item in enumerate(row): 
      matrix[y, x] = item 

def add_matrix(a, b): 
    assert a.rows == b.rows and a.columns == b.columns 
    c = Matrix(a.rows, a.columns) 
    for key, _ in c: 
     c[key] = a[key] + b[key] 
    return c 

def mul_matrix(a, b): 
    assert a.columns == b.rows 
    c = Matrix(a.rows, b.columns) 
    for key, _ in c: 
     row, column = key 
     c[key] = sum(j * k for j, k in 
        zip((a[row, i] for i in range(a.columns)), 
         (b[i, column] for i in range(b.rows)))) 
    return c