File класс

Completion¶

The following functions relate to implementing a custom word completion
function. This is typically operated by the Tab key, and can suggest and
automatically complete a word being typed. By default, Readline is set up
to be used by to complete Python identifiers for
the interactive interpreter. If the module is to be used
with a custom completer, a different set of word delimiters should be set.

(function)

Set or remove the completer function. If function is specified, it will be
used as the new completer function; if omitted or , any completer
function already installed is removed. The completer function is called as
, for state in , , , …, until it
returns a non-string value. It should return the next possible completion
starting with text.

The installed completer function is invoked by the entry_func callback
passed to in the underlying library.
The text string comes from the first parameter to the
callback of the
underlying library.

()

Get the completer function, or if no completer function has been set.

()

Get the type of completion being attempted. This returns the
variable in the underlying library as
an integer.

()

()

Get the beginning or ending index of the completion scope.
These indexes are the start and end arguments passed to the
callback of the
underlying library.

(string)

()

Set or get the word delimiters for completion. These determine the
start of the word to be considered for completion (the completion scope).
These functions access the
variable in the underlying library.

Python NumPy

NumPy IntroNumPy Getting StartedNumPy Creating ArraysNumPy Array IndexingNumPy Array SlicingNumPy Data TypesNumPy Copy vs ViewNumPy Array ShapeNumPy Array ReshapeNumPy Array IteratingNumPy Array JoinNumPy Array SplitNumPy Array SearchNumPy Array SortNumPy Array FilterNumPy Random
Random Intro
Data Distribution
Random Permutation
Seaborn Module
Normal Distribution
Binomial Distribution
Poisson Distribution
Uniform Distribution
Logistic Distribution
Multinomial Distribution
Exponential Distribution
Chi Square Distribution
Rayleigh Distribution
Pareto Distribution
Zipf Distribution

NumPy ufunc
ufunc Intro
ufunc Create Function
ufunc Simple Arithmetic
ufunc Rounding Decimals
ufunc Logs
ufunc Summations
ufunc Products
ufunc Differences
ufunc Finding LCM
ufunc Finding GCD
ufunc Trigonometric
ufunc Hyperbolic
ufunc Set Operations

6.7.4. History list¶

The following functions operate on a global history list:

()

Clear the current history. This calls in the
underlying library. The Python function only exists if Python was
compiled for a version of the library that supports it.

()

Return the number of items currently in the history. (This is different from
, which returns the maximum number of lines that will
be written to a history file.)

(index)

Return the current contents of history item at index. The item index
is one-based. This calls in the underlying library.

(pos)

Remove history item specified by its position from the history.
The position is zero-based. This calls in
the underlying library.

(pos, line)

Replace history item specified by its position with line.
The position is zero-based. This calls
in the underlying library.

Overview¶

The module provides Python’s main facilities for dealing with various
types of I/O. There are three main types of I/O: text I/O, binary I/O
and raw I/O. These are generic categories, and various backing stores can
be used for each of them. A concrete object belonging to any of these
categories is called a . Other common terms are stream
and file-like object.

Independent of its category, each concrete stream object will also have
various capabilities: it can be read-only, write-only, or read-write. It can
also allow arbitrary random access (seeking forwards or backwards to any
location), or only sequential access (for example in the case of a socket or
pipe).

All streams are careful about the type of data you give to them. For example
giving a object to the method of a binary stream
will raise a . So will giving a object to the
method of a text stream.

Changed in version 3.3: Operations that used to raise now raise , since
is now an alias of .

Text I/O

Text I/O expects and produces objects. This means that whenever
the backing store is natively made of bytes (such as in the case of a file),
encoding and decoding of data is made transparently as well as optional
translation of platform-specific newline characters.

The easiest way to create a text stream is with , optionally
specifying an encoding:

f = open("myfile.txt", "r", encoding="utf-8")

In-memory text streams are also available as objects:

f = io.StringIO("some initial text data")

The text stream API is described in detail in the documentation of
.

Binary I/O

Binary I/O (also called buffered I/O) expects
and produces
objects. No encoding, decoding, or newline translation is performed. This
category of streams can be used for all kinds of non-text data, and also when
manual control over the handling of text data is desired.

The easiest way to create a binary stream is with with in
the mode string:

f = open("myfile.jpg", "rb")

In-memory binary streams are also available as objects:

f = io.BytesIO(b"some initial binary data: \x00\x01")

The binary stream API is described in detail in the docs of
.

Other library modules may provide additional ways to create text or binary
streams. See for example.

How to read a File line-by-line using a while loop?

You can make use of a while loop and read the contents from the given file line-by-line. To do that, first, open the file in read mode using open() function. The file handler returned from open(), use it inside while –loop to read the lines.

Python readline() function is used inside while-loop to read the lines. In the case of for-loop, the loop terminates when the end of the file is encountered. But the same is not the case with a while-loop, and you need to keep a check to see if the file is done reading. So once the readline() function returns an empty string, you can make use of the break statement to terminate from the while –loop.

Here is a working example to read a file line by line using a while-loop.

The file that we are going to make use is test.txt .Save the file test.txt and use the location of test.txt inside open() function.

Line No 1
Line No 2
Line No 3
Line No 4
Line No 5

myfile = open("test.txt", "r")
while myfile:
    line  = myfile.readline()
    print(line)
    if line == "":
        break
myfile.close() 

Output:

Line No 1
Line No 2
Line No 3
Line No 4
Line No 5

Summary

• Python readline() is a file method that helps to read one complete line from the given file. It has a trailing newline («\n») at the end of the string returned.
• You can also make use of the size parameter to get a specific length of the line. The size parameter is optional, and by default, the entire line will be returned.
• The readline() method helps to read just one line at a time, and it returns the first line from the file given. We will make use of readline() to read all the lines from the file given.
• To read all the lines from a given file, you can make use of Python readlines() function. The specialty of Python readlines() function is that it reads all the contents from the given file and saves the output in a list.
• The readlines() function reads till the End of the file making use of readline() function internally and returns a list that has all the lines read from the file.
• It is possible to read a file line by line using for loop. To do that, first, open the file using Python open() function in read mode. The open() function will return a file handler. Use the file handler inside your for-loop and read all the lines from the given file line by line. Once done,close the file handler using close() function.
• You can make use of a while loop and read the contents from the given file line by line. To do that, first, open the file in read mode using open() function. The file handler returned from open(), use it inside while –loop to read the lines. Python readline() function is used inside while-loop to read the lines.

Exemple¶

L’exemple suivant démontre comment utiliser les fonctions de lecture et d’écriture de l’historique du module pour charger ou sauvegarder automatiquement un fichier d’historique nommé depuis le répertoire d’accueil de l’utilisateur. Le code ci-dessous doit normalement être exécuté automatiquement durant une session interactive depuis le fichier de l’utilisateur .

import atexit
import os
import readline

histfile = os.path.join(os.path.expanduser("~"), ".python_history")
try
    readline.read_history_file(histfile)
    # default history len is -1 (infinite), which may grow unruly
    readline.set_history_length(1000)
except FileNotFoundError
    pass

atexit.register(readline.write_history_file, histfile)

Ce code est en réalité automatiquement exécuté lorsque Python tourne en (voir ).

L’exemple suivant atteint le même objectif mais gère des sessions interactives concurrentes, en ajoutant seulement le nouvel historique.

import atexit
import os
import readline
histfile = os.path.join(os.path.expanduser("~"), ".python_history")

try
    readline.read_history_file(histfile)
    h_len = readline.get_current_history_length()
except FileNotFoundError
    open(histfile, 'wb').close()
    h_len = 

def save(prev_h_len, histfile):
    new_h_len = readline.get_current_history_length()
    readline.set_history_length(1000)
    readline.append_history_file(new_h_len - prev_h_len, histfile)
atexit.register(save, h_len, histfile)

L’exemple suivant étend la classe pour gérer la sauvegarde/restauration de l’historique.

import atexit
import code
import os
import readline

class HistoryConsole(code.InteractiveConsole):
    def __init__(self, locals=None, filename="<console>",
                 histfile=os.path.expanduser("~/.console-history")):
        code.InteractiveConsole.__init__(self, locals, filename)
        self.init_history(histfile)

    def init_history(self, histfile):
        readline.parse_and_bind("tab: complete")
        if hasattr(readline, "read_history_file"):
            try
                readline.read_history_file(histfile)
            except FileNotFoundError
                pass
            atexit.register(self.save_history, histfile)

    def save_history(self, histfile):
        readline.set_history_length(1000)
        readline.write_history_file(histfile)

History

Linenoise supporst history, so that the user does not have to retype
again and again the same things, but can use the down and up arrows in order
to search and re-edit already inserted lines of text.

The followings are the history API calls:

Use every time you want to add a new element
to the top of the history (it will be the first the user will see when
using the up arrow).

Note that for history to work, you have to set a length for the history
(which is zero by default, so history will be disabled if you don’t set
a proper one). This is accomplished using the
function.

Linenoise has direct support for persisting the history into an history
file. The functions and do
just that. Both functions return -1 on error and 0 on success.

Файлы в Python

В целом различают два типа файлов (и работы с ними):

• текстовые файлы со строками неопределенной длины;
• двоичные (бинарные) файлы (хранящие коды таких данных, как, например, рисунки, звуки, видеофильмы);

Этапы работы с файлом:

1. открытие файла;

• режим чтения,
• режим записи,
• режим добавления данных.

работа с файлом;
закрытие файла.

В python открыть файл можно с помощью функции open с двумя параметрами:

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

В коде это выглядит следующим образом:

Fin = open ( "input.txt" ) 
Fout = open ( "output.txt", "w" ) 
  # работа с файлами 
Fout.close() 
Fin.close()

Работа с текстовыми файлами в Питон

Чтение из файла происходит двумя способами:

1. построчно с помощью метода readline:

файл input.txt:
1
2
3

str1 = Fin.readline() # str1 = 1
str2 = Fin.readline() # str2 = 2

метод read читает данные до конца файла:

файл input.txt:
1
2
3

str = Fin.read() 
''' 
str = 1
2
3
'''

Для получения отдельных слов строки используется метод split, который по пробелам разбивает строку на составляющие компоненты:

str = Fin.readline().split()
print(str)
print(str1)

Пример:
В файле записаны два числа. Необходимо суммировать их.

файл input.txt:
12 17

ответ:
27

Решение: 

1. способ:

Fin = open ( "D:/input.txt" ) 
str = Fin.readline().split()
x, y = int(str), int(str1)
print(x+y)

способ:

...
x, y = int(i) for i in s
print(x+y)

* Функция int преобразует строковое значение в числовое.

В python метод write служит для записи строки в файл:

Fout = open ( "D:/out.txt","w" ) 
Fout.write ("hello")

Запись в файл можно осуществлять, используя определенный
шаблон вывода. Например:

Fout.write ( "{:d} + {:d} = {:d}\n".format(x, y, x+y) )

В таком случае вместо шаблонов {:d} последовательно подставляются значения параметров метода format (сначала x, затем y, затем x+y).

Аналогом «паскалевского» eof (если конец файла) является обычный способ использования цикла while или с помощью добавления строк в список:

1. while True: str = Fin.readline() if not str: break

2. Fin = open ( "input.txt" ) lst = Fin.readlines() for str in lst: print ( str, end = "" ) Fin.close()

3. подходящий способ для Python:

for str in open ( "input.txt" ): 
   print ( str, end = "" )

Задание Python 9_1:
Считать из файла input.txt 10 чисел (числа записаны через пробел). Затем записать их произведение в файл output.txt.

Рассмотрим пример работы с массивами.

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

Решение: 

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

lst =  
while True:
   st = Fin.readline() 
   if not st: break 
   lst.append (int(st))

Сортировка.
Запись отсортированного массива (списка) в файл:

Fout = open ( "output.txt", "w" ) 
Fout.write (str(lst)) # функция str преобразует числовое значение в символьное
Fout.close()

Или другой вариант записи в файл:

for x in lst: 
    Fout.write (str(x)+"\n") # запись с каждой строки нового числа

Задание Python 9_2:
В файле записаны в целые числа. Найти максимальное и минимальное число и записать в другой файл.

Задание Python 9_3:
В файле записаны в столбик целые числа. Отсортировать их по возрастанию суммы цифр и записать в другой файл.

Рассмотрим на примере обработку строковых значений.

Пример:
В файл записаны сведения о сотрудниках некоторой фирмы в виде:

Иванов 45 бухгалтер

Необходимо записать в текстовый файл сведения о сотрудниках, возраст которых меньше 40.

Решение: 

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

st = Fin.readline() 
data = st.split() 
stAge = data1 
intAge = int(stAge)

Более короткая запись будет выглядеть так:

st = Fin.readline() 
intAge = int(st.split()1)

Программа выглядит так:

while True: 
  st = Fin.readline() 
  if not s: break 
  intAge = int (st.split()1)

Но лучше в стиле Python:

for st in open ( "input.txt" ): 
   intAge = int (st.split()1) 
   if intAge < 5: 
      Fout.write (st)

Задание Python 9_4:
В файл записаны сведения о детях детского сада:

Иванов иван 5 лет

Необходимо записать в текстовый файл самого старшего и самого младшего.

Файлы Python

Файл — это всего лишь набор данных, сохраненный в виде последовательности битов на компьютере. Информация хранится в куче данных (структура данных) и имеет название «имя файла» (filename).

В Python существует два типа файлов:

1. Текстовые
2. Бинарные

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

Это файлы с человекочитаемым содержимым. В них хранятся последовательности символов, которые понимает человек. Блокнот и другие стандартные редакторы умеют читать и редактировать этот тип файлов.

Текст может храниться в двух форматах: () — простой текст и () — «формат обогащенного текста».

Бинарные файлы

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

Они хранятся в формате .

Любую операцию с файлом можно разбить на три крупных этапа:

1. Открытие файла
2. Выполнение операции (запись, чтение)
3. Закрытие файла

Бинарные файлы

Стандартный модуль struct позволяет преобразовывать объекты в структуры C в виде строк в бинарном формате и обратно. Данные в строке располагаются в соответствии со строкой формата. Эти возможности могут быть использованы для чтения и сохранения в двоичном формате.

Функции этого модуля:

   pack(format, value1, value2 ...)

Возвращает строку, содержащую значения value1 …, упакованные в соответствии с форматом. Количество и тип аргументов должны соответствовать значениям, которые требует строка формата format.

   unpack(format, string)

Распаковывает строку string в соответствии с форматом format и возвращает кортеж объектов.

   calcsize(format)

Возвращает размер структуры (т.е. длину строки), соответствующей формату format.

Таблица основных форматов

===========================
Format      C Type          Python 	
===========================
c             char               string of length 1 	 
?             Bool              bool 	
i 	   int                  integer 	 
l 	   long               integer 	 
f 	   float               float 	 
d 	   double           float 	 
s 	   char[]            string

Перед символом формата может идти число, обозначающее количество повторений. Например, строка формата ‘4h’ полностью эквивалентна строке ‘hhhh’. Символы пропуска между символами формата игнорируются, однако символы пропуска между числом и символом формата не допускаются.

Число перед символом формата ‘s’ интерпретируется как длина строки, а не число повторений. То есть ’10s’ обозначает строку из 10 символов, в то время как ’10c’ – 10 раз по одному символу.

Можно изменить порядок следования байтов вручную:

  < - little-endian
  > - big-endian

В следующем примере мы упаковываем в структуру два числа – целое и float, строку из пяти символов, сохраняем в бинарный файл, а потом извлекаем из файла:

from struct import *
out = open("123.bin", "wb")    
format = "if5s"                
data   = pack(format, 24,12.48,'12345')
out.write(data)
out.close()
input = open("123.bin", "rb")
data = input.read()
input.close()
format = "if5s"                   # one integer
value,value2,value3 = unpack(format, data) # note the ',' in 'value,': 
	unpack apparently returns a n-uple
print value
print value2
print value3
print calcsize(format)

>>> 24
>>> 12.4799995422
>>> 12345
>>> 13

History file¶

The following functions operate on a history file:

(filename)

Load a readline history file, and append it to the history list.
The default filename is . This calls
in the underlying library.

(filename)

Save the history list to a readline history file, overwriting any
existing file. The default filename is . This calls
in the underlying library.

(nelements, filename)

Append the last nelements items of history to a file. The default filename is
. The file must already exist. This calls
in the underlying library. This function
only exists if Python was compiled for a version of the library
that supports it.

New in version 3.5.

TTY keybindings#

Completion¶

The following functions relate to implementing a custom word completion
function. This is typically operated by the Tab key, and can suggest and
automatically complete a word being typed. By default, Readline is set up
to be used by to complete Python identifiers for
the interactive interpreter. If the module is to be used
with a custom completer, a different set of word delimiters should be set.

(function)

Set or remove the completer function. If function is specified, it will be
used as the new completer function; if omitted or , any completer
function already installed is removed. The completer function is called as
, for state in , , , …, until it
returns a non-string value. It should return the next possible completion
starting with text.

The installed completer function is invoked by the entry_func callback
passed to in the underlying library.
The text string comes from the first parameter to the
callback of the
underlying library.

()

Get the completer function, or if no completer function has been set.

()

Get the type of completion being attempted. This returns the
variable in the underlying library as
an integer.

()

()

Get the beginning or ending index of the completion scope.
These indexes are the start and end arguments passed to the
callback of the
underlying library.

(string)

()

Set or get the word delimiters for completion. These determine the
start of the word to be considered for completion (the completion scope).
These functions access the
variable in the underlying library.

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

Последнее обновление: 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

НазадВперед

Python Tutorial

Python HOMEPython IntroPython Get StartedPython SyntaxPython CommentsPython Variables
Python Variables
Variable Names
Assign Multiple Values
Output Variables
Global Variables
Variable Exercises

Python Data TypesPython NumbersPython CastingPython Strings
Python Strings
Slicing Strings
Modify Strings
Concatenate Strings
Format Strings
Escape Characters
String Methods
String Exercises

Python BooleansPython OperatorsPython Lists
Python Lists
Access List Items
Change List Items
Add List Items
Remove List Items
Loop Lists
List Comprehension
Sort Lists
Copy Lists
Join Lists
List Methods
List Exercises

Python Tuples
Python Tuples
Access Tuples
Update Tuples
Unpack Tuples
Loop Tuples
Join Tuples
Tuple Methods
Tuple Exercises

Python Sets
Python Sets
Access Set Items
Add Set Items
Remove Set Items
Loop Sets
Join Sets
Set Methods
Set Exercises

Python Dictionaries
Python Dictionaries
Access Items
Change Items
Add Items
Remove Items
Loop Dictionaries
Copy Dictionaries
Nested Dictionaries
Dictionary Methods
Dictionary Exercise

Python If…ElsePython While LoopsPython For LoopsPython FunctionsPython LambdaPython ArraysPython Classes/ObjectsPython InheritancePython IteratorsPython ScopePython ModulesPython DatesPython MathPython JSONPython RegExPython PIPPython Try…ExceptPython User InputPython String Formatting