Поиск определенного блока кода в тексте

Предположим, что ваши «блоки» кода разделены заголовками (например, *header). Самый интуитивно понятный способ хранения данных в каждом блоке — это список списков. например [ row1, row2, ...] (где row1=[elem1,elem2,elem3,...]). Затем вы можете сохранить блок в словаре, чтобы получить доступ к блоку через block=dictionary['headername'].

Это сделает что-то вроде того, что вы хотите (эта версия не тестировалась).

import sys

def convert_type(ss):
    try:
        return int(ss)
    except ValueError:
        try:
            return float(ss)
        except ValueError:
            return ss

def parse_file(ff):
    out={}
    block=None
    for i,line in enumerate(ff):
        #Allow for comments to start with '#'.  We break off anything after a '#'
        #and ignore it.  After that, we 
        data=line.split('#',1)
        line=data[0]  #comments (if in line) are in data[1] ... ignore those.
        line=line.strip() #remove whitespace from front and back of line.
        if(line.startswith('*')):
            #python supports multiple assignment.  
            #e.g. out['header'] is the same object as block.  
            #     changing block also changes out['header']
            block=out[line.strip()[1:]]=[]
        elif (block is not None) and line: #checks to make sure there is an active block and the line wasn't empty.
            #If the file could also have floats, you should use float instead of int
            #We also put the parsing in a try/except block.  If parsing fails (e.g. a
            #element can't be converted to a float, you'll know it and you'll know the
            #line which caused the problem.)
            try:
                #block.append(map(int,line.split()))
                block.append(map(convert_type,line.split()))  
            except Exception:
                sys.stderr.write("Parsing datafile choked on line %d '%s'\n"%(i+1,line.rstrip()))
                raise
    return out

with open('textfile.txt','r') as f:
    data_dict=parse_file(f)

#get information from '*load' block:
info=data_dict['load']
for row in info:
    a,b,c=row
    ##same as:
    #a=row[0]
    #b=row[1]
    #c=row[2]
    ##as long as row only has 3 elements.

    #Do something with that particular row. 
    #(each row in the 'load' block will be visited once in this loop)

#get info from stiffness block:
info=data_dict['stiffness']
for row in info:
    pass #Do something with this particular row.

Обратите внимание: если вам гарантировано, что каждая строка в файле данных под определенным заголовком имеет одинаковое количество записей, вы можете думать о переменной info как о двумерной строке, которая индексируется как element=info[row_number][column_number], но вы также можете получить всю строку на row=info[row_number]

Возможно что-то вроде этого:

line = filename.readline()
if line.find("*load") == 0:
    line = filename.readline()
    while line != "\n" and line != "":
        vars = line.split(" ")

vars — это просто пример хранения значений, которые будут ['2', '7', '200'] после запуска этого кода (поэтому вам нужно будет преобразовать их в числа с плавающей запятой или целые числа). Затем вы можете добавить их в массив или переименовать по мере необходимости.

РЕДАКТИРОВАТЬ: Рабочая программа, полученная из вышеизложенного.

filename = open("fff.txt", 'r')
values = {}

line = filename.readline()
while line:
    while line.find("*") != 0:
        line = filename.readline()

    sectionheader = line.strip()[1:]
    values[sectionheader] = []
    line = filename.readline()
    while line != "\n" and line != "":
        vals = [float(i) for i in line.split(" ")]
        values[sectionheader].append(vals)
        line = filename.readline()

print values

Хотя я не могу помочь вам с синтаксисом, вероятно, лучше всего использовать самовызов.

Напишите функцию, которая определяет нужную строку и сохраняет смещение в байтах. Затем заставьте эту функцию вызывать себя, чтобы найти следующую строку (чтобы завершить операцию), также сохраните ее смещение и сравните с ранее сохраненным значением.

Теперь у вас достаточно данных, чтобы определить, какие байты нужно изменить.

Однако самовызывающиеся функции весьма эффективны при правильном использовании, они повышают производительность и просты в повторном использовании.

В php я создал стримрайтер, похожий на тот, что в .net, который работает таким образом. Поэтому я знаю, что теория работает, однако, похоже, это питон.

К сожалению, я недостаточно знаю этот язык. Однако удачи вашему проекту!

Вот что я сделал из вашего кода:

import sys
from Tkinter import *
import tkFileDialog
from tkFileDialog import askopenfile # Open dialog box


fen1 = Tk()                              # Create window
fen1.title("Optimisation")               # Window title

menu1 = Menu(fen1)

def do_open(interesting_parts=[]):
    thefile = askopenfile(filetypes=[("Text files","*.txt")], mode='r')

    data = {} # Create a dictionary to store all the data stored per part name
    part = None
    for line in thefile:
        if line.startswith("*"):
            # A * in the beginning signals a new "part"
            # And another one means the end.
            part = line[1:] # Remove the * in the beginning via slicing to get the name without it.
            if part in interesting_parts:
                data[part] = [] # Create a list inside the dictionary, so that you can add data to it later.
                # Only do this if we are interested in storing anything for this part
        elif part in interesting_parts:
            # Add an a condition to check if the part name is in the list of "parts" you are interested in having.
            line_data = get_something_from_this(part, line) # just a function that returns something based on the line and the part
            if line_data is not None: # Ignore it if it's None (just an option, as there might be newlines that you want to ignore)
                data[part].append(line_data)

    # Here, we return the dictionary to act on it.
    return data

def get_something_from_this(part, line):
    try:
        ints = [int(p) for p in line.split()]
    except ValueError:
        print "Ignoring Line", repr(line), "in", part
        return None # We don't care about this line!
    else:
        print "in", part, ints
        return ints # Store this line's data

data = do_open(["test", "egg"]) # Pass as an argument a list of the interesting "parts"

print data # this is a dictionary

# How do you access it?
print data["test"] # to get all the lines' data in a list
print data["egg"][0] # to get the first line of the data

for part, datalines in data.iterkeys():
    print part, datalines # datalines is the list of all the data, part is the dictionary's key which is the part name
    # Remember data[part] = ... <- Here part is the key.

fen1.mainloop()

1. Не называйте переменную имя файла, если это не "имя файла", а "файл".
2. Вы можете использовать цикл for, чтобы перебирать строки одну за другой.
3. Используйте split, чтобы разделить строку
4. Используйте openswith, чтобы узнать, начинается ли строка с другой строки.
5. Следите за тем, находитесь ли вы в части «*load» переменной.

ОБНОВЛЕНИЕ: не используйте open в качестве имени функции, оно уже есть во встроенных функциях Python. Кроме того, чтобы не анализировать строки *load и *stiffness, я немного изменил код: разбор каждой строки выполняется в операторе elif.

ОБНОВЛЕНИЕ 2:

Обновлен код в соответствии с потребностями OP. Проверено с этим файлом:

*test
1 2 3

*load
2 7 200
3 7 150

*stiffness
2 9 8

*egg
1 2 3
2 4 6

*plant
23 45 78

ОБНОВЛЕНИЕ 3: много комментариев :)

что-то вроде этого должно делать

data=[]
check=false
for i in fid:
    if line.find("*load"):
        check=true
    if check==true and not line.find("*stiffness"):
        line=split(i)
        data.append(map(lambda x: float(x), line))
    if line.find("*stiffness"):
        break

fid.close()
for i in data:
    a=i[0]
    b=i[1]
    c=i[2]

примите это как код как грубое предложение... (я думаю, что исключение теперь исправлено, ну, если нет, мне все равно...)