Marcus Sanatan

Building a GraphQL API with Django

Usman Malik

Seaborn Library for Data Visualization in Python: Part 2

David Landup

Password Encoding with Spring Security

<h2 id="overview">Overview</h2>
<a rel="nofollow" target="_blank" href="https://projectlombok.org/">Lombok</a> is an open-source library that is used to reduce boilerplate code in Java classes. This is achieved by replacing many of the repetitive pieces of code with simple and concise annotations.
Lombok injects itself in the build process (via your project/IDE) and auto generates the Bytecode for the desired methods into your <code>.class</code> files.
So with Lombok, you can get rid of all the getter and setter methods, hash-code, and equals methods and many more just by adding annotations.
<h2 id="lomboksetup">Lombok Setup</h2>
<h3 id="installinglombokintoeclipse">Installing Lombok into Eclipse</h3>
Download the Lombok <code>.jar</code> file from <a rel="nofollow" target="_blank" href="https://projectlombok.org/download">the official website</a>. Run the downloaded <code>lombok.jar</code> file or execute the command in the terminal:
<pre><code class="hljs">java -jar lombok.jar
</code></pre>
This will start the installer:
<img src="https://s3.amazonaws.com/stackabuse/media/project-lombok-1.PNG" alt="project_lombok_setup_1">
If it didn't automatically detect the location of your preferred IDE, you can specify the location manually and then finish the installation by clicking <code>Install/Update</code>.
<img src="https://s3.amazonaws.com/stackabuse/media/project-lombok-2.PNG" alt="project_lombok_setup_2">
You can check whether the installation is active or not in Eclipse's &quot;About&quot; dialog at the end of the copyright text:
<img src="https://s3.amazonaws.com/stackabuse/media/project-lombok-3.PNG" alt="project_lombok_setup_3">
<h3 id="installinglombokintonetbeans">Installing Lombok into NetBeans</h3>
Download the Lombok <code>.jar</code> from <a rel="nofollow" target="_blank" href="https://projectlombok.org/download">the official website</a> and add it to the project libraries.
Activating the plugin is as easy as selecting <code>Project Properties -&gt; Build - Compiling -&gt; Enable Annotation Processing in Editor</code>.
<img src="https://s3.amazonaws.com/stackabuse/media/project-lombok-4.png" alt="project_lombok_setup_4"> 
<a rel="nofollow" target="_blank" href="https://projectlombok.org/setup/netbeans">NetBeans Installation</a>
<h3 id="installinglombokintointellij">Installing Lombok into IntelliJ</h3>
IntelliJ Idea makes it really easy to install plugins into the IDE:
<ul>
<li>
Go to <code>File -&gt; Settings -&gt; Plugins</code> and select <code>Browse Repositories</code> 
<img src="https://s3.amazonaws.com/stackabuse/media/project-lombok-5.PNG" alt="project_lombok_setup_5">
</li>
<li>
Search <code>Lombok Plugin</code> and click <code>Install Plugin</code> 
<img src="https://s3.amazonaws.com/stackabuse/media/project-lombok-6.PNG" alt="project_lombok_setup_6">
</li>
</ul>
After this, just restart the IDE and you're all set.
For other IDE's you can visit their <a rel="nofollow" target="_blank" href="https://projectlombok.org">home page</a> and check the Install section.
<h2 id="lombokdependency">Lombok Dependency</h2>
We need to add the following dependency in our <code>pom.xml</code>:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.projectlombok&lt;/groupId&gt;
 &lt;artifactId&gt;lombok&lt;/artifactId&gt;
 &lt;version&gt;{version}&lt;/version&gt;
 &lt;scope&gt;provided&lt;/scope&gt;
&lt;/dependency&gt;
</code></pre>
Note: The scope is <code>provided</code> as Lombok is a pure build dependency and not a runtime one. This means that we expect the application to provide us with the dependency on runtime.
<h2 id="lombokannotations">Lombok Annotations</h2>
<h3 id="getterandsetter">@Getter and @Setter</h3>
These annotations can be used either at a field or class level. If used at the class level, it will generate getters and setters for all the fields in the class:
<pre><code class="hljs">@Getter
@Setter
public class User {

 private String name;
 private String email;
}
</code></pre>
<img src="https://s3.amazonaws.com/stackabuse/media/project-lombok-7.PNG" alt="project_lombok_setup_6">
As seen in the IDE window, both of the fields now have their respective getter and setter methods, even though we didn't actually define them ourselves.
If you want getters/setters for only certain fields, annotate them accordingly:
<pre><code class="hljs">public class User {

 @Getter
 @Setter
 private String name;
 private String email;
}
</code></pre>
If you'd like to change the access level of the generated methods and fields, you can do so using the <code>AccessLevel</code> argument:
<pre><code class="hljs">@Setter(AccessLevel.PROTECTED)
private String email;
</code></pre>
There are a few access levels that Lombok offers in the form of arguments:
<ul>
<li>MODULE</li>
<li>NONE (Represents not generating anything or the complete lack of a method)</li>
<li>PACKAGE</li>
<li>PRIVATE</li>
<li>PROTECTED</li>
<li>PUBLIC</li>
</ul>
<h2 id="constructorannotations">Constructor Annotations</h2>
<h3 id="allargsconstructor">@AllArgsConstructor</h3>
The <code>@AllArgsConstructor</code> decorator will generate a public constructor will all the fields declared in your class in the same order as they are defined:
<pre><code class="hljs">@AllArgsConstructor
public class User {

 private String name;
 private String email;
}
</code></pre>
The generated constructor would look like:
<pre><code class="hljs">public User(String name, String email) {
 this.name = name;
 this.email = email;
}
</code></pre>
<h3 id="noargsconstructor">@NoArgsConstructor</h3>
<code>@NoArgsConstructor</code> will generate a constructor with no arguments:
<pre><code class="hljs">@NoArgsConstructor
public class User {

 private String name;
 private String email;
}
</code></pre>
The generated constructor would look like:
<pre><code class="hljs">public User() {}
</code></pre>
Note: If the constructor cannot be generated due to the presence of <code>final</code> fields, an error message will occur.
<h3 id="requiredargsconstructor">@RequiredArgsConstructor</h3>
<code>@RequiredArgsConstructor</code> will generate a constructor with all the <code>final</code> fields in the class:
<pre><code class="hljs">@RequiredArgsConstructor
public class User {

 private final String name;
 private String email;
}
</code></pre>
The generated constructor would look like:
<pre><code class="hljs">public User(final String name) {
 this.name = name;
}
</code></pre>
Note: <code>@NoArgsConstructor</code> and <code>@RequiredArgsConstructor</code> can't be used together and will throw a compile time error if you attempt to do so.
<h3 id="equalsandhashcode">@EqualsAndHashCode</h3>
<code>@EqualsAndHashCode</code> can be used at the class level which will generate implementations for <code>equals(Object other)</code> and <code>hashCode()</code> methods.
By default, it will use all the non-static and non-transient fields:
<pre><code class="hljs">@EqualsAndHashCode
public class User {

 private String name;
 private String email;
 private Integer age;
}
</code></pre>
If there are certain fields you don't want to include in the <code>equals</code> or <code>hashCode</code> methods, then we can exclude those specific fields by using <code>@EqualsAndHashCode.Exclude</code>:
<pre><code class="hljs">@EqualsAndHashCode
public class User {

 private String name;

 private String email;

 @EqualsAndHashCode.Exclude
 private Integer age;
}
</code></pre>
Alternatively, we can specify fields to be included by using <code>@EqualsAndHashCode.Include</code> and <code>@EqualsAndHashCode(onlyExplicitlyIncluded = true)</code>:
<pre><code class="hljs">@EqualsAndHashCode(onlyExplicitlyIncluded = true)
public class User {

 @EqualsAndHashCode.Include
 private String name;

 @EqualsAndHashCode.Include
 private String email;

 private Integer age;
}
</code></pre>
<h3 id="tostring">@ToString</h3>
Similarly, <code>@ToString</code> can be used to generate the <code>toString()</code> implementation. By default, all non-static fields will be printed. You can specify to include or skip certain fields by using a combination of <code>@ToString.Exclude</code>, <code>@ToString.Include</code>, and <code>@ToString(onlyExplicitlyIncluded = true)</code> just like before:
<pre><code class="hljs">@ToString(onlyExplicitlyIncluded = true)
public class User {

 @ToString.Include
 private String name;

 @ToString.Include
 private String email;

 private Integer age;
}
</code></pre>
<h3 id="data">@Data</h3>
It's common to have all of the aforementioned annotations in your POJO. Rather than writing an annotation for each of them, Lombok provides an aggregated annotation <code>@Data</code>.
This bundles the features of <code>@Getter/@Setter</code>, <code>@EqualsAndHashCode</code>, <code>@ToString</code> and <code>@RequiredArgsConstructor</code> together as if you've stacked them all:
<pre><code class="hljs">@Data
public class User {

 private final String name;
 private String email;
}
</code></pre>
<h3 id="value">@Value</h3>
Sometimes you want your object to be immutable after their creation. <code>@Value</code> is an immutable variant of <code>@Data</code> and is used exactly for this purpose.
By default, all the fields are made final and setters are not created:
<pre><code class="hljs">@Value
public class User {

 private String name;
 private String email;
}
</code></pre>
<h3 id="builder">@Builder</h3>
<a target="_blank" href="/creational-design-patterns-in-java/#builder">The Builder pattern</a> is a creational design pattern that is used to help build objects in a step-by-step manner.
As you might already know, while the builder pattern does allow you to instantiate objects in a more verbose and clean way than with constructors, the underlying code needed to implement the pattern is quite convoluted.
<code>@Builder</code> lets you automatically produce the code required for it:
<pre><code class="hljs">@Builder
@Data
public class User {

 private String name;
 private String email;
}
</code></pre>
Now you can create the <code>User</code> object using the Builder pattern without all of the code required to support it:
<pre><code class="hljs"> User user = new User.UserBuilder()
 .email(&quot;test@test.com&quot;)
 .name(&quot;test name&quot;)
 .build();

 System.out.println(user.getEmail());
</code></pre>
<h3 id="logging">Logging</h3>
It's common to use loggers in our application and typically we need to initialize a log variable at the top of the class and then use it in our methods.
This can be achieved by <code>@Log</code> which automatically creates this field:
<pre><code class="hljs">@Log
public class Test {

 public static void main(String[] args) {
 log.severe(&quot;Log message&quot;);
 }
}
</code></pre>
<code>@Log</code> creates a log variable with a <code>java.util.logging.Logger.getLogger(LogExample.class.getName())</code> object.
Lombok supports other logging frameworks too, which can be used by annotations like <code>@Log4j</code>, <code>@Slf4j</code> etc.
The full list of supported frameworks can be seen <a rel="nofollow" target="_blank" href="https://projectlombok.org/features/log">here</a>.
<h3 id="writingthreadsafemethods">Writing Thread Safe Methods</h3>
In Java for multi-threaded applications, we use the <code>synchronized</code> keyword at critical sections of the code.
We typically use a <code>synchronized</code> block with an object as a lock:
<pre><code class="hljs">public class SynchronizedJavaExample {
 private static final Object lock = new Object();

 public static void test() {
 synchronized (lock) {
 System.out.println(&quot;test&quot;);
 }
 }
}
</code></pre>
This can be auto-generated using the <code>@Synchronized</code> keyword:
<pre><code class="hljs">public class SynchronizedExample {

 @Synchronized
 public static void test() {
 System.out.println(&quot;test&quot;);
 }

}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've provided an introduction to Project Lombok and saw how it eases up our development process by reducing boilerplate code with simple annotations. This drastically enhances readability and brevity.
The code for the examples used in this article can be found on <a rel="nofollow" target="_blank" href="https://github.com/StackAbuse/java/tree/master/lombok-test">GitHub</a>.

Dhananjay Singh

Project Lombok: Reducing Java Boilerplate Code

Seaborn Library for Data Visualization in Python: Part 1

UNIX/Linux systems offer special mechanisms to communicate between each individual process. One of these mechanisms are <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Signal_(IPC)">signals</a>, and belong to the different methods of communication between processes (Inter Process Communication, abbreviated with IPC).
In short, signals are software interrupts that are sent to the program (or the process) to notify the program of significant events or requests to the program in order to run a special code sequence. A program that receives a signal either stops or continues the execution of its instructions, terminates either with or without a memory dump, or even simply ignores the signal.
Although it is defined in the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/POSIX">POSIX standard</a>, the reaction actually depends on how the developer wrote the script and implemented the handling of signals.
In this article we explain what are signals, show you how to sent a signal to another process from the command line as well as processing the received signal. Among other modules, the program code is mainly based on the <a rel="nofollow" target="_blank" href="https://docs.python.org/3.7/library/signal.html#module-signal">signal module</a>. This module connects the according C headers of your operating system with the Python world.
<h2 id="anintroductiontosignals">An Introduction to Signals</h2>
On UNIX-based systems, there are three categories of signals:
<ul>
<li>
System signals (hardware and system errors): SIGILL, SIGTRAP, SIGBUS, SIGFPE, SIGKILL, SIGSEGV, SIGXCPU, SIGXFSZ, SIGIO
</li>
<li>
Device signals: SIGHUP, SIGINT, SIGPIPE, SIGALRM, SIGCHLD, SIGCONT, SIGSTOP, SIGTTIN, SIGTTOU, SIGURG, SIGWINCH, SIGIO
</li>
<li>
User-defined signals: SIGQUIT, SIGABRT, SIGUSR1, SIGUSR2, SIGTERM
</li>
</ul>
Each signal is represented by an integer value, and the list of signals that are available is comparably long and not consistent between the different UNIX/Linux variants. On a Debian GNU/Linux system, the command <code>kill -l</code> displays the list of signals as follows:
<pre><code class="hljs">$ kill -l
 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP
 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR
31) SIGSYS 34) SIGRTMIN 35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3
38) SIGRTMIN+4 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7
58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX
</code></pre>
The signals 1 to 15 are roughly standardized, and have the following meaning on most of the Linux systems:
<ul>
<li>1 (SIGHUP): terminate a connection, or reload the configuration for daemons</li>
<li>2 (SIGINT): interrupt the session from the dialogue station</li>
<li>3 (SIGQUIT): terminate the session from the dialogue station</li>
<li>4 (SIGILL): illegal instruction was executed</li>
<li>5 (SIGTRAP): do a single instruction (trap)</li>
<li>6 (SIGABRT): abnormal termination</li>
<li>7 (SIGBUS): error on the system bus</li>
<li>8 (SIGFPE): floating point error</li>
<li>9 (SIGKILL): immmediately terminate the process</li>
<li>10 (SIGUSR1): user-defined signal</li>
<li>11 (SIGSEGV): segmentation fault due to illegal access of a memory segment</li>
<li>12 (SIGUSR2): user-defined signal</li>
<li>13 (SIGPIPE): writing into a pipe, and nobody is reading from it</li>
<li>14 (SIGALRM): the timer terminated (alarm)</li>
<li>15 (SIGTERM): terminate the process in a soft way</li>
</ul>
In order to send a signal to a process in a Linux terminal you invoke the <code>kill</code> command with both the signal number (or signal name) from the list above and the id of the process (pid). The following example command sends the signal 15 (SIGTERM) to the process that has the pid 12345:
<pre><code class="hljs">$ kill -15 12345
</code></pre>
An equivalent way is to use the signal name instead of its number:
<pre><code class="hljs">$ kill -SIGTERM 12345
</code></pre>
Which way you choose depends on what is more convenient for you. Both ways have the same effect. As a result the process receives the signal SIGTERM, and terminates immediately.
<h2 id="usingthepythonsignallibrary">Using the Python signal Library</h2>
Since Python 1.4, the <code>signal</code> library is a regular component of every Python release. In order to use the <code>signal</code> library, import the library into your Python program as follows, first:
<pre><code class="hljs">import signal
</code></pre>
Capturing and reacting properly on a received signal is done by a callback function - a so-called signal handler. A rather simple signal handler named <code>receiveSignal()</code> can be written as follows:
<pre><code class="hljs">def receiveSignal(signalNumber, frame):
 print(&#x27;Received:&#x27;, signalNumber)
 return
</code></pre>
This signal handler does nothing else than reporting the number of the received signal. The next step is registering the signals that are caught by the signal handler. For Python programs, all the signals (but 9, SIGKILL) can be caught in your script:
<pre><code class="hljs">if __name__ == &#x27;__main__&#x27;:
 # register the signals to be caught
 signal.signal(signal.SIGHUP, receiveSignal)
 signal.signal(signal.SIGINT, receiveSignal)
 signal.signal(signal.SIGQUIT, receiveSignal)
 signal.signal(signal.SIGILL, receiveSignal)
 signal.signal(signal.SIGTRAP, receiveSignal)
 signal.signal(signal.SIGABRT, receiveSignal)
 signal.signal(signal.SIGBUS, receiveSignal)
 signal.signal(signal.SIGFPE, receiveSignal)
 #signal.signal(signal.SIGKILL, receiveSignal)
 signal.signal(signal.SIGUSR1, receiveSignal)
 signal.signal(signal.SIGSEGV, receiveSignal)
 signal.signal(signal.SIGUSR2, receiveSignal)
 signal.signal(signal.SIGPIPE, receiveSignal)
 signal.signal(signal.SIGALRM, receiveSignal)
 signal.signal(signal.SIGTERM, receiveSignal)
</code></pre>
Next, we add the process information for the current process, and detect the process id using the methode <code>getpid()</code> from the <code>os</code> module. In an endless <code>while</code> loop we wait for incoming signals. We implement this using two more Python modules - <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/os.html">os</a> and <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/time.html">time</a>. We import them at the beginning of our Python script, too:
<pre><code class="hljs">import os
import time
</code></pre>
In the <code>while</code> loop of our main program the print statement outputs &quot;Waiting...&quot;. The <code>time.sleep()</code> function call makes the program wait for three seconds.
<pre><code class="hljs"> # output current process id
 print(&#x27;My PID is:&#x27;, os.getpid())

 # wait in an endless loop for signals 
 while True:
 print(&#x27;Waiting...&#x27;)
 time.sleep(3)
</code></pre>
Finally, we have to test our script. Having saved the script as <code>signal-handling.py</code> we can invoke it in a terminal as follows:
<pre><code class="hljs">$ python3 signal-handling.py 
My PID is: 5746
Waiting...
...
</code></pre>
In a second terminal window we send a signal to the process. We identify our first process - the Python script - by the process id as printed on screen, above.
<pre><code class="hljs">$ kill -1 5746
</code></pre>
The signal event handler in our Python program receives the signal we have sent to the process. It reacts accordingly, and simply confirms the received signal:
<pre><code class="hljs">...
Received: 1
...
</code></pre>
<h2 id="ignoringsignals">Ignoring Signals</h2>
The signal module defines ways to ignore received signals. In order to do that the signal has to be connected with the predefined function <code>signal.SIG_IGN</code>. The example below demonstrates that, and as a result the Python program cannot be interrupted by <code>CTRL+C</code> anymore. To stop the Python script an alternative way has been implemented in the example script - the signal SIGUSR1 terminates the Python script. Furthermore, instead of an endless loop we use the method <code>signal.pause()</code>. It just waits for a signal to be received.
<pre><code class="hljs">import signal
import os
import time

def receiveSignal(signalNumber, frame):
 print(&#x27;Received:&#x27;, signalNumber)
 raise SystemExit(&#x27;Exiting&#x27;)
 return

if __name__ == &#x27;__main__&#x27;:
 # register the signal to be caught
 signal.signal(signal.SIGUSR1, receiveSignal)

 # register the signal to be ignored
 signal.signal(signal.SIGINT, signal.SIG_IGN)

 # output current process id
 print(&#x27;My PID is:&#x27;, os.getpid())

 signal.pause()
</code></pre>
<h2 id="handlingsignalsproperly">Handling Signals Properly</h2>
The signal handler we have used up to now is rather simple, and just reports a received signal. This shows us that the interface of our Python script is working fine. Let's improve it.
Catching the signal is already a good basis but requires some improvement to comply with the rules of the POSIX standard. For a higher accuracy each signal needs a proper reaction (see list above). This means that the signal handler in our Python script needs to be extended by a specific routine per signal. This works best if we understand what a signal does, and what a common reaction is. A process that receives signal 1, 2, 9 or 15 terminates. In any other case it is expected to write a core dump, too.
Up to now we have implemented a single routine that covers all the signals, and handles them in the same way. The next step is to implement an individual routine per signal. The following example code demonstrates this for the signals 1 (SIGHUP) and 15 (SIGTERM).
<pre><code class="hljs">def readConfiguration(signalNumber, frame):
 print (&#x27;(SIGHUP) reading configuration&#x27;)
 return

def terminateProcess(signalNumber, frame):
 print (&#x27;(SIGTERM) terminating the process&#x27;)
 sys.exit()
</code></pre>
The two functions above are connected with the signals as follows:
<pre><code class="hljs"> signal.signal(signal.SIGHUP, readConfiguration)
 signal.signal(signal.SIGTERM, terminateProcess)
</code></pre>
Running the Python script, and sending the signal 1 (SIGHUP) followed by a signal 15 (SIGTERM) by the UNIX commands <code>kill -1 16640</code> and <code>kill -15 16640</code> results in the following output:
<pre><code class="hljs">$ python3 daemon.py
My PID is: 16640
Waiting...
Waiting...
(SIGHUP) reading configuration
Waiting...
Waiting...
(SIGTERM) terminating the process
</code></pre>
The script receives the signals, and handles them properly. For clarity, this is the entire script:
<pre><code class="hljs">import signal
import os
import time
import sys

def readConfiguration(signalNumber, frame):
 print (&#x27;(SIGHUP) reading configuration&#x27;)
 return

def terminateProcess(signalNumber, frame):
 print (&#x27;(SIGTERM) terminating the process&#x27;)
 sys.exit()

def receiveSignal(signalNumber, frame):
 print(&#x27;Received:&#x27;, signalNumber)
 return

if __name__ == &#x27;__main__&#x27;:
 # register the signals to be caught
 signal.signal(signal.SIGHUP, readConfiguration)
 signal.signal(signal.SIGINT, receiveSignal)
 signal.signal(signal.SIGQUIT, receiveSignal)
 signal.signal(signal.SIGILL, receiveSignal)
 signal.signal(signal.SIGTRAP, receiveSignal)
 signal.signal(signal.SIGABRT, receiveSignal)
 signal.signal(signal.SIGBUS, receiveSignal)
 signal.signal(signal.SIGFPE, receiveSignal)
 #signal.signal(signal.SIGKILL, receiveSignal)
 signal.signal(signal.SIGUSR1, receiveSignal)
 signal.signal(signal.SIGSEGV, receiveSignal)
 signal.signal(signal.SIGUSR2, receiveSignal)
 signal.signal(signal.SIGPIPE, receiveSignal)
 signal.signal(signal.SIGALRM, receiveSignal)
 signal.signal(signal.SIGTERM, terminateProcess)

 # output current process id
 print(&#x27;My PID is:&#x27;, os.getpid())

 # wait in an endless loop for signals 
 while True:
 print(&#x27;Waiting...&#x27;)
 time.sleep(3)
</code></pre>
<h2 id="furtherreading">Further Reading</h2>
Using the <code>signal</code> module and an according event handler it is relatively easy to catch signals. Knowing the meaning of the different signals, and to react properly as defined in the POSIX standard is the next step. It requires that the event handler distinguishes between the different signals, and has a separate routine for all of them.

Frank Hofmann

Handling Unix Signals in Python

Python Data Visualization with Matplotlib

Saving data to a file is one of the most common programming tasks you may come across in your developer life.
Generally, programs take some input and produce some output. There are numerous cases in which we'd want to persist these results. We may find ourselves saving data to a file for later processing - from webpages we browse, simple dumps of tabular data we use for reports, machine learning and training or logging during the application runtime - we rely on applications writing to files rather than doing it manually.
Python allows us to save files of various types without having to use third-party libraries. In this article, we'll dive into saving the most common file formats in Python.
<h2 id="openingandclosingafile">Opening and Closing a File</h2>
<h3 id="openingafile">Opening a File</h3>
The contents of a file can be accessed when it's opened, and it's no longer available for reading and writing after it's been closed.
Opening a file is simple in Python:
<pre><code class="hljs">my_data_file = open(&#x27;data.txt&#x27;, &#x27;w&#x27;)
</code></pre>
When opening a file you'll need the filename - a string that could be a relative or absolute path. The second argument is the mode, this determines the actions you can do with the open file.
Here are some of the commonly used ones:
<ul>
<li><code>r</code> - (default mode) open the file for reading</li>
<li><code>w</code> - open the file for writing, overwriting the content if the file already exists with data</li>
<li><code>x</code> - creates a new file, failing if it exists</li>
<li><code>a</code> - open the file for writing, appending new data at the end of the file's contents if it already exists</li>
<li><code>b</code> - write binary data to files instead of the default text data</li>
<li><code>+</code> - allow reading and writing to a mode</li>
</ul>
Let's say you wanted to write to a file and then read it after, your mode should be 'w+'. If you wanted to write and then read from a file, without deleting the previous contents then you'll use 'a+'.
<h3 id="closingafile">Closing a File</h3>
Closing a file is even easier in Python:
<pre><code class="hljs">my_data_file.close()
</code></pre>
You simply need to call the close method on the file object. It's important to close the file after you are finished using it, and there are many good reasons to do so:
<ul>
<li>Open files take up space in RAM</li>
<li>Lowers chance of data corruption as it's no longer accessible</li>
<li>There's a limit of files your OS can have open</li>
</ul>
For small scripts, these aren't pressing concerns, and some Python implementations will actually automatically close files for you, but for large programs don't leave closing your files to chance and make sure to free up the used resources.
<h2 id="usingthewithkeyword">Using the &quot;with&quot; Keyword</h2>
Closing a file can be easily forgotten, we're human after all. Lucky for us, Python has a mechanism to use a file and automatically close it when we're done.
To do this, we simply need to use the <code>with</code> keyword:
<pre><code class="hljs">with open(&#x27;data.txt&#x27;, &#x27;w&#x27;) as my_data_file:
 # TODO: write data to the file
# After leaving the above block of code, the file is closed
</code></pre>
The file will be open for all the code that's indented after using the <code>with</code> keyword, marked as the <code># TODO</code> comment. Once that block of code is complete, the file will be automatically closed.
This is the recommended way to open and write to a file as you don't have to manually close it to free up resources and it offers a failsafe mechanism to keep your mind on the more important aspects of programming.
<h2 id="savingatextfile">Saving a Text File</h2>
Now that we know the best way to access a file, let's get straight into writing data.
Fortunately, Python makes this straightforward as well:
<pre><code class="hljs">with open(&#x27;do_re_mi.txt&#x27;, &#x27;w&#x27;) as f:
 f.write(&#x27;Doe, a deer, a female deer\n&#x27;)
 f.write(&#x27;Ray, a drop of golden sun\n&#x27;)
</code></pre>
The <code>write()</code> function takes a string and puts that content into the file stream. Although we don't store it, the <code>write()</code> function returns the number of characters it just entered i.e. the length of the input string.
Note: Notice the inclusion of the newline character, <code>\n</code>. It’s used to write to a next line in the file, otherwise, all the text would be added as a single line.
<h3 id="savingmultiplelinesatonce">Saving Multiple Lines at Once</h3>
With the <code>write()</code> function we can take one string and put it into a file. What if we wanted to write multiple lines at once?
We can use the <code>writelines()</code> function to put data in a sequence (like a list or tuple) and into a file:
<pre><code class="hljs">with open(&#x27;browsers.txt&#x27;, &#x27;w&#x27;) as f:
 web_browsers = [&#x27;Firefox\n&#x27;, &#x27;Chrome\n&#x27;, &#x27;Edge\n&#x27;]
 f.writelines(web_browsers)
</code></pre>
As before, if we want the data to appear in new lines we include the newline character at the end of each string.
If you'd like to skip the step of manually entering the newline character after each item in the list, it's easy to automate it:
<pre><code class="hljs">with open(&#x27;browsers.txt&#x27;, &#x27;w&#x27;) as f:
 web_browsers = [&#x27;Firefox\n&#x27;, &#x27;Chrome\n&#x27;, &#x27;Edge\n&#x27;]
 f.writelines(&quot;%s\n&quot; % line for line in web_browsers)
</code></pre>
Note: The input for <code>writelines()</code> must be a flat sequence of strings or bytes - no numbers, objects or nested sequences like a list within a list are allowed.
If you're interested in reading more about lists and tuples, we already have an article dedicated to them - <a rel="nofollow" target="_blank" href="/lists-vs-tuples-in-python/">Lists vs Tuples in Python</a>.
<h2 id="savingacsvfile">Saving a CSV File</h2>
CSV (Comma Separated Values) files are commonly used for storing tabular data. Because of its popularity, Python has some built-in methods to make writing files of that type easier:
<pre><code class="hljs">import csv

weekdays = [&#x27;Monday&#x27;, &#x27;Tuesday&#x27;, &#x27;Wednesday&#x27;, &#x27;Thursday&#x27;, &#x27;Friday&#x27;]
sales = [&#x27;10&#x27;, &#x27;8&#x27;, &#x27;19&#x27;, &#x27;12&#x27;, &#x27;25&#x27;]

with open(&#x27;sales.csv&#x27;, &#x27;w&#x27;) as csv_file:
 csv_writer = csv.writer(csv_file, delimiter=&#x27;,&#x27;)
 csv_writer.writerow(weekdays)
 csv_writer.writerow(sales)
</code></pre>
We first need to import the <code>csv</code> library to get their helper functions. We open the file as we're accustomed to but instead of writing content on the <code>csv_file</code> object, we create a new object called <code>csv_writer</code>.
This object provides us with the <code>writerow()</code> method which allows us to put all the row's data in the file in one go.
If you'd like to learn more about using CSV files in Python in more detail, you can read more here: <a rel="nofollow" target="_blank" href="/reading-and-writing-csv-files-in-python/">Reading and Writing CSV Files in Python</a>.
<h2 id="savingajsonfile">Saving a JSON File</h2>
JSON is another popular format for storing data, and just like with CSVs, Python has made it dead simple to write your dictionary data into JSON files:
<pre><code class="hljs">import json

my_details = {
 &#x27;name&#x27;: &#x27;John Doe&#x27;,
 &#x27;age&#x27;: 29
}

with open(&#x27;personal.json&#x27;, &#x27;w&#x27;) as json_file:
 json.dump(my_details, json_file)
</code></pre>
We do need to import the <code>json</code> library and open the file. To actually write the data to the file, we just call the <code>dump()</code> function, giving it our data dictionary and the file object.
If you'd like to know more about using JSON files in Python, you can more from this article: <a rel="nofollow" target="_blank" href="/reading-and-writing-json-to-a-file-in-python/">Reading and Writing JSON to a File in Python</a>.
<h2 id="conclusion">Conclusion</h2>
Saving files can come in handy in many kinds of programs we write. To write a file in Python, we first need to open the file and make sure we close it later.
It's best to use the <code>with</code> keyword so files are automatically closed when we're done writing to them.
We can use the <code>write()</code> method to put the contents of a string into a file or use <code>writelines()</code> if we have a sequence of text to put into the file.
For CSV and JSON data, we can use special functions that Python provides to write data to a file once the file is open.

Saving Text, JSON, and CSV to a File in Python

Guest Contributor

Dimitrije Stamenic

Search Algorithms in Python