<h2 id="introduction">Introduction</h2>
When working in a request-response lifecycle, you want to make sure that a response with the wanted body - or at least an informative response arrives so the client that requested the data stays in the loop. In case of null values, you'll probably want to return a different result.
JavaScript made sure this can be handled with its nullish operator also known as the Null Coalescing Operator, which was added to the language with ECMAScript 2020. With it, you can either return a value or assign it to some other value, depending on a boolean expression.
<blockquote>
This can be used to return default values if another value is missing, or to return different values based on any other boolean expression.
</blockquote>
The Null Coalescing Operator belongs to the group of short-circuiting logical operators, which we'll take a look at in a moment.
It's somewhat similar to the Conditional Operator, which is sometimes known as the Ternary Operator:
<pre><code class="hljs">// Null Coalescing Operator
// If the left-hand side is null, the right-hand side is returned
result = nullValue ?? defaultValue

// Conditional Operator
// If the condition is true, the left side is assigned, otherwise, the right side is assigned
condition ? value : value2
</code></pre>
<blockquote>
In this guide, we'll be taking a look at the nullish/Null Coalescing Operator, short-circuiting and truthy and falsy values - through practical examples.
</blockquote>
<h2 id="whatisshortcircuiting">What is short-circuiting?</h2>
JavaScript evaluates operators from left to right. With exclusive operators where we need both values to evaluate to true, it's sometimes enough to check just the first evaluation statement.
If the left side of the operator is <code>false</code>, regardless of the right side, the operator results in <code>false</code>, so there's no point in evaluating the other side, and it's skipped to preserve computational power.
<blockquote>
This process is called short-circuiting.
</blockquote>
Before ES2020, JavaScript only had two short-circuit logical operators:
<ul>
<li>Logical operator AND - <code>&amp;&amp;</code></li>
<li>Logical operator OR - <code>||</code></li>
</ul>
With the new update, JavaScript introduced another one:
<ul>
<li>Null Coalescing operator - <code>??</code></li>
</ul>
Short-circuiting itself makes code more efficient because less evaluations need to happen, though, via the Null Coalescing operator, we can also alter the code logic based on a short-circuiting operation.
For instance:
<pre><code class="hljs">let x = 10;
let y = 20;

let result;

if (x+y &gt; 20){
 result = &quot;x+y is greater than 20&quot;;
}

console.log(result);
</code></pre>
This code will result in:
<pre><code class="hljs">x+y is greater than 20
</code></pre>
Though, we could also ditch the <code>if</code> statement fully and use a short-circuit AND operator instead to shorten the statements:
<pre><code class="hljs">let x = 10;
let y = 20;

(x+y) &gt; 20 &amp;&amp; console.log(&quot;x+y is greater than 20&quot;);
</code></pre>
<code>(x+y) &gt; 20</code> evaluates to <code>true</code> so the next block is entered, and the message is printed.
<blockquote>
Where is short-circuiting here?
</blockquote>
If the <code>(x+y) &gt; 20</code> was falsy (we'll talk about this in a second), the JavaScript interpreter wouldn't even look at the second part of the expression, and the block would never run.
Similarly enough, we can use the logical OR operator in a similar way:
<pre><code class="hljs">let x = 10;
let y = 20;

(x-y) &gt; 0 || console.log(&quot;x+y is lesser than 0&quot;);
</code></pre>
Naturally, this results in:
<pre><code class="hljs">x+y is lesser than 0
</code></pre>
These examples are pretty simple, yet logical operators can solve a lot of practical problems and make your code a lot cleaner. However, if not used properly, you might cause yourself a headache.
<h2 id="truthyandfalsyvalues">Truthy and Falsy values</h2>
When working with logical operators, you'll come around the terms truthy value and falsy value.
A truthy value is any value that isn't:
<ul>
<li><code>null</code></li>
<li><code>undefined</code></li>
<li><code>0</code></li>
<li><code>''</code> - empty string</li>
<li><code>false</code></li>
<li><code>NaN</code> - Not a Number</li>
</ul>
All these values are considered falsy.
In JavaScript, all the falsy values are evaluated as <code>false</code> when used in loops or <code>if</code> statements and all the truthy values are evaluated as <code>true</code>.
Now that we've got the prerequisites covered, let's finally take a look at the Nullish Operator.
<h2 id="nullishcoalescingoperator">Nullish Coalescing Operator</h2>
The Nullish Operator checks whether the value is nullish, not falsy. A nullish value is <code>undefined</code> or <code>null</code>.
<blockquote>
This allows us to assign default non-null values to variables when we're unsure of the results.
</blockquote>
For instance, let's mock a user service that retrieves a user from a database and returns their name. There's a 10% chance that the user doesn't exist, which is regulated by a <code>Math.random()</code> call. In 10 calls to the database, we're likely to see at least one missing user - denoted by a <code>null</code> result:
<pre><code class="hljs">class DbConnection {
 find(id) {
 if (Math.random() &gt; 0.9) {
 return null;
 } else {
 return `John Doe ${id}`;
 }
 }
}

const db = new DbConnection();

for (let i = 0; i &lt; 10; i++) {
 let user = db.find(i);

 if (user != null){
 console.log(user);
 } else {
 console.log(&#x27;User not found&#x27;);
 }
}
</code></pre>
The code will output either the name or a message denoting the lack of the user's existence in the database, though this requires us to perform null-checks in the <code>if</code> statement.
This results in:
<pre><code class="hljs">John Doe 0
John Doe 1
User not found
John Doe 3
John Doe 4
John Doe 5
User not found
User not found
John Doe 8
John Doe 9
</code></pre>
By happenstance, this seems to be an odd run - 3 <code>null</code> results! This code works just fine, and handles <code>null</code> cases if the database returns a <code>null</code> value.
Alternatively, we could've used something much more concise:
<pre><code class="hljs">class DbConnection {
 find(id) {
 return Math.random() &gt; 0.9 ? null : `John Doe ${id}`
 }
}

const db = new DbConnection();

for (let i = 0; i &lt; 10; i++) {
 let user = db.find(i) ?? &quot;User not found&quot;
 console.log(user)
}
</code></pre>
Using a conditional operator, we've returned either <code>null</code> or <code>John Doe</code> with their respective ID. If <code>Math.random() &gt; 0.9</code>, <code>null</code> is returned, so there's a 10% probability it'll be returned on each call to the database.
Then, assuming possible <code>null</code> values - we've used the Nullish Operator to assign a new value to the <code>user</code> result if it turns out to be <code>null</code>. If <code>db.find()</code> returns <code>null</code>, the right-hand value kicks in and is returned instead.
This code is much cleaner and shorter than the <code>if-else</code> statements, and <code>if-else</code> statements have a higher tendency to cascade and get even more complex. Though, chaining multiple short-circuiting operators gets hard to read as well, so it's not really advisable to replace all <code>if-else</code> blocks:
<pre><code class="hljs">let s1 = (Math.random() &gt; 0.5 ? 1 : null) ?? (Math.random() &gt; 0.5 ? 4 : (Math.random() &gt; 0.5 ? null : 1))

console.log(s1)
</code></pre>
Do you know what this would print? Considering random possibilities, it'd likely take you a while to parse this manually and see which values you can anticipate. This code has a tendency to result in <code>1</code> with <code>null</code> and <code>4</code> in some cases, as the returned default value for the nullish operator in this case is another null. Typically, you won't use more than one, or two, operators in cases like these.
<h2 id="conclusion">Conclusion</h2>
To wrap this up, the sole purpose of the nullish operator is to allow you to always return some kind of default value, instead of returning something that doesn't exist - which, in JavaScript, is what <code>null</code> and <code>undefined</code> mean.

David Landup

Lazar Ristic

In this guide, we'll take a look at the Nullish Operator/Null Coalescing Operator added to JavaScript with ECMAScript 2020, and how we can utilize it to write cleaner code, with some caveats.

Null Coalescing Operator in JavaScript with ECMAScript 2020

<h2 id="introduction">Introduction</h2>
Python is a flexible language, and there's typically several ways to perform the same, menial task. Choosing an approach can depend on the time or space complexity, or simply on your personal preference.
Python's data structures are quite handy and intuitive, and their built-in functionalities are easy to work with. In this article, we'll be looking at how to reverse a list in Python. A Python List is a heterogeneous (can contain differing types) array-like structure that stores references to objects in memory.
When manipulating a list, we can either create a new, changed list, or change the original list in-place. We'll see the differences in these as we proceed through the article.
<h2 id="reversealistusingthereversemethod">Reverse a List Using the reverse() Method</h2>
Python has a powerful built-in library of methods when it comes to manipulating data in data structures. For the purposes of reversing a list, we can utilize the built-in <code>reverse()</code> method.

 <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>reverse()</code> method reverses the list in-place. Reversing a list in-place means that the original list is changed, instead of creating a new, reversed list.

 </div>
 </div>
 </div>
 Due to this, we can't assign the resulting object to a new variable, and if you want to keep the original list in memory, you'll have to copy it before reversing:
<pre><code class="hljs">my_list = [1, 2, 3, 4]
my_list.reverse()
print(my_list) # Output: [4, 3, 2, 1]

new_list = my_list.reverse()
print(new_list) # Output: None
</code></pre>
There's no return value - the list is reversed in-place. However, we can <code>copy()</code> it before reversing:
<pre><code class="hljs">list_1 = [1, 2, 3, 4]
list_2 = list_1.copy()

list_1.reverse()

print(&#x27;Reversed list: &#x27;, list_1)
print(&#x27;Saved original list: &#x27;, list_2)
</code></pre>
This results in
<pre><code class="hljs">Reversed list: [4, 3, 2, 1]
Saved original list: [1, 2, 3, 4]
</code></pre>
<h2 id="reversealistusingslicenotation">Reverse a List Using Slice Notation</h2>
The slice notation allows us to slice and reproduce parts of various collections or collection-based objects in Python, such as <a target="_blank" href="https://stackabuse.com/python-slice-notation-on-list">Lists</a>, <a target="_blank" href="https://stackabuse.com/python-slice-notation-on-string">Strings</a>, <a target="_blank" href="https://stackabuse.com/python-slice-notation-on-tuple">Tuples</a> and <a target="_blank" href="https://stackabuse.com/python-slice-notation-on-numpy-arrays">NumPy Arrays</a>.
When you slice a list, a portion is returned from that list, and every <code>step</code>th element is included:
<pre><code class="hljs">my_list = [1, 2, 3, 4, 5, 6]

# list[start:end:step]
segment_1 = my_list[1:5:1]
segment_2 = my_list[1:5:2]

print(segment_1)
print(segment_2)
</code></pre>
This results in:
<pre><code class="hljs">[2, 3, 4, 5]
[2, 4]
</code></pre>
By omitting the <code>start</code> and <code>end</code> arguments, you can include the entire collection. And by setting the <code>step</code> to a negative number, you iterate through the collection in reverse. Naturally, if you pair these together:
<pre><code class="hljs">original_list = [1, 2, 3, 4, 5, 6]

reversed_list = original_list[::-1]
print(&#x27;Original list: &#x27;, original_list)
print(&#x27;Reversed list: &#x27;, reversed_list)
</code></pre>
This results in:
<pre><code class="hljs">Original list: [1, 2, 3, 4, 5, 6]
Reversed list: [6, 5, 4, 3, 2, 1]
</code></pre>
The Slice Notation doesn't affect the original list at all, so the <code>original_list</code> stays the same even after the operation.
<h2 id="reversealistusingslicemethod">Reverse a List Using slice() Method</h2>
The <code>slice()</code> method accepts the very same parameters - <code>start</code>, <code>end</code> and <code>step</code>, and performs much the same operation as the Slice Notation. Though, instead of omitting the <code>start</code> and <code>end</code> arguments, you can pass in <code>None</code>.
Its return type is a <code>Slice</code> object, which can be then be used to slice a collection according to its contents. It's not called on the collection you're slicing - you're passing in the <code>Slice</code> object after creation, allowing you to create a single reusable and callable object for many different collections.
It's internally transpiled into Slice Notation, so the end result is the same:
<pre><code class="hljs">original_list = [1, 2, 3, 4, 5, 6]

slice_obj = slice(None, None, -1)

print(&#x27;slice_obj type:&#x27;, type(slice_obj))
print(&#x27;Reversed list:&#x27;, original_list[slice_obj])
</code></pre>
This results in:
<pre><code class="hljs">slice_obj type: &lt;class &#x27;slice&#x27;&gt;
Reversed list: [6, 5, 4, 3, 2, 1]
</code></pre>
<h2 id="reversealistusingaforloop">Reverse a List Using a For Loop</h2>
Depending on whether we want to keep the original list intact or not, we can <code>pop()</code> elements from the original list and add them to a new one, or we can just append them in reverse order.
<code>pop()</code> removes the last element from a collection and returns it. We can combine the <code>append()</code> method with this to directly append the removed element to a new list, effectively resulting in a reversed list:
<pre><code class="hljs">original_list = [1, 2, 3, 4] 
reversed_list = []

for i in range(len(original_list)):
 reversed_list.append(original_list.pop())

print(reversed_list) # Output: [4, 3, 2, 1]
</code></pre>
Alternatively, we can iterate through the list backwards, until the <code>-1</code>th index (non-inclusive) and add each element we see along that list. The <code>range()</code> method accepts 3 arguments - <code>start</code>, <code>end</code> and <code>step</code>, which can again be used in much the same way as before:
<pre><code class="hljs">original_list = [1, 2, 3, 4]
reversed_list = []

for i in range(len(original_list)-1, -1, -1):
 reversed_list.append(original_list[i])

print(reversed_list) # Output: [4, 3, 2, 1]
</code></pre>
<h2 id="reversingalistusingthereversedmethod">Reversing a List Using the reversed() Method</h2>
Since iterating with a negative step and then accessing each element in the original list is a bit verbose, the <code>reversed()</code> method was added, which makes it much easier to manually implement the reversal logic, in case you want to add your own twist on it.
The <code>reversed()</code> method returns an iterator, iterating over the collection in a reversed order - and we can easily add these elements into a new list:
<pre><code class="hljs">original_list = [1, 2, 3, 4]
new_list = []

for i in reversed(original_list):
 new_list.append(i)
 
print(new_list) # Output: [4, 3, 2, 1]
print(original_list) # Output: [1, 2, 3, 4] --&gt; Original hasn&#x27;t changed
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Depending on whether you need a new reversed list, an in-place reversed list, as well as whether you want the logic to be taken care of for you, or if you'd like to have the flexibility of adding additional operations or twists during the reversal - there are several ways to reverse a list in Python.
In this tutorial, we've gone over these scenarios, highlighting the difference between each.

In this tutorial, we take a look at how to reverse a list in Python, using the built-in methods such as reverse() and reversed(), as well as our own.

How to Reverse a List in Python

<h2 id="introduction">Introduction</h2>
In this short tutorial, we'll take a look at how to concatenate strings in Python, through a few different approaches.
It's worth noting that strings in Python are immutable - a string object in memory cannot be changed once created:
<pre><code class="hljs">newString = &quot;Some new string&quot;
</code></pre>
If you'd like to change this string in any way - under the hood, a new string with those changes is created. The same applies to concatenating strings - a new object must be created in memory.
<h2 id="stringconcatenationandstringappending">String Concatenation and String Appending</h2>
<blockquote>
Concatenation of strings refers to joining two or more strings together, as if links in a chain. You can concatenate in any order, such as concatenating <code>str1</code> between <code>str2</code> and <code>str3</code>.
</blockquote>
<blockquote>
Appending strings refers to appending one or more strings to the end of another string.
</blockquote>
In some cases, these terms are absolutely interchangeable. Appending strings is the same operation as concatenating strings at the end of another. Let's begin with the simplest way of concatenating/appending two (or more) strings.
<h2 id="concatenateorappendstringswiththeoperator">Concatenate or Append Strings with the + Operator</h2>
In Python, a string is a list of characters, which means that the <code>+</code> operator can be used to add their constituent elements together in a new list:
<pre><code class="hljs">title = &quot;Prof. &quot;
name = &quot;Richard Feynman&quot;

result = title + name
print(result)
</code></pre>
This results in:
<pre><code class="hljs">Prof. Richard Feynman
</code></pre>
This operator doesn't limit the amount of strings which can be added together, so you can easily join a large number of strings:
<pre><code class="hljs">string1 = &quot;Concatenating&quot;
string2 = &quot;strings&quot;
string3 = &quot;in Python&quot;
string4 = &quot;is easy!&quot;

print(string1 + string2 + string3 + string4)
</code></pre>
Though, if your aim is to construct a sentence from a list of strings such as this, concatenating them manually, and without special characters is both inefficient and produces an unintelligible output:
<pre><code class="hljs">Concatenatingstringsin Pythonis easy!
</code></pre>
It'd be much more sensible to iterate through a list of strings, and add them together with a whitespace between each concatenated string:
<pre><code class="hljs">strings = [&quot;Concatenating&quot;, &quot;strings&quot;, &quot;in Python&quot;, &quot;is easy!&quot;]

result = &quot;&quot;
for string in strings:
 result += string + &quot; &quot;

print(result)
</code></pre>
This results in:
<pre><code class="hljs">Concatenating strings in Python is easy! 
</code></pre>
A shorthand operator you can use to concatenate two strings is <code>+=</code>, just like in the previous example. This saves you from the trouble of having to create a new variable to store the results, as you can reuse one of the existing reference variables to assign to the new object in memory:
<pre><code class="hljs">string1 = &quot;one&quot;
string2 = &quot;two&quot;

string1 += string2
print(string1) # Output: onetwo
</code></pre>
<h3 id="limitationoftheoperator">Limitation of the + Operator</h3>
The main limitation of the <code>+</code> operator is the fact that you can't mix-and-match types. You can't add an integer to a list of characters, for instance:
<pre><code class="hljs">print(&quot;some string&quot; + 2)
</code></pre>
Many languages, such as JavaScript and Java pick up on this, and would automatically convert the integer into a string (match the types) and perform the concatenation, though, Python would throw a <code>TypeError</code>:
<pre><code class="hljs">TypeError: can only concatenate str (not &quot;int&quot;) to str
</code></pre>
However, there is an easy workaround - you can use Python's built-in <code>str()</code> function which converts compatible data types into a string. Let's add some integers to our <code>strings</code> list and box all of the items with a <code>str()</code> in case there are non-string elements:
<pre><code class="hljs">strings = [&quot;Concatenating&quot;, &quot;strings&quot;, &quot;in Python&quot;, &quot;is easy!&quot;, 5, 2]

result = &quot;&quot;
for string in strings:
 result += str(string) + &quot; &quot;

print(result)
</code></pre>
This results in:
<pre><code class="hljs">Concatenating strings in Python is easy! 5 2 
</code></pre>
<h2 id="concatenateorappendstringswiththeoperator">Concatenate or Append Strings with the * Operator</h2>
If you want to create a new string by replicating a string <code>n</code> amount of times and appending it, you can achieve this with the <code>*</code> operator:
<pre><code class="hljs">string = &quot;w&quot;

print(string * 3) # Output: www
</code></pre>
This can be even more useful when combined with the <code>+</code> operator:
<pre><code class="hljs">print(&quot;w&quot;*3 + &quot;.&quot; + &quot;stackabuse.com&quot;)
</code></pre>
Which results in:
<pre><code class="hljs">www.stackabuse.com
</code></pre>
<h2 id="concatenateorappendstringswiththeoperator">Concatenate or Append Strings with the % Operator</h2>
Again, concatenation doesn't necessarily mean we're adding a string to the end. Using the <code>%</code> operator, we can perform string interpolation. By adding <code>%</code> in a string as a marker, we can replace the markers with concrete strings later on:
<pre><code class="hljs">string = &quot;This %s is a %s string&quot; % (&quot;here&quot;, &quot;random&quot;)

print(string)
</code></pre>
This should output:
<pre><code class="hljs">This here is a random string
</code></pre>
Similarly enough, you can use other markers for other data types:
<ul>
<li><code>%d</code> - for integer representation:</li>
</ul>
<pre><code class="hljs">string = &quot;This is a string%d&quot; % (1)
print(string) # Output: This is a string
</code></pre>
<ul>
<li><code>%c</code> - for character representation:</li>
</ul>
<pre><code class="hljs">string = &quot;This string starts with a %c&quot; % (&#x27;T&#x27;)
print(string) # Output: This string starts with a T
</code></pre>
<ul>
<li><code>%f</code> - for floating number:</li>
</ul>
<pre><code class="hljs">string = &quot;There is a %f percent chance that you&#x27;ll learn string concatenation in Python after reading this article&quot; % (99.99)
print(string) # Output filled 99,990000 in %f place
</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 you wish to explicitly mark how many digits should the number be rounded to (say 2), you can achieve it with: <code>%.2f</code>.

 </div>
 </div>
 </div>
 <blockquote>
If you'd like to read more about formatting strings in Python and the different ways to do it, read our <a target="_blank" href="https://stackabuse.com/string-formatting-with-python-3s-f-strings">Guide to Formatting Strings in Python 3's f-Strings</a>.
</blockquote>
<h2 id="concatenatingstringswiththejoinmethod">Concatenating Strings With the join() Method</h2>
The <code>join()</code> method takes an iterable as an argument and returns a string created by joining the elements of that iterable. It's worth noting that these have to be strings - each element is not inherently converted using <code>str()</code>, unlike our own method from before.
Additionally, a <code>separator</code> is used to define the separator between the joined strings, and it's the base string we call <code>join()</code> on:
<pre><code class="hljs">my_list = [&quot;1&quot;, &quot;2&quot;, &quot;3&quot;, &quot;4&quot;] # List - iterable
string_from_list = &quot;-&quot;.join(my_list) # The separator is &quot;-&quot;

print(string_from_list)
</code></pre>
This should output:
<pre><code class="hljs">1-2-3-4
</code></pre>
In a lot of cases, the separator is just a whitespace, so you'll commonly be seeing:
<pre><code class="hljs">&quot; &quot;.join(iterable)
</code></pre>
<h2 id="implementingacustomjoinmethod">Implementing a Custom join() Method</h2>
Since the built-in <code>join()</code> method might behave a bit differently than you might've expected, let's implement our own <code>join()</code> method with an adjustable <code>separator</code>.
We'll want it to be able to handle 2D lists as well, so if a list contains another list within itself - <a target="_blank" href="https://stackabuse.com/python-how-to-flatten-list-of-lists">it's flattened to a 1-dimensional list</a>, before joined:
<pre><code class="hljs">import itertools

def join(iterable, separator):
 # Empty string to hold result
 result = &quot;&quot;
 # Flatten 2D potentially 2D list into 1D
 iterable = list(itertools.chain(*iterable))
 # Concatenate strings with separator
 for string in iterable:
 result += str(string) + separator
 return result
 

string = join([&#x27;a&#x27;, &#x27;b&#x27;, &#x27;c&#x27;], &#x27; &#x27;)
string2 = join([&#x27;a&#x27;, [&#x27;b&#x27;, &#x27;c&#x27;], &#x27;d&#x27;], &#x27; &#x27;)

print(string)
print(string2)
</code></pre>
This results in:
<pre><code class="hljs">a b c 
a b c d 
</code></pre>
<h2 id="concatenatingstringsusingspace">Concatenating Strings Using Space</h2>
A simple way to concatenate strings, usually only when you're printing them is to leverage the space bar. This approach is commonly used only for printing, since assigning it to an object in memory is easy, but awkward:
<pre><code class="hljs">print(&quot;Concat&quot; &quot; strings&quot; &quot; using Space&quot;)
</code></pre>
If you'd like to avoid using whitespaces in the strings, you can add commas (<code>,</code>) between each element:
<pre><code class="hljs">print(&quot;Concat&quot;, &quot;strings&quot;, &quot;using Space&quot;)
</code></pre>
Both of these result in:
<pre><code class="hljs">Concat strings using Space
</code></pre>
If you'd like to assign them to a variable, you're free to do so, and they'll automatically be concatenated into a single string:
<pre><code class="hljs">string = &quot;this &quot; &quot;is &quot; &quot;a &quot; &quot;big &quot; &quot;string&quot;
print(type(string))
print(string)
</code></pre>
This results in:
<pre><code class="hljs">&lt;class &#x27;str&#x27;&gt;
this is a big string
</code></pre>
You can even do multi-line strings. To achieve this, we add a <code>\</code> to the end of each line to let Python know there's more than one line:
<pre><code class="hljs">multi_line_string = &quot;this &quot; &quot;string &quot; \
 	 &quot;is coded in &quot; &quot;three lines &quot; \
 &quot;but printed in one&quot;
 	 
print(multi_line_string)
</code></pre>
This results in:
<pre><code class="hljs">this string is coded in three lines but printed in one
</code></pre>
Though, this approach is fiddly and awkward, and others are preferred.

 <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 same effect cannot be achieved with variables, only string literals:
<pre><code class="hljs">string1 = &quot;one string&quot;
string2 = &quot;two string&quot;

final_string = string1 string2
</code></pre>
This results in:
<pre><code class="hljs">File &quot;&lt;string&gt;&quot;, line 4
 final_string = string1 string2
 ^
SyntaxError: invalid syntax
</code></pre>

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
Joining/Appending/Concatenating Strings in Python is fairly simple and like everything related to Python, there are many ways to do it. It just comes down to your needs and preferences.
In this short tutorial, we've taken a look at some of the ways to concatenate strings

In this tutorial, we'll take a look at how to join, concatenate or append strings in Python using several operators, the join() method and a custom join method to cover edge cases.

How to Concatenate Strings in Python

<h2 id="introduction">Introduction</h2>
We commonly need and want to know more about the files and directories that we are working with.
Most people know one of the ways, which is simply to Right Click &gt; Properties on the wanted folder or file to view their properties. Though, for the more terminal-savvy, here's how you can get the same (and more) information via the Terminal in Linux.
<h2 id="thelscommand">The ls Command</h2>
One of the most commonly used commands is the <code>ls</code> command, which lists all of the files and directories you're located in, alongside their names.
Once you position yourself on a file path that you want, you can list all present files/folders via:
<pre><code class="hljs">$ ls
Folder_one large.jpg os.zip
</code></pre>
Alternatively, you can supply a directory name to list files from, without having to move to that directory:
<pre><code class="hljs">$ ls Folder_one
cpfile.c Direct fileinfo.c
</code></pre>
Though, these are just the names, and we can't infer much from them. The <code>ls</code> command has several non-mandatory options which, when turned on, give us much more about these files when listing them.
You can use them alone, or by combining a few of them, depending on what exactly you are looking for.
<h3 id="gettingdetailswiththeloption">Getting Details With the -l Option</h3>
The <code>-l</code> option will modify the <code>ls</code> command to give you much more detailed info, such as whether an entry is a file or directory, the size (usually in bytes), modified date and time, permissions, and more:
<pre><code class="hljs">$ ls -l
</code></pre>
The result of this command should look something like:
<pre><code class="hljs">total 15168
drwxrwxr-x 3 marija marija 4096 Jul 18 19:26 Folder_one
-rwxrwxrwx 1 marija marija 164461 Sep 12 2017 large.jpg
-rw-rw-r-- 1 marija marija 15354276 Oct 25 2018 os.zip
</code></pre>
Here we can see that we have one directory (d in <code>drwxrwxr-x</code>), named <code>Folder_one</code>, and 2 files. We can also see their owner and group, <code>marija</code>, and their size in bytes, as well as their modification date/time.
The number following the permissions is the number of links to the file or directory.
<img src="https://stackabuse.s3.amazonaws.com/media/guide-to-chmod-1.jpg" alt="">
<blockquote>
If you'd like to read more about permissions and how to change them via the terminal, read our <a target="_blank" href="https://stackabuse.com/guide-to-understanding-chmod">Guide to Understanding chmod</a>.
</blockquote>
Note: You can get far with the <code>-l</code> flag, and by combining other flags with it, the <code>ls</code> command will get you far for this task.
<h3 id="humanreadablelhoption">Human-Readable -lh Option</h3>
If you want a more human-readable form, you can add the joined extension <code>-lh</code> or simply <code>-h</code> after the <code>-l</code> option:
<pre><code class="hljs">$ ls -lh
total 15M
drwxrwxr-x 3 marija marija 4,0K Jul 18 19:26 Folder_one
-rwxrwxrwx 1 marija marija 161K Sep 12 2017 large.jpg
-rw-rw-r-- 1 marija marija 15M Oct 25 2018 os.zip
</code></pre>
Now, we can see the size of files shown in KB, MB, GB, etc. instead of showing only in bytes, which can be very helpful. Though, that's mostly the benefit you get from this flag.
<h3 id="showinghiddenfileswiththelaoption">Showing Hidden Files With the -la Option</h3>
Hidden files start with a dot symbol (<code>.</code>) and aren't meant to be picked up by most GUI software, or the <code>ls</code> command. These are typically files that you don't want to see, so this makes perfect sense.
On the other hand, if you'd specifically like to also include hidden files while listing the files of a directory - you can add the <code>-a</code> flag. Combining the <code>-l</code> flag and <code>-a</code> flag, you can print the hidden files alongside regular files - with their information:
<pre><code class="hljs">$ ls -la
total 15212
drwxr-xr-x 3 marija marija 4096 Jul 18 20:03 .
drwxr-xr-x 29 marija marija 4096 Jul 18 20:13 ..
drwxrwxr-x 3 marija marija 4096 Jul 18 19:26 Folder_one
-rwxrwxrwx 1 marija marija 164461 Sep 12 2017 large.jpg
-rw-rw-r-- 1 marija marija 15354276 Oct 25 2018 os.zip
-rw-r--r-- 1 marija marija 12288 Jan 29 2018 .tekst.txt.swn
-rw-r--r-- 1 marija marija 12288 Jan 29 2018 .tekst.txt.swo
-rw-r--r-- 1 marija marija 12288 Jan 29 2018 .tekst.txt.swp
</code></pre>
<h3 id="displayingblocksizewiththesoption">Displaying Block Size With the -s Option</h3>
The <code>-s</code> option displays the file's size in blocks, rather than regular bytes:
<pre><code class="hljs">$ ls -s
total 15168
 4 Folder_one 164 large.jpg 15000 os.zip
</code></pre>
Note: Blocks are the smallest writable unit for your system and hardware.
<h3 id="sortingfilesbysizewiththelsoption">Sorting Files by Size with the -lS Option</h3>
The <code>-S</code> flag, not to be confused with the lowercase <code>-s</code> from earlier, is a sorting flag. It sorts the files by size, in descending order:
<pre><code class="hljs">$ ls -lS
total 15168
-rw-rw-r-- 1 marija marija 15354276 Oct 25 2018 os.zip
-rwxrwxrwx 1 marija marija 164461 Sep 12 2017 large.jpg
drwxrwxr-x 3 marija marija 4096 Jul 18 19:26 Folder_one
</code></pre>
<h3 id="recursivelistingwiththeroption">Recursive Listing with the -R Option</h3>
If you want to list subdirectories, you'll have to make a recursive <code>ls</code> call. The <code>-R</code> option makes this a really simple endeavor.
It will give you a tree representation of all of the files or directories that happen to be in a particular place:
<pre><code class="hljs">$ ls -R directory

Screenshot 2021-07-26 at 18.53.05.png file.txt
Screenshot 2021-07-26 at 21.15.20.png mpl

directory/dvp-articles:
axis-off

directory/dvp-articles/axis-off:
app.py get-pip.py

directory/mpl:
mpl-chapter-2-1.png
</code></pre>
Here, we've recursively called <code>ls</code> on the <code>directory</code>. Within it, there's another directory - <code>dvp-articles</code>, and within it, yet another - <code>axis-off</code>. Within <code>axis-off</code>, there's an <code>app.py</code> and <code>get-pip.py</code>.
Of course, you can chain the <code>-l</code> flag here as well, but the output might get a bit messy:
<pre><code class="hljs">$ ls -lR directory
</code></pre>
<pre><code class="hljs">ls -lR directory

-rw-r--r--@ 1 david staff 369705 Jul 26 23:57 Screenshot 2021-07-26 at 23.57.34.png
-rw-r--r--@ 1 david staff 103861 Jul 27 00:05 Screenshot 2021-07-27 at 00.05.16.png
drwxr-xr-x 3 david staff 96 Jun 17 18:00 dvp-articles
-rw-r--r-- 1 david staff 0 Jun 25 17:11 file.txt
drwxr-xr-x 3 david staff 96 Jul 16 20:19 mpl

directory/dvp-articles:
total 0
drwxr-xr-x@ 4 david staff 128 Jun 17 18:03 axis-off

directory/dvp-articles/axis-off:
total 3800
-rw-r--r-- 1 david staff 463 Jun 17 18:08 app.py
-rw-r--r-- 1 david staff 1937800 Jun 17 18:03 get-pip.py

directory/mpl:
total 376
-rw-r--r--@ 1 david staff 192506 Jul 16 20:18 mpl-chapter-2-1.png
</code></pre>
<h3 id="optioni">Option -i</h3>
To use <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Inode">inode</a>, we can add the <code>-i</code> flag:
<pre><code class="hljs">$ ls -i

688193 Folder_one 
680393 large.jpg 
680392 os.zip
</code></pre>
Of course, you can chain it with other flags such as:
<pre><code class="hljs">$ ls -li
 49323 drwx------@ 3 david staff 96 Jun 16 20:39 Applications
 34615 drwx------+ 15 david staff 480 Jul 27 00:05 Desktop
 ...
</code></pre>
<h2 id="thestatcommand">The stat Command</h2>
The <code>stat</code> command is much more like the good old Right Click &gt; Properties approach, because it formats all of the data and properties in a very readable format. It requires a filepath and isn't as customizable as <code>ls</code>:
<pre><code class="hljs">$ stat Folder_one
</code></pre>
This results in:
<pre><code class="hljs">File: &#x27;Folder_one&#x27; 
 Size: 4096 	Blocks: 8 IO Block: 4096 directory
Device: 805h/2053d	Inode: 688193 Links: 3
Access: (0775/drwxrwxr-x) Uid: ( 1000/ marija) Gid: ( 1000/ marija)
Access: 2021-07-18 20:04:03.205402891 +0200
Modify: 2021-07-18 19:26:00.681976407 +0200
Change: 2021-07-18 20:03:51.617219116 +0200
 Birth: -
</code></pre>
For some, this is a much better solution than the <code>ls</code> command.
With <code>stat</code>, you can also format the printed info via <code>--printf</code>. You can filter out data such as the user name of the owner, group name of owner, or time of last status change, in even more human-readable form:
<pre><code class="hljs">$ stat --printf=&#x27;%U\n%G\n%z\n&#x27; Folder_one/
</code></pre>
Which will in this case results in:
<pre><code class="hljs">marija
marija
2021-07-18 20:03:51.617219116 +0200
</code></pre>
Notice that we are putting ''\n'' after each wanted property, so that each is printed in a new line.
<h2 id="conclusion">Conclusion</h2>
Using the terminal, it's easy to find file properties, using <code>ls</code> with any of its accepted flags or via <code>stat</code>.
In this short guide, we've taken a look at how to display file properties using Linux.

Guest Contributor

In this short guide, we'll take a look at how to display file and directory properties in Linux, via the terminal, using the *ls* and *stat* commands.

Linux: Display File Properties via Terminal

<h2 id="introduction">Introduction</h2>
Software Design Patterns help accelerate the development process by providing a reusable blueprint for your code to solve a particular problem. We follow Design Patterns to write generalized, reusable, and readable code that could be easily understood by others familiar with the patterns we've applied.
<blockquote>
They encapsulate cumulative experience of software engineers solving the same problems, and represent solutions to common design-related issues.
</blockquote>
There are different classifications of design patterns depending on which class of problems they solve - among which the Observer Design Pattern belongs to the Behavioral Pattern class.
This class of patterns determines how objects communicate with each other. In this guide, you will learn everything you need to know about the Observer Design Pattern and understand how we can use it to solve certain problems efficiently.
<h2 id="observerdesignpattern">Observer Design Pattern</h2>
The Observer Design Pattern deals with One-to-Many relationships and utilizes events to let subscribed entities know about changes in an observable.
The source of these events is called the subject or observable which sends events as streams. The observers or sinks can subscribe to the observable to obtain the events. The observable keeps track of the list of observers and notifies them of the changes when the state of the observable changes.
<img src="https://stackabuse.s3.amazonaws.com/media/observer-design-pattern-in-python-01.jpg" alt="Architecture Diagram of Observer Design Pattern - shows a news feed as an observable and multiple readers as observers subscribed to the news feed">
This functionality has many implications and implementations, and similar functionality is all around you. It's an extremely simple, yet very effective and wide-spread pattern.
A similar implementation of this design pattern is seen in generating feeds on your social platforms - the Pub/Sub (Publisher/Subscriber) Model/Pattern. When a content publisher publishes their posts, the subscribers get notified of the content. A similar analogy may be people looking out for a flare signal or a firework for a certain event, and reacting (or not) depending on their specific roles.
<blockquote>
Does that mean that the Observer Design Pattern and Publish/Subscribe Pattern are the same?
</blockquote>
Previously, both patterns were synonymous. Nowadays, each pattern has distinct traits that make them two separate patterns.
The following are the major differences between the Observer Pattern and the Pub/Sub Pattern:
<ul>
<li>Observers and Subjects are tightly coupled. The subjects must keep track of their observers. Whereas in the Pub/Sub pattern, they are loosely coupled with a message queue in between observers and subjects.</li>
<li>The events are passed in a synchronous manner from the Subjects to the Observers. But in Pub/Sub patterns, the events are passed asynchronously.</li>
<li>In the Observer pattern, both the Subjects and Observers reside on the same application locality whereas they can reside on different localities in the Pub/Sub pattern.</li>
</ul>
One of the best ways to get a feel for this pattern is to implement it, let's implement it in Python!
<h2 id="implementation">Implementation</h2>
A basic implementation requires two classes - an <code>Observable</code> and an <code>Observer</code>. The <code>Observer</code> class is initialized with an object as an argument. The object is none other than an <code>Observable</code> to keep track of, to which it is subscribed upon creation.
The class also has a <code>notify()</code> function, which triggers a reaction and acknowledges the receipt of a notification/event from the observable:
<pre><code class="hljs">class Observer:

 def __init__(self, observable):
 observable.subscribe(self)

 def notify(
 self,
 observable,
 *args,
 **kwargs
 ):
 print (&#x27;Got&#x27;, args, kwargs, &#x27;From&#x27;, observable)
</code></pre>
The <code>Observable</code> class is initialized with an empty list to hold the <code>Observer</code> instances. It also has functions such as <code>subscribe()</code> to add an observer, <code>notify_observers()</code> to call the <code>notify()</code> function on each observer, and <code>unsubscribe()</code> to remove the observer from the list:
<pre><code class="hljs">class Observable:

 def __init__(self):
 self._observers = []

 def subscribe(self, observer):
 self._observers.append(observer)

 def notify_observers(self, *args, **kwargs):
 for obs in self._observers:
 obs.notify(self, *args, **kwargs)

 def unsubscribe(self, observer):
 self._observers.remove(observer)
</code></pre>
Plugging in all of the above-mentioned components, let's write some code that sets up an observer and observable and sends messages, which triggers a reaction:
<pre><code class="hljs"># observer_pattern.py

&quot;&quot;&quot;
Demonstrating the Observer pattern implementation
&quot;&quot;&quot;
# Initializing the subject
subject = Observable()

# Initializing two observers with the subject object
observer1 = Observer(subject)
observer2 = Observer(subject)

# The following message will be notified to 2 observers
subject.notify_observers(&#x27;This is the 1st broadcast&#x27;,
 kw=&#x27;From the Observer&#x27;)
subject.unsubscribe(observer2)

# The following message will be notified to just 1 observer since
# the observer has been unsubscribed
subject.notify_observers(&#x27;This is the 2nd broadcast&#x27;,
 kw=&#x27;From the Observer&#x27;)
</code></pre>
Notice that we also unsubscribe an observer before publishing the second message. This will lead to the message being printed only once instead of twice on the second attempt, as it is received by only one subscriber.
Running this code will result in:
<pre><code class="hljs">$ python observer_pattern.py
Got (&#x27;This is the 1st broadcast&#x27;,) {&#x27;kw&#x27;: &#x27;From the Observer&#x27;} From &lt;__main__.Observable object at 0x7f6c50d2fb50&gt;
Got (&#x27;This is the 1st broadcast&#x27;,) {&#x27;kw&#x27;: &#x27;From the Observer&#x27;} From &lt;__main__.Observable object at 0x7f6c50d2fb50&gt;
Got (&#x27;This is the 2nd broadcast&#x27;,) {&#x27;kw&#x27;: &#x27;From the Observer&#x27;} From &lt;__main__.Observable object at 0x7f6c50d2fb50&gt;
</code></pre>
As you can see, the observable can directly interact with the observers and vice versa. The observable will be in interaction with the observer as long as the observer is subscribed to the observable's subscription list.
<h2 id="prosandcons">Pros and Cons</h2>
With the implementation in place, the pros and cons of this design pattern can be compared as follows:
<h3 id="pros">Pros</h3>
<ul>
<li>
The one-to-many relationship is defined between the objects. This ensures that when an object is altered, it will lead to a cascade of changes to be applied to the dependent objects.
</li>
<li>
Loosely coupled objects mean that the components can be interchanged.
</li>
</ul>
<h3 id="cons">Cons</h3>
<ul>
<li>
The communication between the observable and observer is synchronous and with an increased load of subscribing and unsubscribing events, the observable object could be bombarded with requests. This could be mitigated by setting up <a target="_blank" href="https://stackabuse.com/python-make-time-delay-sleep-for-code-execution">a sleep time for each request</a>.
</li>
<li>
The sleep solution could also cause a possible loss of speed, performance, and events. This was the main reason for the Pub/Sub pattern to have a message queue in between the publisher and subscriber.
</li>
<li>
Memory leaks are common in this pattern since there is a strong reference between the observer and observable. The observables need to be mandatorily deregistered from the observable object.
</li>
</ul>
To mitigate most of the cons, a message queue was introduced in between the observer and the observable to overcome all these problems, which led to devising the Pub/Sub pattern - a variation of the Observer Pattern.
<h2 id="conclusion">Conclusion</h2>
This guide covers the Observer Pattern, how it can be implemented, and compares its pros and cons.
It's interesting to note that the Observer Pattern is one of the Behavioral Patterns that has led to many of the features we use today, such as RSS feeds, social media feeds, etc.
By being introduced to the nuances of the Design Patterns, it is easier to build the functionality from the ground up. And of course, knowing different Design Patterns allows you to build the best solution for different types of problems.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

The Observer Design Pattern is an event based system, where one observable sends messages to the observers that are subscribed. Let's implement this pattern in Python!

Observer Design Pattern in Python

<h2 id="introduction">Introduction</h2>
A <code>DataFrame</code> is a data structure that represents a special kind of two-dimensional array, built on top of multiple <code>Series</code> objects. These are the central data structures of Pandas - an extremely popular and powerful data analysis framework for Python.

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: If you're not already familiar with DataFrames and how they work, read our <a target="_blank" href="https://stackabuse.com/python-with-pandas-dataframe-tutorial-with-examples">Guide to DataFrames</a>.

 </div>
 </div>
 </div>
 DataFrames have the ability to give a name to rows and/or columns, and in a sense, represent tables.
Let's import Pandas and create a <code>DataFrame</code> from a dictionary:
<pre><code class="hljs">import pandas as pd

df_data = {
 &quot;column1&quot;: [24, 9, 20, 24],
 &quot;column2&quot;: [17, 16, 201, 16]
}

df = pd.DataFrame(df_data) 
print(df)
</code></pre>
Pandas has a great integration with Python and we can easily create DataFrames from dictionaries. The <code>df</code> we've constructed now contains the columns and their respective values:
<pre><code class="hljs"> column1 column2
0 24 17
1 9 16
2 20 201
3 24 16
</code></pre>
Each column has a list of elements, and we can search for the maximum element of each column, each row or the entire <code>DataFrame</code>.
<h3 id="findmaximumelementinpandasdataframescolumn">Find Maximum Element in Pandas DataFrame's Column</h3>
To find the maximum element of each column, we call the <code>max()</code> method of the <code>DataFrame</code> class, which returns a <code>Series</code> of column names and their largest values:
<pre><code class="hljs">max_elements = df.max()
print(max_elements)
</code></pre>
This will give us the max value for each column of our <code>df</code>, as expected:
<pre><code class="hljs">column1 24
column2 201
dtype: int64
</code></pre>
However, to find the <code>max()</code> element of a single column, you first isolate it and call the <code>max()</code> method on that specific <code>Series</code>:
<pre><code class="hljs">max_element = df[&#x27;column1&#x27;].max()
print(max_element)
</code></pre>
<pre><code class="hljs">24
</code></pre>
<h3 id="findmaximumelementinpandasdataframesrow">Find Maximum Element in Pandas DataFrame's Row</h3>
Finding the max element of each DataFrame row relies on the <code>max()</code> method as well, but we set the <code>axis</code> argument to <code>1</code>.
<blockquote>
The default value for the <code>axis</code> argument is 0. If the <code>axis</code> equals to 0, the <code>max()</code> method will find the max element of each column. On the other hand, if the <code>axis</code> equals to 1, the <code>max()</code> will find the max element of each row.
</blockquote>
<pre><code class="hljs">max_elements = df.max(axis=1)
print(max_elements)
</code></pre>
This will give us the max value for each row of our <code>df</code>, as expected:
<pre><code class="hljs">0 24
1 16
2 201
3 24
dtype: int64
</code></pre>
Alternatively, if you'd like to search through a specific row, you can access it via <code>iloc[]</code>:
<pre><code class="hljs">print(df)

for row in df.index:
 print(f&#x27;Max element of row {row} is:&#x27;, max(df.iloc[row]))
</code></pre>
We've printed the <code>df</code> for reference to make it easier to verify the results, and obtained the <code>max()</code> element of each row, obtained through <code>iloc[]</code>:
<pre><code class="hljs">column1 column2
0 24 17
1 9 16
2 20 201
3 24 16

Max element of row 0 is: 24
Max element of row 1 is: 16
Max element of row 2 is: 201
Max element of row 3 is: 24
</code></pre>
<h3 id="findmaximumelementinentirepandasdataframe">Find Maximum Element in Entire Pandas DataFrame</h3>
Finally, we can take a look at how to find the max element in an entire DataFrame.
Based on what we've previously seen, this should be pretty simple. We'll just use the built-in <code>max()</code> method and pass it one of two previously created lists of max elements - either for all rows or all columns. These are two facets of the same data, so the same result is guaranteed.
This should give us a single highest value in the entire <code>df</code>:
<pre><code class="hljs">max_by_columns = df.max()
max_by_rows = df.max(axis=1)

df_max = max(max_by_columns)
print(&quot;Max element based on the list of columns: &quot;, df_max)

df_max2 = max(max_by_rows)
print(&quot;Max element based on the list of rows: &quot;, df_max2)
</code></pre>
This will output:
<pre><code class="hljs">Max element based on the list of columns: 201
Max element based on the list of rows: 201
</code></pre>
This is both expected and correct! The max element of a list of max elements of each row should be the same as the max element of a list of max elements of each column and both of them should be the same as the max element of the entire DataFrame.
<h2 id="conclusion">Conclusion</h2>
In this short tutorial, we've taken a look at how to find the maximum element of a Pandas DataFrame, for columns, rows and the entire DataFrame instance.

Vladimir Batoćanin

Dimitrije Stamenic

In this tutorial, learn how to find the maximum element in a Pandas DataFrame for columns, rows and the entire DataFrame, using Python.

How to Get the Max Element of a Pandas DataFrame - Rows, Columns, Entire DataFrame

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

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"

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.