Обработка KeyError
Вероятно, вы уже сталкивались с при работе со словарями в Python.
Рассмотрим следующий пример, где у нас есть словарь .
my_dict ={"key1":"value1","key2":"value2","key3":"value3"}
search_key = "non-existent key"
print(my_dict)
В словаре есть 3 пары «ключ-значение»: , и .
Теперь попытаемся получить доступ к значению, соответствующему несуществующему ключу .
Как и ожидалось, мы получим :
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-2-2a61d404be04> in <module>()
1 my_dict ={"key1":"value1","key2":"value2","key3":"value3"}
2 search_key = "non-existent key"
----> 3 my_dict
KeyError: 'non-existent key'
Вы можете обработать почти так же, как и .
- Пробуем получить доступ к значению, которое соответствует ключу, определенному .
- Если — валидный ключ, мы распечатываем соответствующее значение.
- Если ключ невалиден и возникает исключение — задействуется блок except, чтобы сообщить об этом пользователю.
Все это можно видеть в следующем коде:
try:
print(my_dict)
except KeyError:
print("Sorry, that's not a valid key!")
# Output:
# Sorry, that's not a valid key!
Если вы хотите предоставить дополнительный контекст, например имя невалидного ключа, это тоже можно сделать. Возможно, ключ оказался невалидным из-за ошибки в написании. Если вы укажете этот ключ в сообщении, это поможет пользователю исправить опечатку.
Вы можете сделать это, перехватив невалидный ключ как и используя его в сообщении, которое печатается при возникновении исключения:
try:
print(my_dict)
except KeyError as error_msg:
print(f"Sorry,{error_msg} is not a valid key!")
Обратите внимание, что теперь в сообщении об ошибки указано также и имя несуществующего ключа:
Sorry, 'non-existent key' is not a valid key!
Регистрировать ли исключение
Некоторые люди посоветуют вам зарегистрировать исключение . Это почти всегда плохой совет. Сообщения журнала являются частью пользовательского интерфейса вашей программы. По сути, вы всегда должны задавать себе вопрос, регистрировать ли что-нибудь вообще, потому что бесполезное словоблудие может отвлекать и сбивать с толку пользователей, читающих ваш файл журнала («пользователи» включают системных администраторов). Каждое зарегистрированное сообщение должно быть длякакая-то полезная цель. Каждый должен предоставить информацию, которая помогает пользователю принимать решения .
Сообщение о конкретном сбое редко бывает полезным. Как это может помочь пользователю принять решение? Если исключение не помешало вашему методу выполнить свою работу, проблем нет, и никаких действий со стороны пользователя не требуется. Если вашей программе не удалось в потоке, и это является проблемой, что может сделать пользователь, чтобы помочь
Низкоуровневый код обычно не отвечает за ведение журнала. Вместо этого он выполняет абстрактные операции, сообщая о сбоях в части вашей программы более высокого уровня, генерируя исключения. Код, закрывающий поток, обычно имеет довольно низкий уровень, поэтому код, который обнаруживает, что слишком низкий уровень, чтобы вести какую-либо запись.
Конкретный факт сбоя редко бывает полезен. Что может быть полезно, так это знание, что абстрактная операция, которую должен выполнить ваш метод, не удалась. Это можно сделать, если код более высокого уровня перехватит все ожидаемые исключения и сообщит о сбое операции, вместо того, чтобы ваш метод точно сообщал, что «сбой при закрытии».
Оператор try-expect
Если программа Python содержит подозрительный код, который может вызвать исключение, мы должны поместить этот код в блок try. За блоком try должен следовать оператор except, который содержит блок кода, который будет выполнен, если в блоке try возникнет какое-либо исключение.
Синтаксис:
try:
#block of code
except Exception1:
#block of code
except Exception2:
#block of code
#other code
Пример 1.
try:
a = int(input("Enter a:"))
b = int(input("Enter b:"))
c = a/b
except:
print("Can't divide with zero")
Выход:
Enter a:10 Enter b:0 Can't divide with zero
Мы также можем использовать оператор else с оператором try-except, в который мы можем поместить код, который будет выполняться в сценарии, если в блоке try не возникает исключения.
Синтаксис для использования оператора else с оператором try-except приведен ниже.
try:
#block of code
except Exception1:
#block of code
else:
#this code executes if no except block is executed
Рассмотрим следующую программу.
Пример 2
try:
a = int(input("Enter a:"))
b = int(input("Enter b:"))
c = a/b
print("a/b = %d"%c)
# Using Exception with except statement. If we print(Exception) it will return exception class
except Exception:
print("can't divide by zero")
print(Exception)
else:
print("Hi I am else block")
Выход:
Enter a:10 Enter b:0 can't divide by zero <class 'Exception'>
Запись С Помощью FileChannel
Если мы имеем дело с большими файлами, FileChannel может быть быстрее, чем стандартный ввод-вывод. Следующий код записывает Строку в файл с помощью FileChannel :
@Test
public void givenWritingToFile_whenUsingFileChannel_thenCorrect()
throws IOException {
RandomAccessFile stream = new RandomAccessFile(fileName, "rw");
FileChannel channel = stream.getChannel();
String value = "Hello";
byte[] strBytes = value.getBytes();
ByteBuffer buffer = ByteBuffer.allocate(strBytes.length);
buffer.put(strBytes);
buffer.flip();
channel.write(buffer);
stream.close();
channel.close();
// verify
RandomAccessFile reader = new RandomAccessFile(fileName, "r");
assertEquals(value, reader.readLine());
reader.close();
}
Блокировка Файла Перед Записью
Наконец, при записи в файл нам иногда нужно дополнительно убедиться, что никто другой не записывает в этот файл одновременно. В принципе, нам нужно иметь возможность заблокировать этот файл во время записи.
Давайте воспользуемся FileChannel , чтобы попытаться заблокировать файл перед записью в него:
@Test
public void whenTryToLockFile_thenItShouldBeLocked()
throws IOException {
RandomAccessFile stream = new RandomAccessFile(fileName, "rw");
FileChannel channel = stream.getChannel();
FileLock lock = null;
try {
lock = channel.tryLock();
} catch (final OverlappingFileLockException e) {
stream.close();
channel.close();
}
stream.writeChars("test lock");
lock.release();
stream.close();
channel.close();
}
Резюмируем
Обработка исключений, на самом деле, довольно-таки проста, и всё, что вам нужно запомнить, размещено в следующих двух абзацах:
При выбрасывании исключения (оператор throw), точка выполнения программы немедленно переходит к ближайшему блоку try. Если какой-либо из обработчиков catch, прикрепленных к блоку try, обрабатывает этот тип исключения, то точка выполнения переходит в этот обработчик и, после выполнения кода блока catch, исключение считается обработанным.
Если подходящих обработчиков catch не существует, то выполнение программы переходит к следующему блоку try. Если до конца программы не найдены соответствующие обработчики catch, то программа завершает свое выполнение с ошибкой исключения.
Обратите внимание, компилятор не выполняет неявные преобразования при сопоставлении исключений с блоками catch! Например, исключение типа char не будет обрабатываться блоком catch типа int, а исключение типа int, в свою очередь, не будет обрабатываться блоком catch типа float. Это действительно всё, что вам нужно запомнить
Это действительно всё, что вам нужно запомнить.
Исключения[править]
В Java возможна обработка ошибок с помощью исключений:
Double f(Double a, Double b) {
((a == ) || (b == )) {
IllegalArgumentException();
}
a / b;
}
Проверять на равенство нулю уже нет необходимости, так как при делении на ноль метод бросит .
Исключения позволяют:
- разделить обработку ошибок и сам алгоритм;
- не загромождать код проверками возвращаемых значений;
- обрабатывать ошибки на верхних уровнях, если на текущем уровне не хватает данных для обработки. Например, при написании универсального метода чтения из файла невозможно заранее предусмотреть реакцию на ошибку, так как эта реакция зависит от использующей метод программы;
- классифицировать типы ошибок, обрабатывать похожие исключения одинаково, сопоставлять специфичным исключениям определенные обработчики.
Каждый раз, когда при выполнении программы происходит ошибка, создается объект-исключение, содержащий информацию об ошибке, включая её тип и состояние программы на момент возникновения ошибки.
После создания исключения среда выполнения пытается найти в стеке вызовов метод, который содержит код, обрабатывающий это исключение. Поиск начинается с метода, в котором произошла ошибка, и проходит через стек в обратном порядке вызова методов. Если не было найдено ни одного подходящего обработчика, выполнение программы завершается.
Таким образом, механизм обработки исключений содержит следующие операции:
- Создание объекта-исключения.
- Заполнение stack trace’а этого исключения.
- Stack unwinding (раскрутка стека) в поисках нужного обработчика.
Когда использовать условие else
Используйте условие else после блока try-except. Оно будет выполняться в том случае, если исключение не будет выдано. Оператор else всегда должен предшествовать блокам except .
В блоках else можно добавить код, который необходимо запустить, если ошибок не возникло.
В приведенном ниже примере видно, что цикл while работает бесконечно. Код запрашивает значение у пользователя, а затем анализирует его с помощью встроенной функции . Если пользователь вводит нулевое значение, блок except будет заблокирован. В противном случае код будет проходить через блок else.
while True:
# Введете с консоли целое число.
x = int(input())
# Разделите 1 на x, чтобы протестировать ошибку
try:
result = 1 / x
except:
print("Error case")
exit(0)
else:
print("Pass case")
exit(1)
В старые добрые времена.
До Java 7 мы могли использовать для добавления текста в файл и закрытия ресурсов вручную.
package com.mkyong;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class ClassicBufferedWriterExample {
public static void main(String[] args) {
BufferedWriter bw = null;
FileWriter fw = null;
try {
String content = "Hello";
fw = new FileWriter("app.log", true);
bw = new BufferedWriter(fw);
bw.write(content);
} catch (IOException e) {
System.err.format("IOException: %s%n", e);
} finally {
try {
if (bw != null)
bw.close();
if (fw != null)
fw.close();
} catch (IOException ex) {
System.err.format("IOException: %s%n", ex);
}
}
}
}
P.S. Приведенный выше код предназначен только для развлечения и устаревших целей, всегда придерживается метода “попробуй с ресурсами”, чтобы закрыть ресурсы.
Чтение и запись файлов. FileInputStream и FileOutputStream
Последнее обновление: 25.04.2018
Запись файлов и класс FileOutputStream
Класс FileOutputStream предназначен для записи байтов в файл. Он является производным от класса OutputStream, поэтому наследует всю его функциональность.
Через конструктор класса FileOutputStream задается файл, в который производится запись. Класс поддерживает несколько конструкторов:
FileOutputStream(String filePath) FileOutputStream(File fileObj) FileOutputStream(String filePath, boolean append) FileOutputStream(File fileObj, boolean append)
Файл задается либо через строковый путь, либо через объект File. Второй параметр — append задает способ записи: eсли он равен true, то данные дозаписываются в конец файла, а при false — файл полностью перезаписывается
Например, запишем в файл строку:
import java.io.*;
public class Program {
public static void main(String[] args) {
String text = "Hello world!"; // строка для записи
try(FileOutputStream fos=new FileOutputStream("C://SomeDir//notes.txt"))
{
// перевод строки в байты
byte[] buffer = text.getBytes();
fos.write(buffer, 0, buffer.length);
}
catch(IOException ex){
System.out.println(ex.getMessage());
}
System.out.println("The file has been written");
}
}
Для создания объекта FileOutputStream используется конструктор, принимающий в качестве параметра путь к файлу для записи. Если такого файла нет, то он
автоматически создается при записи. Так как здесь записываем строку, то ее надо сначала перевести в массив байтов. И с помощью метода write строка записывается в файл.
Для автоматического закрытия файла и освобождения ресурса объект FileOutputStream создается с помощью конструктции try…catch.
При этом необязательно записывать весь массив байтов. Используя перегрузку метода , можно записать и одиночный байт:
fos.write(buffer); // запись первого байта
Чтение файлов и класс FileInputStream
Для считывания данных из файла предназначен класс FileInputStream, который является наследником класса InputStream и поэтому
реализует все его методы.
Для создания объекта FileInputStream мы можем использовать ряд конструкторов. Наиболее используемая версия конструктора в качестве параметра принимает
путь к считываемому файлу:
FileInputStream(String fileName) throws FileNotFoundException
Если файл не может быть открыт, например, по указанному пути такого файла не существует, то генерируется исключение FileNotFoundException.
Считаем данные из ранее записанного файла и выведем на консоль:
import java.io.*;
public class Program {
public static void main(String[] args) {
try(FileInputStream fin=new FileInputStream("C://SomeDir//notes.txt"))
{
System.out.printf("File size: %d bytes \n", fin.available());
int i=-1;
while((i=fin.read())!=-1){
System.out.print((char)i);
}
}
catch(IOException ex){
System.out.println(ex.getMessage());
}
}
}
В данном случае мы считываем каждый отдельный байт в переменную i:
while((i=fin.read())!=-1){
Когда в потоке больше нет данных для чтения, метод возвращает число -1.
Затем каждый считанный байт конвертируется в объект типа char и выводится на консоль.
Подобным образом можно считать данные в массив байтов и затем производить с ним манипуляции:
byte[] buffer = new byte;
// считаем файл в буфер
fin.read(buffer, 0, fin.available());
System.out.println("File data:");
for(int i=0; i<buffer.length;i++){
System.out.print((char)buffer);
}
Совместим оба класса и выполним чтение из одного и запись в другой файл:
import java.io.*;
public class Program {
public static void main(String[] args) {
try(FileInputStream fin=new FileInputStream("C://SomeDir//notes.txt");
FileOutputStream fos=new FileOutputStream("C://SomeDir//notes_new.txt"))
{
byte[] buffer = new byte;
// считываем буфер
fin.read(buffer, 0, buffer.length);
// записываем из буфера в файл
fos.write(buffer, 0, buffer.length);
}
catch(IOException ex){
System.out.println(ex.getMessage());
}
}
}
Классы FileInputStream и FileOutputStream предназначены прежде всего для записи двоичных файлов, то есть для записи и чтения байтов. И хотя они также могут использоваться для работы с текстовыми файлами,
но все же для этой задачи больше подходят другие классы.
НазадВперед
Файлы
В приведенном ниже примере используется популярный Apache commons-io для добавления строки в конец файла.
commons-iocommons-io2.7
import org.apache.commons.io.FileUtils;
private static void appendToFileFileUtils(File file, String content)
throws IOException {
// append mode
FileUtils.writeStringToFile(
file, content, StandardCharsets.UTF_8, true);
}
Просмотрите файлы подпись; последний или четвертый аргумент указывает режим добавления.
public static void writeStringToFile(final File file, final String data,
final Charset charset,final boolean append)
throws IOException {
try (OutputStream out = openOutputStream(file, append)) {
IOUtils.write(data, out, charset);
}
}
Как читать и записывать объекты Java из / в файл?
ObjectOutputStream используется для сериализации и записи в файл, в то время как ObjectInputStream может использоваться аналогичным образом для чтения сериализованных объектов из файла
Пример
Python
import Java.util.*;
import Java.io.*;
class Student implements Java.io.Serializable {
int ID;
String Name;
Student(int ID, String Name){
this.ID = ID;
this.Name=Name;
}
public String toString() {
return «ID:» + ID + «\nName: » + Name;
}
}
public class TestClass{
public static void main(String[] args) {
Student st1 = new Student(100, «Bill»);
Student st2 = new Student(101, «Gates»);
// запись объекта в файл
try {
FileOutputStream fos = new FileOutputStream(new File(«D:\\JavaObjects.txt»));
ObjectOutputStream oos = new ObjectOutputStream(fos);
// Запись объектов в файл
oos.writeObject(st1);
oos.writeObject(st2);
oos.close();
fos.close();
}
catch (IOException e){
e.printStackTrace();
}
// Чтение объектов из файла
try{
FileInputStream fis = new FileInputStream(new File(«D:\\JavaObjects.txt»));
ObjectInputStream ois = new ObjectInputStream(fis);
Student s1 = (Student) ois.readObject();
Student s2 = (Student) ois.readObject();
System.out.println(s1.toString());
System.out.println(s2.toString());
fis.close();
ois.close();
}catch(Exception ex){
ex.printStackTrace();
}
}
}
|
1 |
importJava.util.*; importJava.io.*; classStudent implements Java.io.Serializable{ intID; StringName; Student(intID,StringName){ this.ID=ID; this.Name=Name; } public StringtoString(){ return»ID:»+ID+»\nName: «+Name; } } publicclassTestClass{ public static void main(Stringargs){ Student st1=newStudent(100,»Bill»); Student st2=newStudent(101,»Gates»); записьобъектавфайл try{ FileOutputStream fos=newFileOutputStream(newFile(«D:\\JavaObjects.txt»)); ObjectOutputStream oos=newObjectOutputStream(fos); Записьобъектоввфайл oos.writeObject(st1); oos.writeObject(st2); oos.close(); fos.close(); } catch(IOExceptione){ e.printStackTrace(); } Чтениеобъектовизфайла try{ FileInputStream fis=newFileInputStream(newFile(«D:\\JavaObjects.txt»)); ObjectInputStream ois=newObjectInputStream(fis); Student s1=(Student)ois.readObject(); Student s2=(Student)ois.readObject(); System.out.println(s1.toString()); System.out.println(s2.toString()); fis.close(); ois.close(); }catch(Exceptionex){ ex.printStackTrace(); } } } |
Используйте класс java.io.File¶
При установлении объекта File вы указываете название файла и дальше используйте метод createNewFile(), который атомарно создает новый пустой файл с названием абстрактного пути, но только в случае, если файл с таким названием не существует.
Данный метод возвращает true, если названный файл не существует и был успешно создан. Возвращает false, если файл существует. Он также создает java.io.IOException, когда не может создать файл. Созданный файл пуст и имеет нулевой байт.
Данный метод не должен быть использован для блокировки файлов, так как протокол, созданный в результате этого, не может надежно работать.
Запомните, что этот метод только создает файл, но не записывает к нему контент.
Типичные ошибки компиляции и запуска Java программ
Команда javac не найдена
Если при запуске javac, т.е. при попытке компиляции Java программы вы получаете ошибку:
"javac" не является внутренней или внешней командой, исполняемой программой или пакетным файлом.
Это означает, что JDK не установлен. Либо установлен, но не настроены переменные окружения. Способы исправления очевидны:
- установить JDK
- настроить переменные окружения
Если JDK установлен, то можно обойтись без добавления переменной окружения. Для этого используйте абсолютный путь до исполнимого файла javac:
C:\Program Files\Java\jdk1.8.0_131\bin\javac.exe программа_для_компиляции.java
Ошибка Class names are only accepted if annotation processing is explicitly requested
Если попытаться скомпилировать программу следующим образом:
"C:\Program Files\Java\jdk1.8.0_131\bin\javac.exe" Welcome2
то возникнет ошибка:
error: Class names, 'Welcome', are only accepted if annotation processing is explicitly requested 1 error
Причина ошибки в том – что вы забыли указать расширение файла .java.
Ошибка записи (error while writing)
Запуск компиляции:
C:\Users\Alex>"C:\Program Files\Java\jdk1.8.0_131\bin\javac.exe" C:\Welcome.java
Компиляция заканчивается ошибкой:
C:\Welcome.java:1: error: error while writing Welcome: C:\Welcome.class (╬Єърчрэю т фюёЄєях)
public class Welcome {
^
1 error
Причина ошибки в том, что у компилятора (javac) недостаточно прав на запись в тот каталог, куда он пытается сохранить новый файл .class. Чтобы ошибка исчезла: предоставьте компилятору дополнительные права (запустите от имени администратора), либо сохраняйте в папку, на которую у текущего пользователя имеются права записи.
Ошибка «class is public, should be declared in a file named»
Запуск компиляции
"C:\Program Files\Java\jdk1.8.0_131\bin\javac.exe" C:\Welcome.java
который заканчивается примерной такой ошибкой
C:\Welcome.java:1: error: class Welcomee is public, should be declared in a file named Welcomee.java
public class Welcomee {
^
1 error
означает, что вы неправильно назвали класс в исходном коде программы. Имя класса должно совпадать с именем файла. В данном случае файл называется Welcome.java, а класс внутри программы назван Welcomee
Error: Could not find or load main class
Если попытаться запустить программу следующим образом:
java Welcome.class
то возникнет ошибка
Error: Could not find or load main class Welcome.class
Причина её в том, что не нужно было добавлять к названию файла расширение .class. Виртуальная машина автоматически добавляет расширение и в приведённом примере она ищет файл Welcome.class.class
Ошибка Error: Could not find or load main class при запуске Java программы по абсолютному пути
Эта ошибка возможно при запуске Java программы по абсолютному пути:
java C:\Welcome
Будет выведено:
Error: Could not find or load main class C:\Welcome
Ошибка возникает как в Windows, так и в Linux:
java /home/mial/Welcome Error: Could not find or load main class .home.mial.Welcome
Если в терминале вы находитесь в той же директории, что и файл, который вы запускаете, то не нужно указывать абсолютный путь. Например, нужно запускать так:
cd C:\ java Welcome
Если же вы находитесь в другой директории, то нужно использовать опцию -cp, после которой указать путь до каталога, где размещена запускаемая программа. А далее указать запускаемый файл без расширения .class:
java -cp C:\ Welcome
Как видно из скриншота, командная строка находится в папке C:\WINDOWS\system32. Файл, который нам нужно запустить, находится в папке C:\ (корень диска). Мы указываем после ключа -cp папку C:\, а затем пишем имя файла программы без расширения – Welcome.
Аналогично нужно поступать в Linux. Пример команды:
java -cp /home/mial/ Welcome
Ошибка Main method not found in class
Если при запуске вы столкнулись с ошибкой:
Error: Main method not found in class Welcome, please define the main method as: public static void main(String[] args) or a JavaFX application class must extend javafx.application.Application
Это означает, что вы не указали метод main, либо написали слово неправильно (например, Main вместо main).
Обработка исключений
Пока арбитр не объявит о штрафном броске, и пока этот штрафной бросок не будет выполнен, игра не возобновится. Другими словами, штрафной бросок должен быть обработан до возобновления игры.
Фактически, обработка исключений — это работа блока(ов) catch. Ключевое слово catch используется для определения блока кода (так называемого «блока catch»), который обрабатывает исключения определенного типа данных.
Вот пример блока catch, который обрабатывает (ловит) исключения типа int:
catch (int a)
{
// Обрабатываем исключение типа int
std::cerr << «We caught an int exception with value» << a << ‘\n’;
}
|
1 |
catch(inta) { // Обрабатываем исключение типа int std::cerr<<«We caught an int exception with value»<<a<<‘\n’; } |
Блоки try и catch работают вместе. Блок try обнаруживает любые исключения, которые были выброшены в нем, и направляет их в соответствующий блок catch для обработки. Блок try должен иметь, по крайней мере, один блок catch, который находится сразу же за ним, но также может иметь и несколько блоков catch, размещенных последовательно (друг за другом).
Как только исключение было поймано блоком try и направлено в блок catch для обработки, оно считается обработанным (после выполнения кода блока catch), и выполнение программы возобновляется.
Параметры catch работают так же, как и параметры функции, причем параметры одного блока catch могут быть доступны и в другом блоке catch (который находится за ним). Исключения фундаментальных типов данных могут быть пойманы по значению (параметром блока catch является значение), но исключения нефундаментальных типов данных должны быть пойманы по константной ссылке (параметром блока catch является константная ссылка), дабы избежать ненужного копирования.
Как и в случае с функциями, если параметр не используется в блоке catch, то имя переменной можно не указывать:
catch (double) // примечание: Мы не указываем имя переменной, так как в этом нет надобности (мы её нигде в блоке не используем)
{
// Обрабатываем исключение типа double здесь
std::cerr << «We caught an exception of type double» << ‘\n’;
}
|
1 |
catch(double)// примечание: Мы не указываем имя переменной, так как в этом нет надобности (мы её нигде в блоке не используем) { // Обрабатываем исключение типа double здесь std::cerr<<«We caught an exception of type double»<<‘\n’; } |
Это предотвратит вывод предупреждений компилятора о неиспользуемых переменных.
Рефакторинг
Первое, что нужно сделать, — заключить код, отвечающий за ввод вывод данных в конструкцию try — catch (так легче управлять исключениями и применять свои исключения). Затем нужно создать отдельную переменную с типом File, куда можно записать адрес и название файла (это удобно, т. к. часто нужно работать с несколькими файлами, их помещают в отдельные переменные и обрабатывают циклом, и только затем результирующая переменная вставляется как параметр в FileWriter).
Также хорошей практикой при работе с потоками ввода/вывода считается использование буфера (класс FileWriter обращается к диску, если данных много это может потребовать много памяти, поэтому разумно манипулировать данными, используя буфер), для этого применяется класс BufferedWriter, а FileWriter записывается в скобки в качестве параметра. Для освобождения буфера вызывается метод flush(), его можно прописать перед методом close(), теперь код будет выглядеть так, как показано ниже.
Обработка ZeroDivisionError
Рассмотрим функцию , показанную ниже. Она принимает два аргумента – и – и возвращает частное от операции деления .
def divide(num,div):
return num/div
Вызов функции с разными аргументами возвращает ожидаемый результат:
res = divide(100,8) print(res) # Output # 12.5 res = divide(568,64) print(res) # Output # 8.875
Этот код работает нормально, пока вы не попробуете разделить число на ноль:
divide(27,0)
Вы видите, что программа выдает ошибку :
# Output
---------------------------------------------------------------------------
ZeroDivisionError Traceback (most recent call last)
<ipython-input-19-932ea024ce43> in <module>()
----> 1 divide(27,0)
<ipython-input-1-c98670fd7a12> in divide(num, div)
1 def divide(num,div):
----> 2 return num/div
ZeroDivisionError: division by zero
Можно обработать деление на ноль как исключение, выполнив следующие действия:
- В блоке поместите вызов функции . По сути, вы пытаетесь разделить на (try в переводе с английского — «пытаться», — прим. перев.).
- В блоке обработайте случай, когда равен 0, как исключение.
- В результате этих действий при делении на ноль больше не будет выбрасываться ZeroDivisionError. Вместо этого будет выводиться сообщение, информирующее пользователя, что он попытался делить на ноль.
Вот как все это выглядит в коде:
try:
res = divide(num,div)
print(res)
except ZeroDivisionError:
print("You tried to divide by zero :( ")
При корректных входных данных наш код по-прежнему работает великолепно:
divide(10,2) # Output # 5.0
Когда же пользователь попытается разделить на ноль, он получит уведомление о возникшем исключении. Таким образом, программа завершается корректно и без ошибок.
divide(10,0) # Output # You tried to divide by zero :(
Запись бинарной информации в файл
Если вам требуется записать не текстовые данные, а бинарные данные, используйте следующий пример. В качестве бинарных данных может выступать любой массив байтов (например, байтовое представление картинки или любого другого файла).
// запись в файл бинарной информации (файл перезаписывается)
byte[] data = "Бинарные данные".getBytes();
Path fileB = Paths.get("output.bin");
Files.write(fileB, data);
Для того, чтобы добавить информацию в конец файла, не перезаписывая его полностью, ипользуйте этот код:
// запись в файл бинарной информации (информация добавляется в конец файла)
byte[] data2 = "Бинарные данные".getBytes();
Path fileB2 = Paths.get("output.bin");
Files.write(fileB2, data, StandardOpenOption.APPEND);
Если же вы используете Java 6 ниже, воспользуйтесь следующими примерами.
Печатающий автор
3.1 В этом примере показано, как использовать PrintWriter для создания и записи в файл.
package com.mkyong.io.file;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
public class CreateFile {
public static void main(String[] args) {
String fileName = "/home/mkyong/newFile.txt";
// Java 10, new constructor, support Charsets
try (PrintWriter writer = new PrintWriter(fileName, StandardCharsets.UTF_8)) {
writer.println("first line!");
writer.println("second line!");
} catch (IOException e) {
e.printStackTrace();
}
// Java 1.5
/*try (PrintWriter writer = new PrintWriter(fileName, "UTF-8")) {
writer.println("first line!");
writer.println("second line!");
} catch (IOException e) {
e.printStackTrace();
}*/
}
}
Что обычно делают блоки catch?
Если исключение направлено в блок catch, то оно считается «обработанным», даже если блок catch пуст. Однако, как правило, вы захотите, чтобы ваши блоки catch делали что-то полезное. Есть три распространенные вещи, которые выполняют блоки catch, когда они поймали исключение:
Во-первых, блок catch может вывести сообщение об ошибке (либо в консоль, либо в лог-файл).
Во-вторых, блок catch может возвратить значение или код ошибки обратно в caller.
В-третьих, блок catch может сгенерировать другое исключения. Поскольку блок catch не находится внутри блока try, то новое сгенерированное исключение будет обрабатываться следующим блоком try.
Сейчас вы уже должны были получить основное представление об исключениях. На следующем уроке мы рассмотрим еще несколько примеров для проверки того, насколько гибкими исключения могут быть.
