What’s new in Python 3.8? – Unveiling the Latest Features & Updates

Python has officially released its latest version Python 3.8 on 14th October 2019. This release has rolled out some great new features for all the Python programmers. Python 3.8 is faster than ever with some major improvements in its performance.

In this Python 3.8 tutorial, let’s see what has been changed from its previous version 3.7

240+ Free Python Tutorials – Get one step closer to your dream of becoming a data scientist

Keeping you updated with latest technology trends, Join DataFlair on Telegram

Python 3.8 Features

whats new in python 3.8 - Python 3.8 Features

Now, we will quickly dive into the latest features of Python 3.8:

1. PEP 572 (Assignment Expressions) – The walrus operator (:=)

You will get to see a new type of operator which is being known as the walrus operator (:=). This allows you to assign variables inside an expression. The major benefit of this is to save you some lines of code and you can write even cleaner and compact code in Python.

Example 1


num = [1,2,3,4,5]
if( (size:=len(num1)) < 10 ):
  print(f”Length of list is small, size={size}”)

Example 2

This can be useful while writing loops, something like this.


Item = getItem()
while Item:
  Item = getItem()

Can be written as:

while Item:= getItem():

Example 3

Simplifying list comprehensions when filtering a value

[y for x in data if (y := f(x)) is not None]

Time to master the concept of Python Loop

2. PEP 570 (Positional only arguments)

There is a new function parameter syntax (/) to highlight that some of the functions must be stated positionally and not by keyword arguments. We also have an operator (*) that indicates that the arguments must be keyword only. This can be a little confusing but after seeing the code this gets easier to understand, so let’s see them in action.

def func(a, b, c, d):

We can call this function however we want with keyword arguments or positions.

func(d=2, a=3, b=2, c=6) #Valid - prints 3 2 6 2
func(1,3,4,5) #Valid - prints 1 2 4 5

Now consider the following definition:

def func( a,b,/,c,d,*,e,f ):
  print(a,b,c,d,e,f )

This will impose the way we can call this function:

  • a and b arguments are positional only.
  • c and d arguments can be positional as well as keyword.
  • e and f arguments are keyword only.
func(1,2, 3,4, e=5, f=6 ) #Valid - prints 1 2 3 4 5 6
func(1,2, c=3,d=4, e=5, f=6 ) #Valid - prints 1 2 3 4 5 6

However, these calls will be invalid

func(a=1,b=2, 3,4, e=5, f=6 ) #Invalid - Error : a and b arguments are positional only 
func(1,2, c=3,d=4, 5, 6 ) #Invalid - Error : e and f are keyword only arguments.

Don’t forget to check the Python Function Arguments

3. PEP 590 ( Vectorcall)

This release has made some improvements in the vectorcall which is a fast calling protocol for CPython. A new C API is introduced to optimize the calls of objects. This feature was already used in CPython but with the new C API, “fastcall” convention can be used by a user-defined extension class.

4. PEP 574 ( Pickle Protocol 5 with out-of-band data)

Pickle is used widely to transfer big amounts of data between Python processors to take full advantage of multicore processors. It’s important to maximize the transfer speed by optimizing memory copies. Pickle protocol 5 now supports out-of-band data buffers and extra metadata is required.

  • PickleBuffer type for __reduce_ex__ returns out-of-band buffers.
  • buffer_callback parameter while pickling handles out-of-band data buffers.
  • buffers parameter while unpickling shows out-of-band data buffers.

5. F-strings now support = (Easy debugging)

A small improvement has been made in the f-strings formatting. They can now support = operator in f-strings that allows debugging easier.

In previous Python versions, this would give you Syntax Error:

A = 5

Now from Python 3.8, we can do the following

print(f”{A=}”) #prints : A=5

6. Improved Typing

6.1 PEP 591 ( Final qualifier )

Python now supports the “final”. Java programmers already know about this. It has 3 major uses:

  • Declaring a class final will prevent it from inheriting.
  • Declaring a variable final will prevent it from reassigning the value.
  • Declaring a method final will prevent it from being overridden.

6.2 PEP 586 (Literal types )

Literal types are used to know the literal value of an attribute or a variable. They are useful in type checking.

Consider this expression:

0== False

This will give True as result but 0 is of type integer and False is of type bool. So with literal, we can force type checks to be literally some specific type.


There are a lot more improvements and changes have been made in the existing Python code. It is also safe to upgrade to python 3.8 and start experimenting with new features like assignment expressions and positional-only arguments.

Thoroughly practice the Python concepts from the Python Master Guide by DataFlair

Did you like the new features of Python 3.8? Let us know in the comments.

2 Responses

  1. Dihfahsih Mugoya says:

    I hope all the libraries in 3.7 where included in this 3.8 because they are super cool

    • VB says:

      num = [1,2,3,4,5]
      if( (size:=len(num1)) < 10 ):
      print(f”Length of list is small, size={size}”)

      I think its not num1, its num. please correct me if i am wrong

      thank you

Leave a Reply

Your email address will not be published. Required fields are marked *

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.