Mateusz Dobrychlop

Python GUI Development with Tkinter: Part 3

<h2 id="introduction">Introduction</h2>
Handling files is an entry-level and fundamental skill for any programmer. They're very commonly used to store application data, user configurations, videos, images, etc. There are a countless number of use-cases for files in software applications, so you'd be smart to make yourself deeply familiar with the tasks of manipulating files. These tasks could include (among others) creating, deleting, and moving files.
In this article, we'll cover the process of working with files using the Python programming language. The built-in methods it offers makes it very easy to handle files using a relatively small amount of code. As with anything in programming, there are many ways to achieve the same goal when it comes to files, but in this article we'll stick with the basics and show the most common ways to perform these actions.
<h2 id="creatingfilesinpython">Creating Files in Python</h2>
<h3 id="fileopeningmodes">File Opening Modes</h3>
There are modes in which you can open a file in Python. The mode you choose depends on how you plan to use the file, or what kind of data you'll be reading (writing) from (to) the file. This mode is specified when opening a file using the built-in <code>open()</code> method, explained in further detail in the next section.
Let's take a look at some of the possible combinations of file modes:
<ul>
<li><code>w</code>: Opens a file for writing and creates a new file if it doesn't yet exist. In the case that the file does exist, it overwrites it.</li>
<li><code>w+</code>: Opens a file for writing but also for reading and creating it if it doesn't exist. If a file already exists, it overwrites it.</li>
<li><code>r</code>: Opens a file for reading only.</li>
<li><code>rb</code>: Opens a file for reading in Binary format.</li>
<li><code>wb</code>: Opens a file for writing in Binary format.</li>
<li><code>wb+</code>: Opens a file for writing and reading in Binary format.</li>
<li><code>a</code>: Opens a file for appending at the end of the file.</li>
<li><code>+</code>: In general, this character is used along side <code>r</code>, <code>w</code>, or <code>a</code> and means both writing and reading.</li>
</ul>
If no file mode is specified, then <code>r</code> will be assumed by default.
When choosing a mode, take in to careful consideration what your use-case is and what all the file will be used for for the duration that it is open.
<h3 id="open">open()</h3>
As with just about anything in Python, performing many file-related tasks is very simple. For example, creating a file in Python can be done in a single line of code:
<pre><code class="hljs">myFile = open(&quot;new.txt&quot;, &quot;w+&quot;)
</code></pre>
In the example above we have opened a file, &quot;new.txt&quot; for reading and writing. In our case, since the file does not already exist, it is automatically created.
The <code>open()</code> method accepts many arguments, although the majority of the time you'll only use these two:
<ul>
<li>filename – Required field to specify the name of the file we wish to open/create. In our example, &quot;new.txt&quot;</li>
<li>mode – Optional argument to specify the file opening mode, in our example &quot;w+&quot;</li>
</ul>
You can omit the second argument, in which case it will be assumed by Python as <code>r</code>.
The other arguments not listed here allow you to configure buffering, encodings, newline handling, etc. For more info on these arguments, check out the <a rel="nofollow" target="_blank" href="https://docs.python.org/3.3/library/functions.html#open">official Python documentation</a> on the <code>open</code> method.
<h3 id="close">close()</h3>
When you open a file you always need to make sure that you also close it. This can be done using the file object's <code>close()</code> method, or opening it using the <code>with</code> keyword that Python provides, which closes it automatically when out of scope. After closing the file, it won't be available for reading or writing within your code anymore, unless you open it back up.
Keeping your files open will use up system resources, slow down your program, and in some cases prevent the file from being used by other code. Python's garbage collection does it's best to automatically close files when they're not being used anymore, but you shouldn't rely on it.
If a file is already closed, calling <code>close()</code> on it again won't affect it at all:
<pre><code class="hljs">myFile.close()
myFile.close() # Doesn&#x27;t affect the file
</code></pre>
<h2 id="movingfilesinpython">Moving Files in Python</h2>
To move a file in Python, we will need to import the <code>os</code> and <code>shutil</code> modules that provide us the ability to copy, move, and remove files in Python. Both of these modules provide methods to do so, although in many cases the <code>shutil</code> module has more convenient methods.
<pre><code class="hljs">import os
import shutil

# Move a file by renaming it&#x27;s path
os.rename(&#x27;/Users/billy/d1/xfile.txt&#x27;, &#x27;/Users/billy/d2/xfile.txt&#x27;)

# Move a file from the directory d1 to d2
shutil.move(&#x27;/Users/billy/d1/xfile.txt&#x27;, &#x27;/Users/billy/d2/xfile.txt&#x27;)
</code></pre>
Keep in mind that the destination directory needs to exist in order for this example to work. Once you've set up the directories &quot;d1&quot; and &quot;d2&quot; (or just changed the example to fit your directory structure), run the code. Now check out the &quot;d2&quot; directory and you should see the xfile.txt if now present in that directory.
Pretty simple, right?
<h2 id="deletingfilesinpython">Deleting Files in Python</h2>
As you probably guessed, it's pretty easy to remove a file in Python using the <code>remove()</code> method from the <code>os</code> module.
In our example below, we'll delete the &quot;xfile.txt&quot;. All we need to do is call the <code>remove()</code> method with the path of the file we want to delete:
<pre><code class="hljs">import os

# Delete xfile.txt
os.remove(&#x27;/Users/billy/d2/xfile.txt&#x27;)
</code></pre>
Now check out the &quot;d2&quot; directory again and the file xfile.txt will now be done. Simple as that!
<h2 id="conclusion">Conclusion</h2>
In this article, we showed very simple examples of how to create, move, and delete files in Python using the built-in functions such as <code>open()</code>, <code>shutil.move()</code>, and <code>os.remove()</code>. In addition, we presented a simple introduction and explanation of Python file modes.

Guest Contributor

How to Create, Move, and Delete Files in Python

Usman Malik

Applying Wrapper Methods in Python for Feature Selection

<h2 id="overview">Overview</h2>
In this article, we'll cover the process of creating custom both checked and unchecked exceptions in Java.
If you'd like to read more about exceptions and exception handling in Java, we've covered it in detail in - <a rel="nofollow" target="_blank" href="/exception-handling-in-java-a-complete-guide-with-best-and-worst-practices/">Exception Handling in Java: A Complete Guide with Best and Worst Practices</a>
<h2 id="whyusecustomexceptions">Why Use Custom Exceptions?</h2>
Although Java exceptions, as they are, cover nearly all exceptional cases and conditions, your application might throw a specific custom exception, unique to your code and logic.
Sometimes, we need to create our own for representing business logic exceptions, i.e. exceptions that are specific to our business logic or workflow. For example <code>EmailNotUniqueException</code>, <code>InvalidUserStateException</code>, etc.
They help application clients to better understand what went wrong. They are particularly useful for doing exception handling for REST APIs as different business logic constraints require different response codes to be sent back to the client.
If defining a custom exception doesn't provide benefit over using a regular exception in Java, there's no need to define custom exceptions and you should just stick to the ones that are already available - no need to invent hot water again.
<h2 id="customcheckedexception">Custom Checked Exception</h2>
Let's consider a scenario where we want to validate an email that is passed as an argument to a method.
We want to check whether it's valid or not. Now we could use Java's built-in <code>IllegalArgumentException</code>, which is fine if we are just checking for a single thing like whether it matches a predefined REGEX or not.
But suppose we also have a business condition to check that all emails in our system need to be unique. Now we have to perform a second check (DB/network call). We can, of course, use the same <code>IllegalArgumentException</code>, but it will be not clear what the exact cause is - whether the email failed REGEX validation or the email already exists in the database.
Let's create a custom exception to handle this situation. To create an exception, like any other exception, we have to extend the <code>java.lang.Exception</code> class:
<pre><code class="hljs">public class EmailNotUniqueException extends Exception {

 public EmailNotUniqueException(String message) {
 super(message);
 }
}

</code></pre>
Note that we provided a constructor that takes a <code>String</code> error message and calls the parent class constructor. Now, this is not mandatory but it's a common practice to have some sort of details about the exception that occurred.
By calling <code>super(message)</code>, we initialize the exception's error message and the base class takes care of setting up the custom message, according to the <code>message</code>.
Now, let's use this custom exception in our code. Since we're defining a method that can throw an exception in the service layer, we'll mark it with the <code>throws</code> keyword.
If the input email already exists in our database (in this case a list), we <code>throw</code> our custom exception:
<pre><code class="hljs">public class RegistrationService { 
 List&lt;String&gt; registeredEmails = Arrays.asList(&quot;abc@gmail.com&quot;, &quot;xyz@gmail.com&quot;);

 public void validateEmail(String email) throws EmailNotUniqueException {
 if (registeredEmails.contains(email)) {
 throw new EmailNotUniqueException(&quot;Email Already Registered&quot;);
 }
 }
}

</code></pre>
Now let's write a client for our service. Since it's a checked exception, we have to adhere to the handle-or-declare rule. In the proceeding example, we decided to &quot;handle&quot; it:
<pre><code class="hljs">public class RegistrationServiceClient { 
 public static void main(String[] args) {
 RegistrationService service = new RegistrationService();
 try {
 service.validateEmail(&quot;abc@gmail.com&quot;);
 } catch (EmailNotUniqueException e) {
 // logging and handling the situation
 }
 }
}

</code></pre>
Running this piece of code will yield:
<pre><code class="hljs">mynotes.custom.checked.exception.EmailNotUniqueException: Email Already Registered 
 at mynotes.custom.checked.exception.RegistrationService.validateEmail(RegistrationService.java:12)
 at mynotes.custom.checked.exception.RegistrationServiceClient.main(RegistrationServiceClient.java:9)

</code></pre>
Note: The exception handling process is omitted for brevity but is an important process nonetheless.
<h2 id="customuncheckedexception">Custom Unchecked Exception</h2>
This works perfectly fine but our code has become a bit messy. Additionally, we are forcing the client to capture our exception in a <code>try-catch</code> block. In some cases, this can lead to forcing developers to write boilerplate code.
In this case, it can be beneficial to create a custom runtime exception instead. To create a custom unchecked exception we have to extend the <code>java.lang.RuntimeException</code> class.
Let's consider the situation where we have to check if the email has a valid domain name or not:
<pre><code class="hljs">public class DomainNotValidException extends RuntimeException {

 public DomainNotValidException(String message) {
 super(message);
 }
}

</code></pre>
Now let use it in our service:
<pre><code class="hljs">public class RegistrationService {

 public void validateEmail(String email) {
 if (!isDomainValid(email)) {
 throw new DomainNotValidException(&quot;Invalid domain&quot;);
 }
 }

 private boolean isDomainValid(String email) {
 List&lt;String&gt; validDomains = Arrays.asList(&quot;gmail.com&quot;, &quot;yahoo.com&quot;, &quot;outlook.com&quot;);
 if (validDomains.contains(email.substring(email.indexOf(&quot;@&quot;) + 1))) {
 return true;
 }
 return false;
 }
}

</code></pre>
Notice that we did not have to use the <code>throws</code> keywords at the method signature since it is an unchecked exception.
Now let's write a client for our service. We don't have to use a <code>try-catch</code> block this time:
<pre><code class="hljs">public class RegistrationServiceClient {

 public static void main(String[] args) {
 RegistrationService service = new RegistrationService();
 service.validateEmail(&quot;abc@gmail1.com&quot;);
 }
}

</code></pre>
Running this piece of code will yield:
<pre><code class="hljs">Exception in thread &quot;main&quot; mynotes.custom.unchecked.exception.DomainNotValidException: Invalid domain 
 at mynotes.custom.unchecked.exception.RegistrationService.validateEmail(RegistrationService.java:10)
 at mynotes.custom.unchecked.exception.RegistrationServiceClient.main(RegistrationServiceClient.java:7)

</code></pre>
Note: Of course, you can surround your code with a <code>try-catch</code> block to capture the arising exception but now it's not being forced by the compiler.
<h2 id="rethrowinganexceptionwrappedinsideacustomexception">Rethrowing an Exception Wrapped Inside a Custom Exception</h2>
Sometimes we need to catch an exception and re-throw it by adding in a few more details. This is usually common if you have various error codes defined in your application that needs to be either logged or returned to the client in case of that particular exception.
Suppose your application has a standard <code>ErrorCodes</code> class:
<pre><code class="hljs">public enum ErrorCodes { 
 VALIDATION_PARSE_ERROR(422);

 private int code;

 ErrorCodes(int code) {
 this.code = code;
 }

 public int getCode() {
 return code;
 }
}

</code></pre>
Let's create our custom exception:
<pre><code class="hljs">public class InvalidCurrencyDataException extends RuntimeException {

 private Integer errorCode;

 public InvalidCurrencyDataException(String message) {
 super(message);
 }

 public InvalidCurrencyDataException(String message, Throwable cause) {
 super(message, cause);
 }

 public InvalidCurrencyDataException(String message, Throwable cause, ErrorCodes errorCode) {
 super(message, cause);
 this.errorCode = errorCode.getCode();
 }

 public Integer getErrorCode() {
 return errorCode;
 }
}

</code></pre>
Notice we have multiple constructors and let the service class decide which one to use. Since we are rethrowing the exception, it's always a good practice to capture the root cause of the exception hence the <code>Throwable</code> argument which can be passed` to the parent class constructor.
We are also capturing the error code in one of the constructors and set the <code>errorCode</code> within the exception itself. The <code>errorCode</code> could be used by the client for logging or any other purpose. This helps in a more centralized standard for exception handling.
Lets write our service class:
<pre><code class="hljs">public class CurrencyService { 
 public String convertDollarsToEuros(String value) {
 try {
 int x = Integer.parseInt(value);
 } catch (NumberFormatException e) {
 throw new InvalidCurrencyDataException(&quot;Invalid data&quot;, e, ErrorCodes.VALIDATION_PARSE_ERROR);
 }
 return value;
 }
}

</code></pre>
So we caught the standard <code>NumberFormatException</code>and threw our own <code>InvalidCurrencyDataException</code>. We passed the parent exception to our custom exception so that we won't lose the root cause from which they occurred.
Let's write a test client for this service:
<pre><code class="hljs">public class CurrencyClient { 
 public static void main(String[] args) {
 CurrencyService service = new CurrencyService();
 service.convertDollarsToEuros(&quot;asd&quot;);
 }
}

</code></pre>
Output:
<pre><code class="hljs">Exception in thread &quot;main&quot; mynotes.custom.unchecked.exception.InvalidCurrencyDataException: Invalid data 
 at mynotes.custom.unchecked.exception.CurrencyService.convertDollarsToEuro(CurrencyService.java:10)
 at mynotes.custom.unchecked.exception.CurrencyClient.main(CurrencyClient.java:8)
Caused by: java.lang.NumberFormatException: For input string: &quot;asd&quot; 
 at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
 at java.lang.Integer.parseInt(Integer.java:580)
 at java.lang.Integer.parseInt(Integer.java:615)
 at mynotes.custom.unchecked.exception.CurrencyService.convertDollarsToEuro(CurrencyService.java:8)
 ... 1 more

</code></pre>
As you can see we have a nice stack-trace of the exception which could be useful for debugging purposes.
<h2 id="bestpracticesforcustomexceptions">Best Practices for Custom Exceptions</h2>
<ul>
<li>Adhere to the general naming convention throughout the Java ecosystem - All custom exception class names should end with &quot;Exception&quot;</li>
<li>Avoid making custom exceptions if standard exceptions from the JDK itself can serve the purpose. In most cases, there's no need to define custom exceptions.</li>
<li>Prefer runtime exceptions over checked exceptions. Frameworks like <a href="https://spring.io/">Spring</a> have wrapped all checked exception to runtime exceptions, hence not forcing the client to write boilerplate code that they don't want or need to.</li>
<li>Provide many overloaded constructors based on how the custom exception would be thrown. If it's being used for rethrowing an existing exception then definitely provide a constructor that sets the cause.</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
Custom exceptions are used for specific business logic and requirements. In this article, we've discussed the need for them as well as covered their usage.
The code for the examples used in this article can be found on <a rel="nofollow" target="_blank" href="https://github.com/StackAbuse/java">Github</a>.

Python GUI Development with Tkinter: Part 3

How to Create, Move, and Delete Files in Python

Applying Wrapper Methods in Python for Feature Selection

How to Make Custom Exceptions in Java

Asynchronous Python for Web Development

Overloading Functions and Operators in Python

Java's Object Methods: clone()

Applying Filter Methods in Python for Feature Selection

Guide to Spring Data JPA