<h2 id="introduction">Introduction</h2>
It's typical for CLI apps to return text in the same color of the terminal. There are always cases when we want to highlight output to the user, for example, a warning or error message. In those cases, a dash of color could make a difference.
This article shows you how to print colored output in the terminal in Python with and without libraries.
<h2 id="ansiescapesequences">ANSI Escape Sequences</h2>
Your Teletypewriter (TTY), or rather your terminal, is not only capable of showing the output of a program. It can display a moving cursor, color the text, clear the entire screen, and much more than just static output. You may have seen command-line utilities with colorful text and progress bars. How do we control the presentation of the data we're outputting to the terminal?
We use ANSI Escape Sequences/Codes. These are special strings that modify the behavior of the terminal. A familiar example would be the <code>\n</code> character, which is a New Line sequence. Entering this character will print a new line in the output.
The text is colored on your terminal based on ANSI Escape sequences. This article focuses on the escape sequences to color text.
Two color schemes are widely used in the terminals:
<ul>
<li>16 colors (8 Background + 8 Foreground)</li>
<li>256 colors</li>
</ul>
Let's begin coloring our output with the 16 color option.
<h2 id="16colorsinrawpython">16 Colors in Raw Python</h2>
The 16 colors scheme comprises two sets of 8 colors each (8 backgrounds and 8 foregrounds) and they can be displayed in the terminal by using the following syntax:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-01.jpg" alt="16 colors syntax">
Let's put this to the test, by printing a cheesy color pattern with a red bold text and yellow background. The style code to represent bold text is <code>2</code>. The color codes for the foreground red text is <code>31</code> and <code>43</code> for the yellow background. So, with that in mind, the syntax for representing this layout is:
<pre><code class="hljs">print(&#x27;\033[2;31;43m CHEESY&#x27;)
</code></pre>
Run the above command in your Python interpreter (or a file). You will see this output:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-02.jpg" alt="16 colors - example1">
That's not quite right, our cheesy text is spilling over to the next line. We need a reset point to stop the printing of colors. This can be done by appending <code>\033[0;0m</code> to the string as:
<pre><code class="hljs">print(&#x27;\033[2;31;43m CHEESY \033[0;0m&#x27;)
</code></pre>
The <code>\033[0;0m</code> code represents a reset pattern that returns the terminal back to its original color scheme. This will provide the following output:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-03.jpg" alt="16 colors - example1">
Looks much better.
<h2 id="16colorsincoloramaabuiltinmodule">16 Colors In Colorama - A Built-in Module</h2>
Colorama is a Python package that provides methods to print colored text in Python. It only supports the 16-colors scheme. The module prepares the ANSI Escape sequences to produce the colored text. Let's install the module with <code>pip</code>:
<pre><code class="hljs">$ pip install colorama
</code></pre>
We recommend you install it within a <a href="/python-virtual-environments-explained/">virtual environment</a>. Once set up, let's get to printing colored text with Colorama:
<pre><code class="hljs"># colorama_demo.py
from colorama import init, Fore, Back, Style

# Initializes Colorama
init(autoreset=True)

print(Style.BRIGHT + Back.YELLOW + Fore.RED + &quot;CHEESY&quot;)
</code></pre>
We first import the functions: <code>init()</code> (to initialize the module and to set the <code>autoreset</code> to <code>True</code> so we don't have to reset it manually), <code>Fore</code> (Foreground text object), <code>Back</code> (Background Object) and <code>Style</code> (Style Object). Each object has its own set of constants that can be called in the <code>print()</code> function.
By appending these components in a human-friendly way, Colorama converts values like <code>YELLOW</code> to <code>43</code>, for the <code>Back</code> object, <code>RED</code> to <code>31</code> for the <code>Fore</code> object, etc. Under the hood, we end up with an ANSI Sequence, just like last time, though, we don't have to know the codes ourselves - Colorama does this for us.
No reset pattern is required, since we've set the <code>autoreset</code> argument to <code>True</code> while initializing the instance.
Running the code will display this:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-04.jpg" alt="Colorama - example">
<h2 id="256colorsinrawpython">256 Colors in Raw Python</h2>
With the advancement in technologies, the 256-color scheme is the most commonly found in terminals. If you are on a Linux based OS, you can check your terminal-supported color scheme by entering the following command:
<pre><code class="hljs">$ echo $TERM
</code></pre>
If this command returns <code>xterm-256color</code>, then your terminal supports a maximum of 256 colors.
<blockquote>
Wondering what those colors are?
</blockquote>
We can dive in right after we understand the syntax of a 256-color scheme. Working with 256 colors is a bit different than working with the 16-color scheme:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-05.jpg" alt="256 colors - syntax">
There's a placeholder to determine whether the color will be applied to the text or the background; 38;5; is for the text and 48;5; is for the background. This is followed by the color code ranging from 0 to 255.
Based on the above syntax, let's try recreating the StackAbuse logo in Python using an ANSI Escape Sequence.
The logo contains a pale gray background (<code>\033[48;5;236m</code>) with the words: Stack in white (<code>\033[38;5;231m</code>) and Abuse in orange (<code>\033[38;5;208m</code>). And of course, the reset code needs to be embedded in the string.
That being said, we can recreate the logo with this ANSI Sequence:
<pre><code class="hljs">&gt;&gt;&gt; print(&quot;\033[48;5;236m\033[38;5;231mStack \033[38;5;208mAbuse\033[0;0m&quot;)
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-06.jpg" alt="Stack Abuse Logo - in Color">
Awesome! What other colors can the terminal print? Let's take a look, by printing all the 256 colors supported by the terminal:
<pre><code class="hljs"># colorspep8.py
def colors_16(color_):
 return(&quot;\033[2;{num}m {num} \033[0;0m&quot;.format(num=str(color_)))


def colors_256(color_):
 num1 = str(color_)
 num2 = str(color_).ljust(3, &#x27; &#x27;)
 if color_ % 16 == 0:
 return(f&quot;\033[38;5;{num1}m {num2} \033[0;0m\n&quot;)
 else:
 return(f&quot;\033[38;5;{num1}m {num2} \033[0;0m&quot;)

print(&quot;The 16 colors scheme is:&quot;)
print(&#x27; &#x27;.join([colors_16(x) for x in range(30, 38)]))
print(&quot;\nThe 256 colors scheme is:&quot;)
print(&#x27; &#x27;.join([colors_256(x) for x in range(256)]))
</code></pre>
This script contains two functions that print the variable you pass into them, in the respective ANSI Escape Sequences. Once we run the script, and pass in <code>x</code> in a certain range, such as <code>(30,38]</code> for the 16-color scheme, or <code>(0-255]</code> for the 256-color scheme, it'll print out the indices in the colors at those values.
This will print out both color-coded schemes in the terminal:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-07.jpg" alt="Stack Abuse Logo - in Color">
This can be very helpful as a quick reference while building command-line utilities.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to print colored output, for the characters we send off to the <code>stdout</code> stream. We've explored how to do this using the built-in functionality Python offers, as well as how to use the Colorama library.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

This article shows you how we can print colored output in the terminal with and without Python libraries. Let's dive in by learning how it works!

How to Print Colored Text in Python

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. Much of Matplotlib's popularity comes from its customization options - you can tweak just about any element from its hierarchy of objects.
In this tutorial, we'll take a look at how to draw a vertical line on a Matplotlib plot, that allows us to mark and highlight certain regions of the plot, without zooming or <a target="_blank" href="/how-to-set-axis-range-xlim-ylim-in-matplotlib/">changing the axis range</a>.
<h2 id="creatingaplot">Creating a Plot</h2>
Let's first create a simple plot with some random data:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots(figsize=(12, 6))

np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)

plt.show()
</code></pre>
Here, we've used NumPy to generate 150 random data points, in a range of <code>[0, 1)</code>.
<img src="https://s3.stackabuse.com/media/articles/matplotlib-draw-vertical-lines-on-plot-1.png" alt="matplotlib plot random values">
Now, since we've set a <code>seed</code>, we can replicate this random image as many times as we'd like. For example, let's draw vertical lines on the <code>20</code> and <code>100</code> marks.
There are two ways we can draw lines, using the <code>vlines()</code> or <code>axvline()</code> functions of the PyPlot instance. Naturally, you can also call these methods on the <code>Axes</code> object.
<h2 id="drawverticallinesonmatplotlibplotwithpyplotvlines">Draw Vertical Lines on Matplotlib Plot with PyPlot.vlines()</h2>
Let's start off with the <code>vlines()</code> function:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots(figsize=(12, 6))

np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)

ax.vlines([20, 100], 0, 1, linestyles=&#x27;dashed&#x27;, colors=&#x27;red&#x27;)

plt.show()
</code></pre>
The <code>vlines()</code> function accepts a few arguments - a scalar, or 1D array of X-values that you'd like to draw lines on. We've supplied <code>[20, 100]</code>, marking two points, though you can go from <code>0..n</code> points here. Then, the <code>ymin</code> and <code>ymax</code> arguments - these are the height of the lines. We've set them to be from <code>0</code> to <code>1</code>, since that's the distribution of the <code>np.random.rand()</code> call as well. Then, you can set styles, such as <code>linestyles</code> or <code>colors</code>, which accept the typical Matplotlib styling options.
Running this code will result in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-draw-vertical-lines-on-plot-2.png" alt="add vertical lines to matplotlib plot with vlines()">
We've got two vertical lines, which are dashed, in red color, at the <code>20</code> and <code>100</code> points on the X-axis.
This function allows us to set the <code>ymin</code> and <code>ymax</code> in concrete values, while <code>axvline()</code> lets us choose the height percentage-wise, or we simply let it plot from the bottom to the top by default.
This feature comes in handy when you'd like to make the lines shorter or longer, for example. Let's change the range of our Y-axis, to include the view from <code>-10</code> to <code>10</code>, instead of <code>0</code> and <code>1</code>. Our random data will still be in the range from <code>[0, 1)</code> so we'll have a better look at it from a different perspective:
<pre><code class="hljs">fig, ax = plt.subplots(figsize=(12, 6))

np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)

ax.set_ylim(-10, 10)
ax.vlines([20, 100], -2, 2, linestyles=&#x27;dashed&#x27;, colors=&#x27;red&#x27;)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/matplotlib-draw-vertical-lines-on-plot-3.png" alt="change axis range and plot vertical lines on matplotlib plot">
Here, we've set the lines to be longer than the range of the random data itself, but still much smaller than the size of the <code>Axes</code> itself.
<h2 id="drawverticallinesonmatplotlibplotwithpyplotaxvline">Draw Vertical Lines on Matplotlib Plot with PyPlot.axvline()</h2>
Now, let's take a look at the <code>axvline()</code> function:
<pre><code class="hljs">fig, ax = plt.subplots(figsize=(12, 6))

np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)

ax.set_ylim(-10, 10)
ax.axvline(20, color=&#x27;red&#x27;)
ax.axvline(100, color=&#x27;red&#x27;)

plt.show()
</code></pre>
It has a few limitations that the other function doesn't have, such as being able to only plot on a single point at a time. If we want to plot on multiple points, such as <code>20</code> and <code>100</code>, we'll have to call the function twice.
It also doesn't really let us specify the <code>linestyle</code> like <code>vlines()</code> let us, though, it doesn't require the <code>ymin</code> and <code>ymax</code> arguments by default. If you omit them, like we have, they'll simply be from the top to the bottom of the <code>Axes</code>:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-draw-vertical-lines-on-plot-4.png" alt="draw vertical line on matplotlib plot axvline">
However, you can change the height if you'd like - this time around though, you'll change the height in terms of percentages. These percentages take the top and bottom of the <code>Axes</code> into consideration so 0% will be at the very bottom, while 100% will be at the very top. Let's draw a line spanning from 50% to 80%:
<pre><code class="hljs">fig, ax = plt.subplots(figsize=(12, 6))

np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)

ax.set_ylim(-10, 10)
ax.axvline(20, 0.8, 0.5, color=&#x27;red&#x27;)
ax.axvline(100, 0.8, 0.5, color=&#x27;red&#x27;)
</code></pre>
This produces:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-draw-vertical-lines-on-plot-5.png" alt="set percentage height of vertical plot on matplotlib axvline">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to draw vertical lines on a Matplotlib Plot.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

David Landup

In this tutorial, we'll take a look at how to draw vertical lines on a Matplotlib plot/axis, in Python, using vlines() and axvline(), with practical examples.

Matplotlib: Draw Vertical Lines on Plot

Ruslan Hasanov

In this tutorial, we’ll learn how to parse, validate and extract phone numbers in Python with the phonenumbers library.

Validating and Formatting Phone Numbers in Python

Validating and Formatting Phone Numbers in Python with phonenumbers

<h2 id="introduction">Introduction</h2>
A stream represents a sequence of elements and supports different kind of operations that lead to the desired result.
The source of these elements is usually a Collection or an Array, from which data is provided to the stream.
Streams differ from collections in several ways; most notably in that the streams are not a data structure that stores elements. They're functional in nature, and it's worth noting that operations on a stream produce a result, but do not modify its source.
<h2 id="sortingalistofintegerswithstreamsorted">Sorting a List of Integers with Stream.sorted()</h2>
Found within the <code>Stream</code> interface, the <code>sorted()</code> method has two overloaded variations that we'll be looking into.
Both of these variations are instance methods, which require an object of its class to be created before it can be used:
<pre><code class="hljs">public final Stream&lt;T&gt; sorted() {}
</code></pre>
This methods returns a stream consisting of the elements of the stream, sorted according to natural order - the ordering provided by the JVM. If the elements of the stream are not <code>Comparable</code>, a <code>java.lang.ClassCastException</code> may be thrown upon execution.
Using this method is fairly simple, so let's take a look at a couple of examples:
<pre><code class="hljs">Arrays.asList(10, 23, -4, 0, 18).stream().sorted().forEach(System.out::println);
</code></pre>
Here, we make a <code>List</code> instance through the <code>asList()</code> method, providing a few integers and <code>stream()</code> them. Once streamed, we can run the <code>sorted()</code> method, which sorts these integers naturally. Once sorted, we've just printed them out, each in a line:
<pre><code class="hljs">-4
0
10
18
23
</code></pre>
If we wanted save the results of sorting after the program was executed, we would have to <code>collect()</code> the data back in a <code>Collection</code> (a <code>List</code> in this example), since <code>sorted()</code> doesn't modify the source.
Let's save this result into a <code>sortedList</code>:
<pre><code class="hljs">List&lt;Integer&gt; list = Arrays.asList(10, 23, -4, 0, 18);
List&lt;Integer&gt; sortedList = list.stream().sorted().collect(Collectors.toList());

System.out.println(list);
System.out.println(sortedList);
</code></pre>
Running this code will produce:
<pre><code class="hljs">[10, 23, -4, 0, 18]
[-4, 0, 10, 18, 23]
</code></pre>
Here we see that the original list stayed unmodified, but we did save the results of the sorting in a new list, allowing us to use both if we need so later on.
<h2 id="sortingalistofintegersindescendingorderwithstreamsorted">Sorting a List of Integers in Descending Order with Stream.sorted()</h2>
<code>Stream.sorted()</code> by default sorts in natural order. In the case of our integers, this means that they're sorted in ascending order.
Sometimes, you might want to switch this up and sort in descending order. There are two simple ways to do this - supply a <code>Comparator</code>, and switch the order, which we'll cover in a later section, or simply use <code>Collections.reverseOrder()</code> in the <code>sorted()</code> call:
<pre><code class="hljs">List&lt;Integer&gt; list = Arrays.asList(10, 23, -4, 0, 18);
List&lt;Integer&gt; sortedList = list.stream()
 .sorted(Collections.reverseOrder())
 .collect(Collectors.toList());

System.out.println(sortedList);
</code></pre>
This results in:
<pre><code class="hljs">[23, 18, 10, 0, -4]
</code></pre>
<h2 id="sortingalistofstringswithstreamsorted">Sorting a List of Strings with Stream.sorted()</h2>
Though, we don't always just sort integers. Sorting Strings is a tiny bit different, since it's a bit less intuitive on how to compare them.
Here, the <code>sorted()</code> method also follows the natural order, as imposed by the JVM. In case of Strings, they're sorted lexicographically:
<pre><code class="hljs">Arrays.asList(&quot;John&quot;, &quot;Mark&quot;, &quot;Robert&quot;, &quot;Lucas&quot;, &quot;Brandon&quot;).stream().sorted().forEach(System.out::println);
</code></pre>
Running this produces:
<pre><code class="hljs">Brandon
John
Lucas
Mark
Robert
</code></pre>
If we wanted the newly sorted list saved, the same procedure as with the integers applies here:
<pre><code class="hljs">List&lt;String&gt; list = Arrays.asList(&quot;John&quot;, &quot;Mark&quot;, &quot;Robert&quot;, &quot;Lucas&quot;, &quot;Brandon&quot;);
List&lt;String&gt; sortedList = list.stream().sorted().collect(Collectors.toList());

System.out.println(sortedList);
</code></pre>
This results in:
<pre><code class="hljs">[Brandon, John, Lucas, Mark, Robert]
</code></pre>
Sorting Strings in reverse order is as simple as sorting integers in reverse order:
<pre><code class="hljs">List&lt;String&gt; list = Arrays.asList(&quot;John&quot;, &quot;Mark&quot;, &quot;Robert&quot;, &quot;Lucas&quot;, &quot;Brandon&quot;);
List&lt;String&gt; sortedList = list.stream()
 .sorted(Collections.reverseOrder())
 .collect(Collectors.toList());
 
System.out.println(sortedList);
</code></pre>
This results in:
<pre><code class="hljs">[Robert, Mark, Lucas, John, Brandon]
</code></pre>
<h2 id="sortingcustomobjectswithstreamsortedcomparatorsupertcomparator">Sorting Custom Objects with Stream.sorted(Comparator&lt;? super T&gt; comparator)</h2>
In all of the previous examples, we've worked with <code>Comparable</code> types. However, if we're working with some custom objects, which might not be <code>Comparable</code> by design, and would still like to sort them using this method - we'll need to supply a <code>Comparator</code> to the <code>sorted()</code> call.
Let's define a <code>User</code> class, which isn't <code>Comparable</code> and see how we can sort them in a <code>List</code>, using <code>Stream.sorted()</code>:
<pre><code class="hljs">public class User {
 
 private String name;
 private int age;

 // Constructor, getters, setters and toString()
}
</code></pre>
In the first iteration of this example, let's say we want to sort our users by their age. If the age of the users is the same, the first one that was added to the list will be the first in the sorted order. Let's say we have the following code:
Let's sort them by age, first. If their age is the same, the order of insertion to the list is what defines their position in the sorted list:
<pre><code class="hljs">List&lt;User&gt; userList = new ArrayList&lt;&gt;(Arrays.asList(
 new User(&quot;John&quot;, 33), 
 new User(&quot;Robert&quot;, 26), 
 new User(&quot;Mark&quot;, 26), 
 new User(&quot;Brandon&quot;, 42)));

List&lt;User&gt; sortedList = userList.stream()
 .sorted(Comparator.comparingInt(User::getAge))
 .collect(Collectors.toList());

sortedList.forEach(System.out::println);
</code></pre>
When we run this, we get the following output:
<pre><code class="hljs">User:[name: Robert, age: 26]
User:[name: Mark, age: 26]
User:[name: John, age: 33]
User:[name: Brandon, age: 42]
</code></pre>
Here, we've made a list of <code>User</code> objects. We're streaming that list, and using the <code>sorted()</code> method with a <code>Comparator</code>. Specifically, we're using the <code>comparingInt()</code> method, and supplying the user's age, via the <code>User::getAge</code> method reference.
There are a few of these built-in comparators that work with numbers (<code>int</code>, <code>double</code>, and <code>long</code>) - <code>comparingInt()</code>, <code>comparingDouble()</code>, and <code>comparingLong()</code>. Ultimately, you can also just use the <code>comparing()</code> method, which accepts a sorting key function, just like the other ones.
All of them simply return a comparator, with the passed function as the sorting key. In our case, we're using the <code>getAge()</code> method as the sorting key.
We can easily reverse this order as well, simply by chaining the <code>reversed()</code> method after the <code>comparingInt()</code> call:
<pre><code class="hljs">List&lt;User&gt; sortedList = userList.stream()
 .sorted(Comparator.comparingInt(User::getAge).reversed())
 .collect(Collectors.toList());

sortedList.forEach(System.out::println);
</code></pre>
This results in:
<pre><code class="hljs">User:[name: Brandon, age: 42]
User:[name: John, age: 33]
User:[name: Robert, age: 26]
User:[name: Mark, age: 26]
</code></pre>
<h2 id="definingacustomcomparatorwithstreamsorted">Defining a Custom Comparator with Stream.sorted()</h2>
While <code>Comparator</code>s produced by methods such as <code>comparing()</code> and <code>comparingInt()</code>, are super-simple to work with and only require a sorting key - sometimes, the automated behavior is not what we're looking for.
If we sort the <code>User</code>s, and two of them have the same age, they're now sorted by the order of insertion, not their natural order, based on their names. <code>Mark</code> should be before <code>Robert</code>, in a list sorted by name, but in the list we've sorted previously, it's the other way around.
For cases like these, we'll want to write a custom <code>Comparator</code>:
<pre><code class="hljs">List&lt;User&gt; userList = new ArrayList&lt;&gt;(Arrays.asList(
 new User(&quot;John&quot;, 33),
 new User(&quot;Robert&quot;, 26),
 new User(&quot;Mark&quot;, 26),
 new User(&quot;Brandon&quot;, 42)));

List&lt;User&gt; sortedList = userList.stream()
 .sorted((o1, o2) -&gt; {
 if(o1.getAge() == o2.getAge())
 return o1.getName().compareTo(o2.getName());
 else if(o1.getAge() &gt; o2.getAge())
 return 1;
 else return -1;
 })
 .collect(Collectors.toList());

sortedList.forEach(System.out::println);
</code></pre>
And now, when we execute this code, we've got the natural order of names, as well as ages, sorted:
<pre><code class="hljs">User:[name: Mark, age: 26]
User:[name: Robert, age: 26]
User:[name: John, age: 33]
User:[name: Brandon, age: 42]
</code></pre>
Here, we've used a Lambda expression to create a new <code>Comparator</code> implicitly and defined the logic for sorting/comparison. Returning a positive number indicates that an element is greater than another. Returning a negative number indicates that an element is lesser than another.
We've used the respective comparison approaches for the names and ages - comparing names lexicographically using <code>compareTo()</code>, if the <code>age</code> values are the same, and comparing ages regularly via the <code>&gt;</code> operator.
If you're not used to Lambda expressions, you can create a <code>Comparator</code> beforehand, though, for the sake of code readability, it's advised to shorten it to a Lambda:
<pre><code class="hljs">Comparator&lt;User&gt; customComparator = new Comparator&lt;User&gt;() {
 @Override
 public int compare(User o1, User o2) {
 if(o1.getAge() == o2.getAge())
 return o1.getName().compareTo(o2.getName());
 else if(o1.getAge() &gt; o2.getAge())
 return 1;
 else return -1;
 }
};

List&lt;User&gt; sortedList = userList.stream()
 .sorted(customComparator)
 .collect(Collectors.toList());
</code></pre>
You can also technically make an anonymous instantiation of the comparator in the <code>sorted()</code> call:
<pre><code class="hljs">List&lt;User&gt; sortedList = userList.stream()
 .sorted(new Comparator&lt;User&gt;() {
 @Override
 public int compare(User o1, User o2) {
 if(o1.getAge() == o2.getAge())
 return o1.getName().compareTo(o2.getName());
 else if(o1.getAge() &gt; o2.getAge())
 return 1;
 else return -1;
 }
 })
 .collect(Collectors.toList());
</code></pre>
And this anonymous call is exactly what gets shortened to the Lambda expression from the first approach.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've covered everything you need to know about the <code>Stream.sorted()</code> method. We've sorted <code>Comparable</code> integers and Strings, in ascending and descending order, as well as used a built-in <code>Comparator</code> for custom objects.
Finally, we've used a custom <code>Comparator</code> and defined custom sorting logic.

Branko Ilic

In this tutorial guide, we'll cover everything you need to know about the Stream.sorted() API. We'll sort integers, strings and custom objects in ascending and descending order as well as define custom comparators in Java.

Java 8 – How to Sort List with Stream.sorted()

Darinka Zobenica

In this guide, we'll cover the theory and implementation of K-Means clustering, using Core Java, with practical examples and pros and cons of the algorithm.

Guide to K-Means Clustering in Java

Guide to K-Means Clustering with Java

<h2 id="introduction">Introduction</h2>
At some point in your software development path, you'll have to convert files from one format to another.
DOCX (used by Microsoft Word) is a pretty common file format for a lot of people to use. And sometimes, we'd like to convert Word Documents into HTML.
This can easily be achieved via the Mammoth package. It's an easy, efficient, and fast library used to convert DOCX files to HTML. In this article, we'll learn how to use Mammoth in Python to convert DOCX to HTML.
<h2 id="installingmammoth">Installing Mammoth</h2>
As a good practice, remember to have your <a href="/python-virtual-environments-explained/" target="_blank">virtual environment</a> ready and activated before the installation:
<pre><code class="hljs">$ python3 -m venv myenv
$ . myenv/bin/activate
</code></pre>
Let's then install Mammoth with <code>pip</code>:
<pre><code class="hljs">$ pip3 install mammoth
</code></pre>
This tutorial uses the Mammoth version <code>1.4.15</code>. Here's a <a href="https://github.com/rhasoff/SA-Convert-Docx-To-Html-With-Python-Mammoth/raw/main/file-sample_100kB.docx" target="_blank" rel="noopener nofollow">sample document</a> you can use throughout this tutorial. If you have a document to convert, make sure that it's a <code>.docx</code> file!
Now that you're ready to go, let's get started with extracting the text and writing that as HTML.
<h2 id="extracttherawtextofadocxfile">Extract the Raw Text of a DOCX File</h2>
Preserving the formatting while converting to HTML is one of the best features of Mammoth. However, if you just need the text of the DOCX file, you'll be pleasantly surprised at how few lines of code are needed.
You can use the <code>extract_raw_text()</code> method to retrieve it:
<pre><code class="hljs">import mammoth

with open(input_filename, &quot;rb&quot;) as docx_file:
 result = mammoth.extract_raw_text(docx_file)
 text = result.value # The raw text
 with open(&#x27;output.txt&#x27;, &#x27;w&#x27;) as text_file:
 text_file.write(text)
</code></pre>
Note that this method does not return a valid HTML document. It only returns the text on the page, hence why we save it with the <code>.txt</code> extension. If you do need to keep the layout and/or formatting, you'll want to extract the HTML contents.
<h2 id="convertdocxtohtmlwithcustomstylemapping">Convert Docx to HTML with Custom Style Mapping</h2>
By default, Mammoth converts your document into HTML but it does not give you a valid HTML page. While web browsers can display the content, it is missing an <code>&lt;html&gt;</code> tag to encapsulate the document, and a <code>&lt;body&gt;</code> tag to contain the document. How you choose to integrate its output is up to you. Let's say you're using a web framework that has templates. You'd likely define a template to display a Word Document and load Mammoth's output inside the template's body.
Mammoth is not only flexible with how you can use its output but how you can create it as well. In Particular, we have a lot of options when we want to style the HTML we produce. We map styles by matching each DOCX formatting rule to the equivalent (or as close as we can get) CSS rule.
To see what styles your DOCX file has, you have two options:
<ol>
<li>You can open your docx file with MS Word and check the Styles toolbar.</li>
<li>You can dig into the XML files by opening your DOCX file with an archive manager, and then navigate to the <code>/word/styles.xml</code> and locate your styles.</li>
</ol>
The second option can be used by those who don't have access to MS Word or an alternative word processor that can interpret and display the styles.
Mammoth already has some of the most common style maps covered by default. For instance, the <code>Heading1</code> docx style is mapped to the <code>&lt;h1&gt;</code> HTML element, bold is mapped to the <code>&lt;strong&gt;</code> HTML element, etc.
We can also use Mammoth to customize the document's styles while mapping them. For example, if you wanted to change all bold occurrences in the DOCX file to italic in the HTML, you can do this:
<pre><code class="hljs">import mammoth

custom_styles = &quot;b =&gt; i&quot;

with open(input_filename, &quot;rb&quot;) as docx_file:
 result = mammoth.convert_to_html(docx_file, style_map = custom_styles)
 text = result.value
 with open(&#x27;output.html&#x27;, &#x27;w&#x27;) as html_file:
 html_file.write(text)
</code></pre>
With the <code>custom_styles</code> variable, the style on the left is from the DOCX file, while the one on the right is the corresponding CSS.
Let's say we wanted to omit the bold occurrences altogether, we can leave the mapping target blank:
<pre><code class="hljs">custom_styles = &quot;b =&gt; &quot;
</code></pre>
Sometimes the document we're porting has many styles to retain. It quickly becomes impractical to create a variable for every style we want to map. Luckily we can use <code>docstrings</code> to map as many styles as we want in one go:
<pre><code class="hljs">custom_styles = &quot;&quot;&quot; b =&gt; del
 u =&gt; em
 p[style-name=&#x27;Heading 1&#x27;] =&gt; i&quot;&quot;&quot;
</code></pre>
You may have noticed that the last mapping was a bit different from the others. When mapping styles, we can use square brackets <code>[]</code> with a condition inside them so that only a subset of elements are styled that way.
In our example, <code>p[style-name='Heading 1']</code> selects paragraphs that have a style name <code>Heading 1</code>. We can also use <code>p[style-name^='Heading']</code> to select each paragraph that has a style name starting with <code>Heading</code>.
Style mapping also allows us to map styles to custom CSS classes. By doing so, we can shape the style of HTML as we like. Let's do an example where we define our basic custom CSS in a docstring like this:
<pre><code class="hljs">custom_css =&quot;&quot;&quot;
 &lt;style&gt;
 .red{
 color: red;
 }
 .underline{
 text-decoration: underline;
 }
 .ul.li{
 list-style-type: circle;
 }
 table, th, td {
 border: 1px solid black;
 }
 &lt;/style&gt;
 &quot;&quot;&quot;
</code></pre>
Now we can update our mapping to reference the CSS classes we've defined in the <code>&lt;style&gt;</code> block:
<pre><code class="hljs">custom_styles = &quot;&quot;&quot; b =&gt; b.red
 u =&gt; em.red
 p[style-name=&#x27;Heading 1&#x27;] =&gt; h1.red.underline&quot;&quot;&quot;
</code></pre>
Now all we need to do is merge the CSS and the HTML together:
<pre><code class="hljs">edited_html = custom_css + html
</code></pre>
If your DOCX file has any of those elements, you will be able to see the results.
Now that we know how to map styles, let's use a more well-known CSS framework (along with the JS) to give our HTML a better look and practice a more likely real-life scenario.
<h3 id="mappingstyleswithbootstraporanyotheruiframework">Mapping Styles with Bootstrap (or Any Other UI Framework)</h3>
Just like we did with the <code>custom_css</code>, we need to ensure that the CSS is loaded with the HTML. We need to add the Bootstrap file URI or CDN to our HTML:
<pre><code class="hljs">bootstrap_css = &#x27;&lt;link href=&quot;https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/css/bootstrap.min.css&quot; rel=&quot;stylesheet&quot; integrity=&quot;sha384-BmbxuPwQa2lc/FVzBcNJ7UAyJxM6wuqIj61tLrc4wSX0szH/Ev+nYRRuWlolflfl&quot; crossorigin=&quot;anonymous&quot;&gt;&#x27;
bootstrap_js = &#x27;&lt;script src=&quot;https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/js/bootstrap.bundle.min.js&quot; integrity=&quot;sha384-b5kHyXgcpbZJO/tY9Ul7kGkf1S0CWuKcCD38l8YkeH8z8QjE0GmW1gYU5S9FOnJ0&quot; crossorigin=&quot;anonymous&quot;&gt;&lt;/script&gt;&#x27;
</code></pre>
We'll also slightly tweak our <code>custom_styles</code> to match our new CSS classes:
<pre><code class="hljs">custom_styles = &quot;&quot;&quot; b =&gt; b.mark
 u =&gt; u.initialism
 p[style-name=&#x27;Heading 1&#x27;] =&gt; h1.card
 table =&gt; table.table.table-hover
 &quot;&quot;&quot;
</code></pre>
In the first line, we're mapping bold DOCX style to the <code>b</code> HTML element with a class <code>mark</code>, which is a Bootstrap class equivalent of the HTML <code>&lt;mark&gt;</code> tag, used for highlighting part of the text.
In the second line, we're adding the <code>initialism</code> class to the <code>u</code> HTML element, slightly decreasing the font size and transforming the text into the uppercase.
In the third line, we're selecting all paragraphs that have the style name <code>Heading 1</code> and converting them to <code>h1</code> HTML elements with the Bootstrap class of <code>card</code>, which sets multiple style properties such as background color, position, and border for the element.
In the last line, we're converting all tables in our docx file to the <code>table</code> HTML element, with Bootstrap's <code>table</code> class to give it a new look, also we're making it highlight when hovered, by adding the Bootstrap class of <code>table-hover</code>.
Like before, we use dot-notation to map multiple classes to the same HTML element, even though the styles come from another source.
Finally, add the Bootstrap CDNs to our HTML:
<pre><code class="hljs">edited_html = bootstrap_css + html + bootstrap_js
</code></pre>
Our HTML is now ready to be shared, with a polished look and feel! Here's the full code for reference:
<pre><code class="hljs">import mammoth

input_filename = &quot;file-sample_100kB.docx&quot;

custom_styles = &quot;&quot;&quot; b =&gt; b.mark
 u =&gt; u.initialism
 p[style-name=&#x27;Heading 1&#x27;] =&gt; h1.card
 table =&gt; table.table.table-hover
 &quot;&quot;&quot;


bootstrap_css = &#x27;&lt;link href=&quot;https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/css/bootstrap.min.css&quot; rel=&quot;stylesheet&quot; integrity=&quot;sha384-BmbxuPwQa2lc/FVzBcNJ7UAyJxM6wuqIj61tLrc4wSX0szH/Ev+nYRRuWlolflfl&quot; crossorigin=&quot;anonymous&quot;&gt;&#x27;
bootstrap_js = &#x27;&lt;script src=&quot;https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/js/bootstrap.bundle.min.js&quot; integrity=&quot;sha384-b5kHyXgcpbZJO/tY9Ul7kGkf1S0CWuKcCD38l8YkeH8z8QjE0GmW1gYU5S9FOnJ0&quot; crossorigin=&quot;anonymous&quot;&gt;&lt;/script&gt;&#x27;


with open(input_filename, &quot;rb&quot;) as docx_file:
 result = mammoth.convert_to_html(docx_file, style_map = custom_styles)
 html = result.value 

edited_html = bootstrap_css + html + bootstrap_js

output_filename = &quot;output.html&quot;
with open(output_filename, &quot;w&quot;) as f: 
 f.writelines(edited_html)
</code></pre>
Also, another point to note here is that in a real-life scenario, you probably will not add Bootstrap CSS directly to the HTML content as we did here. Instead, you would load/inject the HTML content to a special HTML page, which already would have the necessary CSS and JS bundles.
So far you've seen how much flexibility we have to style our output. Mammoth also allows us to modify the content we're converting. Let's take a look at that now.
<h2 id="dealingwithimageswedontwantshared">Dealing With Images We Don't Want Shared</h2>
Let's say we'd like to omit images from our DOCX file from being converted. The <code>convert_to_html()</code> method accepts a <code>convert_image</code> argument, which is an image handler function. It returns a list of images that should be converted and added to the HTML document.
Naturally, if we override it and return an empty list, they'll be omitted from the converted page:
<pre><code class="hljs">def ignore_image(image):
 return []
</code></pre>
Now, let's pass that function as a parameter into the <code>convert_to_html()</code> method:
<pre><code class="hljs">with open(input_filename, &quot;rb&quot;) as docx_file:
 result = mammoth.convert_to_html(docx_file, style_map = custom_styles, convert_image=ignore_image)
 html = result.value
 with open(&#x27;output.html&#x27;, &#x27;w&#x27;) as html_file:
 html_file.write(text)
</code></pre>
That's it! Mammoth will ignore all the images when generating an HTML file.
We've been programmatically using Mammoth with Python so far. Mammoth is also a CLI tool, therefore we have another interface to do DOCX to HTML conversations. Let's see how that works in the next section.
<h2 id="convertdocxtohtmlusingcommandlinetool">Convert DOCX to HTML Using Command Line Tool</h2>
File conversion with Mammoth, using the CLI, typically looks like this:
<pre><code class="hljs">$ mammoth path/to/input_filename.docx path/to/output.html
</code></pre>
If you wanted to separate the images from the HTML, you can specify an output folder:
<pre><code class="hljs">$ mammoth file-sample_100kB.docx --output-dir=imgs
</code></pre>
We can also add custom styles as we did in Python. You need to first create a custom style file:
<pre><code class="hljs">$ touch my-custom-styles
</code></pre>
Then we'll add our custom styles in it, the syntax is same as before:
<pre><code class="hljs">b =&gt; b.red
u =&gt; em.red
p[style-name=&#x27;Heading 1&#x27;] =&gt; h1.red.underline
</code></pre>
Now we can generate our HTML file with custom style:
<pre><code class="hljs">$ mammoth file-sample_100kB.docx output.html --style-map=my-custom-styles
</code></pre>
And you're done! Your document would have been converted with the defined custom styles.
<h2 id="conclusion">Conclusion</h2>
File type-casting is a common situation when working on web technologies. Converting DOCX files into well-known and easy to manipulate HTML allows us to reconstruct the data as much as we need. With Mammoth, we've learned how to extract the text from a docx and how to convert it to HTML.
When converting to HTML we can style the output with CSS rules we create or ones that come with common UI frameworks. We can also omit data we don't want to be available in the HTML. Lastly, we've seen how to use the Mammoth CLI as an alternative option for file conversion.
You can find a sample docx file along with the full code of the tutorial on <a rel="nofollow noopener" target="_blank" href="https://github.com/rhasoff/SA-Convert-Docx-To-Html-With-Python-Mammoth">this GitHub repository</a>.

Mammoth is a tool that can convert docx files to HTML. Let's learn how to use Mammoth with Python to convert DOCX files into HTML while keeping their formatting.

How to Convert DOCX To Html With Python Mammoth

François Dupire

Guide to JPA with Hibernate - Inheritance Mapping

<h2 id="introduction">Introduction</h2>
Splitting strings and lists are common programming activities in Python and other languages. Sometimes we have to split our data in peculiar ways, but more commonly - into even chunks.
The language does not have a built-in function to do this and in this tutorial, we'll take a look at how to split a list into even chunks in Python.
For most cases, you can get by using generators:
<pre><code class="hljs">def chunk_using_generators(lst, n):
 for i in range(0, len(lst), n):
 yield lst[i:i + n]
</code></pre>
Though, there are other interesting ways to do this, each with their own pros and cons!
<h2 id="splitalistintoevenchunksofnelements">Split a List Into Even Chunks of N Elements</h2>
A list can be split based on the size of the chunk defined. This means that we can define the size of the chunk. If the subset of the list doesn't fit in the size of the defined chunk, fillers need to be inserted in the place of the empty element holders. We will be using <code>None</code> in those cases.
Let's create a new file called <code>chunk_based_on_size.py</code> and add the following contents:
<pre><code class="hljs">def chunk_based_on_size(lst, n):
 for x in range(0, len(lst), n):
 each_chunk = lst[x: n+x]

 if len(each_chunk) &lt; n:
 each_chunk = each_chunk + [None for y in range(n-len(each_chunk))]
 yield each_chunk

print(list(chunk_based_on_size([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 7)))
</code></pre>
The above <code>chunk_based_on_size()</code> function takes the arguments: <code>lst</code> for the list and <code>chunk_size</code> for a number to split it by. The function iterates through the list with an increment of the chunk size <code>n</code>. Each chunk is expected to have the size given as an argument. If there aren't enough elements to make a split of the same size, the remaining unused elements are filled with <code>None</code>.
Running this script returns the following list of lists:
<pre><code class="hljs">$ python3 chunk_based_on_size.py
[[1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, None]]
</code></pre>
The list has been split into equal chunks of 7 elements each.
Python has utilities to simplify this process. We can use the <code>zip_longest</code> function from <code>itertools</code> to simplify the previous function. Let's create a new file <code>chunk_using_itertools.py</code> and add the following code:
<pre><code class="hljs">from itertools import zip_longest

def chunk_using_itertools(lst):
 iter_ = iter(lst)
 return list(zip_longest(iter_, iter_, iter_, iter_, iter_, iter_, iter_))

print(chunk_using_itertools([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]))
</code></pre>
This code iterates elements and returns a chunk of the desired length - based on the arguments you provide. We've put 7 <code>iter_</code> arguments here. The <code>zip_longest()</code> function aggregates and returns elements from each iterable. In this case, it would aggregate the elements from the list that's iterated 7 times in one go. This then creates numerous iterators that contain 7 sequential elements, which are then converted to a list and returned.
When you execute this snippet, it'll result in:
<pre><code class="hljs">$ python3 chunk_using_itertools.py
[[1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, None]]
</code></pre>
This shorter function produces the same input. However, it's much more limited as we have to manually write how many elements we want in the code, and it's a bit awkward to just put a bunch of <code>iter_</code>s in the <code>zip_longest()</code> call.
The best solution would be using generators. Let's create a new file, <code>chunk_using_generators.py</code>:
<pre><code class="hljs">def chunk_using_generators(lst, n):
 for i in range(0, len(lst), n):
 yield lst[i:i + n]

print(list(chunk_using_generators([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 7)))
</code></pre>
This generator yields a sublist containing <code>n</code> elements. At the end, it would have yielded a sublist for every chunk. Running this code produces this output:
<pre><code class="hljs">$ python3 chunk_using_generators.py
[[1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13]]
</code></pre>
This solution works best if you don't need padding with <code>None</code> or otherwise.
<h2 id="splitalistintoanevenchunks">Split a List Into a N Even Chunks</h2>
In the previous section, we split the list based on the size of individual chunks so that each chunk has the same amount of elements. There's another way to interpret this problem. What do we do when we want to split a list not based on the number of elements in each chunk, but on the number of chunks we want to be created?
For example, instead of splitting a list into chunks where every chunk has 7 elements, we want to split a list into 7 even chunks. In this case, we may not know the size of each chunk.
The logic is similar to the previous solutions, however, the size of the chunk is the ceiling value of the length of the list divided by the number of chunks required. Similar to the previous code samples, if a chunk happens to have vacant spots, those will be filled by the filler value <code>None</code>:
<pre><code class="hljs">import math

def chunk_based_on_number(lst, chunk_numbers):
 n = math.ceil(len(lst)/chunk_numbers)

 for x in range(0, len(lst), n):
 each_chunk = lst[x: n+x]

 if len(each_chunk) &lt; n:
 each_chunk = each_chunk + [None for y in range(n-len(each_chunk))]
 yield each_chunk

print(list(chunk_based_on_number([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], chunk_numbers=7)))
</code></pre>
We determine how many lists we need to create and store that value in <code>n</code>. We then create a sublist for the two elements at a time, padding the output in case our chunk size is smaller than the desired length.
When we execute that file we'll see:
<pre><code class="hljs">$ python3 chunk_based_on_number.py
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, None]]
</code></pre>
As seen in the output above, the list has been split into 7 individual lists of equal sizes, based on the argument <code>chunk_numbers</code> provided.
<h2 id="conclusion">Conclusion</h2>
In this article, we have seen some of the ways by which a list can be split into even-sized chunks and lists based on custom methods and by using the built-in modules.
The solutions mentioned in this tutorial, are not limited to the ones defined here, but there are multiple other creative ways by which you can split your list into even-chunks too.

In this article, we show how to split a list into even sized chunks in Python - splitting into chunks of N elements and into N chunks of equal size.

How to Split a List Into Even Chunks in Python

How to Split a List into Even Chunks in Python

<h2 id="introduction">Introduction</h2>
The <code>print()</code> function in Python appends a newline to the output when displayed on the tty (teletypewriter A.K.A the terminal). When you don't want your message displayed with newlines or with spaces, how can you change the behavior of <code>print()</code>?
This can easily be achieved by altering the default values of the <code>sep</code> and <code>end</code> parameters of the <code>print()</code> function.
<h2 id="printingwithoutanewline">Printing without a Newline</h2>
Until Python version 2.x, <code>print</code> was a reserved keyword that acts as a special statement. Since Python version 3.x, the <code>print</code> command has evolved into a function.
This version of <code>print()</code> is capable of taking the following arguments:
<img src="https://stackabuse.s3.amazonaws.com/media/python-how-to-print-without-a-newline-space-1.jpg" alt="Print function - syntax">
The values (<code>value1</code>, <code>value2</code>) mentioned above can be any string or any of the data types like list, float, string, etc. The other arguments include a separator (<code>sep</code>) used to divide the values given as arguments whereas the argument <code>end</code> is the <code>\n</code> newline character by default. This is the reason why whenever the <code>print()</code> function is called, the cursor slides to the next line.
In Python 3.x, the most straightforward way to print without a newline is to set the <code>end</code> argument as an empty string i.e. <code>''</code>. For example, try executing the following snippet in your Python interpreter:
<pre><code class="hljs">print(&quot;I am a sentence&quot;, &quot;I am also a sentence&quot;)
</code></pre>
The interpreter would output the following:
<pre><code class="hljs">I am a sentence I am also a sentence
&gt;&gt;&gt;
</code></pre>
We are printing two strings, so Python will use the value of <code>sep</code>, a blank space by default, to print them together. Python also adds a newline character at the end, so the interpreter prompt goes to the end line.
Now modify the previous statement to look like this:
<pre><code class="hljs">print(&quot;I am a sentence&quot;, &quot;I am also a sentence&quot;, sep=&quot;; &quot;, end=&quot;&quot;)
</code></pre>
Upon executing it in the interpreter, you will get an output resembling:
<pre><code class="hljs">I am a sentence; I am also a sentence&gt;&gt;&gt;
</code></pre>
Two things happened here - the separator between the two strings now also includes a semicolon. The interpreter prompt also appears on the same line because we removed the automatically appended newline character.
<h2 id="printingwithoutanewlineinpython2x">Printing Without a Newline in Python 2.X</h2>
For earlier versions of Python - less than 3 but greater than 2.6 - you can import <code>print_function</code> from the <code>__future__</code> module. This will override the existing <code>print</code> keyword with the <code>print()</code> function as shown below:
<pre><code class="hljs">from __future__ import print_function

print(&quot;I am a sentence&quot;, &quot;I am also a sentence&quot;, sep=&quot;; &quot;, end=&quot;&quot;)
</code></pre>
This will also yield:
<pre><code class="hljs">I am a sentence; I am also a sentence&gt;&gt;&gt;
</code></pre>
This is how you can use Python version 3's <code>print()</code> function in Python 2.x.
<h2 id="usingstdoutwrite">Using stdout.write()</h2>
The <code>sys</code> module has built-in functions to write directly to the file or the tty. This function is available for Python 2.x and 3.x versions. We can use the <code>write()</code> method of the <code>sys</code> module's <code>stdout</code> object to print on the console like this:
<pre><code class="hljs">import sys

sys.stdout.write(&quot;I am a line&quot;)
</code></pre>
Let's execute this and take a look at the output:
<pre><code class="hljs">I am a line&gt;&gt;&gt;
</code></pre>
Although this gives the output of what we are trying to achieve, there are quite a few differences between the <code>write()</code> function and the <code>print()</code> function. The <code>print()</code> function can print multiple values at a time, can accept non-string values, and is friendlier to developers.
<h2 id="conclusion">Conclusion</h2>
In this article, we have explored the different ways by which values can be printed without a newline character/carriage return. This strategy can come quite handy while printing the elements in the outputs of algorithms such as a binary tree or printing the contents of a list next to each other.

In this tutorial, we'll take a look at how to print without a newline or space in Python, using the print() and write() functions, through examples.