Review all the concepts, as trivial as they may appear. Each step has a purpose and we should be comfortable with our understanding of the role it plays.
pyg = 'ay'
Defining string constants and initializing other working variables is generally the best first step in a program. We also initialize the main working string in this step, so,
original = raw_input( ... )
is part of the initialization process.
When user inputs are present in the data, it is important that we validate it before proceeding further. We need to be sure we are not feeding illegal values to the program.
if len(orginal) > 0
tests the input for string length. This lets us avoid any empty strings. Cannot really process nothing,
tests that the string contains only letters, also important since even while this is a pseudo-language, it is still not gibberish.
word = original.lower()
preserves the original inputs and mutates the copy which is assigned to
word. In practice it is often necessary to preserve inputs, especially if our program is modifying the data. We can do whatever we wish with the copy.
The next steps are the final composition of the new word adapted to the Pyglatin language syntax.
first = word # a copy of the first letter
new_word = word + first + pyg # build the working string
To complete the process we take a slice of the new_word string that excludes the first letter:
new_word = new_word[1:len(new_word)]
The above shows explicitly that we are taking the entire string from the second letter onwards. The implicit slice will return the same...
new_word = new_word[1:]
but it is not as obvious until we are comfortable with the notation.
That's the review portion. Next comes the tinkering and experimentation. Work with the concepts, not the code alone. Stretch your understanding of each one by applying it in as many different test cases as you can dream up.
How many ways can we use length information?
Where else might we have need to test for letterness?
How well do we understand string manipulation and slicing?
And so on...