Python vs. JavaScript: A Comparison of Built-in Modules and Core Functionality

This document aims to provide an in-depth comparison of the core built-in modules in Python's "standard library" with JavaScript's built-in objects and Node.js core modules, helping developers understand the design philosophy differences between the two languages in providing basic functionality.

References:

• Comparing Python and JavaScript: A Guide for Developers

---

Core Philosophies and Concepts

• Python: "Batteries Included" Python is famous for its large and feature-complete standard library. A vast number of high-quality modules can be used with a simple import without any extra installation, covering everything from mathematical operations to OS interaction.

• JavaScript: Lightweight Core + Host Environment/Ecosystem JavaScript's core language specification (ECMAScript) is itself very lean. Most of its functionality is provided by the host environment. In a browser, this means the Web APIs; on the server-side, this means Node.js's core modules. For more advanced features, JavaScript relies heavily on the massive npm ecosystem.

Feature Area	Python	JavaScript (& Node.js)
Math Operations	math module	Math global object
Random Numbers	random module	Math.random() (basic), crypto module (more robust)
Date & Time	datetime module (powerful)	Date global object (basic, clunky API)
OS Interaction	os (general), sys (interpreter) modules	os, process (Node.js core modules)
JSON Handling	json module	JSON global object
Regular Expressions	re module	RegExp global object, deeply integrated with string methods
Import Method	Almost all features require import	Core objects are global; Node.js modules require import or require

---

1. Math Operations: math vs. Math

Both provide basic mathematical constants and functions, but the way they are called differs.

Python: math module

Requires importing the math module first.

import math

print(math.pi)          # -> 3.141592653589793
print(math.sqrt(16))    # -> 4.0
print(math.ceil(4.2))   # -> 5
print(math.floor(4.8))  # -> 4

JavaScript: Math global object

Math is a global object and can be used directly without an import.

console.log(Math.PI);          // -> 3.141592653589793
console.log(Math.sqrt(16));    // -> 4
console.log(Math.ceil(4.2));   // -> 5
console.log(Math.floor(4.8));  // -> 4

Core Comparison: Similar feature set, the main difference is Python's explicit import vs. JavaScript's global availability.

---

2. Date & Time: datetime vs. Date

This is an area where the design differences are significant.

Python: datetime module

Powerful and well-designed, providing several specialized classes for handling dates and times.

from datetime import datetime, timedelta

# Get current time
now = datetime.now()
print(now) # -> 2023-10-27 10:30:00.123456

# Format output (strftime)
print(now.strftime("%Y-%m-%d %H:%M:%S")) # -> "2023-10-27 10:30:00"

# Parse from string (strptime)
date_str = "2023-01-01"
dt_obj = datetime.strptime(date_str, "%Y-%m-%d")
print(dt_obj)

# Time calculations
one_day_later = now + timedelta(days=1)
print(one_day_later)

JavaScript: Date global object

The API is relatively basic and clunky, with the month being 0-indexed as a classic "quirk."

// Get current time
const now = new Date();
console.log(now); // -> Fri Oct 27 2023 10:30:00 GMT+...

// Get parts
console.log(now.getFullYear()); // -> 2023
console.log(now.getMonth());    // -> 9 (because October is the 10th month, index 9)

// Formatting (no built-in strftime/strptime)
// Usually requires manual concatenation or using toISOString, toLocaleString, etc.
console.log(now.toISOString()); // -> "2023-10-27T10:30:00.123Z"

// Time calculations
const oneDayLater = new Date(now);
oneDayLater.setDate(now.getDate() + 1);
console.log(oneDayLater);

Core Comparison: Python's datetime is far superior to JS's Date in terms of feature completeness and API friendliness. In the JS ecosystem, date handling often relies heavily on third-party libraries (like date-fns, day.js).

---

3. OS and Process Interaction

Python: os and sys modules

Responsibilities are clearly divided: os is for interacting with the operating system, and sys is for interacting with the Python interpreter.

import os
import sys

# os module
print(os.getcwd())        # Get current working directory
print(os.environ.get("PATH")) # Get an environment variable

# sys module
print(sys.argv)           # Get command-line arguments
print(sys.platform)       # Get the OS platform
# sys.exit(1)               # Exit the program

JavaScript (Node.js): os and process

Node.js concentrates most of this functionality in the os module and the global process object.

import os from 'os';
// 'process' is a global object and doesn't need to be imported
import process from 'process';

// os module
console.log(os.homedir());  // Get user's home directory
console.log(os.platform()); // Get the OS platform

// process object
console.log(process.cwd());   // Get current working directory
console.log(process.argv);    // Get command-line arguments
console.log(process.env.PATH);// Get an environment variable
// process.exit(1);            // Exit the program

Core Comparison: The functionality is highly overlapping, but Python's division of responsibilities is finer. The process object in Node.js plays the role of Python's sys and parts of the os module.

---

4. JSON Handling: json vs. JSON

The functionality is almost identical, serving as a cornerstone for data exchange between languages.

Python: json module

import json

# Python dictionary to JSON string (serialization)
my_dict = {"name": "Alice", "age": 30}
json_string = json.dumps(my_dict, indent=2)
print(json_string)

# JSON string to Python dictionary (deserialization)
parsed_dict = json.loads(json_string)
print(parsed_dict["name"]) # -> "Alice"

JavaScript: JSON global object

// JS object to JSON string (serialization)
const myObj = { name: "Alice", age: 30 };
const jsonString = JSON.stringify(myObj, null, 2); // indent=2
console.log(jsonString);

// JSON string to JS object (deserialization)
const parsedObj = JSON.parse(jsonString);
console.log(parsedObj.name); // -> "Alice"

Core Comparison: The API naming and functionality are almost identical (dumps/stringify, loads/parse). The main difference remains that Python requires an import, while in JS it's globally available.

---

5. Regular Expressions: re vs. RegExp

Python: re module

All regex operations are performed through functions in the re module.

import re

text = "My email is alice@example.com"
match = re.search(r"(\w+)@(\w+\.\w+)", text)

if match:
    print("Match found!")
    print(match.group(0)) # -> "alice@example.com"
    print(match.group(1)) # -> "alice"

JavaScript: RegExp object and string methods

Regular expressions are first-class citizens in JavaScript, can be created with literals, and their core API is integrated into String.prototype.

const text = "My email is alice@example.com";
const regex = /(\w+)@(\w+\.\w+)/;

const match = text.match(regex);

if (match) {
  console.log("Match found!");
  console.log(match[0]); // -> "alice@example.com"
  console.log(match[1]); // -> "alice"
}

Core Comparison: Python centralizes regex functionality in the re module. JavaScript integrates it deeply into the language core and string methods, making the syntax more direct.

---

6. Overview of Python's Standard Library Modules

The following list, based on the official Python Standard Library documentation, aims to showcase Python's "Batteries Included" design philosophy. This stands in stark contrast to JavaScript's lightweight core. The list is extensive, so only a representative selection of modules is shown.

Module	Primary Purpose
A
abc	Support for Abstract Base Classes, used to define interfaces.
argparse	For parsing command-line options, arguments, and sub-commands.
ast	Process Abstract Syntax Trees of Python code.
asyncio	Framework for writing concurrent code using async/await.
atexit	Register cleanup functions to be executed upon interpreter exit.
B
base64	Provides data encoding and decoding in Base16, Base32, Base64.
bisect	Provides binary search algorithms for sorted lists.
builtins	Provides all built-in identifiers like len(), str, Exception.
bz2	Provides support for the bzip2 compression format.
C
calendar	Provides general calendar-related functions.
collections	High-performance alternatives to standard data types (dict, list).
concurrent.futures	High-level interface for asynchronously executing callables.
csv	For reading and writing comma-separated value (CSV) files.
D
dataclasses	Decorator and functions for auto-generating special methods like __init__().
datetime	Basic classes for working with dates and times.
F
functools	Tools for higher-order functions and callable objects.
G
glob	Unix shell-style pathname pattern expansion.
gzip	Support for the gzip compression format.
H
hashlib	Implements a variety of secure hash and message digest algorithms.
http	HTTP client and server implementations.
I
importlib	The implementation of the import statement.
inspect	Provides tools for inspecting live objects.
itertools	Functions creating iterators for efficient looping.
J
json	Encoder and decoder for JSON (JavaScript Object Notation).
L
logging	Flexible event logging system for applications and libraries.
M
multiprocessing	Process-based parallelism support.
O
os	A portable way of using operating system dependent functionality.
P
pathlib	Object-oriented filesystem paths.
pickle	Python object serialization and deserialization.
pprint	"Pretty-prints" data structures to be more readable.
Q
queue	A synchronized queue class for multi-threaded programming.
S
shutil	High-level file operations like copying, moving, and deleting.
socket	Low-level networking interface (BSD sockets).
sqlite3	A DB-API 2.0 compliant interface for SQLite databases.
ssl	TLS/SSL wrapper for socket objects.
subprocess	Spawn new processes, connect to their I/O/error pipes.
sys	Access to system-specific parameters and functions.
T
tempfile	Generate temporary files and directories.
threading	Thread-based parallelism support.
U
unittest	The Python unit testing framework.
urllib.parse	For breaking URL strings into components.
urllib.request	For opening and reading URLs.
V
venv	Creation of lightweight virtual environments.
W
weakref	Support for weak references.
X
xml.etree.ElementTree	Simple and efficient API for parsing and creating XML data.
Z
zipfile	Work with ZIP archives.
zlib	Data compression compatible with gzip.