为什么我的列表不能并排打印？

Question

I'm writing a program where I want the dice to print side by side. However, the actual output only places the top base of the second die next to the bottom base of the first die. Can anyone help me understand why this is happening?

die1 = ('+-------+\n|       |\n|   *   |\n|       |\n+-------+')
die2 = ('+-------+\n| *     |\n|       |\n|     * |\n+-------+')
die3 = ('+-------+\n| *     |\n|   *   |\n|     * |\n+-------+')
die4 = ('+-------+\n| *   * |\n|       |\n| *   * |\n+-------+')
die5 = ('+-------+\n| *   * |\n|   *   |\n| *   * |\n+-------+')
die6 = ('+-------+\n| * * * |\n|       |\n| * * * |\n+-------+')

list_die = ['0', die1, die2, die3, die4, die5, die6]

x = list_die[1]+'   ' + list_die[2]
print(x)

my output
+-------+
|       |
|   *   |
|       |
+-------+   +-------+
| *     |
|       |
|     * |
+-------+

Answer 1

Try using zip and lists

To have them print side by side you will need to concat them with zip

die1 = ('+-------+','|       |','|   *   |','|       |','+-------+')
die2 = ('+-------+','| *     |','|       |','|     * |','+-------+')
die3 = ('+-------+','| *     |','|   *   |','|     * |','+-------+')
die4 = ('+-------+','| *   * |','|       |','| *   * |','+-------+')
die5 = ('+-------+','| *   * |','|   *   |','| *   * |','+-------+')
die6 = ('+-------+','| * * * |','|       |','| * * * |','+-------+')

list_die = ['0',die1,die2,die3,die4,die5,die6];

die_a = list_die[1];
die_b = list_die[2];

for line in zip(die_a,die_b):
    print line;

output:
('+-------+', '+-------+')
('|       |', '| *     |')
('|   *   |', '|       |')
('|       |', '|     * |')
('+-------+', '+-------+')

Answer 2

Take apart to get the individual lines, concatenate those lines, and then rejoin. Note that the final result has fewer \\n than a simple concatenation of the original strings:

def pair(i,j):
    linesI = list_die[i].split('\n')
    linesJ = list_die[j].split('\n')
    return '\n'.join(x+y for x,y in zip(linesI,linesJ))

For example,

>>> print(pair(1,2))
+-------++-------+
|       || *     |
|   *   ||       |
|       ||     * |
+-------++-------+

On Edit; It is inefficient to repeatedly split the same strings again and again. Keeping your original definitions, you could use the following lines:

list_die = ['0',die1,die2,die3,die4,die5,die6]
list_die = [d.split('\n') for d in list_die]

Now list_die contains the splits.

You could now simply use:

def pair(i,j):
    return '\n'.join(x+y for x,y in zip(list_die[i],list_die[j]))

Which is functionally the same as above.

At the risk of being a little too cute, you can make a more flexible version which will print any number of dice on a single line (useful for eg coding the game of Risk or Yahtzee, with often involve three or more dice):

def dice(*args):
    return '\n'.join(''.join(t) for t in zip(*(list_die[i] for i in args)))

So, for example:

>>> print(dice(1))
+-------+
|       |
|   *   |
|       |
+-------+
>>> print(dice(1,2))
+-------++-------+
|       || *     |
|   *   ||       |
|       ||     * |
+-------++-------+
>>> print(dice(3,1,4))
+-------++-------++-------+
| *     ||       || *   * |
|   *   ||   *   ||       |
|     * ||       || *   * |
+-------++-------++-------+

On Further Edit: You can do this without zip , although at the cost of making the code longer. zip is designed for parallel iteration . For example, you assemble the pair of side-by-side dice but iterating down the two dice face in parallel. Without using zip , you would need to use list indices to keep the iteration parallel. For example, the second version of pair() (where list_die contains the dice faces already split into lines) would look like:

def pair(i,j):
    lines = []
    for k in range(len(list_die[i])):
        lines.append(list_die[i][k] + list_die[j][k])
    return '\n'.join(lines)

This works, but is over 200% longer (5 lines rather than 2).

Answer 3

To answer the question of why this behavior happens, note that your calls to print and explicit \\n s insert a newline in the text, which forces the output to go down a line.

Unless you use code that manipulates the console, once you go down a line, you can't go back up. You print left to right, top to down, like a printer. You can't unprint.

If you want this functionality, look into graphics libraries . Curses is the easy goto library for C++, and may have a python equivalent.

Of course, as the other answers mention, you can just format the text side-by-side, which for you current purpose is probably the better option.