如何在 python 中打印金字塔 - 验证

Question

I have a little slight confusion, below pattern is printed by adding 3 spaces with '* '. Is it a right approach to do?

        *   
      *   *   
    *   *   *   
  *   *   *   *   
*   *   *   *   * 

Code:

for row in range(1,5+1):
  print(' ' * (5-row)*2 + row * '*   ')

Or i need to follow any different approach to print it. Suggest me some other approach?

Answer 1

If your task is to print the pyramid that you have shown - yes, you chose a correct approach.

If you want to make the code a little bit more flexible and reusable, you cant put the logic into a function. I suggest print_pyramid . After realizing that the number 5 is just the height of the pyramid you can replace 5 with a variable height and provide it as an argument to the function.

For good measure I would do the same with the padding (three blanks) and the marker '*' .

The final print statement first looked like

print(" " * (height - row) * padding + row * cell)

which can be expressed with an f-string as

print(f'{" " * (height - row) * padding}{row * cell}')

I prefer f-strings whenever I encounter string-concatenation as I consider them more readable.

In sum I would suggest the following

def print_pyramid(height, padding=3, marker="*"):
    padding_ws = " " * (padding * 2 - 1)
    cell = marker + padding_ws
    for row in range(1, height + 1):
        print(f'{" " * (height - row) * padding}{row * cell}')


if __name__ == '__main__':
    print_pyramid(height=5)

Note that you can now also generate variants of your pyramid like print_pyramid(7, padding=2, marker="x") .

Answer 2

This is a general solution which takes advantage of the simmetry of the tree:

c = [" ", "*"]

def print_pyramid(n_layers):
    n = (n_layers * 2 - 1)
    s = " " * n
    for x in range(n_layers + 1):
        s = (s + " " + c[int(x%2)])[-n:]
        print(s + s[:-1][::-1])

So for example:

print_pyramid(5)

OUTPUT

        *
      *   *
    *   *   *
  *   *   *   *
*   *   *   *   *

or

print_pyramid(10)

OUTPUT

                  *
                *   *
              *   *   *
            *   *   *   *
          *   *   *   *   *
        *   *   *   *   *   *
      *   *   *   *   *   *   *
    *   *   *   *   *   *   *   *
  *   *   *   *   *   *   *   *   *
*   *   *   *   *   *   *   *   *   *

The solution is focused in building half of the tree, given its symmetry:

• The user inputs the number of layers" in the pyramid
• Given that number of layers, the size of the base can be worked out: for example, if a pyramid has 2 layers, the base will be 5 characters wide; if, as in the question, there are 5 layers, the base will be 17 wide. In general, the size of the base will be (n_layers - 1) * 4 + 1
• Half a pyramid - including the central symmetry lines - will be n = (n_layers - 1) * 2 + 1 = n_layers * 2 - 1
• We take advantage to this property in the loop - where in each iteration we append a space and, in turns, a space or an asteristik (note that int(x%2) will return a 0 if the loop is even, 1 otherwise)
• We then print this half pyramid and its reverse, dropping the centre given that we don't won't to print it twice

Answer 3

Yes your logic work's. One benefit about your code is that you can print different variant's of pyramids.

Make your code a generic, so that it can be used for any number of input

If required different variant of pyramid you can change the ljust value from 4 to any other number.

Code:

def print_pyramid(n):
  for row in range(1,n+1):
    print(' ' * (n-row)*2 + row * '*'.ljust(4))

print_pyramid(10)

Output:

                  *   
                *   *   
              *   *   *   
            *   *   *   *   
          *   *   *   *   *   
        *   *   *   *   *   *   
      *   *   *   *   *   *   *   
    *   *   *   *   *   *   *   *   
  *   *   *   *   *   *   *   *   *   
*   *   *   *   *   *   *   *   *   *

Answer 4

You could make fewer calculations by altering a string at each iteration to adjust it for the indent and extra star before printing:

n = 5
row = "  "*(n-1)
for _ in range(n):
    row = row[2:]+"   *"
    print(row)

         *
       *   *
     *   *   *
   *   *   *   *
 *   *   *   *   *