files are iterators (unlike lists) so you can just make a second for loop:

with open(inputfile, 'r') as infile:
    for line in infile:
        if line.startswith(">"):
            print line, # comma on the end prevents the double spacing from printing a file line
            for line in infile:
                print line,
                if line.startswith(">"):
                    break # stop this inner for loop; outer loop picks up on the next line

Edit: I get the feeling I don't understand your problem. Can you show some example data and what you want out?

The built-in str.partition() method will do this for you. Unlike str.split() it won't bother to cut the rest of the str into different strs.

text = raw_input("Type something:")
left_text = text.partition("!")[0]

Explanation

str.partition() returns a 3-tuple containing the beginning, separator, and end of the string. The [0] gets the first item which is all you want in this case. Eg.:

"wolfdo65gtornado!salmontiger223".partition("!")

returns

('wolfdo65gtornado', '!', 'salmontiger223')

This is pretty straight forward, you can terminate a loop early with a break statement.

filename = 'somefile.txt'

with open(filename, 'r') as input:
   for line in input:
       if 'indicator' in line:
            break

Using with creates a compound statement that ensures that upon entering and leaving the scope of the with statement __enter__() and __exit__() will be called respectively. For the purpose of file reading this will prevent any dangling filehandles.

The break statement tells the loop to terminate immediately.

The easiest way would be to read the file in as a single string and then split it across your separator:

with open('myFileName') as myFile:
  text = myFile.read()
result = text.split(separator)  # use your \-1 (whatever that means) here

In case your file is very large, holding the complete contents in memory as a single string for using .split() is maybe not desirable (and then holding the complete contents in the list after the split is probably also not desirable). Then you could read it in chunks:

def each_chunk(stream, separator):
  buffer = ''
  while True:  # until EOF
    chunk = stream.read(CHUNK_SIZE)  # I propose 4096 or so
    if not chunk:  # EOF?
      yield buffer
      break
    buffer += chunk
    while True:  # until no separator is found
      try:
        part, buffer = buffer.split(separator, 1)
      except ValueError:
        break
      else:
        yield part

with open('myFileName') as myFile:
  for chunk in each_chunk(myFile, separator='\\-1\n'):
    print(chunk)  # not holding in memory, but printing chunk by chunk

Read line by line. Use #main as a flag to start processing. Use #extra as a flag to stop processing.

start = '#main'
end = '#extra'
numbers = []
file_handler = open('read_up_to_a_point.txt')
started = False
for line in file_handler:
    if end in line:
        started = False       
    if started:
        numbers.append(line.strip())
    if start in line:
        started = True
file_handler.close()
print numbers

sample output

python read_up_to_a_point.py ['60258960', '33031674', '72302403']

useful = []
with open ("Report.txt", "r") as myfile:
    for line in myfile:
        if "===" in line:
            break
    for line in myfile:
        useful.append(line)
a_string = "".join(useful)

I would however prefer to hide it away in a generator, like this:

def report_iterator():
    with open ("Report.txt", "r") as myfile:
        for line in myfile:
            if "===" in line:
                break
        for line in myfile:
            yield line

for line in report_iterator():
    # do stuff with line

All the filtering and nitpicking is done in the generator function, and you can separate the logic of "filtering input" from the logic of "working with the input".

You need to use a byte string as the pattern in your regex, something like the following should work:

if re.search(b"enum " + enum_name.encode('utf-8'), line):
    ...

The enum_name.encode('utf-8') here is used to convert the user input to a bytes object, depending on your environment you may need to use a difference encoding.

Note that if your regex is really this simple, then you can probably just use a substring search instead.

Look at the docs. Read until wants the expected string as a positional argument and an optional timeout. I would do it like this:

>>> try:
...     response = tn.read_until(">", timeout=120) #or whatever timeout you choose.
... except EOFError as e:
...     print "Connection closed: %s" % e

>>> if ">" in response:
...    action1
... else:
...    action2

If you want multiple different characters you can use read_some()

>>> while True: #really you should set some sort of a timeout here.
...    r = tn.read_some()
...    if any(x in r for x in ["#", ">"]):
...        break

StockSearch = input("Search For Product (Name Or Code):\n")
found = False
with io.open('/home/jake/Projects/Stock','r', encoding='utf8') as f:
    for line in f:
        line = line.rstrip('\n')
        if StockSearch == line:      
            print(line)
            found = True
            break
if not found:
    print("Nothing found")

If you simply want the block of text between Start and End, you can do something simple like:

with open('test.txt') as input_data:
    # Skips text before the beginning of the interesting block:
    for line in input_data:
        if line.strip() == 'Start':  # Or whatever test is needed
            break
    # Reads text until the end of the block:
    for line in input_data:  # This keeps reading the file
        if line.strip() == 'End':
            break
        print line  # Line is extracted (or block_of_lines.append(line), etc.)

In fact, you do not need to manipulate line numbers in order to read the data between the Start and End markers.

The logic ("read until…") is repeated in both blocks, but it is quite clear and efficient (other methods typically involve checking some state [before block/within block/end of block reached], which incurs a time penalty).