Comparing Python and JavaScript: A Guide for Developers

Overview

In this article, I provide a comparison of the most commonly used features of Python and JavaScript. Lesser used features are omitted.

Note: PEP stands for Python Enhancement Proposal.

Some oddities about Python code formatting include:

• leaving two blank lines before and after every function and class definition
• leaving two spaces before every comment that appears on the same line as code

Pros and Cons

JavaScript

Pros:

• ability to run in web browsers (clients) and from command line (servers) using Node.js
• great support for asynchronous code
• performance
• compact syntax for functional programming (e.g., reduce vs. functools)
• can use TypeScript, a superset of JavaScript, to add type checking

Cons:

• still in transition from require to import syntax in Node.js
• type coercions can result in surprising results if not familiar with them

Python

Pros:

• targeted at scripting and rapid application development
• quantity and maturity of libraries for data analysis and machine learning
• multiple number types, not just double-precision float
• some syntax is easier for beginners
  • no curly braces or semicolons, and fewer parentheses
  • and instead of &&, or instead of ||, and not instead of !
  • print vs. console.log
• can add functions implemented in C/C++ or any language callable from C
• can use type hints and tools like mypy to add type checking
• oddly satisfying to type fewer characters (e.g., comment with # instead of //)

Cons:

• Even though Python convention is to separate words in multi-word variable, function, and method names with an underscore, there are many examples where no separation is used. This makes it difficult to guess the correct name.
• Dictionary references for retrieving and setting values are more verbose than JavaScript object references. Rather than using dot syntax such as d.key, we must use d['key'] or d.get('key') even if the key is a single word.
• Anonymous functions are limited to a single expression.
• Lambda functions are more verbose than JavaScript arrow functions (lambda vs. =>).
• The classic ternary operator using a ? and : is not supported. See the conditional logic section for an example.
• There is no syntax for multi-line comments, so commenting out a block of code is tedious.
• Magic methods such as __init__ use "dunder" names (for double underscore) which is an odd and verbose way to distinguish special values. Other programming languages typically use a single special character prefix. See a list in the Python magic methods section.
• Use of operator overloading (supported by magic methods) can be confusing.
• These was no built-in support for asynchronous code until the asyncio module was added in Python 3.4. Some features require Python 3.7+.
• Python programs have poor performance. For examples, see The Computer Language Benchmark Game.
• V3 contains breaking changes, so care must be taken when reading documentation and examples to verify version compatibility.

Running Scripts

JavaScript

JavaScript source files have an extension of .js or .mjs (for ECMAScript modules).

To run a JavaScript script outside a web browser:

• install Node.js.
• enter node {name}.js

Python

Python source files have an extension of .py.

Multiple words in file names should be separated by underscores rather than hyphens because the file name becomes the module name and hyphens are not valid in module names. Avoid using file names that match that of an existing module because doing so will prevent you from being able to import the existing module.

To run a Python script:

• install the Python interpreter from python.org
• enter python3 {name}.py or python {name}.py

In both cases, command line arguments can be passed to the script.

• A JavaScript script running in Node.js can get command line arguments from the array process.argv. The first element is the path to the node executable, the second is the path to the script that is running, and the remaining elements are the command line arguments.
• A Python script can get command line arguments from sys.argv. The first element is the path to the script that is running, and the remaining elements are the command line arguments.

To make a Python source file directly executable in UNIX systems:

• Add this as the first line: #!/usr/bin/env python3
• Make the file executable by entering chmod a+x {file-name}.py
• To run it from a terminal, enter ./{name}.py

To automatically restart a script when it or a file it imports is modified:

1. Install Node.js.
2. npm install -g nodemon
3. If running a JavaScript script, enter nodemon {name}.js
4. If running a Python script, enter nodemon --exec python3 {name}.py.

Getting Help

JavaScript

In JavaScript, perform web searches that begin with "MDN" (for the Mozilla Developer Network) followed by a JavaScript search term. For example, "mdn regexp".

Python

For Python help, see the list of resources at the end of this article.

You can also enter the python command to start the REPL and enter help() to start the help utility. Once inside, enter the name of a module to get help on it. To exit the help utility and return to the Python REPL, enter quit or just q.

Alternatively, once a module has been imported, help on it can be obtained by passing it to the help function. For example:

Comments

Workarounds for multiline comments in Python include using triple-quoted strings and adding if False: before a code block.

Naming Conventions

While Python uses a naming convention to identify constants (all uppercase), they can still be modified. And the naming convention for private instance variables (start with an underscore) doesn't prevent access from outside the class.

Many Python libraries, including the standard library, deviate from the Python naming conventions. In particular, it is common to find multi-word function and method names that are all lowercase with no separator between words. For example, the functools standard library defines the functions partial_method (follows convention) and singledispatchmethod (does not).

Built-in Types

Everything is an object in Python, even values that are primitives in JavaScript like Booleans, numbers, and strings.

Python has "sequences," whereas JavaScript has arrays. Kinds of sequences include string, list, tuple, range, set, and buffer. A list is a mutable sequence of values that typically have the same type. A tuple is an immutable sequence of values that can have varying types. A range is an immutable sequence of numbers that is often be used for looping.

JavaScript object keys must be strings, but Map keys can be any kind of value. Python dict keys can be any immutable type.

The values that are treated as false when used in a Boolean context are listed below:

In JavaScript empty collections evaluate to true. These include arrays, objects, Map instances, and Set instances.

In Python the "not a number" value math.nan evaluates to true.

Modules

In both JavaScript and Python, modules are defined by a single source file. A source file can import other modules, and those can import more modules.

In both JavaScript and Python each module is imported only once. If its code is modified, the script must be re-run to interpret the changes.

JavaScript modules that are imported with a relative file path are only searched for in that location. JavaScript modules that are imported with only a name are searched for in the project node_modules directory and the global node_modules directory.

Python searches for modules in the following order:

• built-in modules
• directory relative to importing file (using dotted module names)
• directories listed in the PYTHONPATH environment variable
• installation-specific directories

To see the directories that will be searched, import sys and execute print(sys.path).

Several module-related topics are described in the following table:

In Python aliases are typically assigned to commonly used packages. The community has landed on using the aliases shown in the imports below.

Packages

JavaScript Packages

JavaScript "packages" are managed using the npm tool, which is installed when Node.js is installed. To allow each project to use different versions of packages and make it easy for other developers to install the same set of packages, create a package.json file in each project by entering npm init and answering some questions.

Python Packages

Python "packages" are managed using the pip tool, which is installed when Python is installed. The name is an acronym for "Pip Installs Packages." It installs packages from the Python Package Index (pypi). To upgrade the version of pip being used, enter python -m pip install --upgrade pip.

To allow each project to use different versions of packages and make it easy for other developers to install the same set of packages, create a virtual environment. There are several tools that can be used to do this. Options include Anaconda, virtualenv (primarily for Python 2), and venv (a subset of virtualenv for Python 3).

To create a virtual environment using venv, enter python -m venv env while in the project root directory. This creates an env subdirectory.

To activate this virtual environment, run the activate script in the env/bin directory. In Windows, enter env\bin\activate.bat. In UNIX environments, enter source env/bin/activate. (When using the Fish shell, add the .fish extension.)

Activating a virtual environment changes the environment to use versions of tools and libraries found in the project env directory instead of global ones. Note that rather than including a copy of a specific version of the Python interpreter, a symbolic link to it is created. This also changes the shell prompt to indicate the environment directory being used, env in this case.

To deactivate a virtual environment and return to using global versions of tools and libraries, enter deactivate.

Note that Python virtual environments must be activated to take effect. This differs from Node.js where simply changing to the directory of a project causes its dependencies versions to be used based on the contents of the node_modules subdirectory.

For details on using Anaconda to manage virtual environments, see here.

Using Packages

Project Python Packages

Project Python packages enable importing modules from subdirectories. These are subdirectories whose names are a package name. The subdirectories must contain a __init__.py file that can be empty or contain initialization code for the package.

Add .py files in the package directories that define modules. Then in .py files that wish to use a module in a package (located in ancestor directories), use from package-name import module-name. To import specific things from package modules, use from package-name.module-name import name1, name2.

The directory structure can be as deep as you like with each subdirectory containing a __init__.py file. When there are nested packages, imports look like from pkg1.pkg2 import module-name or from pkg1.pkg2.module-name import name1, name2.

For more information on Python packages, see the Packages in the Python Tutorial.

Printing/Logging

Variables and Assignment

JavaScript variables should be declared using either the const or let keyword. Python variables are not declared and are created when a value is assigned to them.

JavaScript variable assignments can appear inside expressions such as an if or loop condition, which many developers find confusing. This was not allowed in Python until version 3.8, which adds the "walrus operator" for assigning values to variables inside larger expressions. For example:

Comparison

Python comparisons can be chained, but JavaScript comparisons cannot. For example, to determine whether the value of a variable is between 10 and 20 inclusive:

• in JavaScript, 10 <= n && n <= 20
• in Python, 10 <= n <= 20

Code blocks

JavaScript

JavaScript code blocks are surrounded by curly brackets ({ code }). Long statements can be split over multiple lines without including any special character at the ends of initial lines.

Python

Python uses leading whitespace (indentation) to determine which lines are part of the same block. All consecutive lines with the same indentation, ignoring empty lines, are considered to be in the same block.

For the purpose of this determination, tab characters are replaced by spaces so that the number of spaces is a multiple of eight. This is significant when a mixture of tabs and spaces is used, which is not recommended.

Python style guides recommend using multiples of four spaces for indentation and not using tab characters. Long statements can be split over multiple lines by adding a backslash (\) at the end of all but the last line when it is not clear that a statement is continuing.

Conditional Logic

In the JavaScript syntax below, sOrB is short for "statement or block." It can be a single statement or a set of statements surrounded by curly braces.

A JavaScript if statement can contain any number of else if parts.

A Python if statement can contain any number of elif parts. Python blocks must start on a new line and be indented.

Here's an example of using a Python ternary statement.

Iteration

As we will see in the Key/Value Collections section later, JavaScript can store key/value pairs in plain objects or in instances of the Map class. Python uses "dictionaries" (or dicts) to store key/value pairs.

Functions

JavaScript

In JavaScript, functions can be defined in two ways.

Execute Later or at Intervals

In JavaScript, the setTimeout function registers a function to be called after some number of milliseconds in the future. For example:

Asynchronous Functions

In Python 3.4+, asynchronous functions are supported by the asyncio library.

In JavaScript, async functions return a Promise object.

Here is an example of running tasks that take a simulated amount of time to complete. The first takes 3 seconds, the second takes 2, and the third takes 1. Each tasks outputs its "starting" message immediately. The "ending" messages appear in reverse order due to their differing sleep durations.

Classes

In addition to the @staticmethod decorator, Python also supports the @classmethod decorator. The difference is that methods defined with the latter are passed the class as the first argument.

Here is an example of a JavaScript class:

Built-in Functions

JavaScript provides a small number (9) of built-in functions. Python provides many more (68). The tables below summarize these.

Often one of the languages does not have an equivalent function to the other, so the closest alternative is shown instead.

Descriptions below that begin with "determines if" mean that a Boolean value is returned.

The JavaScript parseFloat and parseInt functions can process strings that contain additional characters after those in the number. For example, parseFloat('3.14pi') returns the number 3.14. The Python float and int functions do not support this.

Boolean Operations

Numeric Operations

Math Operations

Lesser used constants and functions are omitted from the table below.

To use the Python functions, import math.

JavaScript can use the following functions to compute some of the values marked as "not built-in" in the table above:

String Operations

Sequences

JavaScript stores sequences of values in arrays.

Python primarily uses the four sequence types, list, tuple, range, and set, for this purpose:

• Python lists are mutable and are typically homogeneous (elements have the same type).
• Python tuples are immutable and are typically heterogeneous (elements can have different types).
• Python ranges are immutable sequences of numbers and are often used in for loops.
• Python sets are mutable sequences that do not allow duplicate values and are typically homogeneous.

To create a JavaScript array:

Python doesn't have a simple, built-in way to find the first item in a list that matches some criteria. This naive approach is probably the most efficient.

Sorting

Suppose we have a sequence of objects that represent people, and we wish to sort the sequence by last name following by first name.

Here is how this can be done in JavaScript:

List Comprehensions

Python supports list comprehensions that create a list, but JavaScript does not. Here are some examples.

Sets

Sets are unordered collections with no duplicate values.

Set Comprehensions

Python supports set comprehensions that create a set, but JavaScript does not. Here is an example.

Key/Value Collections

JavaScript uses plain objects or instances of the Map class to store associations between keys and values. Keys in JavaScript objects must be must be strings, integers, or symbols, but keys in Map instances can be any type.

Python uses dictionaries to store associations between keys and values. The keys must be immutable types like strings, numbers, and tuples containing these.

Python 3.9 added the | and |= operators for merging dict objects.

Creating a dictionary object

There are four ways to create a Python dictionary:

Regular Expressions

JavaScript

In JavaScript, regular expressions are a built-in type. An instance can be created in two ways:

Python match objects support the following methods:

• group() – returns the matching string
• start() – returns the start index of the match (inclusive)
• end() – returns the end index of the match (exclusive)
• span() – returns a tuple containing the start and end indexes

For more information on regular expression support in Python, see the Python Standard Library Documentation.

Error Handling

Python refers to errors as exceptions.

In JavaScript:

Exit with Status

Both JavaScript programs running in Node.js and Python programs can explicitly exit and set a status code.

In Node.js, the exit method of the process global object is used.

JSON

In Python, in order to use JSON methods include import json.

Writing and Reading Files

Node.js and Python can both read and write files containing text or binary data.

• For details on how this works in Node.js, see the Node.js File system docs.
• For details on how this works in Python, see Reading and Writing Files in Python.

One case to consider is when the file can easily fit in memory. We will see an example using JSON that demonstrates this. Another case is when it cannot and therefore must be processed using streams, perhaps one line at a time. We will see an example using CSV that demonstrates this.

Writing and Reading Small Files

Let's write a JSON file and then read it back in to verify that it worked.

Here is a JavaScript version: Note that it uses top-level awaits, which requires the code to be in an ES module. One way to satisfy this is to give the file a .mjs file extension.

Shell Commands

JavaScript

JavaScript code running in Node.js can execute shell commands, provide input to them, and capture output written to stdout and stderr.

In the example code below we execute the ps command to get the status of all currently running processes and then output the process id (pid) and running time of all "node" processes.

Decorators

Python supports decorators, which are annotations placed before functions and classes to alter their behavior. The TC39 committee that controls the ECMAScript standard for JavaScript has been discussing adding decorators for many years, but they have not yet been added.

Here is a simple example of a decorator that logs the arguments and return value of every invocation value of functions to which it is applied:

Check for Running as Main

Some source files can be used as both the starting point of a script and a module imported by others. To include code that is run only when the file is executed as a script, wrap it in one of the following if statements.

In Node.js, use if (require.main === module) { ... }

In Python, use if __name__ == '__main__': ...

HTTP Servers

HTTP servers can be implemented in both Node.js and Python.

• In Node.js, a popular option is to use the Express package.
• In Python, popular options include Flask and FastAPI.

To demonstrate these options, we will implement HTTP servers that:

• serve static files in a "public" directory
• implement REST services that provide CRUD operations on a collection of dogs

The collection of dogs could be persisted to a database, but we will just hold them in memory in a key/value collection where the keys are dog ids and the values are dog objects that have id, breed, and name properties.

We want the servers to:

• provide request logging
• support cross-origin resource sharing (CORS), so web apps that are served from a different domain can invoke them
• handle GET /dog requests by returning all the dogs as JSON
• handle POST /dog requests by adding the dog described in the request body
• handle PUT /dog/id requests by updating the dog with the given id using the data in the request body
• handle DELETE /dog/id requests by deleting the dog with the given id

JavaScript Express REST Server

1. Create a directory for the project and cd to it.

2. Create a package.json file for the project by entering npm init and answering the questions it asks.

3. Install the required dependencies by entering npm install cors express pino-http and npm install -D nodemon.

4. Replace the "test" script in package.json with "start": "nodemon server.js". The nodemon command provides automatic file watch and server restart.

5. Create the file server.js containing the following:

HTTP Clients

JavaScript

JavaScript applications often use the Fetch API to send HTTP requests. This is built into modern web browsers and can be used in Node applications by installing the node-fetch package with npm install node-fetch.

Here is an example were we fetch an image of a given dog breed.

Python Magic Methods

Python magic methods support many operations on classes and class instances. These include operator overloading.

The following table provides a categorized, partial list of the magic methods that a Python class can implement.

The "method missing" pattern supports calling non-existent methods on an object and inferring meaning at runtime. This is frequently used in the "Ruby on Rails" framework in the implementation of "Active Record."

For example, suppose we want to implement a class whose objects support methods whose names begin with "add" and end with a number. These methods accept another number as an argument and return the sum of the numbers. This could be implemented as follows:

Types

To gain type checking for JavaScript, use the TypeScript compiler. TypeScript is a superset of JavaScript that adds types.

Two popular tools that provide type checking on Python source files are mypy and Pyright.

The remainder of this section focuses on Python type checking.

Python type specifications are referred to as "type hints." The python interpreter ignores type hints, but they make startup time take slightly longer. They are useful as documentation, even without using a type checker. IDEs can use them to flag type issues.

The primitive types supported are:

The collection types supported are:

Other types supported are:

All types above whose names begin with a capital letter must be imported from the "typing" module. For example, from typing import Any, List. Python 3.9 is supposed to make this unnecessary, but perhaps mypy does not yet support the new type syntax.

The Union type can be used in collection types to allow elements to have a set of types.

Aliases can be defined for long type descriptions. This is useful when the same type description is used in many places. For example, IntToStrMap = Dict[int, str].

To add a "type hint" to a variable or function parameter, follow its name with a colon, a space, and the type.

To add a return type hint to a function, follow the argument list right parenthesis with -> and the type.

For example, if IceCream is a class we have defined:

Testing

See Python testing.

Popular Tools/Libraries/Frameworks

Linting

JavaScript

To lint JavaScript using ESLint:

• npm install eslint eslint-plugin-import
• eslint *.js

To configure the rules used by ESLint, create the file .eslintrc.json in project directories or in a user home directory.

For example:

Formatting

To format JavaScript code, use Prettier.

To format Python code, use autopep8 or Black.

To install and run autopep8:

VS Code

The VS Code extension "Python" from Microsoft adds "IntelliSense, linting, debugging, code navigation, code formatting, Jupyter notebook support, refactoring, variable explorer, test explorer, snippets, and more."

Other useful VS Code extensions for Python code include autopep8 and pylint.

Resources

JavaScript Resources

• Node API docs
• npm
• Mozilla Developer Network

Python Resources

• Python home page
• Python Tutorial
• Python Standard Library
• Python Language Reference
• Python HOWTOs
• Python FAQ
• Real Python
• tutororialspoint Learn Python 3