<h2 id="introduction">Introduction</h2>
In this guide, we'll take a look at how to find the maximum element of a few common data structures in Python, such as a list, dictionary, and tuple.
The <code>max()</code> method, built into the Python namespace works wonders here for built-in types.
<h2 id="howtogetthemaxelementofapythonlist">How to Get the Max Element of a Python List</h2>
A list is Pythons' built-in type that is used to sequentially store multiple references in a single object in memory.
When compared to the other programming languages, a Python list is essentially a simple array. Elements are indexed based on their position in the list and there can be multiple elements with the same value.
<blockquote>
The main difference is that lists in Python can contain elements of different types. They're heterogenous.
</blockquote>
<pre><code class="hljs"># List of different type elements 
example_list = [&quot;string&quot;, 5, &quot;five&quot;, 4, &quot;4&quot;]
</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: If elements are not comparable via the comparison operators (&lt;,&gt;,==,!=), the <code>max()</code> function won't work. Thus, we'll want to ensure that a list is homogeneous before attempting to find the maximum element.

 </div>
 </div>
 </div>
 As long as you can compare the elements properly, you can find the maximum element regardless of type. Most of the time, you'll be working with integers:
<pre><code class="hljs">integer_list = [24, 9, 20, 17, 201, 16, 7]
</code></pre>
The easiest way to get the max element of a list is to use the built-in <code>max()</code> method:
<pre><code class="hljs">max_element = max(integer_list)
print(&quot;Max element of a list: &quot;, max_element)
</code></pre>
This code will have the expected output:
<pre><code class="hljs">Max element: 201
</code></pre>
You can also compare strings lexicographically, and find the lexicographically greatest string in a list via the <code>max()</code> function:
<pre><code class="hljs">string_list = [&quot;string&quot;, &quot;five&quot;, &quot;4&quot;]
max_element = max(string_list)

print(&quot;Max element:&quot;, max_element)
</code></pre>
This results in:
<pre><code class="hljs">Max element: string
</code></pre>
Another way to find the max element of a list is to sort it using the <code>sort()</code> method, and then get the last element of the sorted list, because the <code>sort()</code> method sorts list in an ascending order:
<pre><code class="hljs">integer_list = [24, 9, 20, 17, 201, 16, 7]
integer_list.sort()
# myList = [7, 9, 16, 17, 20, 24, 201]
max_element = integer_list[-1]

print(&quot;Max element of a list: &quot;, max_element)
</code></pre>
This code will also have the same output as the previous:
<pre><code class="hljs">Max element of a list: 201
</code></pre>
If we'd like to also find the index of the max element, the easiest way is to use the built-in <code>index()</code> method:
<pre><code class="hljs">integer_list = [24, 9, 20, 17, 201, 16, 7]

max_element = max(integer_list)
max_element_index = integer_list.index(max_element)

print(&quot;Max element of a list: &quot;, max_element, &quot; at index: &quot;, max_element_index)
</code></pre>
Which will output:
<pre><code class="hljs">Max element of a list: 201 at index: 4
</code></pre>
<h2 id="howtogetthemaxelementofapythondictionary">How to Get the Max Element of a Python Dictionary</h2>
Dictionaries in Python are used to store key-value pairs. Pairs with the same key are not allowed and, since Python 3.7, pairs in a dictionary are considered to be ordered.
Dictionaries are defined with the list of <code>key-value</code> pairs between a pair of curly brackets:
<pre><code class="hljs">dictionary = {
 &quot;key24&quot;: 24, 
 &quot;key7&quot;: 9,
 &quot;key20&quot;: 201,
 &quot;key17&quot;: 17, 
 &quot;key201&quot;: 201, 
}
</code></pre>
The easiest way to retrieve the value of the max element of a dictionary is also to use the built-in <code>max()</code> method, with the list of values passed as the argument:
<pre><code class="hljs">max_element = max(dictionary.values())
print(&quot;Max element of a dict: &quot;, max_element)
</code></pre>
This boils down to the previous method, since the <code>values()</code> method returns the values stored in a list. This will give the correct output:
<pre><code class="hljs">Max element of a dict: 201
</code></pre>
If we want to find the key of the first element with the max value as well, the easiest way is to use the <code>max()</code> method supplying the dictionary and retrieving the element via <code>dictionary.get()</code>.
<pre><code class="hljs">max_val = max(dictionary.values())
max_val_key = max(dictionary, key=dictionary.get)

print(&quot;Max element of a dict:&quot;, max_val, &quot;with the key:&quot;, max_val_key)
</code></pre>
This will output the value of the max element and the first matching key:
<pre><code class="hljs">Max element of a dict: 201 with the key: key20
</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: You might be tempted to use <code>max(dictionary)</code> to find the key with the maximum value. However, this approach will return the maximum key itself. In our case, it would return the key with the maximum lexicographical value in the dictionary.

 </div>
 </div>
 </div>
 <h2 id="howtogetthemaxelementofatuple">How to Get the Max Element of a Tuple</h2>
A tuple is Pythons' built-in type sequentially store references to multiple objects in memory. They're in many ways similar to lists, and the most notable difference between the two of them is that a tuple is an immutable data structure, unlike a list.
They're commonly used to store only a few results, typically as function return types.
In Python, we define tuples using a pair of brackets:
<pre><code class="hljs"># Tuple of different element types 
exampleTuple = (&quot;string&quot;, 5, &quot;five&quot;, 4, &quot;4&quot;)
</code></pre>
In much the same way how comparison in lists works, you can only run the <code>max()</code> method on compatible data types:
<pre><code class="hljs">int_tuple = (24, 9, 20, 17, 201, 16, 7)
string_tuple = (&#x27;one&#x27;, &#x27;two&#x27;, &#x27;three&#x27;)
</code></pre>
Probably the easiest way to get the max element of a tuple is to use the built-in <code>max()</code> method:
<pre><code class="hljs">int_tuple = (24, 9, 20, 17, 201, 16, 7)
string_tuple = (&#x27;one&#x27;, &#x27;two&#x27;, &#x27;three&#x27;)

max_int = max(int_tuple)
print(&quot;Max element of a tuple: &quot;, max_int)

max_str = max(string_tuple)
print(&quot;Max element of a tuple: &quot;, max_str)
</code></pre>
Again, this results in the greatest integer, and lexicographically greatest string:
<pre><code class="hljs">Max element of a tuple: 201
Max element of a tuple: two
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Finding the max element of a data structure is a pretty common task. All standard data structures in Python have a similar way of finding the max element - relying on the <code>max()</code> method for all collections.
In this guide, we've covered how to find the max element of a few most popular data structures in Python, while taking into consideration the special features of each of them.

Vladimir Batoćanin

Dimitrije Stamenic

In this tutorial, learn how to find the maximum element of a Python list, dictionary or tuple using the `max()` method.

Python: Get Max Element of List, Dictionary, or Tuple

In this introductory guide, we'll lay the foundations of using Oh My Zsh to pimp and customize your UNIX terminal.

Pimp my Terminal - An Introduction to "Oh My Zsh"

David Landup

Lazar Ristic

In this guide, we'll take a look at how to send HTTP requests in Python with the urllib3 module, as well as how to enable secure connections and upload files.

Guide to Sending HTTP Requests in Python with urllib3

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().