Cfrtjryk

Can I make this simpler anyhow?

My code displays it correctly:

v = lambda x: [x[0:i+1] for i in range(len(x))]+[x[0:-i-1] for i in range(len(x))]  

print(*v(input("Enter a sentence: ")), sep="n")

This also works:

text = input("Enter a sentence: ")

v = [text[:i] for i in range(1, len(text)+1)]

print(*(v + v[::-1]), sep='n')

This is what it prints:

Enter something: test

t

te

tes

test

tes

te

t

Since the program is only a snippet, there's not much to talk about in terms of larger design choices, but there are a few things of note:

• 
  Inconsistency / non-identical programs: Your two programs are not identical: the first one produces the original word once, while the second version produces the ascending list and then the same list reversed; hence, the original word appears twice. This could be fixed by tweaking the first list to remove the last element, like v[:-1]. You can read more about list slices here; they're generally a useful tool.


• 
  

  Efficiency: Unless having the list for a later part of the program is important, it can be made more efficient by using iterators. Iterators can output a pattern's elements one-by-one without storing the entire pattern in memory. For a small program like this, it doesn't make any difference, but being aware of the technique is useful as the situations scale up. This SO answer explains the rationale of using iterators in a bit more detail. Using iterators, one could write:

  
  
  

  import itertools as it
  
  intext = input("Enter a sentence: ")
  
  for s in it.chain((intext[:i] for i in range(1, len(intext))),
  
                    (intext[:i] for i in range(len(intext), 0, -1))):
  
      print(s)
  
  

  
  
  

  Here, itertools (an extremely useful standard library, probably one of the most commonly used standard libraries), is used to chain two two iterators together so they are iterated one after another using the nicely named chain function. The mid-line indent is used to limit the line length, and complies with PEP 8's guidelines about indenting split lines.

  
  



• Other critiques: Concatenating two lists together is generally something to avoid if you can, because it's somewhat inefficient. Lambda functions should probably be used sparingly unless they offer a utility over functions in your particular situation. Unpacking argument lists is clever, but in this situation, it's probably more clear and efficient to just iterate through a for-loop as shown above.

If you want to learn more Python, I highly recommend starting to read through portions of the Python docs as they become relevant. They're generally very well-written and easy to understand. Reading Stack Overflow questions to find solutions to specific programming problems also helps, but the docs help fill in the gaps.