Gnu readline

Текстовые файлы

Последнее обновление: 21.06.2017

Запись в текстовый файл

Чтобы открыть текстовый файл на запись, необходимо применить режим w (перезапись) или a (дозапись). Затем для записи применяется метод write(str), в который передается записываемая строка. Стоит отметить, что записывается именно строка, поэтому, если нужно записать числа, данные других типов, то их предварительно нужно конвертировать в строку.

Запишем некоторую информацию в файл «hello.txt»:


with open("hello.txt", "w") as file:
    file.write("hello world")

Если мы откроем папку, в которой находится текущий скрипт Python, то увидем там файл hello.txt. Этот файл можно открыть в любом текстовом редакторе и при желании изменить.

Теперь дозапишем в этот файл еще одну строку:

with open("hello.txt", "a") as file:
    file.write("\ngood bye, world")

Дозапись выглядит как добавление строку к последнему символу в файле, поэтому, если необходимо сделать запись с новой строки, то можно использовать эскейп-последовательность «\n». В итоге файл hello.txt будет иметь следующее содержимое:

hello world
good bye, world

Еще один способ записи в файл представляет стандартный метод print(), который применяется для вывода данных на консоль:

with open("hello.txt", "a") as hello_file:
    print("Hello, world", file=hello_file)

Для вывода данных в файл в метод print в качестве второго параметра передается название файла через параметр file. А первый параметр представляет записываемую в файл строку.

Чтение файла

Для чтения файла он открывается с режимом r (Read), и затем мы можем считать его содержимое различными методами:

  • readline(): считывает одну строку из файла

  • read(): считывает все содержимое файла в одну строку

  • readlines(): считывает все строки файла в список

Например, считаем выше записанный файл построчно:

with open("hello.txt", "r") as file:
    for line in file:
        print(line, end="")

Несмотря на то, что мы явно не применяем метод для чтения каждой строки, но в при переборе файла этот метод автоматически вызывается для получения каждой новой строки. Поэтому в цикле вручную нет смысла вызывать метод readline. И поскольку строки разделяются символом перевода строки «\n», то чтобы исключить излишнего переноса на другую строку в функцию print передается значение .

Теперь явным образом вызовем метод для чтения отдельных строк:

with open("hello.txt", "r") as file:
    str1 = file.readline()
    print(str1, end="")
    str2 = file.readline()
    print(str2)

Консольный вывод:

hello world
good bye, world

Метод readline можно использовать для построчного считывания файла в цикле while:

with open("hello.txt", "r") as file:
    line = file.readline()
    while line:
        print(line, end="")
        line = file.readline()

Если файл небольшой, то его можно разом считать с помощью метода read():

with open("hello.txt", "r") as file:
    content = file.read()
    print(content)

И также применим метод readlines() для считывания всего файла в список строк:

with open("hello.txt", "r") as file:
    contents = file.readlines()
    str1 = contents
    str2 = contents
    print(str1, end="")
    print(str2)

При чтении файла мы можем столкнуться с тем, что его кодировка не совпадает с ASCII. В этом случае мы явным образом можем указать кодировку с помощью параметра encoding:

filename = "hello.txt"
with open(filename, encoding="utf8") as file:
    text = file.read()

Теперь напишем небольшой скрипт, в котором будет записывать введенный пользователем массив строк и считывать его обратно из файла на консоль:

# имя файла
FILENAME = "messages.txt"
# определяем пустой список
messages = list()

for i in range(4):
    message = input("Введите строку " + str(i+1) + ": ")
    messages.append(message + "\n")

# запись списка в файл
with open(FILENAME, "a") as file:
    for message in messages:
        file.write(message)

# считываем сообщения из файла
print("Считанные сообщения")
with open(FILENAME, "r") as file:
    for message in file:
        print(message, end="")

Пример работы программы:

Введите строку 1: hello
Введите строку 2: world peace
Введите строку 3: great job
Введите строку 4: Python
Считанные сообщения
hello
world peace
great job
Python

НазадВперед

New answers tagged readlines

The solution, as commented by hpaulj, is to use np.load rather than read or readlines. import numpy as np

mylist =

np.save(‘mylist’, mylist)

with open(‘mylist.npy’) as last: lst = np.load(lst, allow_pickle = True) print(lst)

answered Aug 12 at 17:22 Sam Spedding 10133 bronze badges

I would make use of the Array.filter() function. Basically, you call filter() on an array, and define a callback function that checks every item of that array. If the checking function returns true for a particular item, keep that item — put it in a new array If the checking function returns false, do not put the item in the new array So, in your case, once …

answered Aug 8 at 3:36 William Mizzi 7266 bronze badges

You can store all of the points from line 3 and beyond in a list of lists. You just need to replace: # parse remaining lines . . . # having trouble here… . . .

with: line = list() points = list()

for i in range(2,len(data)): line.extend(data.split())

points = for x in range(0, len(line),3)]

or if you want to store each of them as …

answered Aug 8 at 0:26 nerm 6633 bronze badges

def regular_line_parse(data, line_number): line_index = line_number — 1 scope_data = data line_parts = scope_data.split() cluster_size = len(line_parts) / 3

X, Y, PEN = [], [], [] for i in range(cluster_size): X.append(float(line_parts)) Y.append(float(line_parts)) PEN.append(…

answered Aug 8 at 0:26 Hesam Korki 14166 bronze badges

1

Try this: import csv import re

with open(‘file.csv’, ‘r’) as csv_file: csv_reader = csv.reader(csv_file)

ff = [] for line in csv_reader: ff.append( ).group(1),re.search(‘modelno=»(.+?)»‘, line ).group(1),re.search(‘qtyavail=»(.+?)»‘, line ).group(1)]) df = pd….

answered Aug 7 at 0:36 Marios 3,15811 gold badge77 silver badges2525 bronze badges

Use print(line) to select custom cell.

answered Aug 7 at 0:29 osmanraifgunes 1,27911 gold badge1515 silver badges3636 bronze badges

The problem with your code is the creation of the tokens dictionary — you loop ofer the tokens but you alway overwrite the value mapped to the «Token» key. Moreover there are a few bad practices in you code.

please be careful with the inline opening of files like you did file_lines = open(«tokens.txt», «r»).readlines() Rather …

answered Jul 25 at 14:15 Marvin Taschenberger 52766 silver badges1717 bronze badges

In your case tokens = {«Token»: <last_token>} Modify your code like this so that for each token one request can be sent. tokens = set() »’ <- You can use list also but in this case set is better as it will ensure only one request for one token even if your tokens file contains duplicate line. »’ url_list = [ «https://www….

answered Jul 25 at 14:00 Kaushal 87111 gold badge88 silver badges1919 bronze badges

You are doing data = tokens and at that point tokens is the assignment from the last line. If you want all tokens, you need to do something likej: tokens = set() for line file_lines: tokens.add(……)

answered Jul 25 at 13:54 Anthon 44.8k1919 gold badges135135 silver badges191191 bronze badges

I do not know..

so, I did it using the TdmsFile.open() command. Then an error occurred

answered Jul 24 at 7:09 Okgukui 1322 bronze badges

Here you go =^..^= from nptdms import TdmsFile import pandas as pd

# load file tdms_file = TdmsFile(‘20200609_130131.69.tdms’) # show groups groups_data = tdms_file.groups() print(groups_data) # show channels channels_data = tdms_file.channels() print(channels_data) # show data in channel selected_data = tdms_file …

answered Jul 24 at 6:48 Zaraki Kenpachi 3,92011 gold badge55 silver badges2323 bronze badges

So the error is because of that extra dot in the number that means it is not a valid float. If that extra dot was there by mistake, and you wanted to remove it, you could use: index = y.find(‘.’, 2) // find if there is a ‘.’ in the string, at a position greater than 2

if(index != -1): // if there is a ‘.’ found (find() returns -1 if the character is not …

answered Jul 23 at 16:21 ACarter 4,50077 gold badges3535 silver badges4747 bronze badges

You’ve correctly identified what’s going wrong. 0.130.0980224609375 confuses Python, and would confuse most humans as well. Does it mean 0.13009…? Does it mean 0.130? Is it 2 decimal numbers? Is it an ip address? Python doesn’t do much thinking, just shrugs its shoulders and quits. This code will assume you mean one decimal. def clean(s): while s.count(…

answered Jul 23 at 16:20 JimmyCarlos 1,68111 gold badge88 silver badges2222 bronze badges

Top 50 recent answers are included

Complex problem (Regular Grammar)

Now we must address the more complex issue of a Regular Grammar. This time we will take into account for the fact that we may have a tree of commands, as if several verbs, several objects specific to each verb. I am restricting this example to grammars represented by acyclic graphcs (so it is not truely a regular grammar, but this is also just an example).

For this example, we will auto-complete an interface for a silly game (I am saving all the applicable examples for real problems). We are in control of a military base that can build structures, train infantry and research technology. This simple example has a small number of cases, but it will illustrate the point.

So a few example commands would be:

  • train riflemen
  • build generator
  • research armor

However, it would be incorrect to say:

  • research barracks
  • train generator
  • build food

Now we need a data structure to hold this simple language of ours. Ideally (and maybe in a later article) we would setup a regex engine to deal with this sort of grammar, and we would use a full table to act as an finite automata to process the string so far. However, for the sake of simple practicality, we will just use a bunch of nested python dictionaries.

{ ‘build’: { ‘barracks’:None, ‘generator’:None, ‘lab’:None }, ‘train’: { ‘riflemen’:None, ‘rpg’:None, ‘mortar’:None }, ‘research’: { ‘armor’:None, ‘weapons’:None, ‘food’:None } }

So we have used Python Dictionaries to build a simple tree structure. We can traverse this tree using simple recusive decent.

psuedocode for a traversal function:
if no leaf provided
    no possible completions
if end of path
    search this branch for completion
if path incomplete
    continue walking tree

The complete code is structured as follows. The class ARLCompleter is short for Acyclic Regular Language Completer. It takes the dictionary tree described above as its constructor parameter. Internally it defines the complete function which does some book keeping, then calls the recusrive function traverse.

ex4.py:

#!/usr/bin/python

import readline
readline.parse_and_bind("tab: complete")

class ARLCompleter:
    def __init__(self,logic):
        self.logic = logic

    def traverse(self,tokens,tree):
        if tree is None:
            return []
        elif len(tokens) == 0:
            return []
        if len(tokens) == 1:
            return )]
        else:
            if tokens in tree.keys():
                return self.traverse(tokens,tree])
            else:
                return []
        return []

    def complete(self,text,state):
        try:
            tokens = readline.get_line_buffer().split()
            if not tokens or readline.get_line_buffer() == ' ':
                tokens.append()
            results = self.traverse(tokens,self.logic) + 
            return results
        except Exception,e:
            print e

logic = {
    'build':
            {
            'barracks':None,
            'bar':None,
            'generator':None,
            'lab':None
            },
    'train':
            {
            'riflemen':None,
            'rpg':None,
            'mortar':None
            },
    'research':
            {
            'armor':None,
            'weapons':None,
            'food':None
            }
    }

completer = ARLCompleter(logic)
readline.set_completer(completer.complete)

line = raw_input('prompt> ')

This is a very powerful design, since any change to the dictionary tree will immedialy work, no matter the depth of the tree, and no mater the relationships. This is sufficient for most all usual control systems. All future examples are really overkill for most all real world scenarios.

Simple FSAs

This simple tree structure really provides almost all functionality we will ever need. But just in case, I will try to keep on going with the examples. If nothing else, this will provide examples of how to handle complex grammars for simple tasks in python.

Работа с файлами в языке Си

Для программиста открытый файл представляется как последовательность считываемых или записываемых данных. При открытии файла с ним связывается поток ввода-вывода. Выводимая информация записывается в поток, вводимая информация считывается из потока. Когда поток открывается для ввода-вывода, он связывается со стандартной структурой типа FILE, которая определена в stdio.h. Структура FILE содержит необходимую информацию о файле. Открытие файла осуществляется с помощью функции fopen(), которая возвращает указатель на структуру типа FILE, который можно использовать для последующих операций с файлом.

  FILE *fopen(name, type);

nametype

  • «r» — открыть файл для чтения (файл должен существовать);
  • «w» — открыть пустой файл для записи; если файл существует, то его содержимое теряется;
  • «a» — открыть файл для записи в конец (для добавления); файл создается, если он не существует;
  • «r+» — открыть файл для чтения и записи (файл должен существовать);
  • «w+» — открыть пустой файл для чтения и записи; если файл существует, то его содержимое теряется;
  • «a+» — открыть файл для чтения и дополнения, если файл не существует, то он создаётся.

  Возвращаемое значение — указатель на открытый поток. Если обнаружена ошибка, то возвращается значение NULL. Функция fclose() закрывает поток или потоки, связанные с открытыми при помощи функции fopen() файлами. Закрываемый поток определяется аргументом функции fclose(). Возвращаемое значение: значение 0, если поток успешно закрыт; константа EOF, если произошла ошибка.

12345678910111213141516

#include <stdio.h>int main() {  FILE *fp;  char name[] = «my.txt»;  if ((fp = fopen(name, «r»)) == NULL)  {    printf(«Не удалось открыть файл»);    getchar();    return 0;  }  // открыть файл удалось  …      // требуемые действия над данными  fclose(fp);  getchar();  return 0;}

Чтение символа из файла

char fgetc(поток);

FILEEOFЗапись символа в файл

  fputc(символ,поток);

Аргументами функции являются символ и указатель на поток типа FILE. Функция возвращает код считанного символа. Функции fscanf() и fprintf() аналогичны функциям scanf() и printf(), но работают с файлами данных, и имеют первый аргумент — указатель на файл.

  fscanf(поток, «ФорматВвода», аргументы);

  fprintf(поток, «ФорматВывода», аргументы);

Функции fgets() и fputs() предназначены для ввода-вывода строк, они являются аналогами функций gets() и puts() для работы с файлами.

  fgets(УказательНаСтроку, КоличествоСимволов, поток);

Символы читаются из потока до тех пор, пока не будет прочитан символ новой строки ‘\n’, который включается в строку, или пока не наступит конец потока EOF или не будет прочитано максимальное количество символов. Результат помещается в указатель на строку и заканчивается нуль- символом ‘\0’. Функция возвращает адрес строки.

  fputs(УказательНаСтроку,поток);

Копирует строку в поток с текущей позиции. Завершающий нуль- символ не копируется.Пример Ввести число и сохранить его в файле s1.txt. Считать число из файла s1.txt, увеличить его на 3 и сохранить в файле s2.txt.

12345678910111213141516171819202122

#include <stdio.h>#include <stdlib.h>int main(){  FILE *S1, *S2;  int x, y;  system(«chcp 1251»);  system(«cls»);  printf(«Введите число : «);  scanf(«%d», &x);  S1 = fopen(«S1.txt», «w»);  fprintf(S1, «%d», x);  fclose(S1);  S1 = fopen(«S1.txt», «r»);  S2 = fopen(«S2.txt», «w»);  fscanf(S1, «%d», &y);  y += 3;  fclose(S1);  fprintf(S2, «%d\n», y);  fclose(S2);  return 0;}

Результат выполнения — 2 файла Работа с файлами в C++ описана здесь.

Язык Си

Designing a Completer class

Lets re-do the last example but we want to pack it into a class so we can extend its functionality more easily. We want a class which has its volcabulary or logic setup by the constructor. After that, we can make good use of pythons first class functions, and pass the complete function defined inside of the class, without losing access to our class object.

stub:

class VolcabCompleter:

def __init__(self,volcab): … def complete(self,text,state): …

So now lets fill in that stub. ex3.1.py

#!/usr/bin/python

import readline
readline.parse_and_bind("tab: complete")

class VolcabCompleter:
    def __init__(self,volcab):
        self.volcab = volcab

    def complete(self,text,state):
        results =   + 
        return results

words = 
completer = VolcabCompleter(words)

readline.set_completer(completer.complete)

line = raw_input('prompt> ')

Alternatively, one could use closures and nested functions to reduce the total code length, but that will make your code much harder to understand for future users of your code.

Открытие и закрытие файлов

До этого при вводе-выводе данных мы работали со стандартными потоками — клавиатурой и монитором. Теперь рассмотрим, как в языке C реализовано получение данных из файлов и запись их туда. Перед тем как выполнять эти операции, надо открыть файл и получить доступ к нему.

В языке программирования C указатель на файл имеет тип FILE и его объявление выглядит так:

С другой стороны, функция  открывает файл по указанному в качестве первого аргумента адресу в режиме чтения («r»), записи («w») или добавления («a») и возвращает в программу указатель на него. Поэтому процесс открытия файла и подключения его к программе выглядит примерно так:


При чтении или записи данных в файл обращение к нему осуществляется посредством файлового указателя (в данном случае, myfile).

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

Объявление функции  содержится в заголовочном файле stdio.h, поэтому требуется его подключение. Также в stdio.h объявлен тип-структура FILE.

После того, как работа с файлом закончена, принято его закрывать, чтобы освободить буфер от данных и по другим причинам

Это особенно важно, если после работы с файлом программа продолжает выполняться. Разрыв связи между внешним файлом и указателем на него из программы выполняется с помощью функции 

В качестве параметра ей передается указатель на файл:

В программе может быть открыт не один файл. В таком случае каждый файл должен быть связан со своим файловым указателем. Однако если программа сначала работает с одним файлом, потом закрывает его, то указатель можно использовать для открытия второго файла.

The open Function

Before you can read or write a file, you have to open it using Python’s built-in open() function. This function creates a file object, which would be utilized to call other support methods associated with it.

Syntax

file object = open(file_name )

Here are parameter details −

  • file_name − The file_name argument is a string value that contains the name of the file that you want to access.

  • access_mode − The access_mode determines the mode in which the file has to be opened, i.e., read, write, append, etc. A complete list of possible values is given below in the table. This is optional parameter and the default file access mode is read (r).

  • buffering − If the buffering value is set to 0, no buffering takes place. If the buffering value is 1, line buffering is performed while accessing a file. If you specify the buffering value as an integer greater than 1, then buffering action is performed with the indicated buffer size. If negative, the buffer size is the system default(default behavior).

Here is a list of the different modes of opening a file −

Sr.No. Modes & Description
1

r

Opens a file for reading only. The file pointer is placed at the beginning of the file. This is the default mode.

2

rb

Opens a file for reading only in binary format. The file pointer is placed at the beginning of the file. This is the default mode.

3

r+

Opens a file for both reading and writing. The file pointer placed at the beginning of the file.

4

rb+

Opens a file for both reading and writing in binary format. The file pointer placed at the beginning of the file.

5

w

Opens a file for writing only. Overwrites the file if the file exists. If the file does not exist, creates a new file for writing.

6

wb


Opens a file for writing only in binary format. Overwrites the file if the file exists. If the file does not exist, creates a new file for writing.

7

w+

Opens a file for both writing and reading. Overwrites the existing file if the file exists. If the file does not exist, creates a new file for reading and writing.

8

wb+

Opens a file for both writing and reading in binary format. Overwrites the existing file if the file exists. If the file does not exist, creates a new file for reading and writing.

9

a

Opens a file for appending. The file pointer is at the end of the file if the file exists. That is, the file is in the append mode. If the file does not exist, it creates a new file for writing.

10

ab

Opens a file for appending in binary format. The file pointer is at the end of the file if the file exists. That is, the file is in the append mode. If the file does not exist, it creates a new file for writing.

11

a+

Opens a file for both appending and reading. The file pointer is at the end of the file if the file exists. The file opens in the append mode. If the file does not exist, it creates a new file for reading and writing.

12

ab+

Opens a file for both appending and reading in binary format. The file pointer is at the end of the file if the file exists. The file opens in the append mode. If the file does not exist, it creates a new file for reading and writing.

Пример кода

Следующий код написан на C :

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <readline/readline.h>
#include <readline/history.h>

int main()
{
    char* input, shell_prompt100];

    for(;;)
    {
        // getting the current user's path
        snprintf(shell_prompt, sizeof(shell_prompt), "%s:%s $ ", getenv("USER"), getcwd(NULL, 1024));
        // inputing...
        input = readline(shell_prompt);
        // eof
        if (!input)
            break;
	// path autocompletion when tabulation hit
        rl_bind_key('\t', rl_complete);
        // adding the previous input into history
        add_history(input);

        /* do stuff */

        // Т. к. вызов readline() выделяет память, но не освобождает (а возвращает), то эту память нужно вернуть (освободить).
        free(input);
    }
}

Slightly more complex (Stateless, No Grammar)

Now, in those examples pressing tab would turn the word provided entirely into the word «example», which doesn’t make any sense. In this example, I will provide a small dictionary of interesting words which we will complete based on the actual text provided.

Our volcabulary will consist of the following words: dog,cat,rabbit,bird,slug,snail

I specifically chose slug and snail to start with the same letter for example purposes.

This example of filling out volcabularies is simple because it is stateless, we will see a few more complex tasks coming up soon.

ex3.py:

#!/usr/bin/python

import readline
readline.parse_and_bind("tab: complete")

def complete(text,state):
    volcab = 
    results =  + 
    return results

readline.set_completer(complete)

line = raw_input('prompt> ')

Now we can try running this:

run 1:

jkenyon@prometheus:~/src/python/complete$ ./ex3.py 
prompt> <tab double tapped here>
bird    cat     dog     rabbit  slug    snail
prompt> 

run 2:

jkenyon@prometheus:~/src/python/complete$ ./ex3.py 
prompt> r<tab pressed here>
jkenyon@prometheus:~/src/python/complete$ ./ex3.py 
prompt> rabbit

run 3:

jkenyon@prometheus:~/src/python/complete$ ./ex3.py 
prompt> s<tab double tapped here>
slug   snail
prompt> s

This is already a fantastic improvement over a purely dumb terminal, and the amount of work required was trivial.


С этим читают