Top 10 Python Extensions for Visual Studio Code

Daniel Morales
Oct 09, 2021

Contents Outline

Top 10 Python Extensions for Visual Studio Code

Oct 09, 2021 7 minutes read

In this new post we want to talk about the most useful Python extensions for Visual Studio Code. 

Visual Studio Code is an integrated development environment created by Microsoft for Windows, Linux and macOS. Among its features are debugging, syntax highlighting, smart code completion, snippets, code refactoring and integrated Git. Users can change the theme, keyboard shortcuts, preferences and install extensions that add additional functionality.

Precisely we are going to talk about the extensions you can install for VS. Here is a list of our favorites


1- Python




Python extension for Visual Studio Code

A Visual Studio Code extension with rich support for the Python language (for all actively supported versions of the language: >=3.6), including features such as IntelliSense (Pylance), linting, debugging, code navigation, code formatting, refactoring, variable explorer, test explorer, and more!

NOTE: Web support -- e.g., github.dev -- is limited.

Installed extensions
The Python extension will automatically install the Pylance and Jupyter extensions to give you the best experience when working with Python files and Jupyter notebooks. However, Pylance is an optional dependency, which means that the Python extension will remain fully functional if it is not installed. You can also uninstall it at the expense of some features if you are using a different language server.

2- Python Indent




It is used to correct Python indentation in Visual Studio Code.

How it works
Every time you press the Enter key in a Python context, this extension will parse your Python file down to the location of your cursor, and determine exactly how much to indent the next line (or two in the case of hanging indents) and how much to indent nearby lines.

There are three main cases when determining the correct indent. Review the documentation here: https://github.com/kbrose/vsc-python-indent

3- Python Doctring Generator



Visual Studio Code extension to quickly generate docstrings for python functions.

Features
  • Quickly generate a docstring fragment that can be tabbed.
  • Choose from several types of docstring formats.
  • Infer parameter types via pep484 type hints, default values and var names.
  • Support for args, kwargs, decorators, errors and parameter types.

Docstring Formats
  • Google (default)
  • docBlockr
  • Numpy
  • Sphinx
  • PEP0257 (coming soon)

Usage
  • The cursor must be on the line directly below the definition to generate a complete auto-populated docstring.
  • Press enter after opening the docstring with triple quotes ("""" or ''')
  • Keyboard shortcut: ctrl+shift+2 or cmd+shift+2 for mac
  • Can be changed in Preferences -> Keyboard shortcuts -> extension.generateDocstring
  • Command: Generate Docstring
  • Right-click menu: Generate Docstring


4- Python Extended





Python Extended is a vscode snippet that makes it easy to write Python code by providing completion options along with all arguments.

Usage
Run vscode and in a python file, type the name of the method to complete and press tab or enter on selection.

How to install
Open vscode. Press F1, search for "ext install" followed by the extension name, in this case "ext install Python Extended" without the ">". Or if you prefer ">ext install", press enter, search for "Python Extended".



5- Python Preview





A Visual Studio Code extension with debug preview support for the Python language.

Requirements
  • Install a version of Python 3.6 or Python 2.7. Make sure that the location of your Python interpreter is included in your PATH environment variable.
  • It is best to install the Python extension for Python Intellisense.


6- AREPL for Python




AREPL automatically evaluates Python code in real time as you type.

Usage
  • First, make sure you have python 3.7 or higher installed.
  • Open a python file and click on the cat in the top right bar to open AREPL. You can click the cat again to close it.
  • Or run AREPL via the search command: control-shift-p
  • or use the shortcuts: control-shift-a (current document) / control-shift-q (new document)

Features
  • Real-time evaluation: no need to run - AREPL evaluates your code automatically. You can control this (or even disable it) in the settings.
  • Variable display: The final state of your local variables is displayed in a collapsible JSON format.
  • Error display: The moment you make a mistake an error is displayed with the stack trace.
  • Settings: AREPL offers many settings to suit your user experience. Customize the look and feel, bounce time, python options and much more.

7- Python Path




This extension adds a set of tools to help generate internal import statements in a Python project.

Features
  • "Copy Python Path" is accessible from:
  • Command line
  • Explorer context menu
  • Editor context menu
  • Editor title context menu


8- Python Test Explorer




This extension allows you to run your Python Unittest, Pytest or Testplan tests with the Test Explorer user interface.

How to get started
  • Install the extension
  • Configure Visual Studio Code to discover your tests (see the Configuration section and the documentation for the test framework of your choice:
  • Unittest documentation
  • Pytest documentation
  • Testplan documentation
  • Open the sidebar of the test view
  • Execute your tests via the Run icon in the Test Explorer

Features
  • Displays a Test Explorer in the test view in the VS Code sidebar with all detected tests and suites and their status
  • Convenient error reporting during test detection
  • Unittest, Pytest and Testplan debugging
  • Displays the log of a failed test when the test is selected in the explorer
  • Test rerun when saving tests
  • Supports multi-root workspaces
  • Supports Unittest, Pytest and Testplan test frameworks and their plugins

9- Python Snippets




A snippet package to make working with Python more productive This snippet package contains all of the following Python methods
  • all built-in python snippets and contains at least one example for each method
  • all python string snippets contain at least one example for each method
  • all python list snippets contain at least one example for each method
  • all Python set snippets contain at least one example for each method
  • all Python tuple snippets contain at least one example for each method
  • all python dictionary snippets contain at least one example for each method
  • And it contains many other code snippets (such as if/else, for, while, while/else, try/catch, file process, and
  • class snippets and class examples for oop (polymorphism, encapsulation, inheritance, etc.).

If you don't use a method don't worry this extension contains a lot of code examples for each python method.

This extension is not just a code snippet, it will also be useful for learning the python programming language.

You will learn all python methods with a lot of code examples.
For example, if you want to use the string replacement method, you just need to use .replace.

But if you don't know how to use the replace method then use string.replace =>

10- Jupyter




A Visual Studio Code extension that provides basic notebook support for language kernels that are compatible with Jupyter Notebooks today. Many language kernels will work without any modifications. To enable advanced features, modifications to the VS Code language extensions may be necessary.

Notebook support
The Jupyter Extension uses VS code's built-in notebook support. This interface offers a number of advantages to notebook users:

  • Out-of-the-box support for VS Code's wide range of basic code editing functions, such as hot output, search and replace, and code folding.
  • Editor extensions such as VIM, bracket coloring, linters and many more are available while editing a cell.
  • Deep integration with the general workbench and file-based features of VS Code, such as outline view (table of contents), breadcrumbs, and other operations.
  • Fast load times for Jupyter notebook (.ipynb) files. Any notebook file is loaded and rendered as quickly as possible, while execution-related operations are initialized behind the scenes.
  • Includes a notebook diff tool, which makes it easy to compare and visualize differences between code cells, results and metadata.
  • Extensibility beyond what the Jupyter extension provides. Extensions can now add their own specific language or runtime to notebooks, such as the .NET and Gather interactive notebooks.
  • Although the Jupyter extension comes with a comprehensive set of the most commonly used renderers for output, the marketplace supports installable custom renderers to make working with your notebooks even more productive. To get started writing your own, check out the VS Code renderer api documentation.

Conclusion


There are many extensions that you can use with your Visual Studio Code, and deciding which one to use will involve testing, reviewing utilities, use cases and so on in order to make your work easier while coding!

Also read: Why Decorators In Python Are Pure Genius?

Related Posts

Understanding Python's Collections Module

How to Use Python Datetimes Correctly?

Why Decorators In Python Are Pure Genius?

Categories

Data Science Machine Learning Deep learning Flask Deployment Big Data Business Python SQL Programming Libraries Jupyter Numpy News Pandas Matplotlib Visualization

Join Competition

Code the Light Fantastic- Final Level 3

Keyword Recency Prediction

Most Related Articles

Python
Programming
Why Decorators In Python Are Pure Genius?

Analyze, test, and re-use your code with little more than an @ symbolIf there’s one thing that makes Python incredibly successful, that would be its readability. Everything else hinges on that: if code is unreadable, it’s hard to maintain. It’s also not beginner-friendly then — a novice getting boggled by unreadable code won’t attempt writing its own one day.Python was already readable and beginner-friendly before decorators came around. But as the language started getting used for more and more things, Python developers felt the need for more and more features, without cluttering the landscape and making code unreadable.Decorators are a prime-time example of a perfectly implemented feature. It does take a while to wrap your head around, but it’s worth it. As you start using them, you’ll notice how they don’t overcomplicate things and make your code neat and snazzy.Before anything else: higher-order functionsIn a nutshell, decorators are a neat way to handle higher-order functions. So let’s look at those first!Functions returning functionsSay you have one function, greet() — it greets whatever object you pass it. And let’s say you have another function, simon() — it inserts “Simon” wherever appropriate. How can we combine the two? Think about it a minute before you look below.def greet(name): return f"Hello, {name}!" def simon(func): return func("Simon") simon(greet)The output is 'Hello, Simon!'. Hope that makes sense to ya!Of course we could have just called greet("Simon"). However, the whole point is that we might want to put “Simon” into many different functions. And if we don’t use “Simon” but something more complicated, we can save a whole lot of lines of code by packing it into a function like simon().Functions inside other functionsWe can also define functions inside other functions. That’s important because decorators will do that, too! Without decorators it looks like this:def respect(maybe): def congrats(): return "Congrats, bro!" def insult(): return "You're silly!" if maybe == "yes": return congrats else: return insultThe function respect() returns a function; respect("yes") returns the congrats function, respect("brother") (or some other argument instead of "brother") returns the insult function. To call the functions, enter respect("yes")() and respect("brother")(), just like a normal function.Also read: Python Books You Must Read in 2020Got it? Then you’re all set for decorators!Code is beautifully nerdy. Image by author.The ABC of Python decoratorsFunctions with an @ symbolLet’s try a combination of the two previous concepts: a function that takes another function and defines a function. Sounds mind-boggling? Consider this:def startstop(func): def wrapper(): print("Starting...") func() print("Finished!") return wrapper def roll(): print("Rolling on the floor laughing XD") roll = startstop(roll)The last line ensures that we don’t need to call startstop(roll)() anymore; roll() will suffice. Do you know what the output of that call is? Try it yourself if you’re unsure!Now, as a very good alternative, we could insert this right after defining startstop():@startstop def roll(): print("Rolling on the floor laughing XD")This does the same, but glues roll() to startstop() at the onset.Added flexibilityWhy is that useful? Doesn’t that consume exactly as many lines of code as before?In this case, yes. But once you’re dealing with slightly more complicated stuff, it gets really useful. For once, you can move all decorators (i.e. the def startstop() part above) into its own module. That is, you write them into a file called decorators.py and write something like this into your main file:from decorators import startstop @startstop def roll(): print("Rolling on the floor laughing XD")In principle, you can do that without using decorators. But this way it makes life easier because you don’t have to deal with nested functions and endless bracket-counting anymore.You can also nest decorators:from decorators import startstop, exectime @exectime @startstop def roll(): print("Rolling on the floor laughing XD")Note that we haven’t defined exectime() yet, but you’ll see it in the next section. It’s a function that can measure how long a process takes in Python.This nesting would be equivalent to a line like this:roll = exectime(startstop(roll))Bracket counting is starting! Imagine you had five or six of those functions nested inside each other. Wouldn’t the decorator notation be much easier to read than this nested mess?You can even use decorators on functions that accept arguments. Now imagine a few arguments in the line above and your chaos would be complete. Decorators make it neat and tidy.Also read: How to Get a Job With PythonFinally, you can even add arguments to your decorators — like @mydecorator(argument). Yeah, you can do all of this without decorators. But then I wish you a lot of fun understanding your decorator-free code when you re-read it in three weeks…Decorators make everything easier. Image by author.Applications: where decorators cut the creamNow that I’ve hopefully convinced you that decorators make your life three times easier, let’s look at some classic examples where decorators are basically indispensable.Measuring execution timeLet’s say we have a function called waste time() and we want to know how long it takes. Well, just use a decorator!import time def measuretime(func): def wrapper(): starttime = time.perf_counter() func() endtime = time.perf_counter() print(f"Time needed: {endtime - starttime} seconds") return wrapper @measuretime def wastetime(): sum([i**2 for i in range(1000000)]) wastetime()A dozen lines of code and we’re done! Plus, you can use measuretime() on as many functions as you want.Slowing code downSometimes you don’t want to execute code immediately but wait a while. That’s where a slow-down decorator comes in handy:import time def sleep(func): def wrapper(): time.sleep(300) return func() return wrapper @sleep def wakeup(): print("Get up! Your break is over.") wakeup()Calling wakeup() makes lets you take a 5-minute break, after which your console reminds you to get back to work.Also read: Building A Linear Regression Model With Python To Predict Retail Customer SpendingTesting and debuggingSay you have a whole lot of different functions that you call at different stages, and you’re losing the overview over what’s being called when. With a simple decorator for every function definition, you can bring more clarity. Like so:def debug(func): def wrapper(): print(f"Calling {func.__name__}") return wrapper @debug def scare(): print("Boo!") scare()There is an a lot more elaborate example here. Note, though, that to understand that example, you’ll have to check how to decorate functions with arguments. Still, it’s worth the read!Reusing codeThis kinda goes without saying. If you’ve defined a function decorator(), you can just sprinkle @decorator everywhere in your code. To be honest, I don’t think it gets any simpler than that!Handling loginsIf you have functionalities that should only be accessed if a user is logged in, that’s also fairly easy with decorators. I’ll refer you to the full example for reference, but the principle is quite simple: first you define a function like login_required(). Before any function definition that needs logging in, you pop @login_required. Simple enough, I’d say.Syntactic sugar — or why Python is so sweetIt’s not like I’m not critical of Python or not using alternative languages where it’s appropriate. But there’s a big allure to Python: it’s so easy to digest, even when you’re not a computer scientist by training and just want to make things work.If C++ is an orange, then Python is a pineapple: similarly nutritious, but three times sweeter. Decorators are just one factor in the mix.But I hope you’ve come to see why it’s such a big sweet-factor. Syntactic sugar to add some pleasure to your life! Without health risks, except for having your eyes glued on a screen.I wish you lots of sweet code!Also Read: How to Use Python Datetimes Correctly?

Python
SQL
Programming
How to Use Python Datetimes Correctly?

Datetime is basically a python object that represents a point in time, like years, days, seconds, milliseconds. This is very useful to create our programs.The datetime module provides classes to manipulate dates and times in a simple and complex way. While date and time arithmetic is supported, the application focuses on the efficient extraction of attributes for formatting and manipulating output

Python
3 Python Tricks That Will Improve Your Code

I’ve been coding in Python for more than 10 years. There was a time when I thought I knew it all, which was a clear sign I was getting complacent.Then I decided to do a bit of research about Python improvements. Those 3.6, 3.7, 3.8 Python versions aren’t there for nothing, right?After going through release notes, I found these neat tricks that I would like to share with you.By reading this article, you’ll learn:How to format big integers more clearlyA better way to work with file pathsThe proper way of string formating1. Formatting big integersUsing Underscores in Numeric Literals. Image by Roman OracFrom Python 3.6 (and onwards) you can use underscores to make numbers easier to read. See PEP 515 for more details.Let’s look at an example:a = 1000000000 # Is variable a billion or 100 millions? # Let's use underscores to make it easier to read a = 1_000_000_000 # You can group numbers as you like b = 1_0_9_0It also works with hexadecimal addresses and grouping bits.# grouping hexadecimal addresses by words addr = 0xCAFE_F00D # grouping bits into nibbles in a binary literal flags = 0b_0011_1111_0100_1110Also read: Why Decorators In Python Are Pure Genius?2. PathlibPhoto by Alice Donovan Rouse on UnsplashWorking with paths can be challenging especially if your code needs to run on multiple operating systems.Luckily for us, Python standard library has pathllib.Let’s look at an example:from pathlib import Path path = Path("some_folder") print(path) # output: some_folder # We can add more subfolders in a readable way path = path / "sub_folder" / "sub_sub_folder" print(path) # output: some_folder/sub_folder/sub_sub_folder # make path absolute print(path.resolve()) # output: /Users/r.orac/some_folder/sub_folter/sub_sub_folderDespite using / sign as the separator to concatenate paths, pathlib makes it operating system agnostic, meaning it will also work on Windows OS.Also read: Using Python And Pandas Datareader to Analyze Financial Data3. Simplify string formattingf-string formatting in Python. Image by Roman OracI’m used to using old school string formatting in Python:person = 'Roman' exercise = 0 print("%d-times %s exercised during corona epidemic" % (exercise, person)) # output # 0-times Roman exercised during corona epidemicUntil recently, I didn’t know there is a better (more modern) way of string formatting in Python.In Python 3.6, PEP 498 introduces Literal String Interpolation, which simplifies the string formatting.We can rewrite the example above to:person = 'roman' exercise = 0 print(f"{exercise}-times {person} exercised during corona epidemic") # output # 0-times Roman exercised during corona epidemicA string prefixed with f is known as fstring.fstrings even support math operations:print(f"{exercise+1}-times {person} exercised during corona epidemic") # Output # '1-times roman exercised during corona epidemic'But I didn’t exercise during the corona epidemic so adding +1 in the fstring would simply be a lie 😂What about formatting float values?f = 0.333333 print(f"this is f={f:.2f} rounded to 2 decimals") # Output this is f=0.33 rounded to 2 decimalsAlso read: How to Use Python Datetimes Correctly?ConclusionThese Python tricks will make your code more concise and will make coding more enjoyable.Many Python developers don’t know about these tricks — you’re not one of them anymore.Before you goFollow me on Twitter, where I regularly tweet about Data Science and Machine Learning.Also read: Understanding Python's Collections Module

Python
Programming
Libraries
Understanding Python's Collections Module

The Python collections module has different specialized data types that function as containers and can be used to replace the general purpose Python containers (`dict`, `tuple`, `list` and `set`). We will study the following parts of this module:- `ChainMap`- `defaultdict`- `deque`There is a submodule of collections called abc or Abstract Base Classes. These will not be covered in this post, let's start with the ChainMap container!ChainMapA ChainMap is a class that provides the ability to link multiple mappings together so that they end up as a single unit. If you look at the documentation, you will notice that it accepts `**maps*`, which means that a ChainMap will accept any number of mappings or dictionaries and convert them into a single view that you can update. Let's see an example so you can see how it works:from collections import ChainMap car_parts = {'hood': 500, 'engine': 5000, 'front_door': 750} car_options = {'A/C': 1000, 'Turbo': 2500, 'rollbar': 300} car_accessories = {'cover': 100, 'hood_ornament': 150, 'seat_cover': 99} car_pricing = ChainMap(car_accessories, car_options, car_parts)car_pricing >> ChainMap({'cover': 100, 'hood_ornament': 150, 'seat_cover': 99}, {'A/C': 1000, 'Turbo': 2500, 'rollbar': 300}, {'hood': 500, 'engine': 5000, 'front_door': 750}) car_pricing['hood'] >> 500Here we import ChainMap from our collections module. Next we create three dictionaries. Then we create an instance of our ChainMap by passing it the three dictionaries we just created.Finally, we try to access one of the keys of our ChainMap. When we do this, the ChainMap will go through each map to see if that key exists and has a value. If it does, then the ChainMap will return the first value it finds that matches that key.This is especially useful if you want to set default values. Suppose we want to create an application that has some default values. The application will also know the operating system environment variables. If there is an environment variable that matches one of the keys we have as a default in our application, the environment will override our default value. In addition, let's assume that we can pass arguments to our application. These arguments take precedence over the environment and the defaults. This is one place where a ChainMap can really come in handy. Let's look at a simple example that is based on one from the Python documentation:Note: do not run this code from Jupyter Notebook, but from your favorite IDE and calling it from a terminal. this command `python chain_map.py -u daniel`import argparse import os from collections import ChainMap def main(): app_defaults = {'username':'admin', 'password':'admin'} parser = argparse.ArgumentParser() parser.add_argument('-u', '--username') parser.add_argument('-p', '--password') args = parser.parse_args() command_line_arguments = {key:value for key, value in vars(args).items() if value} chain = ChainMap(command_line_arguments, os.environ, app_defaults) print(chain['username']) if __name__ == '__main__': main() os.environ['username'] = 'test' main()➜ python python3 post.py -u daniel daniel daniel Let's break this down a bit. Here we import the Python `argparse` module along with the `os` module. We also import `ChainMap`.Next we have a simple function that has some defaults. I have seen these defaults used for some popular routers. We then set up our argument parser and tell it how to handle certain command line options. You'll notice that argparse doesn't provide a way to get a dictionary object from its arguments, so we use a dict comprehension to extract what we need. The other interesting piece here is the use of Python's built-in vars. If you called it without a vars argument it would behave like Python's built-in locales. But if you pass it an object, then vars is the equivalent of the `__dict__` property of object. In other words, vars(args) is equal to `args.__dict__`. Finally we create our ChainMap by passing our command line arguments (if any), then the environment variables and finally the default values.At the end of the code, we try calling our function, then setting an environment variable and calling it again. Try it and you will see that it prints admin and then tests as expected. Now let's try calling the script with a command line argument:python chain_map.py -u danielWhen I run this on my machine, it returns daniel twice. This is because our command line argument overrides everything else. It doesn't matter what we set the environment to because our ChainMap will look at the command line arguments first before anything else. If you try it without the `-u daniel` it will run the actual arguments, in my case `"admin" "test"`.Now that you know how to use ChainMaps, we can move on to Counter!CounterThe collections module also provides us with a small tool that allows us to perform convenient and fast counting. This tool is called `Counter`. You can run it with most iterables. Let's try it with a stringfrom collections import Counter Counter('superfluous') >> Counter({'s': 2, 'u': 3, 'p': 1, 'e': 1, 'r': 1, 'f': 1, 'l': 1, 'o': 1})counter = Counter('superfluous') counter['u'] >> 3In this example, we import `Counter` from `collections` and pass it a string. This returns a Counter object which is a subclass of the Python dictionary. We then run the same command but assign it to the counter variable so that we can access the dictionary more easily. In this case, we have seen that the letter `"u"` appears three times in the example string.The counter provides some methods that you may be interested in. For example, you can call elements which will get an iterator over the elements that are in the dictionary, but in an arbitrary order. This function can be considered as an "encoder", since the output in this case is an encoded version of the string.list(counter.elements()) >> ['s', 's', 'u', 'u', 'u', 'p', 'e', 'r', 'f', 'l', 'o']Another useful method is most_common. You can ask the Counter what are the most common elements by passing a number that represents what are the most recurring `"n"` elements:counter.most_common(2) [('u', 3), ('s', 2)]Here we just asked our Counter which were the two most recurring items. As you can see, it produced a list of tuples that tells us that `"u"` occurred 3 times and `"s"` occurred twice.The other method I want to cover is the subtract method. The `subtract` method accepts an iterable or a mapping and uses that argument to subtract. It's a little easier to explain if you see some code:counter_one = Counter('superfluous') counter_one >> Counter({'s': 2, 'u': 3, 'p': 1, 'e': 1, 'r': 1, 'f': 1, 'l': 1, 'o': 1}) counter_two = Counter('super') counter_one.subtract(counter_two) counter_one >> Counter({'s': 1, 'u': 2, 'p': 0, 'e': 0, 'r': 0, 'f': 1, 'l': 1, 'o': 1})So here we recreate our first counter and print it out so we know what's in it. Thus we create our second Counter object. Finally we subtract the second counter from the first. If you look closely at the output at the end, you will notice that the number of letters in five of the elements has been decreased by one.As I mentioned at the beginning of this section, you can use Counter against any iterable or mapping, so you don't have to use only strings. You can also pass tuples, dictionaries and lists to it.Try it on your own to see how it works with those other data types. Now we are ready to move on to `defaultdict`!`defaultdict`The collections module has a handy tool called `defaultdict`. The `defaultdict` is a subclass of the Python dict that accepts a `default_factory` as its main argument. The `default_factory` is usually a Python data type, such as int or a list, but you can also use a function or a lambda. Let's start by creating a regular Python dictionary that counts the number of times each word is used in a sentence:sentence = "The red for jumped over the fence and ran to the zoo for food" words = sentence.split(' ') words >> ['The', 'red', 'for', 'jumped', 'over', 'the', 'fence', 'and', 'ran', 'to', 'the', 'zoo', 'for', 'food'] reg_dict = {} for word in words: if word in reg_dict: reg_dict[word] += 1 else: reg_dict[word] = 1 print(reg_dict) >> {'The': 1, 'red': 1, 'for': 2, 'jumped': 1, 'over': 1, 'the': 2, 'fence': 1, 'and': 1, 'ran': 1, 'to': 1, 'zoo': 1, 'food': 1}Now let's try to do the same with defaultdict!from collections import defaultdict sentence = "The red for jumped over the fence and ran to the zoo for food" words = sentence.split(' ') d = defaultdict(int) for word in words: d[word] += 1 print(d) >> defaultdict(<class 'int'>, {'The': 1, 'red': 1, 'for': 2, 'jumped': 1, 'over': 1, 'the': 2, 'fence': 1, 'and': 1, 'ran': 1, 'to': 1, 'zoo': 1, 'food': 1})You will notice right away that the code is much simpler. The defaultdict will automatically assign zero as a value to any key it doesn't already have in it. We add one to make it make more sense and it will also increment if the word appears multiple times in the sentence.Now let's try using a Python list type as our `default_factory`. We will start with a regular dictionary, as before.my_list = [(1234, 100.23), (345, 10.45), (1234, 75.00), (345, 222.66), (678, 300.25), (1234, 35.67)] reg_dict = {} for acct_num, value in my_list: if acct_num in reg_dict: reg_dict[acct_num].append(value) else: reg_dict[acct_num] = [value]If you run this code, you should get output similar to the following:print(reg_dict) >> {1234: [100.23, 75.0, 35.67], 345: [10.45, 222.66], 678: [300.25]}Now let's reimplement this code using defaultdict:from collections import defaultdict my_list = [(1234, 100.23), (345, 10.45), (1234, 75.00), (345, 222.66), (678, 300.25), (1234, 35.67)] d = defaultdict(list) for acct_num, value in my_list: d[acct_num].append(value)Again, this eliminates the if/else conditional logic and makes the code easier to follow. Here is the output of the above code:print(d) >> defaultdict(<class 'list'>, {1234: [100.23, 75.0, 35.67], 345: [10.45, 222.66], 678: [300.25]})This is a very good thing! Let's try using a `lambda` also as our `default_factory`!from collections import defaultdict animal = defaultdict(lambda: "Monkey") animal >> defaultdict(<function __main__.<lambda>()>, {}) animal['Sam'] = 'Tiger' print (animal['Nick']) >> Monkey animal >> defaultdict(<function __main__.<lambda>()>, {'Sam': 'Tiger', 'Nick': 'Monkey'})Here we create a `defaultdict` that will assign `Monkey` as default value to any key. The first key is set to `Tiger`, and the next key is not set. If you print the second key, you will see that it has 'Monkey' assigned to it. In case you haven't noticed yet, it is basically impossible to cause a KeyError as long as you set the `default_factory` to something that makes sense. The documentation mentions that if you set the `default_factory` to `None`, then you will receive a KeyError.Let's see how that works:from collections import defaultdict x = defaultdict(None) x['Mike'] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-30-d21c3702d01d> in <module> 1 from collections import defaultdict 2 x = defaultdict(None) ----> 3 x['Mike'] KeyError: 'Mike'In this case, we just created a `defaultdict` with an error. It can no longer assign a default value to our key, so it throws a `KeyError` instead. Of course, since it is a subclass of `dict`, we can simply set the key to some value and it will work. But that defeats the purpose of `defaultdict`.`deque`According to the Python documentation, deques "is a generalization of stacks and queues (stacks and queues)". It is pronounced `deck`, which is short for `double-ended queue`. They are a replacement container for the Python list. Deques are thread-safe and allow you to efficiently add and remove data from memory from either side of the deque. A list is optimized for fast fixed-length operations. Full details can be found in the Python documentation. A deque accepts a `maxlen` argument that sets the limits for the deque. Otherwise, the deque will grow to an arbitrary size. When a bounded deque is full, any new elements added will cause the same number of elements to come out the other end.As a general rule, if you need to add or remove elements quickly, use a deque. If you need quick random access use a list. Let's take a moment to see how a deque can be created and used.from collections import deque import string d = deque(string.ascii_lowercase) for letter in d: print(letter) >> a b c d e f g h i j k l m n o p q r s t u v w x y zHere we import the deque from our collections module and we also import the strings module. To create an instance of a deque, we need to pass it an iterable. In this case, we pass `string.ascii_lowerercase`, which returns a list of all the lowercase letters of the alphabet. Finally, we loop over our deque and print each element. Now let's look at some of the methods that deque has.d.append('bye') d >> deque(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'bye']) d.appendleft('hello') d >> deque(['hello', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'bye']) d.rotate(1) d >> deque(['bye', 'hello', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'])Let's break this down a bit. First we add a chain to the right end of the deque. Then we add another string to the left side of the deque. Finally, we call `rotate` on our deque and pass it a one, which causes it to rotate once to the right. In other words, it makes an element rotate from the far right and in front. You can pass it a negative number to make the deque rotate to the left instead. Let's end this section with an example based on some of the Python documentationfrom collections import deque def get_last(filename, n=5): """ Returns the last n lines from the file """ try: with open(filename) as f: return deque(f, n) except OSError: print("Error opening file: {}".format(filename)) raiseThis code works much like the Linux tail program does. Here we pass a `filename` to our script along with the `n` number of lines we want it to return. The deque is limited to whatever number we pass as `n`. This means that once the deque is full, when new lines are read and added to the deque, the oldest lines are pulled from the other end and discarded. I have also wrapped the file opening with a simple exception handler because it is very easy to pass a malformed path. This will catch files that do not exist.ConclusionWe've covered a lot of ground in this post. You learned how to use a defaultdict and a Count. We also learned about a subclass of the Python list, the deque. Finally, we saw how to use them to perform various activities. I hope you found each of these collections interesting. They may be of great use to you in your day-to-day work.

Join our private community in Discord

Keep up to date by participating in our global community of data scientists and AI enthusiasts. We discuss the latest developments in data science competitions, new techniques for solving complex challenges, AI and machine learning models, and much more!

Join our Discord