如何在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