<h2 id="introduction">Introduction</h2>
Pandas is one of the most commonly used Python libraries for data handling and visualization. The <a rel="nofollow noopener" target="_blank" href="https://pandas.pydata.org/">Pandas library</a> provides classes and functionalities that can be used to efficiently read, manipulate and visualize data, stored in a variety of file formats.
In this article, we'll be reading and writing JSON files using Python and Pandas.
<h2 id="whatisajsonfile">What is a JSON File?</h2>
JavaScript Object Notation (JSON) is a data format that stores data in a human-readable form. While it can technically be used for storage, JSON files are primarily used for serialization and information exchange between a client and server.
Although it was derived from JavaScript, it's platform-agnostic and is a widely-spread and used format - most prevalently in REST APIs.
<h2 id="creatingajsonfile">Creating a JSON File</h2>
To create JSON files via Python, data has to be stored in a certain way. There are multiple ways of storing this data using Python. Some of the methods have been discussed in <a target="_blank" href="/reading-and-writing-json-to-a-file-in-python/">this article</a>.
We'll first create a file using core Python and then read and write to it via Pandas.
<h3 id="creatingjsondataviaanesteddictionaries">Creating JSON Data via a Nested Dictionaries</h3>
In Python, to create JSON data, you can use nested dictionaries. Each item inside the outer dictionary corresponds to a column in the JSON file.
The key of each item is the column header and the value is another dictionary consisting of rows in that particular column. Let's create a dictionary that can be used to create a JSON file that stores a record of fictional patients:
<pre><code class="hljs">patients = {
 &quot;Name&quot;:{&quot;0&quot;:&quot;John&quot;,&quot;1&quot;:&quot;Nick&quot;,&quot;2&quot;:&quot;Ali&quot;,&quot;3&quot;:&quot;Joseph&quot;},
 &quot;Gender&quot;:{&quot;0&quot;:&quot;Male&quot;,&quot;1&quot;:&quot;Male&quot;,&quot;2&quot;:&quot;Female&quot;,&quot;3&quot;:&quot;Male&quot;},
 &quot;Nationality&quot;:{&quot;0&quot;:&quot;UK&quot;,&quot;1&quot;:&quot;French&quot;,&quot;2&quot;:&quot;USA&quot;,&quot;3&quot;:&quot;Brazil&quot;},
 &quot;Age&quot; :{&quot;0&quot;:10,&quot;1&quot;:25,&quot;2&quot;:35,&quot;3&quot;:29}
}
</code></pre>
In the script above, the first item corresponds to the <code>Name</code> column. The item value consists of a dictionary where dictionary items represent rows. The keys of the inner dictionary items correspond to the index numbers of rows, where values represent row values.
Since that might be a bit hard to visualize just like that, here's a visual representation:
<img src="https://stackabuse.s3.amazonaws.com/media/reading-writing-json-files-with-pandas-1.PNG" alt="patients visualized">
In the <code>Name</code> column, the first record is stored at the 0th index where the value of the record is <code>John</code>, similarly, the value stored at the second row of the <code>Name</code> column is <code>Nick</code> and so on.
<h3 id="creatingjsondatavialistsofdictionaries">Creating JSON Data via Lists of Dictionaries</h3>
Another way to create JSON data is via a list of dictionaries. Each item in the list consists of a dictionary and each dictionary represents a row. This approach is a lot more readable than using nested dictionaries.
Let's create a list that can be used to create a JSON file that stores information about different cars:
<pre><code class="hljs">cars = [
 {&quot;Name&quot;:&quot;Honda&quot;, &quot;Price&quot;: 10000, &quot;Model&quot;:2005, &quot;Power&quot;: 1300},
 {&quot;Name&quot;:&quot;Toyota&quot;, &quot;Price&quot;: 12000, &quot;Model&quot;:2010, &quot;Power&quot;: 1600},
 {&quot;Name&quot;:&quot;Audi&quot;, &quot;Price&quot;: 25000, &quot;Model&quot;:2017, &quot;Power&quot;: 1800},
 {&quot;Name&quot;:&quot;Ford&quot;, &quot;Price&quot;: 28000, &quot;Model&quot;:2009, &quot;Power&quot;: 1200},
 
]
</code></pre>
Each dictionary item corresponds to a row in a JSON file. For example the first item in the first dictionary stores the value <code>Honda</code> in the <code>Name</code> column. Similarly, the value of the <code>Price</code> column in the first row will be <code>10000</code> and so on.
<h3 id="writingdatatoajsonfileviapython">Writing Data to a JSON File via Python</h3>
With our nested dictionary and a list of dictionaries, we can store this data in a JSON file. To achieve this, we'll use the <code>json</code> module and the <code>dump()</code> method:
<pre><code class="hljs">import json
with open(&#x27;E:/datasets/patients.json&#x27;, &#x27;w&#x27;) as f:
 json.dump(patients, f)
 
with open(&#x27;E:/datasets/cars.json&#x27;, &#x27;w&#x27;) as f:
 json.dump(cars, f) 
</code></pre>
Now, we have two JSON files - <code>patients.json</code> and <code>cars.json</code>. The next step is to read these files via the Pandas library.
If you'd like to read more about <a target="_blank" href="/reading-and-writing-json-to-a-file-in-python/">Reading and Writing JSON to a File in Core Python</a>, we've got you covered!
<h2 id="readingjsonfileswithpandas">Reading JSON Files with Pandas</h2>
To read a JSON file via Pandas, we'll utilize the <code>read_json()</code> method and pass it the path to the file we'd like to read. The method returns a Pandas <code>DataFrame</code> that stores data in the form of columns and rows.
Though, first, we'll have to install Pandas:
<pre><code class="hljs">$ pip install pandas
</code></pre>
<h3 id="readingjsonfromlocalfiles">Reading JSON from Local Files</h3>
The following script reads the <code>patients.json</code> file from a local system directory and stores the result in the <code>patients_df</code> dataframe. The header of the dataframe is then printed via the <code>head()</code> method:
<pre><code class="hljs">import pandas as pd
patients_df = pd.read_json(&#x27;E:/datasets/patients.json&#x27;)
patients_df.head()
</code></pre>
Running this code should yield: 
<img src="https://stackabuse.s3.amazonaws.com/media/reading-writing-json-files-with-pandas-1.PNG" alt="patients dataframe">
Similarly, the following script reads the <code>cars.json</code> file from the local system and then calls the <code>head()</code> method on the <code>cars_df</code> to print the header:
<pre><code class="hljs">cars_df = pd.read_json(&#x27;E:/datasets/cars.json&#x27;)
cars_df.head()
</code></pre>
Running this code should yield: 
<img src="https://stackabuse.s3.amazonaws.com/media/reading-writing-json-files-with-pandas-2.PNG" alt="cars dataframe">
<h3 id="readingjsonfromremotefiles">Reading JSON from Remote Files</h3>
The <code>read_json()</code> method isn't limited to only reading local files. You can also read JSON files located on remote servers. You just have to pass the path of the remote JSON file to the function call.
Let's read and print out the head of the Iris Dataset - a really popular dataset containing information about various Iris flowers:
<pre><code class="hljs">import pandas as pd
iris_data = pd.read_json(&quot;https://raw.githubusercontent.com/domoritz/maps/master/data/iris.json&quot;)
iris_data.head()
</code></pre>
Running this code should yield us: 
<img src="https://stackabuse.s3.amazonaws.com/media/reading-writing-json-files-with-pandas-3.PNG" alt="iris plant dataframe">
<h2 id="writingjsondatafilesviapandas">Writing JSON Data Files via Pandas</h2>
To convert a Pandas dataframe to a JSON file, we use the <code>to_json()</code> function on the dataframe, and pass the path to the soon-to-be file as a parameter.
Let's create a JSON file from the <code>tips</code> dataset, which is included in the Seaborn library for data visualization.
First off, let's install Seaborn:
<pre><code class="hljs">$ pip install seaborn
</code></pre>
Then, let's import it and load the tips it into a dataset:
<pre><code class="hljs">import seaborn as sns

dataset = sns.load_dataset(&#x27;tips&#x27;)
dataset.head()
</code></pre>
This is how the dataset looks like: 
<img src="https://stackabuse.s3.amazonaws.com/media/reading-writing-json-files-with-pandas-4.PNG" alt="tips dataset header">
Seaborn's <code>load_dataset()</code> function returns a Pandas <code>DataFrame</code>, so loading the dataset like this allows us to simply call the <code>to_json()</code> function to convert it.
Once we've gotten a hold of the dataset, let's save its content in a JSON file. We've set up a <code>datasets</code> directory for this:
<pre><code class="hljs">dataset.to_json(&#x27;E:/datasets/tips.json&#x27;)
</code></pre>
Navigating to the <code>E:/datasets</code> directory, you should see <code>tips.json</code>. Opening the file, we can see JSON that correspond to records in the Pandas dataframe containing the <code>tips</code> dataset:
<pre><code class="hljs">{
 &quot;total_bill&quot;:{
 &quot;0&quot;:16.99,
 &quot;1&quot;:10.34,
 &quot;2&quot;:21.01,
 &quot;3&quot;:23.68,
 &quot;4&quot;:24.59,
 &quot;5&quot;:25.29,
 ...
 }
 &quot;tip&quot;:{
 &quot;0&quot;:1.01,
 &quot;1&quot;:1.66,
 &quot;2&quot;:3.5,
 &quot;3&quot;:3.31,
 &quot;4&quot;:3.61,
 &quot;5&quot;:4.71,
 ...
 }
 &quot;sex&quot;:{
 &quot;0&quot;:&quot;Female&quot;,
 &quot;1&quot;:&quot;Male&quot;,
 &quot;2&quot;:&quot;Male&quot;,
 &quot;3&quot;:&quot;Male&quot;,
 &quot;4&quot;:&quot;Female&quot;,
 &quot;5&quot;:&quot;Male&quot;,
 ...
 }
 &quot;smoker&quot;:{
 &quot;0&quot;:&quot;No&quot;,
 &quot;1&quot;:&quot;No&quot;,
 &quot;2&quot;:&quot;No&quot;,
 &quot;3&quot;:&quot;No&quot;,
 &quot;4&quot;:&quot;No&quot;,
 &quot;5&quot;:&quot;No&quot;,
 ...
 }
 ...
</code></pre>
<h2 id="conclusion">Conclusion</h2>
JSON is a widely-used format for data storage and exchange between a client and a server. Developers often use this format over formats like XML due to how lightweight and readable it is.
In this article, we've covered how to read and write JSON files using Python's popular Pandas library - from local to remote files.

Usman Malik

JSON files are widespread due to how lightweight and readable they are. In this article, we'll use Python and Pandas to read and write JSON files.

Reading and Writing JSON Files in Python with Pandas

<h2 id="introduction">Introduction</h2>
In this article, we'll be diving into the Singleton Design Pattern, implemented in Python.
As time progresses, software gets more tailored to solving specific problems in different domains. While there are many difference in the application-level of our software, some aspects of software design remain largely the same. These aspects might not remain the same for all software out there but will hold true for a lot of scenarios. Therefore, learning and understanding them will be highly beneficial in helping us build resilient programs.
This is the first in a series about Design Patterns in Python and the different patterns that we can utilize to build software.
<h2 id="whatisadesignpattern">What is a Design Pattern?</h2>
A design pattern is a particular approach to solving a recurring problem in software development and is also used to represent good practices. It is not actual code, but it represents a particular way of organizing code to produce the desired solution in a recommended way. This means that we do not have to strictly follow set design patterns for all of our code, but analyze our needs and apply the best-suited design pattern for our needs.
Design patterns arise from a wealth of experience in solving problems in software development and are tried and tested to fit particular scenarios. Another reason to learn about design patterns is that, while a pattern may not work for a particular scenario, it can offer a base off which a solution can be formulated.
However, as much as design patterns can help us out of various situations, it is important to assess the current situation and explore all the options available before jumping directly into a pattern because there may be a better solution out there.
Design patterns are divided into a few broad categories, though mainly Creational patterns, Structural patterns, and Behavioral patterns.
<h2 id="creationalpatterns">Creational Patterns</h2>
There are several aspects of design patterns that set them apart from each other, including the complexity of the design pattern, the application level within a system, and the amount of detail.
Creational patterns include those that define ways to create objects that contribute to increased flexibility and reusability of code throughout the entire application.
Examples of creational patterns include the Singleton pattern, Factory Method, Abstract Factory, Builder and Prototype patterns.
<h2 id="thesingletonpattern">The Singleton Pattern</h2>
<h3 id="definition">Definition</h3>
The singleton pattern is a common creational pattern that is used to define the creation of a single instance of a class while providing a single global access point to that object.
This pattern restricts the number of objects that can be created from a class to one single object that will often-times be shared globally in an application.
<h3 id="motivation">Motivation</h3>
This pattern is commonly implemented in features that require control over access to a shared resource such as a database connection or a file. By ensuring that a class can only be used to create a single instance and providing a single global access point, access to the shared resource can be restricted and integrity can be maintained.
The creation of single instances also helps ensure that some aspects of our programs cannot be overwritten by other classes resulting in unsafe or inefficient code. This also allows us to access the same object in multiple points of our programs without the fear that it may be overwritten at some point in our program.
For instance, database connections are done once in our programs, and the same object is used to perform operations on our database all over the application. If different parts of our application could create their own database connections, integrity issues may arise over time as each part tries to access the database on their own.
<h3 id="implementation">Implementation</h3>
The Singleton pattern requires that the instantiation of a class is restricted to one object only. The control of object creation is achieved by implementing a creation method that saves the created object in a static field.
All calls to this creation method either return the original singleton object or an error signaling the existence of an instantiated object. This prevents the creation of more than one object for our class and maintains the singleton property.
A good analogy of a singleton pattern is that a country can have a single government that controls access and operations within the country. Any attempts to create another government are forbidden.
We can implement this government analogy in a singleton class as follows in Python:
<pre><code class="hljs">class SingletonGovt:
 __instance__ = None

 def __init__(self):
 &quot;&quot;&quot; Constructor.
 &quot;&quot;&quot;
 if SingletonGovt.__instance__ is None:
 SingletonGovt.__instance__ = self
 else:
 raise Exception(&quot;You cannot create another SingletonGovt class&quot;)

 @staticmethod
 def get_instance():
 &quot;&quot;&quot; Static method to fetch the current instance.
 &quot;&quot;&quot;
 if not SingletonGovt.__instance__:
 SingletonGovt()
 return SingletonGovt.__instance__
</code></pre>
In our example, we define the variable that will hold the single object to be instantiated. Our constructor checks if there is an existing class and raises an error.
When fetching the object using the <code>get_instance()</code> method, we check whether an existing instance is available and return it. If not, we create one and return it.
Our <code>SingletonGovt</code> in action:
<pre><code class="hljs">government = SingletonGovt()
print(government)

same_government = SingletonGovt.get_instance()
print(same_government)

another_government = SingletonGovt.get_instance()
print(another_government)

new_government = SingletonGovt()
print(new_government)
</code></pre>
When we run our script, we can see that we have just one <code>SingletonGovt</code> instance stored at a single point in memory. Any attempts to create another government are thwarted by the exception that we raise:
<img src="https://stackabuse.s3.amazonaws.com/media/singleton-design-pattern-in-python-1.png" alt="singleton design pattern in python results">
<h2 id="prosandcons">Pros and Cons</h2>
<h3 id="pros">Pros</h3>
<ul>
<li>The Singleton pattern offers the guarantee that only one instance of our class exists and reduces the risk of unexpected behavior in our program.</li>
<li>Since the creation of the class is controlled by a single class, this offers flexibility since changes only need to be made to one class and object.</li>
</ul>
<h3 id="cons">Cons</h3>
<ul>
<li>A class created using the singleton pattern violates the <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Single-responsibility_principle">Single Responsibility Principle</a> since the class may have to handle more than one responsibility at a given time.</li>
<li>Life cycle management can pose problems in other areas such as testing since the singleton class is kept alive during the lifespan of the application and different test cases might require new versions of the class.</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
In this post, we have introduced, discussed and implemented the Singleton Design Pattern.
Just like any other design pattern, it has its pros and cons and while it may be suitable for some situations, it might not apply to all our development needs. It is therefore up to us to analyze the problem at hand and make the decision whether or not the singleton pattern will make our work easier.

Robley Gori

The singleton is a common creational pattern used to define the creation of a single instance and access point to an object. 

In this article, we'll be diving into the Singleton Design Pattern, implemented in Python.

The Singleton Design Pattern in Python

<h2 id="introduction">Introduction</h2>
The Proxy Design Pattern is a design pattern belonging to the set of <a target="_blank" href="/structural-design-patterns-in-java/">structural patterns</a>. Structural patterns are a category of design patterns used to simplify the design of a program on its structural level.
As its name suggests, the proxy pattern means using a proxy for some other entity. In other words, a proxy is used as an intermediary in front of, or wrapped around, an existing object. This can be used, for example, when the actual object is very resource-intensive or when there are certain conditions which need to be checked before using the actual object. A proxy can also be useful if we'd like to limit the access or functionality of an object.
In this article, we'll describe the proxy pattern and show some examples in which it can be used.
<h2 id="theideabehindproxy">The Idea behind Proxy</h2>
Proxy is used to encapsulate functionalities of another object or system. Consider <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Java_remote_method_invocation">remote method invocation</a>, for example, which is a way of calling methods on another machine. In Java, this is accomplished via a remote proxy which is essentially an object providing a local representation of another remote object. Calling a method from another machine is then made possible simply by calling a method of the proxy object.
Each proxy is realized in such a way that it offers exactly the same interface to the client as a real object. This means that the client effectively notices no difference while using the proxy object.
There are several type of proxy objects. As can probably be inferred from the previous example, remote proxies are used to access some remote objects or resources. Besides remote proxies, there are also virtual proxies and protection proxies. Let's briefly describe each of them for a better understanding.
<h3 id="remoteproxies">Remote Proxies</h3>
Remote Proxies provide a local representation of another remote object or resource. Remote proxies are responsible not just for representation but also for some maintenance work. Such work could include connecting to a remote machine and maintaining the connection, encoding and decoding characters obtained through networking traffic, parsing, etc.
<h3 id="virtualproxies">Virtual Proxies</h3>
Virtual Proxies wrap expensive objects and loads them on-demand. Sometimes we don't immediately need all functionalities that an object offers, especially if it is memory/time-consuming. Calling objects only when needed might increase performance quite a bit, as we'll see in the example below.
<h3 id="protectionproxies">Protection Proxies</h3>
Protection Proxies are used for checking certain conditions. Some objects or resources might need appropriate authorization for accessing them, so using a proxy is one of the ways in which such conditions can be checked. With protection proxies, we also get the flexibility of having many variations of access control.
For example, if we're trying to provide access to a resource of an operating system, there are usually multiple categories of users. We could have a user who isn't allowed to view or edit the resource, a user who can do with the resource whatever they wish, etc.
Having proxies act as wrappers around such resources is a great way of implementing customized access control.
<h2 id="implementation">Implementation</h2>
<h3 id="virtualproxyexample">Virtual Proxy Example</h3>
One example of a virtual proxy is loading images. Let's imagine that we're building a file manager. Like any other file manager, this one should be able to display images in a folder that a user decides to open.
If we assume there exists a class, <code>ImageViewer</code>, responsible for loading and displaying images - we might implement our file manager by using this class directly. This kind of approach seems logical and straight-forward but it contains a subtle problem.
If we implement the file manager as described above, we're going to be loading images every time they appear in the folder. If the user only wishes to see the name or size of an image, this kind of approach would still load the entire image into memory. Since loading and displaying images are expensive operations, this can cause performance issues.
A better solution would be to display images only when actually needed. In this sense, we can use a proxy to wrap the existing <code>ImageViewer</code> object. This way, the actual image viewer will only get called when the image needs to be rendered. All other operations (such as obtaining the image name, size, date of creation, etc.) don't require the actual image and can therefore be obtained through a much lighter proxy object instead.
Let's first create our main interface:
<pre><code class="hljs">interface ImageViewer {
 public void displayImage();
}
</code></pre>
Next, we'll implement the concrete image viewer. Note that operations occurring in this class are costly:
<pre><code class="hljs">public class ConcreteImageViewer implements ImageViewer {

 private Image image;

 public ConcreteImageViewer(String path) {
 // Costly operation
 this.image = Image.load(path);
 }

 @Override
 public void displayImage() {
 // Costly operation
 image.display();
 }
}
</code></pre>
Now we'll implement our lightweight image viewer proxy. This object will call the concrete image viewer only when needed, i.e. when the client calls the <code>displayImage()</code> method. Until then, no images will be loaded or processed, which will make our program much more efficient.
<pre><code class="hljs">public class ImageViewerProxy implements ImageViewer {

 private String path;
 private ImageViewer viewer;

 public ImageViewerProxy(String path) {
 this.path = path;
 }

 @Override
 public void displayImage() {
 this.viewer = new ConcreteImageViewer(this.path);
 this.viewer.displayImage();
 }
}
</code></pre>
Finally, we'll write the client-side of our program. In the code below, we are creating six different image viewers. First, three of them are the concrete image viewers that automatically load images on creation. The last three images don't load any images into memory on creation.
Only with the last line will the first proxy viewer start loading the image. Compared to the concrete viewers, performance benefits are obvious:
<pre><code class="hljs">public static void main(String[] args) {
 ImageViewer flowers = new ConcreteImageViewer(&quot;./photos/flowers.png&quot;);
 ImageViewer trees = new ConcreteImageViewer(&quot;./photos/trees.png&quot;);
 ImageViewer grass = new ConcreteImageViewer(&quot;./photos/grass.png&quot;);

 ImageViewer sky = new ImageViewerProxy(&quot;./photos/sky.png&quot;);
 ImageViewer sun = new ImageViewerProxy(&quot;./photos/sun.png&quot;);
 ImageViewer clouds = new ImageViewerProxy(&quot;./photos/clouds.png&quot;);

 sky.displayImage();
}
</code></pre>
Another thing we could do is add a <code>null</code>-check in the <code>displayImage()</code> method of the <code>ImageViewerProxy</code>:
<pre><code class="hljs">@Override
public void displayImage() {
 if (this.viewer == null) {
 this.viewer = new ConcreteImageViewer(this.path);
 }
 this.viewer.displayImage();
}
</code></pre>
So, if we call:
<pre><code class="hljs">ImageViewer sky = new ImageViewerProxy(&quot;./photos/sky.png&quot;);

sky.displayImage();
sky.displayImage();
</code></pre>
Only once will the <code>new ConcreteImageViewer</code> call be executed. This will even further decrease the memory footprint of our application.
<blockquote>
Note: This example does not contain fully-compilable Java code. Some method calls, such as <code>Image.load(String path)</code>, are fictional and written in a simplified way mostly for illustration purposes.
</blockquote>
<h3 id="protectionproxyexample">Protection Proxy Example</h3>
In this example, we'll be flying a spaceship. Prior to that, we need to create two things: The <code>Spaceship</code> interface and the <code>Pilot</code> model:
<pre><code class="hljs">interface Spaceship {
 public void fly();
}
</code></pre>
<pre><code class="hljs">public class Pilot {
 private String name;

 // Constructor, Getters, and Setters
}
</code></pre>
Now we're going to implement the <code>Spaceship</code> interface and create an actual spaceship class:
<pre><code class="hljs">public class MillenniumFalcon implements Spaceship {
 @Override
 public void fly() {
 System.out.println(&quot;Welcome, Han. The Millennium Falcon is starting up its engines!&quot;);
 }
}
</code></pre>
The <code>MillenniumFalcon</code> class represents a concrete spaceship which can be used by our <code>Pilot</code>. However, there could be some conditions we might like to check before allowing the pilot to fly the spaceship. For example, perhaps we would like to see if the pilot has the appropriate certificate or if they are old enough to fly. To check these conditions, we can use the proxy design pattern.
In this example, we're going to be checking if the pilot's name is &quot;Han Solo&quot; since he is the rightful owner of the ship. We start by implementing the <code>Spaceship</code> interface as before.
We are going to use <code>Pilot</code> and <code>Spaceship</code> as our class variables since we can obtain all relevant information from them:
<pre><code class="hljs">public class MillenniumFalconProxy implements Spaceship {

 private Pilot pilot;
 private Spaceship falcon;

 public MillenniumFalconProxy(Pilot pilot) {
 this.pilot = pilot;
 this.falcon = new MillenniumFalcon();
 }

 @Override
 public void fly() {
 if (pilot.getName().equals(&quot;Han Solo&quot;)) {
 falcon.fly();
 } else {
 System.out.printf(&quot;Sorry %s, only Han Solo can fly the Falcon!\n&quot;, pilotName);
 }
 }
}
</code></pre>
The client side of the program can then be written as shown below. If &quot;Han Solo&quot; is the pilot, the Falcon will be allowed to fly. Otherwise, it won't be allowed to leave the hangar:
<pre><code class="hljs">public static void main(String[] args) {
 Spaceship falcon1 = new MillenniumFalconProxy(new Pilot(&quot;Han Solo&quot;));
 falcon1.fly();

 Spaceship falcon2 = new MillenniumFalconProxy(new Pilot(&quot;Jabba the Hutt&quot;));
 falcon2.fly();
}
</code></pre>
The output for the above calls will then result in the following:
<pre><code class="hljs">Welcome, Han. The Millennium Falcon is starting up its engines!
Sorry Jabba the Hutt, only Han Solo can fly the Falcon!
</code></pre>
<h2 id="prosandcons">Pros and Cons</h2>
<h3 id="pros">Pros</h3>
<ul>
<li>Security: By using a proxy, certain conditions can be checked while accessing the object and controlled usage of potentially &quot;dangerous&quot; classes and resources is enforced.</li>
<li>Performance: Some objects might be highly demanding in terms of memory and execution time. By using a proxy, we can wrap such objects with costly operations so that they are called only when really needed, or avoid unnecessary instantiation.</li>
</ul>
<h3 id="cons">Cons</h3>
<ul>
<li>
Performance: Yes, performance can also be a disadvantage of the proxy pattern. How, you might ask? Let's say that a proxy object is used to wrap an object existing somewhere across the network. Since this is a proxy, it can hide from the client the fact that remote communication is involved.
This can in turn make the client inclined to write inefficient code because they will not be aware that an expensive network call is being made in the background.
</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
The Proxy Design Pattern is a clever way of using some costly resources or providing certain access rights. It is structurally similar to the <a target="_blank" href="/structural-design-patterns-in-java/#adapter">Adapter</a> and <a target="_blank" href="/structural-design-patterns-in-java/#decorator">Decorator</a> patterns, although with a different purpose.
Proxy can be used in a variety of circumstances since demanding resources are a common occurrence in programming, especially when dealing with databases and networking.
Knowing how to efficiently access those resources while providing appropriate access control is therefore crucial for building scalable and secure applications.

Luka Čupić

The Proxy Pattern is a Structural Pattern which limits the functionality of potentially costly objects through a proxy. In this article, we'll implement two different kinds of Proxies in Java.

The Proxy Design Pattern in Java

Marcus Sanatan

Leodanis Pozo Ramos

Unpacking uses * to assign multiple variables from a single iterable in one assignment statement. This makes your Python code cleaner and quicker to write.

Unpacking in Python: Beyond Parallel Assignment

<h2 id="introduction">Introduction</h2>
In computer science, data can be represented in a lot of different ways, and naturally, every single one of them has its advantages as well as disadvantages in certain fields.
Since computers are unable to process categorical data as these categories have no meaning for them, this information has to be prepared if we want a computer to be able to process it.
This action is called preprocessing. A big part of preprocessing is encoding - representing every single piece of data in a way that a computer can understand (the name literally means &quot;convert to computer code&quot;).
In many branches of computer science, especially machine learning and digital circuit design, One-Hot Encoding is widely used.
In this article, we will explain what one-hot encoding is and implement it in Python using a few popular choices, <a rel="nofollow noopener" target="_blank" href="https://pandas.pydata.org/">Pandas</a> and <a rel="nofollow noopener" target="_blank" href="https://scikit-learn.org/">Scikit-Learn</a>. We'll also compare it's effectiveness to other types of representation in computers, its strong points and weaknesses, as well as its applications.
<h2 id="whatisonehotencoding">What is One-Hot Encoding?</h2>
One-hot Encoding is a type of vector representation in which all of the elements in a vector are 0, except for one, which has 1 as its value, where 1 represents a <code>boolean</code> specifying a category of the element.
There also exists a similar implementation called One-Cold Encoding, where all of the elements in a vector are 1, except for one, which has 0 as its value.
For instance, <code>[0, 0, 0, 1, 0]</code> and <code>[1 ,0, 0, 0, 0]</code> could be some examples of one-hot vectors. A similar technique to this one, also used to represent data, would be <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Dummy_variable_(statistics)">dummy variables</a> in statistics.
This is very different from other encoding schemes, which all allow multiple bits to have 1 as its value. Below is a table that compares the representation of numbers from 0 to 7 in binary, Gray code, and one-hot:
<table class="table table-striped">
 <thead>
 <tr>
 <th>Decimal</th>
 <th>Binary</th>
 <th>Gray code</th>
 <th>One-Hot</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>0</td>
 <td>000</td>
 <td>000</td>
 <td>0000000</td>
 </tr>
 <tr>
 <td>1</td>
 <td>001</td>
 <td>001</td>
 <td>0000001</td>
 </tr>
 <tr>
 <td>2</td>
 <td>010</td>
 <td>011</td>
 <td>0000010</td>
 </tr>
 <tr>
 <td>3</td>
 <td>011</td>
 <td>010</td>
 <td>0000100</td>
 </tr>
 <tr>
 <td>4</td>
 <td>100</td>
 <td>110</td>
 <td>0001000</td>
 </tr>
 <tr>
 <td>5</td>
 <td>101</td>
 <td>111</td>
 <td>0010000</td>
 </tr>
 <tr>
 <td>6</td>
 <td>110</td>
 <td>101</td>
 <td>0100000</td>
 </tr>
 <tr>
 <td>7</td>
 <td>111</td>
 <td>100</td>
 <td>1000000</td>
 </tr>
 </tbody>
</table>
Practically, for every one-hot vector, we ask n questions, where n is the number of categories we have:
<blockquote>
Is this the number 1? Is this the number 2? ... Is this the number 7?
</blockquote>
Each &quot;0&quot; is &quot;false&quot; and once we hit a &quot;1&quot; in a vector, the answer to the question is &quot;true&quot;.
One-hot encoding transforms categorical features to a format that works better with classification and regression algorithms. It's very useful in methods where multiple types of data representation is necessary.
For example, some vectors may be optimal for regression (approximating functions based on former return values), and some may be optimal for classification (categorization into fixed sets/classes, typically binary):
<table class="table table-striped">
 <tr>
 <th>Label</th>
 <th>ID</th>
 </tr>
 <tr>
 <td>Strawberry</td>
 <td>1</td>
 </tr>
 <tr>
 <td>Apple</td>
 <td>2</td>
 </tr>
 <tr>
 <td>Watermelon</td>
 <td>3</td>
 </tr>
 <tr>
 <td>Lemon</td>
 <td>4</td>
 </tr>
 <tr>
 <td>Peach</td>
 <td>5</td>
 </tr>
 <tr>
 <td>Orange</td>
 <td>6</td>
 </tr>
</table>
Here we have six sample inputs of categorical data. The type of encoding used here is called &quot;label encoding&quot; - and it is very simple: we just assign an ID for a categorical value.
Our computer now knows how to represent these categories, because it knows how to work with numbers. However, this method of encoding is not very effective, because it tends to naturally give the higher numbers higher weights.
It wouldn't make sense to say that our category of &quot;Strawberries&quot; is greater or smaller than &quot;Apples&quot;, or that adding the category &quot;Lemon&quot; to &quot;Peach&quot; would give us a category &quot;Orange&quot;, since these values are not ordinal.
If we represented these categories in one-hot encoding, we would actually replace the rows with columns. We do this by creating one <code>boolean</code> column for each of our given categories, where only one of these columns could take on the value 1 for each sample:
<table class="table table-striped">
 <tr>
 <th>Strawberry</th>
 <th>Apple</th>
 <th>Watermelon</th>
 <th>Lemon</th>
 <th>Peach</th>
 <th>Orange</th>
 <th>ID</th>
 </tr>
 <tr>
 <td>1</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>1</td>
 </tr>
 <tr>
 <td>0</td>
 <td>1</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>2</td>
 </tr>
 <tr>
 <td>0</td>
 <td>0</td>
 <td>1</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>3</td>
 </tr>
 <tr>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>1</td>
 <td>0</td>
 <td>0</td>
 <td>4</td>
 </tr>
 <tr>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>1</td>
 <td>0</td>
 <td>5</td>
 </tr>
 <tr>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>1</td>
 <td>6</td>
 </tr>
</table>
We can see from the tables above that more digits are needed in one-hot representation compared to Binary or Gray code. For n digits, one-hot encoding can only represent n values, while Binary or Gray encoding can represent 2n values using n digits.
<h2 id="implementation">Implementation</h2>
<h3 id="pandas">Pandas</h3>
Let's take a look at a simple example of how we can convert values from a categorical column in our dataset into their numerical counterparts, via the one-hot encoding scheme.
We'll be creating a really simple dataset - a list of countries and their ID's:
<pre><code class="hljs">import pandas as pd

ids = [11, 22, 33, 44, 55, 66, 77]
countries = [&#x27;Spain&#x27;, &#x27;France&#x27;, &#x27;Spain&#x27;, &#x27;Germany&#x27;, &#x27;France&#x27;]

df = pd.DataFrame(list(zip(ids, countries)),
 columns=[&#x27;Ids&#x27;, &#x27;Countries&#x27;])
</code></pre>
In the script above, we create a Pandas dataframe, called <code>df</code> using two lists i.e. <code>ids</code> and <code>countries</code>. If you call the <code>head()</code> method on the dataframe, you should see the following result:
<pre><code class="hljs">df.head()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/one-hot-encoding-in-python-with-pandas-and-scikit-learn-1.PNG" alt="dataframe header one hot encoding">
The <code>Countries</code> column contain categorical values. We can convert the values in the <code>Countries</code> column into one-hot encoded vectors using the <code>get_dummies()</code> function:
<pre><code class="hljs">y = pd.get_dummies(df.Countries, prefix=&#x27;Country&#x27;)
print(y.head())
</code></pre>
We passed <code>Country</code> as the value for the <code>prefix</code> attribute of the <code>get_dummies()</code> method, hence you can see the string <code>Country</code> prefixed before the header of each of the one-hot encoded columns in the output.
Running this code yields:
<pre><code class="hljs"> Country_France Country_Germany Country_Spain
0 0 0 1
1 1 0 0
2 0 0 1
3 0 1 0
4 1 0 0
</code></pre>
<h3 id="scikitlearn">Scikit-Learn</h3>
An alternative would be to use another popular library - Scikit-Learn. It offers both the <code>OneHotEncoder</code> class and the <code>LabelBinarizer</code> class for this purpose.
First, let's start by importing the <code>LabelBinarizer</code>:
<pre><code class="hljs">from sklearn.preprocessing import LabelBinarizer
</code></pre>
And then, using the same dataframe as before, let's instantiate the <code>LabelBinarizer</code> and fit it:
<pre><code class="hljs">y = LabelBinarizer().fit_transform(df.Countries)
</code></pre>
Printing <code>y</code> would yield:
<pre><code class="hljs">[[0 0 1]
 [1 0 0]
 [0 0 1]
 [0 1 0]
 [1 0 0]]
</code></pre>
Though, this isn't nearly as pretty as the Pandas approach.
Similarly, we can use the <code>OneHotEncoder</code> class, which supports multi-column data, unlike the previous class:
<pre><code class="hljs">from sklearn.preprocessing import OneHotEncoder
</code></pre>
And then, let's populate a list and fit it in the encoder:
<pre><code class="hljs">x = [[11, &quot;Spain&quot;], [22, &quot;France&quot;], [33, &quot;Spain&quot;], [44, &quot;Germany&quot;], [55, &quot;France&quot;]]
y = OneHotEncoder().fit_transform(x).toarray()
print(y)
</code></pre>
Running this will yield:
<pre><code class="hljs">[[1. 0. 0. 0. 0. 0. 0. 1.]
 [0. 1. 0. 0. 0. 1. 0. 0.]
 [0. 0. 1. 0. 0. 0. 0. 1.]
 [0. 0. 0. 1. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1. 1. 0. 0.]]
</code></pre>
<h2 id="applicationsofonehotencoding">Applications of One-Hot Encoding</h2>
One-hot encoding has seen most of its application in the fields of Machine Learning and Digital Circuit Design.
<h3 id="machinelearning">Machine Learning</h3>
As stated above, computers aren't very good with categorical data. While we understand categorical data just fine, it's due to a kind of prerequisite knowledge that computers don't have.
Most Machine Learning techniques and models work with a very bounded dataset (typically binary). Neural networks consume data and produce results in the range of <code>0..1</code> and rarely will we ever go beyond that scope.
In short, the vast majority of machine learning algorithms receive sample data (&quot;training data&quot;) from which features are extracted. Based on these features, a mathematical model is created, which is then used to make predictions or decisions without being explicitly programmed to perform these tasks.
A great example would be <a target="_blank" href="/classification-in-python-with-scikit-learn-and-pandas/">Classification</a>, where the input can be technically unbounded, but the output is typically limited to a few classes. In the case of binary classification (say we're teaching a neural network to classify cats and dogs), we'd have a mapping of <code>0</code> for cats, and <code>1</code> for dogs.
Most of the time, the training data we wish to perform predictions on is categorical, like the example with fruit mentioned above. Again, while this makes a lot of sense to us, the words themselves are of no meaning to the algorithm as it doesn't understand them.
Using one-hot encoding for representation of data in these algorithms is not technically necessary, but pretty useful if we want an efficient implementation.
<h3 id="digitalcircuitdesign">Digital Circuit Design</h3>
Many basic digital circuits use one-hot notation in order to represent their I/O values.
For example, it can be used to indicate the state of a <a target="_blank" href="/theory-of-computation-finite-state-machines/">finite-state machine</a>. If some other type of representation, like Gray or Binary, is used, a decoder is needed to determine the state as they're not as naturally compatible. Contrarily, a one-hot finite-state machine does not need the decoder, because if the nth bit is high, the machine is, logically, in the nth state.
A good example of a finite-state machine is a ring counter - a type of counter composed of flip-flops connected to a shift register, in which the output of one flip-flop connects to the input of the other one.
The first flip-flop in this counter represents the first state, the second represents the second state, and so on. At the beginning, all of the flip-flops in the machine are set to '0', except for the first one, which is set to '1'.
The next clock edge arriving at the flip flops advances the one 'hot' bit to the second flip flop. The 'hot' bit advances like this until the last state, after which the machine returns to the first state.
Another example of usage of one-hot encoding in digital circuit design would be an address decoder, which takes a Binary or Gray code input, and then converts it to one-hot for the output, as well as a priority encoder (shown in the picture below).
It's the exact opposite and takes the one-hot input and converts it to Binary or Gray:
<img src="https://stackabuse.s3.amazonaws.com/media/one-hot-encoding-in-python-with-pandas-and-scikit-learn-2.jpg" alt="digital circuit design">
<h2 id="advantagesanddisadvantagesofonehotencoding">Advantages and Disadvantages of One-hot encoding</h2>
Like every other type of encoding, one-hot has many good points as well as problematic aspects.
<h3 id="advantages">Advantages</h3>
A great advantage of one-hot encoding is that determining the state of a machine has a low and constant cost, because all it needs to do is access one flip-flop. Changing the state of the machine is almost as fast, since it just needs to access two flip-flops.
Another great thing about one-hot encoding is the easy implementation. Digital circuits made in this notation are very easy to design and modify. Illegal states in the finite-state machine are also easy to detect.
A one-hot implementation is known for being the fastest one, allowing a state machine to run at a faster clock rate than any other encoding of that state machine.
<h3 id="disadvantages">Disadvantages</h3>
One of the main disadvantages that one-hot encoding has is the above mentioned fact that it can't represent many values (for n states, we would need n digits - or flip-flops). This is why, if we wanted to implement a one-hot 15-state ring counter for example, we would need 15 flip-flops, whereas the binary implementation would only need three flip-flops.
This makes it especially impractical for PAL devices, and it can also be very expensive, but it takes advantage of an FPGA's abundant flip-flops.
Another problem with this type of encoding is that many of the states in a finite-state machine would illegal - for every n valid states, there is (2n - n) illegal ones. A good thing is that these illegal states are, as previously said, really easy to detect (one XOR gate would be enough), so it's not very hard to take care of them.
<h2 id="conclusion">Conclusion</h2>
Since one-hot encoding is very simple, it is easy to understand and use in practice. It's no surprise that it is this popular in the world of computer science.
Due to the fact that the cons aren't too bad, its seen wide application. At the end of the day, its pros clearly outweigh the cons, which is why this type of implementation will definitely stick around for a long time in the future.

David Landup

Mila Lukic

One-Hot Encoding is a fundamental and common encoding schema used in Machine Learning and Data Science. In this article, we'll tackle One-Hot Encoding with Pandas and Scikit-Learn in Python.

One-Hot Encoding in Python with Pandas and Scikit-Learn

The MS Word utility from Microsoft Office suite is one of the most commonly used tools for writing text documents, both simple and complex. Though humans can easily read and write MS Word documents, assuming you have the Office software installed, oftentimes you need to read text from Word documents within another application.
For instance, if you are developing a <a target="_blank" href="/what-is-natural-language-processing/">natural language processing</a> application in Python that takes MS Word files as input, you will need to read MS Word files in Python before you can process the text. Similarly, oftentimes you need to write text to MS Word documents as output, which could be a dynamically generated report to download, for example.
In this article, you will see how to read and write MS Word files in Python.
<h2 id="installingthepythondocxlibrary">Installing the <code>python-docx</code> Library</h2>
Several libraries exist that can be used to read and write MS Word files in Python. However, we will be using the <a rel="nofollow noopener" target="_blank" href="https://python-docx.readthedocs.io/en/latest/">python-docx</a> module owing to its ease-of-use. Execute the following <code>pip</code> command in your terminal to download the <code>python-docx</code> module as shown below:
<pre><code class="hljs">$ pip install python-docx
</code></pre>
<h2 id="readingmswordfileswiththepythondocxmodule">Reading MS Word Files with the <code>python-docx</code> Module</h2>
In this section, you will see how to read text from MS Word files via the <code>python-docx</code> module.
Create a new MS Word file and rename it as &quot;my_word_file.docx&quot;. I saved the file in the root of my &quot;E&quot; directory, although you can save the file anywhere you want. The my_word_file.docx file should have the following content:
<img src="https://stackabuse.s3.amazonaws.com/media/reading-and-writing-ms-word-files-in-python-1.PNG" alt="reading ms word files in python">
To read the above file, first import the <code>docx</code> module and then create an object of the <code>Document</code> class from the <code>docx</code> module. Pass the path of the my_word_file.docx to the constructor of the <code>Document</code> class, as shown in the following script:
<pre><code class="hljs">import docx

doc = docx.Document(&quot;E:/my_word_file.docx&quot;)
</code></pre>
The <code>Document</code> class object <code>doc</code> can now be used to read the content of the my_word_file.docx.
<h3 id="readingparagraphs">Reading Paragraphs</h3>
Once you create an object of the <code>Document</code> class using the file path, you can access all the paragraphs in the document via the <code>paragraphs</code> attribute. An empty line is also read as a paragraph by the <code>Document</code>. Let's fetch all the paragraphs from the my_word_file.docx and then display the total number of paragraphs in the document:
<pre><code class="hljs">all_paras = doc.paragraphs
len(all_paras)
</code></pre>
Output:
<pre><code class="hljs">10
</code></pre>
Now we'll iteratively print all the paragraphs in the my_word_file.docx file:
<pre><code class="hljs">for para in all_paras:
 print(para.text)
 print(&quot;-------&quot;)
</code></pre>
Output:
<pre><code class="hljs">-------
Introduction
-------

-------
Welcome to stackabuse.com
-------
The best site for learning Python and Other Programming Languages
-------
Learn to program and write code in the most efficient manner
-------

-------
Details
-------

-------
This website contains useful programming articles for Java, Python, Spring etc.
-------
</code></pre>
The output shows all of the paragraphs in the Word file.
We can even access a specific paragraph by indexing the <code>paragraphs</code> property like an array. Let's print the 5th paragraph in the file:
<pre><code class="hljs">single_para = doc.paragraphs[4]
print(single_para.text)
</code></pre>
Output:
<pre><code class="hljs">The best site for learning Python and Other Programming Languages
</code></pre>
<h3 id="readingruns">Reading Runs</h3>
A run in a word document is a continuous sequence of words having similar properties, such as similar font sizes, font shapes, and font styles. For example, if you look at the second line of the my_word_file.docx, it contains the text <code>Welcome to stackabuse.com</code>, here the text <code>Welcome to</code> is in plain font, while the text <code>stackabuse.com</code> is in bold. Hence, the text <code>Welcome to</code> is considered as one run, while the bold faced text <code>stackabuse.com</code> is considered as another run.
Similarly, &quot;Learn to program and write code in the&quot; and &quot;most efficient manner&quot; are treated as two different runs in the paragraph &quot;Learn to program and write code in the most efficient manner&quot;.
To get all the runs in a paragraph, you can use the <code>run</code> property of the <code>paragraph</code> attribute of the <code>doc</code> object.
Let's read all the runs from paragraph number 5 (4th index) in our text:
<pre><code class="hljs">single_para = doc.paragraphs[4]
for run in single_para.runs:
 print(run.text)
</code></pre>
Output:
<pre><code class="hljs">The best site for
learning Python
 and Other
Programming Languages
</code></pre>
In the same way, the following script prints all the runs from the 6th paragraph of the my_word_file.docx file:
<pre><code class="hljs">second_para = doc.paragraphs[5]
for run in second_para.runs:
 print(run.text)
</code></pre>
Output:
<pre><code class="hljs">Learn to program and write code in the
most efficient manner
</code></pre>
<h2 id="writingmswordfileswiththepythondocxmodule">Writing MS Word Files with the <code>python-docx</code> Module</h2>
In the previous section, you saw how to read MS Word files in Python using the <code>python-docx</code> module. In this section, you will see how to write MS Word files via the <code>python-docx</code> module.
To write MS Word files, you have to create an object of the <code>Document</code> class with an empty constructor, or without passing a file name.
<pre><code class="hljs">mydoc = docx.Document()
</code></pre>
<h3 id="writingparagraphs">Writing Paragraphs</h3>
To write paragraphs, you can use the <code>add_paragraph()</code> method of the <code>Document</code> class object. Once you have added a paragraph, you will need to call the <code>save()</code> method on the <code>Document</code> class object. The path of the file to which you want to write your paragraph is passed as a parameter to the <code>save()</code> method. If the file doesn't already exist, a new file will be created, otherwise the paragraph will be appended at the end of the existing MS Word file.
The following script writes a simple paragraph to a newly created MS Word file named &quot;my_written_file.docx&quot;.
<pre><code class="hljs">mydoc.add_paragraph(&quot;This is first paragraph of a MS Word file.&quot;)
mydoc.save(&quot;E:/my_written_file.docx&quot;)
</code></pre>
Once you execute the above script, you should see a new file &quot;my_written_file.docx&quot; in the directory that you specified in the <code>save()</code> method. Inside the file, you should see one paragraph which reads &quot;This is the first paragraph of a MS Word file.&quot;
Let's add another paragraph to the my_written_file.docx:
<pre><code class="hljs">mydoc.add_paragraph(&quot;This is the second paragraph of a MS Word file.&quot;)
mydoc.save(&quot;E:/my_written_file.docx&quot;)
</code></pre>
This second paragraph will be appended at the end of the existing content in my_written_file.docx.
<h3 id="writingruns">Writing Runs</h3>
You can also write runs using the <code>python-docx</code> module. To write runs, you first have to create a handle for the paragraph to which you want to add your run. Take a look at the following example to see how it's done:
<pre><code class="hljs">third_para = mydoc.add_paragraph(&quot;This is the third paragraph.&quot;)
third_para.add_run(&quot; this is a section at the end of third paragraph&quot;)
mydoc.save(&quot;E:/my_written_file.docx&quot;)
</code></pre>
In the script above we write a paragraph using the <code>add_paragraph()</code> method of the <code>Document</code> class object <code>mydoc</code>. The <code>add_paragraph()</code> method returns a handle for the newly added paragraph. To add a run to the new paragraph, you need to call the <code>add_run()</code> method on the paragraph handle. The text for the run is passed in the form of a string to the <code>add_run()</code> method. Finally, you need to call the <code>save()</code> method to create the actual file.
<h3 id="writingheaders">Writing Headers</h3>
You can also add headers to MS Word files. To do so, you need to call the <code>add_heading()</code> method. The first parameter to the <code>add_heading()</code> method is the text string for header, and the second parameter is the header size. The header sizes start from 0, with 0 being the top level header.
The following script adds three headers of level 0, 1, and 2 to the file my_written_file.docx:
<pre><code class="hljs">mydoc.add_heading(&quot;This is level 1 heading&quot;, 0)
mydoc.add_heading(&quot;This is level 2 heading&quot;, 1)
mydoc.add_heading(&quot;This is level 3 heading&quot;, 2)
mydoc.save(&quot;E:/my_written_file.docx&quot;)
</code></pre>
<h3 id="addingimages">Adding Images</h3>
To add images to MS Word files, you can use the <code>add_picture()</code> method. The path to the image is passed as a parameter to the <code>add_picture()</code> method. You can also specify the width and height of the image using the <code>docx.shared.Inches()</code> attribute. The following script adds an image from the local file system to the my_written_file.docx Word file. The width and height of the image will be 5 and 7 inches, respectively:
<pre><code class="hljs">mydoc.add_picture(&quot;E:/eiffel-tower.jpg&quot;, width=docx.shared.Inches(5), height=docx.shared.Inches(7))
mydoc.save(&quot;E:/my_written_file.docx&quot;)
</code></pre>
After executing all the scripts in the Writing MS Word Files with the <code>python-docx</code> module section of this article, your final my_written_file.docx file should look like this:
<img src="https://stackabuse.s3.amazonaws.com/media/reading-and-writing-ms-word-files-in-python-2.PNG" alt="writing ms word files in python">
In the output, you can see the three paragraphs that you added to the MS word file, along with the three headers and one image.
<h2 id="conclusion">Conclusion</h2>
The article gave a brief overview of how to read and write MS Word files using the <code>python-docx</code> module. The article covers how to read paragraphs and runs from within a MS Word file. Finally, the process of writing MS Word files, adding a paragraph, runs, headers, and images to MS Word files have been explained in this article.

The article explains how to read and write MS Word files with the Python-Docx module with the help of various examples. 

Reading and Writing MS Word Files in Python via Python-Docx Module

Multithreading often leads to headaches. In this article, we'll take a look at the often misunderstood volatile keyword in Java and how it's used in a multi-threaded environment.

Concurrency in Java: The volatile Keyword

Guest Contributor

The article shows how to read and write CSV files using Python's Pandas library. To read a CSV file, the `read_csv()` method of the Pandas library is used.

Reading and Writing CSV Files in Python with Pandas

Janith Kasun

Using Handlebars with Node, we can create dynamic webpages that render on the server-side. Using conditionals, loops, partials and custom helper functions, with Handlebars, our web pages become more than just static HTML.