Read: примеры (PYTHON)

Короткие примеры использования

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

with open('example.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    print(type(content))
    print(len(content))

<class 'str'>
245

Чтение заданного количества символов

with open('example.txt', 'r', encoding='utf-8') as f:
    first_part = f.read(10)
    second_part = f.read(15)
    print(f'Первая часть: "{first_part}"')
    print(f'Вторая часть: "{second_part}"')

Первая часть: "Это начал"
Вторая часть: "о текста файла"

Чтение в бинарном режиме

with open('image.png', 'rb') as f:
    header = f.read(8)
    print(f'Заголовок файла: {header}')
    print(f'Тип данных: {type(header)}')

Заголовок файла: b'\x89PNG\r\n\x1a\n'
Тип данных: <class 'bytes'>

Чтение после достижения EOF

with open('example.txt', 'r', encoding='utf-8') as f:
    full = f.read() # Читает всё
    empty = f.read() # Достигнут конец файла
    print(f'Полное содержимое (длина): {len(full)}')
    print(f'Следующее чтение: "{empty}" (длина: {len(empty)})')

Полное содержимое (длина): 245
Следующее чтение: "" (длина: 0)

Похожие функции в Python

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

readline(size=-1)

Читает одну строку из файла. Если аргумент size задан, читает указанное количество символов/байт, но не более одной строки. Возвращает строку. Используется для последовательного построчного чтения, особенно при работе с текстовыми файлами большого объема, когда нецелесообразно загружать всё в память.

readlines(hint=-1)

Читает все строки файла и возвращает их в виде списка. Если указан аргумент hint, читает строки, пока общий размер прочитанных данных не превысит это значение. Удобен, когда необходимо получить все строки файла в виде списка для дальнейшей обработки.

Итерация по файловому объекту

Файловый объект является итерируемым. Цикл for line in file: эффективно читает файл построчно, не загружая его целиком в память. Это предпочтительный способ для последовательной обработки текстовых файлов.

Когда что использовать?

• read() - для чтения файлов небольшого размера, бинарных данных или чтения определённых порций.
• readline() - для интерактивного или последовательного построчного чтения (например, логи).
• readlines() - когда нужен список всех строк, и размер файла позволяет хранить его в памяти.
• Итерация - стандартный и эффективный способ построчной обработки больших текстовых файлов.

Аналоги функции в других языках

PHP

fread() работает аналогично, читая указанное количество байт. file_get_contents() читает весь файл в строку.

// PHP
$handle = fopen("example.txt", "r");
$content = fread($handle, filesize("example.txt"));
fclose($handle);
echo $content;

Содержимое файла example.txt

JavaScript (Node.js)

Используются асинхронные методы fs.readFile() (весь файл) и fs.read() (часть файла).

// JavaScript (Node.js)
const fs = require('fs');
fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

Содержимое файла example.txt

Java

Используются классы FileInputStream для байтов и BufferedReader для текста. Метод read() читает байты.

// Java
import java.nio.file.*;
Path path = Paths.get("example.txt");
String content = Files.readString(path);
System.out.println(content);

Содержимое файла example.txt

C#

File.ReadAllText() читает весь текст, Stream.Read() читает байты в массив.

// C#
string content = File.ReadAllText("example.txt");
Console.WriteLine(content);

Содержимое файла example.txt

Go

ioutil.ReadFile() читает весь файл в срез байт. Пакет bufio предоставляет методы для буферизированного чтения.

// Go
package main
import (
    "fmt"
    "io/ioutil"
)
data, err := ioutil.ReadFile("example.txt")
if err != nil {
    panic(err)
}
fmt.Println(string(data))

Содержимое файла example.txt

Kotlin

Функция-расширение File.readText() читает весь файл как текст.

// Kotlin
import java.io.File
val content = File("example.txt").readText()
println(content)

Содержимое файла example.txt

Основное отличие Python-функции read() - её универсальность для любых файлоподобных объектов и работа как с текстом, так и с байтами в зависимости от режима открытия файла.

Типичные ошибки

Чтение после закрытия файла

Попытка чтения из закрытого файлового объекта вызывает ValueError.

f = open('example.txt', 'r')
f.close()
try:
    data = f.read()
except ValueError as e:
    print(f'Ошибка: {e}')

Ошибка: I/O operation on closed file.

Неправильная кодировка для текстового файла

Если кодировка файла не соответствует указанной при открытии, возникает UnicodeDecodeError.

# Файл сохранён в кодировке cp1251
with open('win1251.txt', 'r', encoding='utf-8') as f:
    try:
        data = f.read()
    except UnicodeDecodeError as e:
        print(f'Ошибка декодирования: {e}')

Ошибка декодирования: 'utf-8' codec can't decode byte 0xff in position 0: invalid start byte

Игнорирование пустого результата при чтении по частям

Цикл чтения может стать бесконечным, если не проверять возвращаемое пустое значение.

with open('example.txt', 'r') as f:
    while True:
        chunk = f.read(5)
        if not chunk: # Если chunk - пустая строка
            print('Конец файла достигнут')
            break
        print(chunk, end='')

Это н
ачало
...
Конец файла достигнут

Изменения в последних версиях Python

Семантика функции read() оставалась стабильной на протяжении многих версий. Ключевые изменения связаны с развитием модуля io и обработкой текста.

• В Python 3 все строки являются Unicode, поэтому read() для текстового режима всегда возвращает str. В Python 2 возвращалась строка байт.
• Начиная с Python 3.3, улучшена работа с кодировкой по умолчанию на различных платформах (особенно Windows).
• В Python 3.7 повышена производительность некоторых внутренних операций ввода-вывода.
• Сам метод read() файловых объектов, возвращаемых open(), не претерпел значительных синтаксических изменений, сохраняя обратную совместимость.

Расширенные примеры использования

Чтение файла по блокам для обработки больших файлов

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

def process_large_file(filename, block_size=1024*1024):
    """Обрабатывает большой файл блоками по block_size байт."""
    with open(filename, 'rb') as f:
        block_number = 0
        while True:
            chunk = f.read(block_size)
            if not chunk:
                break
            # Обработка блока данных (chunk - bytes)
            block_number += 1
            print(f'Обработан блок {block_number}, размер: {len(chunk)} байт')
    print(f'Обработано блоков: {block_number}')

# Пример вызова
process_large_file('large_video.mkv', block_size=5*1024*1024)

Обработан блок 1, размер: 5242880 байт
Обработан блок 2, размер: 5242880 байт
...
Обработано блоков: 120

Использование с объектами io.StringIO и io.BytesIO

Функция read() работает с объектами памяти как с файлами.

import io

# Работа со строкой в памяти
string_buffer = io.StringIO('Первая строка\nВторая строка\n')
print(string_buffer.read(7))
print(string_buffer.read())

Первая
 строка
Вторая строка

Чтение из сетевого сокета

Сокеты в Python также предоставляют метод read() (или recv()).

import socket
# Упрощённый пример
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('example.com', 80))
request = b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n'
sock.send(request)
# Чтение ответа (первые 500 байт)
response_chunk = sock.recv(500) # Аналог read() для сокетов
print(response_chunk.decode()[:200])
sock.close()

HTTP/1.1 200 OK
Content-Encoding: gzip
Accept-Ranges: bytes
Age: 516427
Cache-Control: max-age=604800
Content-Type: text/html; charset=UTF-8
...

Чтение с обработкой исключений и восстановлением позиции

def safe_read_with_fallback(filename):
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            return f.read()
    except (UnicodeDecodeError, OSError):
        # Попытка прочитать как бинарный файл или другим способом
        try:
            with open(filename, 'rb') as f:
                return f.read().decode('utf-8', errors='ignore')
        except OSError as e:
            return f"Не удалось прочитать файл: {e}"

print(safe_read_with_fallback('some_file.txt'))

Имитация чтения с таймаутом (на примере io.BytesIO)

import io, time

class SlowStream(io.BytesIO):
    """Поток, который возвращает данные с задержкой."""
    def read(self, size=-1):
        time.sleep(0.1) # Искусственная задержка
        return super().read(size)

stream = SlowStream(b'x' * 1000) # 1000 байт
start = time.time()
data = stream.read(100) # Читает 100 байт с задержкой
end = time.time()
print(f'Прочитано {len(data)} байт за {end-start:.2f} секунд')

Прочитано 100 байт за 0.10 секунд

Комбинирование read() с другими методами чтения

with open('data.txt', 'r') as f:
    # Прочитать заголовок (первые 50 символов)
    header = f.read(50)
    # Прочитать следующую строку целиком
    next_line = f.readline()
    # Прочитать оставшееся содержимое
    rest = f.read()
    print(f'Заголовок: {header}')
    print(f'Следующая строка: {next_line}')
    print(f'Длина остатка: {len(rest)} символов')