There is no do-while loop in Python.

This is a similar construct, taken from the link above.

 while True:
     do_something()
     if condition():
        break

REPEAT
    ...
UNTIL cond

Is equivalent to

while True:
    ...
    if cond:
        break

continue is a keyword that requires no arguments. It simply tells the current loop to continue immediately to the next iteration. It can be used inside of while and for loops.

Your code should then be placed within the while loop, which will keep going until the condition is met. Your condition syntax is not correct. It should read while response != 'exit':. Because you are using a condition, the continue statement is not needed. It will by design continue as long as the value is not "exit".

Your structure would then look like this:

response = ''
# this will loop until response is not "exit"
while response != 'exit':
    response = raw_input("foo")

If you wanted to make use of continue, it might be used if you were going to do other various operations on the response, and might need to stop early and try again. The break keyword is a similar way to act on the loop, but it instead says we should immediately end the loop completely. You might have some other condition that is a deal breaker:

while response != 'exit':
    response = raw_input("foo")

    # make various checks on the response value
    # obviously "exit" is less than 10 chars, but these
    # are just arbitrary examples
    if len(response) < 10:
        print "Must be greater than 10 characters!"
        continue  # this will try again 

    # otherwise
    # do more stuff here
    if response.isdigit():
        print "I hate numbers! Unacceptable! You are done."
        break

The equivalent is a while x1 != x2 loop.

Thus, your code becomes:

x = 10
lst = [] #Note: do not use list as a variable name, it shadows the built-in
while x != 0:
    lst.append(raw_input('Enter a word: '))
    x-=1

There is no do...while loop because there is no nice way to define one that fits in the statement: indented block pattern used by every other Python compound statement. As such proposals to add such syntax have never reached agreement.

Nor is there really any need to have such a construct, not when you can just do:

while True:
    # statement(s)
    if not condition:
        break

and have the exact same effect as a C do { .. } while condition loop.

See PEP 315 -- Enhanced While Loop:

Rejected [...] because no syntax emerged that could compete with the following form:

    while True:
        <setup code>
        if not <condition>:
            break
        <loop body>

A syntax alternative to the one proposed in the PEP was found for a basic do-while loop but it gained little support because the condition was at the top:

    do ... while <cond>:
        <loop body>

or, as Guido van Rossum put it:

Please reject the PEP. More variations along these lines won't make the language more elegant or easier to learn. They'd just save a few hasty folks some typing while making others who have to read/maintain their code wonder what it means.

I am not sure what you are trying to do. You can implement a do-while loop like this:

while True:
  stuff()
  if fail_condition:
    break

Or:

stuff()
while not fail_condition:
  stuff()

What are you doing trying to use a do while loop to print the stuff in the list? Why not just use:

for i in l:
  print i
print "done"

Update:

So do you have a list of lines? And you want to keep iterating through it? How about:

for s in l: 
  while True: 
    stuff() 
    # use a "break" instead of s = i.next()

Does that seem like something close to what you would want? With your code example, it would be:

for s in some_list:
  while True:
    if state is STATE_CODE:
      if "//" in s:
        tokens.add( TOKEN_COMMENT, s.split( "//" )[1] )
        state = STATE_COMMENT
      else :
        tokens.add( TOKEN_CODE, s )
    if state is STATE_COMMENT:
      if "//" in s:
        tokens.append( TOKEN_COMMENT, s.split( "//" )[1] )
        break # get next s
      else:
        state = STATE_CODE
        # re-evaluate same line
        # continues automatically

What you are doing is called "busy waiting". In order to do this without eating up CPU time, you should sleep for a short interval in each iteration of the loop:

while True:
  if first_number == second_number:
    do_something()
    break
  time.sleep(0.1)

Adjust the sleep interval as appropriate.

But there's likely a better way to accomplish what you want. How is first_number changing value if it's "out of your control"? Is your program receiving input? Reading from a socket? Are you sending a network request for data? Is this data shared among processes using multiprocessing's facilities?

Wouldn't a better way be to just use modulus.

>>> x = 2885
>>> y = 1440
>>> x%y
5
>>> 

Or still using loops

>>> x = 2885
>>> y = 1440
>>> while x >= y :
...     x = x - y
... 
>>> x
5
>>>

Instead, you can use a while loop. What I mean here is you can simply:

principal = float(input("How much money to start? :"))
apr = float(input("What is the apr? :"))
amount = float(input("What is the amount you want to get to? :"))


def interestCalculator():
    global principal
    i = 1

    if principal > amount:
        print("Can't calculate interest. Error: Amount is less than principal")

    while principal < amount:
        principal = principal + principal*apr
        print("After year " + str (i)+" the account is at " + str(principal))
        if principal > amount:
            print("It would take" + str(year) + " years to reach your goal!")
        i += 1


interestCalculator()