Чтение определенных строк только

Если Вы хотите считать определенные строки, такие как строка, запускающаяся после некоторой пороговой строки затем, можно использовать следующие коды, file = open("files.txt","r") lines = file.readlines() ## convert to list of lines datas = lines[11:] ## raed the specific lines

f = open(filename, 'r')
totalLines = len(f.readlines())
f.close()
f = open(filename, 'r')

lineno = 1
while lineno < totalLines:
    line = f.readline()

    if lineno == 26:
        doLine26Commmand(line)

    elif lineno == 30:
        doLine30Commmand(line)

    lineno += 1
f.close()

Файловые объекты имеют метод .Readlines (), который даст вам список содержимого файла, одну строку в элемент списка. После этого вы можете просто использовать методы нарезки обычного списка.

http://docs.cython.org/library/stdtypes.html#file.Readlines

• Установка большого innodb_buffer_pool_size (2GB или более)
• предварительно обновит старые файлы данных/индексов myisam с помощью команд оболочки
• innodb_log_file_size (256 МБ)
• Изменение таблицы в X параллельных потоках, где X - количество ядер ЦП на сервере
• другие незначительные сдвиги только для преобразования (innodb_doublewrite=0, innodb_flush_log_at_trx_commit=0)

Установка innodb_buffer_pool_size как можно выше является типичным способом ускорения создания таблиц innodb - ваш набор данных выглядит так, будто он может поместиться в буферный пул 2GB innodb, поэтому любой достойный 64-битный сервер должен это позволить. alter table type = innodb также быстрее решения dump + reimport и легко выполняется параллельно.

Также убедитесь, что вы увеличили innodb_log_file_size со значения по умолчанию 5Mb до 128 или 256MB. Осторожно с этим, и ему нужно чистое отключение + стирание старого ib_logfile*.

Если ваш сервер имеет что-то вроде 8GB ram, и что вы используете 64-битную версию mysql, я бы предложил 2GB innodb_buffer_pool, и вы даже можете предварительно подготовить старые файлы MYD и MYI перед закрытием для простоя, так что они будут в кэше страниц ОС, когда начнется реальная работа.

Если вы также идете на незначительные изменения, пожалуйста, имейте в виду, что вам нужно отменить их после преобразования (другое небольшое время простоя), чтобы ваши данные были безопасны, я сомневаюсь, что они того стоит для такого небольшого набора данных, хотя.

Удачи.

Если вы не возражаете против импорта, то файл делает именно то, что вам нужно (это вы можете прочитать номер строки текущей строки)

Как насчет этого:

>>> with open('a', 'r') as fin: lines = fin.readlines()
>>> for i, line in enumerate(lines):
      if i > 30: break
      if i == 26: dox()
      if i == 30: doy()

def getitems(iterable, items):
  items = list(items) # get a list from any iterable and make our own copy
                      # since we modify it
  if items:
    items.sort()
    for n, v in enumerate(iterable):
      if n == items[0]:
        yield v
        items.pop(0)
        if not items:
          break

print list(getitems(open("/usr/share/dict/words"), [25, 29]))
# ['Abelson\n', 'Abernathy\n']
# note that index 25 is the 26th item

Я предпочитаю этот подход, потому что это более общего назначения, то есть вы можете использовать его в файле, на результате F.Readlines () , на A Stringio Объект, что угодно:

def read_specific_lines(file, lines_to_read):
   """file is any iterable; lines_to_read is an iterable containing int values"""
   lines = set(lines_to_read)
   last = max(lines)
   for n, line in enumerate(file):
      if n + 1 in lines:
          yield line
      if n + 1 > last:
          return

>>> with open(r'c:\temp\words.txt') as f:
        [s for s in read_specific_lines(f, [1, 2, 3, 1000])]
['A\n', 'a\n', 'aa\n', 'accordant\n']

Вы можете сделать SEECH () вызов () . Это не поможет вам, если вы точно не знаете, сколько байтов (символов) записываются в файл до линии, которую вы хотите прочитать. Возможно, ваш файл строго отформатирован (каждая строка х количество байтов?) Или, вы можете подсчитать количество персонажей самостоятельно (не забудьте включить невидимые символы, такие как линейные разрывы), если вы действительно хотите повысить скорость.

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

Вот мои маленькие 2 цента, для чего это стоит;)

def indexLines(filename, lines=[2,4,6,8,10,12,3,5,7,1]):
    fp   = open(filename, "r")
    src  = fp.readlines()
    data = [(index, line) for index, line in enumerate(src) if index in lines]
    fp.close()
    return data


# Usage below
filename = "C:\\Your\\Path\\And\\Filename.txt"
for line in indexLines(filename): # using default list, specify your own list of lines otherwise
    print "Line: %s\nData: %s\n" % (line[0], line[1])

Быстрым и компактным подходом может быть:

def picklines(thefile, whatlines):
  return [x for i, x in enumerate(thefile) if i in whatlines]

он принимает любой открытый файл-подобный объект файл (оставляя на усмотрение вызывающего абонента, должен ли он быть открыт из дискового файла, или через сокет, или другой файл-подобный поток) и набор нулевых линейных индексов какие строки , и возвращает список, с небольшой занимаемой памятью и разумной скоростью. Если количество возвращаемых строк огромно, вы можете предпочесть генератор:

def yieldlines(thefile, whatlines):
  return (x for i, x in enumerate(thefile) if i in whatlines)

, который, по сути, хорош только для того, чтобы на него наезжать -- заметьте, что единственная разница заключается в том, что в выражении return используются округлые, а не квадратные скобки, что делает понятным список и выражение-генератор, соответственно.

Далее обратите внимание, что, несмотря на упоминание "строк" и "файла", эти функции гораздо, гораздо более общие -- они будут работать над любым итерабельным, будь то открытый файл или любой другой, возвращая список (или генератор) элементов на основе их прогрессивных нумераций элементов. Поэтому я бы предложил использовать более подходящие общие имена;-).

@OP, вы можете использовать перечисление

for n,line in enumerate(open("file")):
    if n+1 in [26,30]: # or n in [25,29] 
       print line.rstrip()

Быстрый ответ:

f=open('filename')
lines=f.readlines()
print lines[25]
print lines[29]

или:

lines=[25, 29]
i=0
f=open('filename')
for line in f:
    if i in lines:
        print i
    i+=1

Есть более элегантное решение для извлечения многих линий: Linecache (предоставлена ​​ Python: как Чтобы перейти к определенной линии в огромном текстовом файле? », предыдущий вопрос Stackoverflow.com).

цитируют документацию Python, связанную выше:

>>> import linecache
>>> linecache.getline('/etc/passwd', 4)
'sys:x:3:3:sys:/dev:/bin/sh\n'

Измените 4 на желаемый номер строки, и вы включены. Обратите внимание, что 4 принесет пятую строку, поскольку счет на основе нуля.

Если файл может быть очень большим, и вызвать проблемы при чтении в память, может возникла хорошая идея, чтобы взять @ Alok, совет и используйте перечисление () .

Для заключения:

• Использование FileObject.Readlines () или для линии в FileObject в качестве быстрого решения для небольших файлов.
• Использование Linecache для более элегантного решения, которое будет довольно быстро для чтения многих файлов, возможно, возможен несколько раз.
• Возьмите @ ALOK совет и используйте перечисление () для файлов, которые могут быть очень большими и не помещаются в память. Обратите внимание, что использование этого метода может медленно медленно, потому что файл прочитан последовательно.