{"id":25015,"date":"2020-01-16T12:15:53","date_gmt":"2020-01-16T10:15:53","guid":{"rendered":"https:\/\/www.webcodegeeks.com\/?p=25015"},"modified":"2020-06-23T14:57:25","modified_gmt":"2020-06-23T11:57:25","slug":"8-coolest-python-programming-language-features","status":"publish","type":"post","link":"https:\/\/www.webcodegeeks.com\/python\/8-coolest-python-programming-language-features\/","title":{"rendered":"8 Coolest Python Programming Language Features"},"content":{"rendered":"\n

After writing nearly 20 articles just about Python, I\u2019ve decided to take some time to reflect on what I\u2019ve learned. For instance, I recently wrote a compilation article which includes 70+ Python code snippets<\/a>. Now, I\u2019ve put together a list of some of the coolest Python programming language features.<\/p>\n\n\n\n

Coolest Python Features List<\/h2>\n\n\n\n

And without further ado, let\u2019s take a look at some of the coolest Python features. If you think I\u2019ve missed any, feel free to drop them in the comments.<\/p>\n\n\n\n

List Comprehensions<\/h3>\n\n\n\n

By far, my favorite feature in Python is the list comprehension. Honestly, the feature isn\u2019t all that interesting; it\u2019s just a convenient way to generate lists. That said, it\u2019s a feature that I haven\u2019t seen in any other popular language (e.g. Java, C, C++, etc.). As a result, I make sure to take advantage of it as often as possible. Here are a few examples:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n
15<\/div>\n
16<\/div>\n
17<\/div>\n
18<\/div>\n<\/td>\n
\n
\n
# Generates a list containing values from <\/code>0<\/code> to <\/code>9<\/code><\/div>\n
[i <\/code>for<\/code> i in range(<\/code>10<\/code>)]<\/code><\/div>\n
 <\/div>\n
# Generates a list of all even values from <\/code>0<\/code> to <\/code>9<\/code><\/div>\n
[i <\/code>for<\/code> i range(<\/code>10<\/code>) <\/code>if<\/code> i % <\/code>2<\/code> == <\/code>0<\/code>]<\/code><\/div>\n
 <\/div>\n
# Generates a list containing values from <\/code>1<\/code> to <\/code>10<\/code><\/div>\n
[i + <\/code>1<\/code> for<\/code> i in range(<\/code>10<\/code>)]<\/code><\/div>\n
 <\/div>\n
# Generates a list containing values from  <\/code>0<\/code> to -<\/code>9<\/code><\/div>\n
[-i <\/code>for<\/code> i in range(<\/code>10<\/code>)]<\/code><\/div>\n
 <\/div>\n
# Generates all possible pairs between <\/code>0<\/code> and <\/code>9<\/code><\/div>\n
[(a, b) <\/code>for<\/code> a in range(<\/code>10<\/code>) <\/code>for<\/code> b in range(<\/code>10<\/code>)]<\/code><\/div>\n
 <\/div>\n
# Shallow copies another list<\/code><\/div>\n
my_list = [<\/code>1<\/code>, <\/code>3<\/code>, <\/code>5<\/code>, <\/code>7<\/code>, <\/code>9<\/code>]<\/code><\/div>\n
[item <\/code>for<\/code> item in my_list]<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Since a list comprehension creates a list, we\u2019re able to work with the output like any other list:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
# Generates a list containing values from <\/code>0<\/code> to <\/code>9<\/code><\/div>\n
nums = [i <\/code>for<\/code> i in range(<\/code>10<\/code>)]<\/code><\/div>\n
nums[<\/code>0<\/code>]  # returns <\/code>0<\/code><\/div>\n
nums[<\/code>1<\/code>]  # returns <\/code>1<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

If you\u2019re interested in learning how to write these yourself, I have an article just for you<\/a>. In it, you\u2019ll learn more about the syntax as well as a few application areas. If you have any of your own examples, feel free to share them in the comments.<\/p>\n\n\n\n

Generator Expressions<\/h3>\n\n\n\n

One of the nice things about learning the list comprehension syntax is that it allows you to also write generator expressions. After all, they\u2019re very similar\u2014one just saves you space. That\u2019s right! Generator expressions don\u2019t actually create lists. Instead, they provide the means for generating one item at a time of a list without ever constructing that list. Take a look:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n
15<\/div>\n
16<\/div>\n
17<\/div>\n
18<\/div>\n<\/td>\n
\n
\n
# Generates values from <\/code>0<\/code> to <\/code>9<\/code><\/div>\n
(i <\/code>for<\/code> i in range(<\/code>10<\/code>)])<\/code><\/div>\n
 <\/div>\n
# Generates values from <\/code>0<\/code> to <\/code>9<\/code><\/div>\n
(i <\/code>for<\/code> i range(<\/code>10<\/code>) <\/code>if<\/code> i % <\/code>2<\/code> == <\/code>0<\/code>)<\/code><\/div>\n
 <\/div>\n
# Generates values from <\/code>1<\/code> to <\/code>10<\/code><\/div>\n
(i + <\/code>1<\/code> for<\/code> i in range(<\/code>10<\/code>)])<\/code><\/div>\n
 <\/div>\n
# Generates values from  <\/code>0<\/code> to -<\/code>9<\/code><\/div>\n
(-i <\/code>for<\/code> i in range(<\/code>10<\/code>))<\/code><\/div>\n
 <\/div>\n
# Generates all possible pairs between <\/code>0<\/code> and <\/code>9<\/code><\/div>\n
((a, b) <\/code>for<\/code> a in range(<\/code>10<\/code>) <\/code>for<\/code> b in range(<\/code>10<\/code>))<\/code><\/div>\n
 <\/div>\n
# Generates a shallow copy of another list<\/code><\/div>\n
my_list = [<\/code>1<\/code>, <\/code>3<\/code>, <\/code>5<\/code>, <\/code>7<\/code>, <\/code>9<\/code>]<\/code><\/div>\n
(item <\/code>for<\/code> item in my_list)<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Notice how similar the syntax is to the list comprehension. However, the application is slightly different. Instead of indexing the elements, we have to use a special function:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
# Generates values from <\/code>0<\/code> to <\/code>9<\/code><\/div>\n
nums = (i <\/code>for<\/code> i in range(<\/code>10<\/code>)])<\/code><\/div>\n
next(num)  # returns <\/code>0<\/code><\/div>\n
next(num)  # returns <\/code>1<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Since a generator is an iterable, we can also get away with using the for loop syntax:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
# Generates values from <\/code>0<\/code> to <\/code>9<\/code><\/div>\n
nums = (i <\/code>for<\/code> i in range(<\/code>10<\/code>)])<\/code><\/div>\n
for<\/code> num in nums:<\/code><\/div>\n
    <\/code>print(num)  # prints each item in the generator<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Once we\u2019ve exhausted every element, the generator expression becomes useless. In other words, we can only generate every element once. After that, we have to write the expression again.<\/p>\n\n\n\n

Slice Assignment<\/h3>\n\n\n\n

Have you ever wanted to replace entire sections of a list? Well, Python has a feature that allows you to do just that in a single line: slice assignment. Like slicing, slice assignment allows you to specify a region of a list. Of course, the difference is that slice assignment then lets you replace that region with whatever you want:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n<\/td>\n
\n
\n
my_list = [<\/code>1<\/code>, <\/code>2<\/code>, <\/code>3<\/code>]<\/code><\/div>\n
 <\/div>\n
# Appending a list with slice assignment<\/code><\/div>\n
my_list[len(my_list):] = [<\/code>4<\/code>]<\/code><\/div>\n
 <\/div>\n
# Prepending a list with slice assignment<\/code><\/div>\n
my_list[:<\/code>0<\/code>] = [<\/code>0<\/code>]<\/code><\/div>\n
 <\/div>\n
# Replacing middle element<\/code><\/div>\n
midpoint = len(my_list) <\/code>\/\/ 2<\/code><\/div>\n
my_list[midpoint: midpoint + <\/code>1<\/code>] = [-<\/code>2<\/code>]<\/code><\/div>\n
 <\/div>\n
# Replacing arbitrary subsection<\/code><\/div>\n
my_list[:<\/code>2<\/code>] = [<\/code>3<\/code>, <\/code>4<\/code>, <\/code>5<\/code>]<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

As I\u2019ve mentioned in a related article, slice assignment doesn\u2019t stop there<\/a>. We can use any iterable on the right side. For example, we could use strings, tuples, list comprehensions, or even generator expressions. In other words, our previous two features can make an appearance:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n<\/td>\n
\n
\n
my_list = [<\/code>1<\/code>, <\/code>2<\/code>, <\/code>3<\/code>]<\/code><\/div>\n
my_list[len(my_list):] = (item <\/code>for<\/code> item in range(<\/code>5<\/code>))<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Since learning about slice assignment in late 2019, I\u2019ve been obsessed with it. As a result, I think it\u2019s my second favorite feature right behind list comprehensions. Right now, I don\u2019t have an article covering this feature in more detail, so you\u2019re welcome to share some of your favorite examples in the comments.<\/p>\n\n\n\n

Iterable Unpacking (aka Destructuring)<\/h3>\n\n\n\n

If you\u2019ve checked out my article on getting the last item of a list<\/a>, you might recall that iterable unpacking was one of the solutions. The idea being that we can split a list into two pieces: the last item and everything else:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n<\/td>\n
\n
\n
my_list = [<\/code>1<\/code>, <\/code>2<\/code>, <\/code>3<\/code>]<\/code><\/div>\n
*remainder, last_item = my_list<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Well, iterable unpacking can do more than retrieve the end of a list. For example, it can be used to swap variables:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n<\/td>\n
\n
\n
a = <\/code>1<\/code><\/div>\n
b = <\/code>2<\/code><\/div>\n
b, a = a, b<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Normally, we\u2019d need three lines of code to perform a swap: one to create a temporary variable, another to overwrite one of the variables, and the last to copy the temporary variable to the other variable. With iterable unpacking, it\u2019s a single line of code.<\/p>\n\n\n\n

If iterable unpacking looks familiar to you, you might know it from its other name: destructuring. Oddly enough, I featured destructuring in an article covering some of my favorite features of any programming language<\/a>.<\/p>\n\n\n\n

That said, I don\u2019t use iterable unpacking very often. If you have any good examples that would supplement this list, feel free to share them.<\/p>\n\n\n\n

Negative Indexing<\/h3>\n\n\n\n

Of all the features on this list, negative indexing is perhaps the most subtle. After all, many modern programming languages have some form of list indexing. However, few have a way of getting the last element of a list<\/a> so elegantly:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n<\/td>\n
\n
\n
my_list = [<\/code>1<\/code>, <\/code>2<\/code>, <\/code>3<\/code>]<\/code><\/div>\n
last_item = my_list[-<\/code>1<\/code>]<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

In addition to being able to access list elements in reverse, we can also use negative indexing with list methods like insert()<\/code>, pop()<\/code>, and index()<\/code>:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
my_list = [<\/code>'h'<\/code>, <\/code>'e'<\/code>, <\/code>'l'<\/code>, <\/code>'l'<\/code>, <\/code>'o'<\/code>]<\/code><\/div>\n
my_list.insert(-<\/code>1<\/code>, <\/code>'l'<\/code>)  # [<\/code>'h'<\/code>, <\/code>'e'<\/code>, <\/code>'l'<\/code>, <\/code>'l'<\/code>, <\/code>'l'<\/code>, <\/code>'o'<\/code>]<\/code><\/div>\n
my_list.pop(-<\/code>2<\/code>)  # [<\/code>'h'<\/code>, <\/code>'e'<\/code>, <\/code>'l'<\/code>, <\/code>'l'<\/code>, <\/code>'o'<\/code>]<\/code><\/div>\n
my_list.index(<\/code>'l'<\/code>, -<\/code>2<\/code>)  # <\/code>3<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

If you like negative indexing, you\u2019ll be happy to know this feature doesn\u2019t stop with lists. Feel free to use it with strings, tuples, and other sequences.<\/p>\n\n\n\n

Dictionary Comprehensions<\/h3>\n\n\n\n

Previously in this list, I mentioned list comprehensions. Apparently, that feature is so good that the developers decided to expand its capabilities to encompass other data structures like dictionaries. After all, wouldn\u2019t it be nice to be able to generate a dictionary in a single line of code? Well, as of PEP 274<\/a>, you can:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n<\/td>\n
\n
\n
# Generates a dictionary of numbers to letters<\/code><\/div>\n
{num: chr(<\/code>65<\/code> + num) <\/code>for<\/code> num in range(<\/code>5<\/code>)} <\/code><\/div>\n
 <\/div>\n
# Generates the same thing<\/code><\/div>\n
nums = [<\/code>1<\/code>, <\/code>2<\/code>, <\/code>3<\/code>, <\/code>4<\/code>, <\/code>5<\/code>]<\/code><\/div>\n
letters = [<\/code>\"A\"<\/code>, <\/code>\"B\"<\/code>, <\/code>\"C\"<\/code>, <\/code>\"D\"<\/code>, <\/code>\"E\"<\/code>]<\/code><\/div>\n
{num: letter <\/code>for<\/code> num, letter in zip(nums, letters)}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Typically, I use a dictionary comprehension to merge two lists into a dictionary<\/a>. That said, I\u2019m sure there are other use cases. Feel free to share some of your favorite it in the comments.<\/p>\n\n\n\n

Chaining Comparisons<\/h3>\n\n\n\n

In many modern programming languages, comparing values is a simple process. For example, in Java, I can compare two numbers as follows:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n<\/td>\n
\n
\n
17<\/code> > <\/code>5<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

In this example, the result is a boolean, true<\/code>. As a result, the following expression is illegal in Java:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n<\/td>\n
\n
\n
17<\/code> > <\/code>5<\/code> > <\/code>1<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Here, 17 > 5<\/code> evaluates to true. Then, the expression true > 1<\/code> is evaluated. Since this is nonsensical, the compiler crashes.<\/p>\n\n\n\n

In Python, however, we can chain comparisons<\/strong> without any risks. In other words, the same expression above is perfectly valid, and it returns True<\/code>.<\/p>\n\n\n\n

Under the hood, each comparison is computed just like Java. However, each intermediate result is ANDed with the result of the other comparison. For example, 17 > 5<\/code> returns True<\/code>. Then, 5 > 1<\/code> returns True. Finally, the results are combined by and<\/code> which returns True<\/code>.<\/p>\n\n\n\n

Personally, I haven\u2019t used this feature much, but it\u2019s gotten a lot of attention on the development end. For example, PEP 535<\/a> mentions a few updates to the chaining protocol. If you know of any cool use cases for this feature, let me know in the comments.<\/p>\n\n\n\n

f-Strings<\/h3>\n\n\n\n

Finally, we come to one of my favorite \u201cnew\u201d (PEP 498<\/a>) Python features, f-Strings. Normally, when we create strings for debugging, we lazily print them with concatenation. If we\u2019re clever, we might use some of the string formatting techniques<\/a>. Now, we can get the best of both worlds with f-Strings:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n<\/td>\n
\n
\n
age = <\/code>25<\/code><\/div>\n
name = <\/code>'Jeremy'<\/code><\/div>\n
print(f<\/code>'My name is {name}, and I am {age}'<\/code>)<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

In this example, we\u2019ve created a string from two variables: name<\/code> and age<\/code>. All we had to do was prepend our string with an f<\/code>. Then, we can place any expression we want in braces, and it will be interpreted. For example, age<\/code> is a number which is automatically converted to its string representation.<\/p>\n\n\n\n

I really love this f-String syntax because it solves a lot of common string formatting issues. For example, it makes string formatting very easy to read (unlike concatenation). Likewise, it makes it obvious what the output string will look like (again, unlike concatenation). Finally, there\u2019s no issues with positioning of variables (unlike string interpolation). What you see is what you get.<\/p>\n\n\n\n

While f-Strings are really helpful, I don\u2019t find myself using them beyond debugging. Do you have any examples you\u2019d like to share?<\/p>\n\n\n\n

Honorable Mentions<\/h2>\n\n\n\n

As someone who really loves working with Python, I had a hard time keeping this list short. As a result, here are a few additional features that didn\u2019t make the cut:<\/p>\n\n\n\n