David Landup

Juan Hurtado

In this guide, we'll take a look at the theory and implementation of the Prototype Design Pattern in Python and benchmark the performance boost.

The Prototype Design Pattern in Python

<h2 id="introduction">Introduction</h2>
In this guide, we'll take a look at how to get the maximum or minimum element in a Java Collection, both for primitive types and custom comparable objects, via their fields.
<h2 id="gettingthemaximumorminimumelementwithcollectionsmax">Getting the Maximum or Minimum Element with Collections.max()</h2>
The <code>Collections</code> framework provides us with a wide variety of helper, static methods for working with Collections in Java. It's no wonder that this same framework allows us to search and return the maximum or minimum element of a collection as well.
<h3 id="collectionsmaxandcollectionsminwithprimitivetypes">Collections.max() and Collections.min() with Primitive Types</h3>
Working with primitive types is fairly easy in most regards, and as long as they're <code>Comparable</code> - we can easily search through them.
To find the maximum or minimum element of a Collection consisting of primitive types, we simply call the <code>Collections.max()</code> or <code>Collections.min()</code> methods, passing in the collections we're searching in:
<pre><code class="hljs">List&lt;Integer&gt; list = List.of(1, 5, 4, 3, 7, 6, 9, 4);
 
Integer min = Collections.min(list);
Integer max = Collections.max(list);

System.out.println(String.format(&quot;Minimum element is %s&quot;, min));
System.out.println(String.format(&quot;Maximum element is %s&quot;, max));
</code></pre>
Running this code returns our maximum and minimum elements:
<pre><code class="hljs">Minimum element is 1
Maximum element is 9
</code></pre>
<h3 id="collectionsmaxandcollectionsminwithcustomobjects">Collections.max() and Collections.min() with Custom Objects</h3>
Though, we rarely only work with just primitive types. Typically, we'll be working with objects. Naturally, since these structures are much more complex - you get to decide what constitutes a greater element between the two.
Usually, this is achieved by implementing the <code>Comparable</code> interface, which allows you to compare any two instances of a class to determine which is greater. Let's define a class and make it <code>Comparable</code>:
<pre><code class="hljs">public class Book implements Comparable&lt;Book&gt; {
 private String author;
 private String name;
 private int pageNumber;

 // Constructor, getters and setters

 @Override
 public int compareTo(Book book) {
 return (this.pageNumber &gt; book.pageNumber) ? 1 : -1;
 }

 @Override
 public String toString() {
 return &quot;Book{&quot; +
 &quot;author=&#x27;&quot; + author + &#x27;\&#x27;&#x27; +
 &quot;, name=&#x27;&quot; + name + &#x27;\&#x27;&#x27; +
 &quot;, pageNumber=&quot; + pageNumber +
 &#x27;}&#x27;;
 }
}

</code></pre>
You'll have to <code>@Override</code> the <code>compareTo()</code> method and define by which criteria the entities are compared with. It'll typically boil down to simple primitive types in the end, such as comparing the <code>pageNumber</code> attribute. We've also added a <code>toString()</code> method for convenient formatting.
Now, searching for the maximum or minimum element, in a collection of custom objects is as easy as calling <code>Collections.max()</code> or <code>Collections.min()</code> on the Collection:
<pre><code class="hljs">List&lt;Book&gt; bookList = new ArrayList&lt;&gt;();
bookList.add(new Book(&quot;Nick Bostrom&quot;, &quot;Superintelligence&quot;, 352));
bookList.add(new Book(&quot;Ray Kurzweil&quot;, &quot;The Singularity is Near&quot;, 652));
bookList.add(new Book(&quot;Max Tegmark&quot;, &quot;Our Mathematical Universe&quot;, 432));

Book min = Collections.min(bookList);
Book max = Collections.max(bookList);

System.out.println(String.format(&quot;Minimum element is %s&quot;, min));
System.out.println(String.format(&quot;Maximum element is %s&quot;, max));
</code></pre>
Given our comparison criteria, the results are:
<pre><code class="hljs">Minimum element is Book{author=&#x27;Nick Bostrom&#x27;, name=&#x27;Superintelligence&#x27;, pageNumber=352}
Maximum element is Book{author=&#x27;Ray Kurzweil&#x27;, name=&#x27;The Singularity is Near&#x27;, pageNumber=652}
</code></pre>
<h3 id="customcomparator">Custom Comparator</h3>
You can avoid making the <code>Book</code> comparable, if you can't by supplying a new <code>Comparator</code> in the <code>Collections</code> calls. Though, this solution is verbose and best avoided/substituted with the techniques outlined after this.
Nevertheless, it's a fully valid way to compare entities and find the maximum/minimum value:
<pre><code class="hljs">Book min = Collections.min(bookList, new Comparator&lt;Book&gt;() {
 @Override
 public int compare(Book o1, Book o2) {
 return (o1.getPageNumber() &gt; o2.getPageNumber()) ? 1 : -1;
 }
});

System.out.println(String.format(&quot;Minimum by page count is %s&quot;, min));
</code></pre>
Or, this can be shortened through a <a target="_blank" href="https://stackabuse.com/lambda-expressions-in-java">Lambda Expression</a>:
<pre><code class="hljs">Book min = Collections.min(bookList, 
 (o1, o2) -&gt; (o1.getPageNumber() &gt; o2.getPageNumber()) ? 1 : -1);
</code></pre>
<h2 id="gettingthemaximumorminimumelementwithstreammaxandstreammin">Getting the Maximum or Minimum Element with Stream.max() and Stream.min()</h2>
With the advent of Java 8, we've been introduced to a wonderful Stream API that allows us to perform various processing pipelines. A <code>Stream</code> can find a maximum or minimum element via the <code>max()</code> or <code>min()</code> methods, leveraging either a new <code>Comparator</code> for the job, or using an already existing one, such as the comparator we've built-into our <code>Book</code> class.
This allows you to have non-<code>Comparable</code> classes and quickly use a new <code>Comparator</code> to set the criteria using any field. This flexibility is what makes Streams so amazing for processing data.
<h3 id="streammaxandstreamminwithprimitivetypes">Stream.max() and Stream.min() with Primitive Types</h3>
Let's start off with a simple Collection of primitive types. To get the maximum or minimum element of the collection, we <code>stream()</code> it and call the <code>min()</code> or <code>max()</code> methods:
<pre><code class="hljs">List&lt;Integer&gt; list = List.of(1, 5, 4, 3, 7, 6, 9, 4);
Integer maxInt = list.stream().mapToInt(i -&gt; i).max().getAsInt();
Integer minInt = list.stream().mapToInt(i -&gt; i).min().getAsInt();

System.out.println(String.format(&quot;Minimum element is %s&quot;, minInt));
System.out.println(String.format(&quot;Maximum element is %s&quot;, maxInt));
</code></pre>
Instead of mapping <code>i -&gt; i</code>, we could've alternatively just use:
<pre><code class="hljs">Integer maxInt = list.stream().mapToInt(Integer::intValue).max().getAsInt();
</code></pre>
The <code>max()</code> and <code>min()</code> methods return an <code>Optional</code> - or a derivative of the class, such as <code>OptionalInt</code>, <code>OptionalDouble</code>, etc. To extract the integer value - we use the <code>getAsInt()</code> at the end of the call chain.
Running this code results in:
<pre><code class="hljs">Minimum element is 1
Maximum element is 9
</code></pre>
Instead of <code>mapToInt()</code> you can also use a <code>Comparator</code>, such as <code>comparing()</code> or <code>comparingInt()</code> (both of which would produce the same output):
<pre><code class="hljs">Integer maxInt = list.stream().max(Comparator.comparing(Integer::intValue)).get();
Integer minInt = list.stream().min(Comparator.comparingInt(Integer::intValue)).get();
</code></pre>
Again, these methods return an <code>Optional</code>, so we <code>get()</code> the result in the end. <code>comparing()</code> has the flexibility of comparing non-Integer values as well, but since we're constraining ourselves to just Integers here, it doesn't make any difference.
<h3 id="streammaxandstreamminwithcustomobjects">Stream.max() and Stream.min() with Custom Objects</h3>
Using custom comparators with custom objects is where Streams shine the most and where they provide the most flexibility. When using the <code>Collections</code> framework, we were constrained to compare the elements via the <code>compareTo()</code> method, overridden from the <code>Comparable</code> interface, if you don't want to define a chunky <code>new Comparator</code>.
With Streams - we can define a new <code>Comparator</code> on the fly with any field, without the class even having to implement the <code>Comparable</code> interface. Let's find the maximum and minimum element of a collection with custom objects, using a custom comparator and streams:
<pre><code class="hljs">List&lt;Book&gt; bookList = new ArrayList&lt;&gt;();
bookList.add(new Book(&quot;Nick Bostrom&quot;, &quot;Superintelligence&quot;, 352));
bookList.add(new Book(&quot;Ray Kurzweil&quot;, &quot;The Singularity is Near&quot;, 652));
bookList.add(new Book(&quot;Max Tegmark&quot;, &quot;Our Mathematical Universe&quot;, 432));

// Using native compareTo() Method
Book min = bookList.stream().min(Book::compareTo).get();
Book max = bookList.stream().max(Book::compareTo).get();

// Using custom new Comparator
Book minByAuthor = bookList.stream().min(Comparator.comparing(Book::getAuthor)).get();
Book maxByAuthor = bookList.stream().max(Comparator.comparing(Book::getAuthor)).get();

System.out.println(String.format(&quot;Minimum by page count is %s&quot;, min));
System.out.println(String.format(&quot;Maximum by page count is %s&quot;, max));

System.out.println(String.format(&quot;Minimum by author is %s&quot;, minByAuthor));
System.out.println(String.format(&quot;Maximum by author is %s&quot;, maxByAuthor));
</code></pre>
This time around, we can use any field and supply it to the <code>Comparator.comparing()</code> method. You can also use alternative methods, such as <code>comparingInt()</code> here, but since we're comparing the lexicographical value of <code>String</code>s, we'll be sticking with the generic <code>comparing()</code> method.
Running this code results in:
<pre><code class="hljs">Minimum by page count is Book{author=&#x27;Nick Bostrom&#x27;, name=&#x27;Superintelligence&#x27;, pageNumber=352}
Maximum by page count is Book{author=&#x27;Ray Kurzweil&#x27;, name=&#x27;The Singularity is Near&#x27;, pageNumber=652}

Minimum by author is Book{author=&#x27;Max Tegmark&#x27;, name=&#x27;Our Mathematical Universe&#x27;, pageNumber=432}
Maximum by author is Book{author=&#x27;Ray Kurzweil&#x27;, name=&#x27;The Singularity is Near&#x27;, pageNumber=652}
</code></pre>
<h2 id="usingaforloop">Using a for Loop</h2>
Finally, the good old <code>for</code> loop can be used to search for a maximum or minimum element:
<pre><code class="hljs">List&lt;Book&gt; bookList = new ArrayList&lt;&gt;();
bookList.add(new Book(&quot;Nick Bostrom&quot;, &quot;Superintelligence&quot;, 352));
bookList.add(new Book(&quot;Ray Kurzweil&quot;, &quot;The Singularity is Near&quot;, 652));
bookList.add(new Book(&quot;Max Tegmark&quot;, &quot;Our Mathematical Universe&quot;, 432));

List&lt;Integer&gt; intList = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9);

// Instantiate as the first book initially
Book maxBook = bookList.get(0);
Integer maxInt = 0;

for (Book book : bookList) {
 // book.getPageNumber() &lt; minBook.getPageNumber()
 if (book.getPageNumber() &gt; maxBook.getPageNumber()) {
 maxBook = book;
 }
}

for (Integer integer : intList) {
 // integer &lt; minInt
 if (integer &gt; maxInt) {
 maxInt = integer;
 }
}

System.out.println(String.format(&quot;Maximum by page count is %s&quot;, maxBook));
System.out.println(String.format(&quot;Maximum int is %s&quot;, maxInt));
</code></pre>
This results in the same results we've been seeing so far:
<pre><code class="hljs">Maximum by page count is Book{author=&#x27;Ray Kurzweil&#x27;, name=&#x27;The Singularity is Near&#x27;, pageNumber=652}
Maximum int is 9
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to find the maximum and minimum elements of a Java Collection. We've taken a look at both primitive types and custom objects, default and custom comparators, and best practices, including a manual <code>for</code> loop.

In this guide, we'll go over how to find the max and min elements of a Java Collection using default and custom comparators, the Collections framework and the Java 8 Stream API.

How to Get Max or Min Element in Java Collection

Arpendu Kumar Garai

Learn how to build your own Quartz Management Console with Java and Spring Boot - perform job scheduling and automation with one of the powerful schedulers.

Guide to Quartz with Spring Boot - Job Scheduling and Automation

<h2 id="introduction">Introduction</h2>
Working with datetime can be a bit daunting and challenging, and handling datetime in Python is no exception. Python's built-in <code>datetime</code> module introduced us to several classes - <code>date</code>, <code>datetime</code>, <code>time</code>, <code>timezone</code> and <code>timedelta</code>, and several external libraries have spawned to address the issues present in the official module, such as <a target="_blank" href="https://stackabuse.com/working-with-datetime-in-python-with-arrow">Arrow</a>.
In this guide, we'll take a look at how to perform time and date arithmetic, alteration and truncation of datetime objects in Delorean - a library built upon <a rel="nofollow noopener" target="_blank" href="https://pypi.org/project/pytz/">pytz</a> which is the standard library for solving problems relating to time zones, and <a rel="nofollow noopener" target="_blank" href="https://dateutil.readthedocs.io/en/stable/">dateutil</a> which is used to calculate deltas between any 2 given datetime objects.
<h2 id="installingdeloreansettingupavirtualenvironment">Installing Delorean Setting Up a Virtual Environment</h2>
Delorean is available for installation via <code>pip</code>. It is generally advisable to work in a virtual environment because it enables you to organize dependencies required by different projects isolated.
On Linux, or MacOS to create a virtual environment, we'd run:
<pre><code class="hljs">$ python3 -m venv env
$ source env/bin/activate
$ python3 -m pip install delorean
</code></pre>
Alternatively, on Windows we can run:
<pre><code class="hljs">$ virtualenv env
$ .\env\Scripts\activate
$ python3 -m pip install delorean
</code></pre>
<h3 id="addingandsubtractingtimewithtimedelta">Adding and Subtracting Time with Timedelta</h3>
<code>timedelta</code> represents the difference between two <code>datetime</code> objects, and has a microsecond resolution. Using <code>timedelta</code>, we can define durations of different length, such as <code>microseconds</code>, <code>seconds</code>, <code>minutes</code>, <code>hours</code>, <code>days</code> and <code>weeks</code>.
It doesn't contain any information about dates - just the duration. The <code>timedelta</code> between the 5th of June and the 10th of June is the same as the <code>timedelta</code> between the 5th of May and the 10th of May - 5 days.
This makes it really easy to add or subtract a duration of time from <code>datetime</code> objects:
<pre><code class="hljs">from delorean import Delorean
import datetime

dt_tm_future = Delorean()
dt_tm_future += datetime.timedelta(days=3)

dt_tm_past = Delorean()
dt_tm_past -= datetime.timedelta(weeks=3)

print(&quot;The date 3 days from now is: &quot;, dt_tm_future)
print(&quot;The date 3 weeks before now was: &quot;, dt_tm_past)
</code></pre>
This results in:
<pre><code class="hljs">The date 3 days from now is: Delorean(datetime=datetime.datetime(2021, 7, 17, 10, 22, 51, 403546), timezone=&#x27;UTC&#x27;)
The date 3 weeks before now was: Delorean(datetime=datetime.datetime(2021, 6, 23, 10, 22, 51, 403643), timezone=&#x27;UTC&#x27;)
</code></pre>
<h2 id="getnumberofdaysbetweendateswithdelorean">Get Number Of Days Between Dates with Delorean</h2>
A common unknown with multiple dates is the number of days between two given dates. This result is typically packed in a <code>timedelta</code> object given the fact that it's designed to represent this difference.
Given how easy it is to add or subtract <code>timedelta</code> from and to dates, it's only natural that this operation is easy as well.
To get the number of days between two dates in Python with Delorean, we just subtract the dates, which results in a <code>timedelta</code> representation of the difference:
<pre><code class="hljs">present_date = Delorean()
new_year = Delorean(datetime=datetime.datetime(2022, 1, 1), timezone=&#x27;UTC&#x27;)
until_new_year = new_year - present_date
print(&quot;Days until 2022 &quot;, until_new_year)
print(&quot;Days till 2022 &quot;, until_new_year.days)
</code></pre>
We can print the entire <code>timedelta</code> object, or just access its <code>days</code> attribute:
<pre><code class="hljs">Days until 2022 170 days, 13:24:22.817417
Days till 2022 170
</code></pre>
<h2 id="alterationoftimeanddate">Alteration of Time and Date</h2>
Delorean lets you effortlessly alter datetime objects by replacing or shifting values. For this, we use the <code>replace()</code> and <code>shift()</code> methods.
The <code>replace()</code> method lets you replace a certain aspect of the datetime instance, while <code>shift()</code> lets you shift the timezone:
<pre><code class="hljs">from delorean import Delorean

date = Delorean(datetime=datetime.datetime(2021, 5, 14, 12), timezone=&#x27;Europe/Paris&#x27;)

altered_tm = date.replace(hour=10)
altered_dt = date.replace(month=10)

print(&quot;Altered time is:&quot;, altered_tm)
print(&quot;Altered date is:&quot;, altered_dt)

altered_dt.shift(&#x27;US/Pacific&#x27;)
print(&quot;Shifted object:&quot;, altered_dt)
</code></pre>
We've created a <code>Delorean</code> instance, changed its <code>hour</code> and <code>month</code> attributes, and then shifted the new, altered datetime object into a new timezone:
<pre><code class="hljs">Altered time is: Delorean(datetime=datetime.datetime(2021, 5, 14, 10, 0), timezone=&#x27;Europe/Paris&#x27;)
Altered date is: Delorean(datetime=datetime.datetime(2021, 10, 14, 12, 0), timezone=&#x27;Europe/Paris&#x27;)
Shifted object: Delorean(datetime=datetime.datetime(2021, 10, 14, 3, 0), timezone=&#x27;US/Pacific&#x27;)
</code></pre>
<h2 id="truncatedatetimeobjectswithdelorean">Truncate Datetime Objects with Delorean</h2>
Depending on the reason you're using <code>datetime</code> for - you might not care about the smaller-order measurements such as seconds or milliseconds. While you can simply print out the data without the measurements - you can also <code>truncate()</code> them out of the <code>Delorean</code> object itself.
The method works on higher-order measurements as well, and accepts all valid Delorean time frames, up to <code>years</code>:
<pre><code class="hljs">from delorean import Delorean

date = Delorean()
print(&quot;Date before truncation:&quot;, date)

trun_min = date.truncate(&#x27;minute&#x27;) # Truncate to minutes
print(&quot;Truncated to minutes = &quot;, trun_min)
</code></pre>
It's worth noting that you're truncating to a certain measurement level. That's to say - if you truncate to minutes - seconds and milliseconds will be dropped. In essence - you're setting the resolution of the <code>Delorean</code> instance:
<pre><code class="hljs">Date before truncation: Delorean(datetime=datetime.datetime(2021, 7, 14, 10, 52, 9, 893770), timezone=&#x27;UTC&#x27;)
Truncated to minutes = Delorean(datetime=datetime.datetime(2021, 7, 14, 10, 52), timezone=&#x27;UTC&#x27;)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to perform time and date arithmetic, alteration and truncation in Python with Delorean.

Geoffery, Joseph

In this guide, we'll take a look at how to perform datetime arithmetic, alteration and truncation in Python with Delorean.

Datetime Arithmetic, Alteration and Truncation with Python's Delorean

<h2 id="introduction">Introduction</h2>
Working with datetime can be a bit daunting and challenging, and handling datetime in Python is no exception. Python's built-in <code>datetime</code> module introduced us to several classes - <code>date</code>, <code>datetime</code>, <code>time</code>, <code>timezone</code> and <code>timedelta</code>, and several external libraries have spawned to address the issues present in the official module, such as <a target="_blank" href="https://stackabuse.com/working-with-datetime-in-python-with-arrow">Arrow</a>.
In this guide, we'll take a look at how to humanize datetime objects in Delorean - a library built upon <a rel="nofollow noopener" target="_blank" href="https://pypi.org/project/pytz/">pytz</a> which is the standard library for solving problems relating to time zones, and <a rel="nofollow noopener" target="_blank" href="https://dateutil.readthedocs.io/en/stable/">dateutil</a> which is used to calculate deltas between any 2 given datetime objects.
<h2 id="installingdeloreansettingupavirtualenvironment">Installing Delorean Setting Up a Virtual Environment</h2>
Delorean is available for installation via <code>pip</code>. It is generally advisable to work in a virtual environment because it enables you to organize dependencies required by different projects isolated.
On Linux, or MacOS to create a virtual environment, we'd run:
<pre><code class="hljs">$ python3 -m venv env
$ source env/bin/activate
$ python3 -m pip install delorean
</code></pre>
Alternatively, on Windows we can run:
<pre><code class="hljs">$ virtualenv env
$ .\env\Scripts\activate
$ python3 -m pip install delorean
</code></pre>
<h3 id="humanizingdeloreandatetimeobjectswithhumanize">Humanizing Delorean Datetime Objects with humanize()</h3>
While Epoch timestamps are extremely precise and great for digital devices - they're not too understandable by humans. We don't have a cognitive awareness of such scales. Additionally, we don't naturally comprehend dates the way computers do, except for some more rare occasions. Most people might not have known what date it is, were it not for the constant clock and calendar built into most digital devices - from stationary to mobile.
For most of the time, we've been dealing with time in reference to where we are now. When did you see your friend? On the 12th of July, 2021, or yesterday? The <code>humanize()</code> function takes a factual date, and turns it into what people would use while conveying the time of an event:
<pre><code class="hljs">import delorean
datetime_strings = [&quot;Thu July 12 2021&quot;, &quot;June 5th, 2021&quot;, &quot;April 28th, 2052&quot;]

for date in datetime_strings:
 delorean_object = delorean.parse(date)
 human_date = delorean_object.humanize()
 print(human_date)
</code></pre>
These date strings are parsed into Delorean objects and then humanized:
<pre><code class="hljs">4 hours from now
a month ago
30 years from now
</code></pre>
This is a great feature for annotating the time before or until events on applications. For example, you might tell a user that they've received a notification a day ago, or that a concert is coming up in a month. This can also be switched between if the event is, say, older than N days.
To do this, we'd measure if a date has occurred more than N days before the current date, using <code>timedelta</code> and adjust the message appropriately:
<pre><code class="hljs">import delorean
# Dates denote events, such as notifications.
# First event occurred recently before writing this guide.
# The second event occurred a bit over a month before that.
datetime_strings = [&quot;Thu July 12 2021&quot;, &quot;June 5th, 2021&quot;]

for index, date in enumerate(datetime_strings):
 delorean_object = delorean.parse(date)
 current_time = delorean.Delorean()
 if (current_time-delorean_object) &lt; datetime.timedelta(5):
 human_date = delorean_object.humanize()
 print(f&#x27;Event {index} happened&#x27;, human_date)
 else:
 print(f&#x27;Event {index} happened on&#x27;, delorean_object.date)
</code></pre>
This results in:
<pre><code class="hljs">Event 0 happened 14 hours ago
Event 1 happened on 2021-06-05
</code></pre>
This makes a lot of sense, because if you tell someone that something happened yesterday, there's not much thought required to make that out. But if you say that something happened a month ago, they'll likely look at the calendar to get a feel of when that was.
<h2 id="humanizerelativedateswithdelorean">Humanize Relative Dates with Delorean</h2>
Delorean also makes it easy to reference dates in relation to another date in a very intuitive and human-like way.
<blockquote>
See you this time next Friday.
</blockquote>
This is well understood by people, but tedious to code by hand using <code>timedelta</code>. Using a combination of <code>next_</code> and <code>last_</code> with days of the week, months or even years, we can calculate and create Delorean objects based on already existing datetimes:
<pre><code class="hljs">from delorean import Delorean

dt_tm = Delorean()
nxt_fri = dt_tm.next_friday()
print(&quot;Friday next week: &quot;, nxt_fri)

# Date for Two Fridays ago
two_fridays_ago = dt_tm.last_friday(2)
print(&quot;Friday two weeks ago: &quot;, two_fridays_ago)

# Get Two Fridays from now at midnight
two_fridays_from_now_at_midnight = dt_tm.next_friday(2).midnight
print(&quot;Two Fridays from now at midnight: &quot;, two_fridays_from_now_at_midnight)

# Get this time next month
next_month = dt_tm.next_month()
print(&quot;This time next month: &quot;, next_month)

# Get this time next year, at midnight
next_month = dt_tm.next_year().midnight
print(&quot;This time next month: &quot;, next_month)
</code></pre>
To get the date of a day of the week more than just last or next week - we pass in a number denoting the number of weeks we're traversing. The same goes for days, months or years:
<pre><code class="hljs">Friday next week: Delorean(datetime=datetime.datetime(2021, 7, 16, 19, 25, 34, 427028), timezone=&#x27;UTC&#x27;)
Friday two weeks ago: Delorean(datetime=datetime.datetime(2021, 7, 2, 19, 25, 34, 427028), timezone=&#x27;UTC&#x27;)
Two Fridays from now at midnight: 2021-07-23 00:00:00+00:00
This time next month: Delorean(datetime=datetime.datetime(2021, 8, 11, 19, 25, 34, 427028), timezone=&#x27;UTC&#x27;)
This time next month: 2022-07-11 00:00:00+00:00
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to humanize Delorean datetime objects in Python. Humanization is the process of converting datetime instances to a more human format - using words and relative time frames. Given the relativity of these time frames, it makes sense to humanize dates in some cases, while not in others.

Humanizing dates is important for a good user experience. In this guide, we'll take a look at how to humanize dates and relative dates using Delorean and Python.

How to Humanize Delorean Datetime Objects

<h2 id="introduction">Introduction</h2>
Working with datetime can be a bit daunting and challenging, and handling datetime in Python is no exception. Python's built-in <code>datetime</code> module introduced us to several classes - <code>date</code>, <code>datetime</code>, <code>time</code>, <code>timezone</code> and <code>timedelta</code>, and several external libraries have spawned to address the issues present in the official module, such as <a target="_blank" href="https://stackabuse.com/working-with-datetime-in-python-with-arrow">Arrow</a>.
In this guide, we'll take a look at how to create and parse datetime objects in Delorean - a library built upon <a rel="nofollow noopener" target="_blank" href="https://pypi.org/project/pytz/">pytz</a> which is the standard library for solving problems relating to time zones, and <a rel="nofollow noopener" target="_blank" href="https://dateutil.readthedocs.io/en/stable/">dateutil</a> which is used to calculate deltas between any 2 given datetime objects.
<h2 id="installingdeloreansettingupavirtualenvironment">Installing Delorean Setting Up a Virtual Environment</h2>
Delorean is available for installation via <code>pip</code>. It is generally advisable to work in a virtual environment because it enables you to organize dependencies required by different projects isolated.
On Linux, or MacOS to create a virtual environment, we'd run:
<pre><code class="hljs">$ python3 -m venv env
$ source env/bin/activate
$ python3 -m pip install delorean
</code></pre>
Alternatively, on Windows we can run:
<pre><code class="hljs">$ virtualenv env
$ .\env\Scripts\activate
$ python3 -m pip install delorean
</code></pre>
<h2 id="creatingadeloreandatetimeobject">Creating a Delorean Datetime Object</h2>
The main class we'll be working with, which represents all datetime objects is the <code>Delorean()</code> class. Let's go ahead and import it from the <code>delorean</code> module, and instantiate a datetime object:
<pre><code class="hljs">from delorean import Delorean

dt_tm = Delorean() 
print(&quot;Datetime: &quot;, dt_tm)
</code></pre>
After running the code, you should see the following on your terminal/command line:
<pre><code class="hljs">Datetime: Delorean(datetime=datetime.datetime(2021, 7, 11, 18, 40, 43, 760187), timezone=&#x27;UTC&#x27;)
</code></pre>
As usual, it's a wrapper for the standard <code>datetime</code> object, which is situated inside the <code>Delorean</code> object assigned to it. The default timezone is <code>'UTC'</code>, though, you can easily switch this by either defining the timezone while instantiating the object or by shifting the time to a different timezone.
Since the output is a bit hard to parse by humans - it makes sense to extract some of the data from the wrapper to make it easier to interpret. While the descending hierarchy of time is clear - it takes too long to go through it and parse it with our eyes. Let's get the <code>date</code> of this object and print just that:
<pre><code class="hljs">from delorean import Delorean 
dt_tm = Delorean()

dt = Delorean().date
print(&quot;Date: &quot;, dt)
</code></pre>
This results in:
<pre><code class="hljs">Date: 2021-07-11
</code></pre>
If you're interested in just the time, without much regard for the date itself, you can get both the timezone-aware time, as well as the timezone-naive time fairly easily:
<pre><code class="hljs">from delorean import Delorean
dt_tm = Delorean()

tm = dt_tm.datetime.time()
print(&quot;Timezone-aware time: &quot;, tm)

naive_dt_tm = dt_tm.naive
print(&quot;Timezone-naive datetime: &quot;, naive_dt_tm)
</code></pre>
This results in:
<pre><code class="hljs">Timezone-aware time: 18:40:21.235708
Timezone-naive datetime: 2021-07-11 18:40:21.235708
</code></pre>
To change the timezone, we either supply it to the constructor call, or shift the time:
<pre><code class="hljs">from delorean import Delorean

dt_tm = Delorean(timezone=&#x27;Europe/Paris&#x27;)
print(&quot;Datetime Object: &quot;, dt_tm)
print(&quot;Time: &quot;, dt_tm.datetime.time())
dt_tm.shift(&#x27;US/Pacific&#x27;)
print(&quot;Shifted time: &quot;, dt_tm.datetime.time())
</code></pre>
<pre><code class="hljs">Datetime Object: Delorean(datetime=datetime.datetime(2021, 7, 11, 20, 43, 26, 990117), timezone=&#x27;Europe/Paris&#x27;)
Time: 20:43:26.990117
Shifted time: 11:43:26.990117
</code></pre>
To take a look at all the available timezones, since Delorean uses <code>pytz</code> under the hood - we can simply print them out:
<pre><code class="hljs">import pytz

timezones = pytz.all_timezones
num = len(timezones)
print(f&quot;There are {num} timezones: \n&quot;)

for tz in pytz.all_timezones:
 print(tz)
</code></pre>
Which results in:
<pre><code class="hljs">There are 593 timezones: 

Africa/Abidjan
Africa/Accra
...
US/Michigan
US/Mountain
UTC
Universal
W-SU
WET
Zulu
</code></pre>
<h3 id="convertstringtodeloreandatetimeobject">Convert String to Delorean Datetime Object</h3>
No library would be complete without the ability to parse strings into datetime objects. Delorean is versatile with the string formats and assumes that the day comes first if there is any ambiguity in the parsed string. The <code>parse()</code> method is used to parse a string, and it optionally accepts timezone information - otherwise, <code>'UTC'</code> is assumed:
<pre><code class="hljs">import delorean

# Datetime strings of differing formats
datetime_strings = [&quot;Mon May 12 2021 00:01:02&quot;, 
 &quot;25-12-2021&quot;, &quot;8/6/2019&quot;, 
 &quot;15-12-1987 7:00:32&quot;, 
 &quot;June 5th, 2021&quot;, 
 &quot;5th of April, 2012&quot;, 
 &quot;Thu 13 of July&quot;]

for date in datetime_strings:
 delorean_object = delorean.parse(date)
 print(delorean_object)
</code></pre>
Running this code results in:
<pre><code class="hljs">Delorean(datetime=datetime.datetime(2021, 5, 12, 0, 1, 2), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2021, 12, 25, 0, 0), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2019, 6, 8, 0, 0), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(1987, 12, 15, 7, 0, 32), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2021, 6, 5, 0, 0), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2012, 4, 5, 0, 0), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2021, 7, 13, 0, 0), timezone=&#x27;UTC&#x27;)
</code></pre>
You can notice how in the ambiguous case of <code>8/6/2019</code>, it was assumed that the day comes first, hence it was parsed as the 8th of June, instead of the 6th of August. Also, since we didn't provide the year of the final date - it's automatically assigned to the current year.
If you'd like to turn this behavior around, you can set the <code>dayfirst</code> argument to <code>False</code>. Additionally, you can also set the <code>yearfirst</code> argument to <code>True</code>, which is <code>False</code> by default, in which case, the first expected value will be the year:
<pre><code class="hljs">delorean_object = delorean.parse(&quot;8/6/2019&quot;, dayfirst=False)
print(delorean_object)
</code></pre>
This results in:
<pre><code class="hljs">Delorean(datetime=datetime.datetime(2019, 8, 6, 0, 0), timezone=&#x27;UTC&#x27;)
</code></pre>
<h3 id="epochtimestamptodeloreanobject">Epoch Timestamp to Delorean Object</h3>
Since all modern computers adopted the use of UNIX time, also known as Epoch time - it's needless to say that we can convert a UNIX/Epoch timestamp into a Delorean object. This is the underlying mechanism that allows for working with time anyway. To convert a Unix timestamp into a Delorean datetime object, we use the <code>epoch()</code> method of the <code>delorean</code> module:
<pre><code class="hljs">import delorean

timestamp = 3141592653
delorean_object = delorean.epoch(timestamp)
print(delorean_object)
</code></pre>
We've inconspicuously used the first 10 digits of Pi to form a timestamp into the future, resulting in a time well beyond that of this guide:
<pre><code class="hljs">Delorean(datetime=datetime.datetime(2069, 7, 21, 0, 37, 33), timezone=&#x27;UTC&#x27;)
</code></pre>
<h2 id="generatingasequenceofdates">Generating a Sequence of Dates</h2>
A great way to produce a sequence of Delorean objects is via the <code>stops()</code> generator. You can generate N dates following a pattern, such as every Tuesday, or every hour or every 10 weeks. This is useful for creating, say, monthly payment plans or calculating ROI plans for instance.
Using this approach, you can also generate a series of dates on which something should occur, such as running a script every week at the same time, to gather data from an application for aggregation. Though, you can also use the <a target="_blank" href="/scheduling-jobs-with-python-crontab">python-crontab</a> library for that, or the underlying <a target="_blank" href="/how-to-use-the-crontab-command-in-unix">crontab utility tool</a> instead.
The <code>stops()</code> generator accepts a <code>freq</code> argument, denoting the frequency, a <code>timezone</code> and a <code>count</code>, denoting how many dates it should generate. The frequency can be set to any valid Delorean constant - <code>SECONDLY</code>, <code>MINUTELY</code>, <code>HOURLY</code>, <code>DAILY</code>, <code>WEEKLY</code>, <code>MONTHLY</code> or <code>YEARLY</code>:
<pre><code class="hljs">import delorean

for stop in delorean.stops(freq=delorean.HOURLY, timezone=&#x27;UTC&#x27;, count=10):
 print(stop)
</code></pre>
This generates a sequence of datetime objects following this pattern:
<pre><code class="hljs">Delorean(datetime=datetime.datetime(2021, 7, 12, 13, 35, 12), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2021, 7, 12, 14, 35, 12), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2021, 7, 12, 15, 35, 12), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2021, 7, 12, 16, 35, 12), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2021, 7, 12, 17, 35, 12), timezone=&#x27;UTC&#x27;)
</code></pre>
If you're unsure how many datetime objects you want exactly but do have a target datetime in mind, you can also set it to loop until a given date occurs:
<pre><code class="hljs">import delorean

dt1 = delorean.Delorean().naive
dt2 = delorean.Delorean(datetime=datetime.datetime(2022, 1, 1), timezone=&#x27;UTC&#x27;).naive

for stop in delorean.stops(freq=delorean.MONTHLY, start=dt1, stop=dt2):
 print(stop)
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: The <code>stops()</code> method only accepts timezone-naive datetime instances for the <code>start</code> and <code>stop</code> arguments, and returns timezone-aware dates. But it also requires you to specify a <code>timezone</code> when instantiating a <code>Delorean</code> instance using the constructor. What we're left with is - defining a <code>timezone</code> for the instance, and then using the <code>naive</code> datetime for both instead.

 </div>
 </div>
 </div>
 Running this code will give us a date for each month until it reaches the first of January, 2022:
<pre><code class="hljs">Delorean(datetime=datetime.datetime(2021, 7, 12, 13, 46, 1), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2021, 8, 12, 13, 46, 1), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2021, 9, 12, 13, 46, 1), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2021, 10, 12, 13, 46, 1), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2021, 11, 12, 13, 46, 1), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2021, 12, 12, 13, 46, 1), timezone=&#x27;UTC&#x27;)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to create and parse Delorean objects in Python. We've seen how to convert a string to datetime in various formats, how to convert an epoch timestamp into datetime, and how to generate a sequence of dates using the <code>stops()</code> generator.

In this guide, we'll take a look at how to create and parse datetime objects in Python with Delorean, from various string formats, epoch timestamps and how to generate a sequence of dates using stops().

Creating and Parsing Datetime in Python with Delorean

<h2 id="introduction">Introduction</h2>
In this guide, we'll take a look at how to remove a character from a string in Python.
Strings, and especially user-generated input may contain unwanted characters, such as special characters in a username field we don't want to store. In those cases, we might prefer to remove specific characters from a given string.
The most common way to remove a character from a string is with the <code>replace()</code> method, but we can also utilize the <code>translate()</code> method, and even replace one or more occurrences of a given character.
<h2 id="removecharacterinpythonusingreplace">Remove Character in Python Using replace()</h2>
The <code>string</code> class provides a <code>replace()</code> method that replaces a character with another. It's worth noting that his function returns a new string with the characters replaced, since strings are immutable. The original string remains unchanged, but the object in memory is lost unless we keep a reference to it alive. Typically, you'll assign the returned value either to the same pointer or a new one.
The method replaces all occurrences of a character, with a new one. For example, <code>any_string.replace('a', 'b')</code> will replace all occurrences of <code>'a'</code> in <code>any_string</code> with the character <code>'b'</code>. To remove a character from a string via <code>replace()</code>, we'll replace it with an empty character:
<pre><code class="hljs">original_string = &quot;stack abuse&quot;
# Removing character &#x27;a&#x27; and replacing with an empty character
new_string = original_string.replace(&#x27;a&#x27;, &#x27;&#x27;)
print(&quot;String after removing the character &#x27;a&#x27;:&quot;, new_string)
</code></pre>
Once we run this code, we're greeted with:
<pre><code class="hljs">String after removing the character &#x27;a&#x27;: stck buse
</code></pre>
<h2 id="removecharacterinpythonusingtranslate">Remove Character in Python Using translate()</h2>
Python strings have a <code>translate()</code> method which replaces the characters with other characters specified in a translation table.
<blockquote>
A translation table is just a dictionary of key-value mappings where each key will be replaced with a value.
</blockquote>
For this method to work, we have to specify the Unicode value for the strings, which we can get via the <code>ord()</code> function.
For example, <code>any_string.ranslate({ord('a'):ord('z'), ord('b'):ord('y')})</code> will replace occurrences of <code>'a'</code> with <code>'z'</code> and <code>'b'</code> with <code>'y'</code>.
To remove a character from a string using <code>translate()</code>, you'll need to map the Unicode value of the character with <code>None</code> in the translation table:
<pre><code class="hljs">original_string = &quot;stack abuse&quot;
# removing character &#x27;a&#x27;
new_string = original_string.translate({ord(&#x27;a&#x27;): None})
print(&quot;String after removing the character &#x27;a&#x27;:&quot;, new_string)
</code></pre>
This code results in:
<pre><code class="hljs">String after removing the character &#x27;a&#x27;: stck buse
</code></pre>
<h2 id="removeanumberofoccurrencesofacharacter">Remove a Number of Occurrences of a Character</h2>
The <code>replace()</code> and <code>translate()</code> methods replace all the occurrences of a given character with another. However, the <code>replace()</code> method takes an optional argument <code>count</code>. If it is given, it only replaces <code>count</code> number of occurrences of the given character.
Let's try only removing the first <code>'a'</code> from the string, instead of all occurrences:
<pre><code class="hljs">original_string = &quot;stack abuse&quot;
# removing character &#x27;s&#x27;
new_string = original_string.replace(&#x27;a&#x27;, &#x27;&#x27;, 1)
print(&quot;String after removing the character &#x27;a&#x27;:&quot;, new_string)
</code></pre>
The output of the above code will look like this:
<pre><code class="hljs">String after removing the character &#x27;a&#x27;: stck abuse
</code></pre>
As the count is set to <code>1</code>, only the first occurrence of <code>'a'</code> is replaced - this is useful when you want to remove one and only one character.
<h2 id="manuallycreateanewstringwithoutacharacter">Manually Create a New String Without a Character</h2>
A somewhat esoteric, but straightforward technique would be to create an empty string and loop through the original string. In the loop, we'll write every character into the new string except the one to remove.
This is actually what happens under the hood, with some extra validation. Since Python is implemented in C, we can take a peak at <a target="_blank" rel="nofollow noopener" href="https://svn.python.org/projects/python/trunk/Objects/stringobject.c">the <code>stringobject.c</code> source code</a>, which defines the <code>replace()</code> method, which ultimately calls either <code>replace_single_character()</code> or <code>replace_single_character_in_place()</code>:
<pre><code class="hljs"> start = self_s;
 end = self_s + self_len;
 while (count-- &gt; 0) {
 next = findchar(start, end-start, from_c);
 if (next == NULL)
 break;

 if (next == start) {
 /* replace with the &#x27;to&#x27; */
 Py_MEMCPY(result_s, to_s, to_len);
 result_s += to_len;
 start += 1;
 } else {
 /* copy the unchanged old then the &#x27;to&#x27; */
 Py_MEMCPY(result_s, start, next-start);
 result_s += (next-start);
 Py_MEMCPY(result_s, to_s, to_len);
 result_s += to_len;
 start = next+1;
 }
 }
 /* Copy the remainder of the remaining string */
 Py_MEMCPY(result_s, start, end-start);

 return result;
</code></pre>
To gain an appreciation for how much logic is abstracted behind simple, intuitive, high-level APIs, we can do this process manually:
<pre><code class="hljs">def remove_character(original_string, character, occurrence_num):
 new_string = &quot;&quot;
 for char in original_string:
 if char == character and occurrence_num &gt; 0:
 occurrence_num = occurrence_num-1
 continue
 else:
 new_string += char
 return new_string 
 
 
string = &#x27;stack abuse&#x27;
print(remove_character(string, &#x27;a&#x27;, 0))
print(remove_character(string, &#x27;a&#x27;, 1))
print(remove_character(string, &#x27;a&#x27;, 2))
</code></pre>
The above piece of code will produce the following output:
<pre><code class="hljs">stack abuse
stck abuse
stck buse
</code></pre>
We we can see - our own method performs in much the same way the <code>replace()</code> method does, but it's a lot less efficient:
<pre><code class="hljs">print(&quot;Time taken by manual method: {}&quot;
 .format(timeit.timeit(&quot;remove_character(&#x27;stack abuse&#x27;, &#x27;a&#x27;, 1)&quot;, &quot;from __main__ import remove_character&quot;)))
 
print(&quot;Time taken by replace(): {}&quot;
 .format(timeit.timeit(&quot;&#x27;stack abuse&#x27;.replace(&#x27;a&#x27;, &#x27;&#x27;, 1)&quot;)))
</code></pre>
Timing these methods results in:
<pre><code class="hljs">Time taken by manual method: 1.3785062030074187
Time taken by replace(): 0.13279212499037385
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we explored how we can remove characters from a string in Python. We have seen how to use the <code>replace()</code> and <code>translate()</code> methods to remove characters by replacing them with an empty string or their Unicode with <code>None</code>.
Later, we have used <code>replace()</code> to remove a predefined number of occurrences of the given character, and even the good old <code>for</code> loop. The <code>translate()</code> method is useful if we have to remove a set of characters, as we can give it a translation table. And the <code>replace()</code> method is handy if we want to remove a number of occurrences of a given character.

Marcus Sanatan

Naazneen Jatu

The most common way to remove a character from a string in Python is with the replace() method. We'll explore replace(), translate() and a custom manual approach to removing a character from a string.

Python: How to Remove a Character from a String

In this guide, we'll take a look at how and why to perform Feature Scaling for Machine Learning projects, using Python's ScikitLearn library.

Feature Scaling Data with Scikit-Learn for Machine Learning in Python

<h2 id="introduction">Introduction</h2>
There are multiple ways to remove whitespace and other characters from a string in Python. The most commonly known methods are <code>strip()</code>, <code>lstrip()</code>, and <code>rstrip()</code>. Since Python version 3.9, two highly anticipated methods were introduced to remove the prefix or suffix of a string: <code>removeprefix()</code> and <code>removesuffix()</code>.
In this guide, we'll quickly go over how to use these methods, and why they are handy. We'll also show how to remove the prefix and suffix for Python versions lower than 3.9 with the help of the <code>startswith()</code> and <code>endswith()</code> methods.
<blockquote>
If you'd like to learn more about <code>strip()</code>, <code>lstrip()</code> and <code>rstrip()</code>, read our <a target="_blank" href="https://stackabuse.com/guide-to-pythons-strip-method">Guide to Python's strip() Method and its Variants</a>.
</blockquote>
<h2 id="whynotusethestripmethods">Why Not Use the strip() Methods?</h2>
You might wonder what's wrong with using <code>lstrip()</code> and <code>rstrip()</code> methods to trim the prefixes and suffixes? Nothing is wrong with them, however, there's a possibility of removing the entire text with these methods instead of just removing the first or last occurrence alone.
For instance, let's attempt removing the prefix in a string with a common pattern:
<pre><code class="hljs">line = &quot;xyyyxyxyxy&quot;
print(line.lstrip(&quot;xy&quot;))
</code></pre>
This code strips the string pairing &quot;xy&quot; in any order, starting from the left. Since our input string only contains &quot;xy&quot; pairs, the entire text gets stripped away:
<pre><code class="hljs">$ python strip_test.py
$
</code></pre>
The <code>strip()</code> methods won't cut it if you only need to remove the first or last n characters. This requirement was common in the Python community, and as an answer - the <code>removeprefix()</code> and <code>removesuffix()</code> methods were added.
Depending on the Python version (&lt; 3.9 or &gt; 3.9), there are two ways by which one can remove prefixes or suffixes from a string.
<h3 id="removeprefixsuffixinpythonversions39">Remove Prefix/Suffix in Python Versions &gt;= 3.9</h3>
For Python versions 3.9 and above, the <code>removeprefix()</code> and <code>removesuffix()</code> methods come as methods built-in to the namespace, used to remove the prefix and suffix from strings.
Let's consider a patterned string like before:
<pre><code class="hljs">line = &quot;xy&quot;*5+&quot; | &quot;+&quot;yz&quot;*5
prefix = &quot;xy&quot;
line_new = line.removeprefix(prefix)
print(&quot;Before: &quot;, line, line.count(prefix))
print(&quot;After: &quot;, line_new, line_new.count(prefix))
</code></pre>
This code removes the prefix &quot;xy&quot; of the first string and displays a number of occurrences of the prefix for both lines, at the end. Let's run the code:
<pre><code class="hljs">$ python remove_prefix.py
Before: xyxyxyxyxy | yzyzyzyzyz 5
After: xyxyxyxy | yzyzyzyzyz 4
</code></pre>
Similarly, the suffix can be removed using the <code>removesuffix()</code> method:
<pre><code class="hljs">line = &quot;xy&quot;*5+&quot; | &quot;+&quot;yz&quot;*5
suffix = &quot;yz&quot;
line_new = line.removesuffix(suffix)
print(&quot;Before: &quot;, line, line.count(suffix))
print(&quot;After: &quot;, line_new, line_new.count(suffix))
</code></pre>
Running this code results in:
<pre><code class="hljs">$ python remove_suffix.py
Before: xyxyxyxyxy | yzyzyzyzyz 5
After: xyxyxyxyxy | yzyzyzyz 4
</code></pre>
<h3 id="removeprefixsuffixinpythonversions39">Remove Prefix/Suffix in Python Versions &lt; 3.9</h3>
In Python versions lesser than 3.9, this problem can be solved indirectly by using a combination of the <code>startswith()</code> and <code>endswith()</code> methods, mixed with <a target="_blank" href="/python-slice-notation-on-string">slicing a string</a>. This validates if the prefix/suffix is present and the corresponding segments can be snipped from the string.
Here's how the prefix can be easily removed from the string:
<pre><code class="hljs">line = &quot;xy&quot;*5+&quot; | &quot;+&quot;yz&quot;*5
prefix = &quot;xy&quot;
 
if line.startswith(prefix):
 line_new = line[len(prefix):]
 
print(&quot;Before: &quot;, line, line.count(prefix))
print(&quot;After: &quot;, line_new, line_new.count(prefix))
</code></pre>
After verifying that the prefix exists, we slice the string to contain everything but the prefix and return the results. This gives the following output where the prefix &quot;xy&quot; is removed from the string:
<pre><code class="hljs">$ python remove_prefix_alt.py
Before: xyxyxyxyxy | yzyzyzyzyz 5
After: xyxyxyxy | yzyzyzyzyz 4
</code></pre>
To remove the suffix, we just adjust the order of parameters in the slicing notation to iterate from the end of the string:
<pre><code class="hljs">line = &quot;xy&quot;*5+&quot; | &quot;+&quot;yz&quot;*5
suffix = &quot;yz&quot;
 
if line.endswith(suffix):
 line_new = line[:-len(suffix)]
 
print(&quot;Before: &quot;, line, line.count(suffix))
print(&quot;After: &quot;, line_new, line_new.count(suffix))
</code></pre>
Again, we first validate the line using the <code>endswith()</code> method to check if the suffix is present. If this is true, the suffix is removed from the string:
<pre><code class="hljs">$ python remove_suffix_alt.py
Before: xyxyxyxyxy | yzyzyzyzyz 5
After: xyxyxyxyxy | yzyzyzyz 4
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Removing prefixes and suffixes can be very helpful when it comes to performing text processing. Python v3.9+ comes with two new functions to make this possible: <code>removeprefix()</code> and <code>removesuffix()</code>. When we are using Python versions less than 3.9, we can use the <code>startswith()</code> and <code>endswith()</code> methods with string slicing to remove a prefix and suffix respectively.

Sathiya Sarathi Gunasekaran

Learn how to remove the prefix or suffix of a string in Python with removeprefix(), removesuffix(), startswith() and endswith()