Logo
Tutorials Articles Code Playground
Sign In Get Started
Module: Libraries

Standard Libraries

Python Standard Libraries

Python comes with a rich set of built-in modules, known as the standard library. These modules provide a wide range of functionalities, eliminating the need to install external packages for many common tasks. Here's a breakdown of some of the most useful and frequently used standard libraries, categorized for clarity.

1. Core Functionality & Data Structures

  • builtins: This module provides access to built-in functions and constants available in all Python environments (e.g., print(), len(), int(), str(), True, False, None). You don't explicitly import it.
  • sys: Provides access to system-specific parameters and functions. Useful for interacting with the Python runtime environment.
    • sys.argv: List of command-line arguments.
    • sys.exit(): Exits the program.
    • sys.path: List of directories Python searches for modules.
    • sys.version: Python version information.
  • math: Mathematical functions.
    • math.sqrt(): Square root.
    • math.sin(), math.cos(), math.tan(): Trigonometric functions.
    • math.pi: The value of pi.
    • math.log(): Natural logarithm.
  • datetime: Working with dates and times.
    • datetime.datetime: Represents a specific date and time.
    • datetime.date: Represents a date.
    • datetime.time: Represents a time.
    • datetime.timedelta: Represents a duration or difference between dates/times.
  • collections: Container datatypes beyond lists, tuples, dictionaries, and sets.
    • collections.Counter: Counts hashable objects.
    • collections.deque: Double-ended queue (efficient for appending and popping from both ends).
    • collections.namedtuple: Creates tuple-like objects with named fields.
    • collections.defaultdict: Dictionary that calls a factory function to supply missing values.
  • random: Generating pseudo-random numbers.
    • random.random(): Returns a random float between 0.0 and 1.0.
    • random.randint(a, b): Returns a random integer between a and b (inclusive).
    • random.choice(seq): Returns a random element from a sequence.
    • random.shuffle(x): Shuffles a list in place.

2. File & I/O Operations

  • os: Operating system interfaces. Provides functions for interacting with the operating system (e.g., file system navigation, process management).
    • os.getcwd(): Get the current working directory.
    • os.chdir(path): Change the current working directory.
    • os.listdir(path): List files and directories in a directory.
    • os.path.join(path1, path2, ...): Join path components intelligently.
    • os.remove(path): Delete a file.
    • os.mkdir(path): Create a directory.
  • io: Working with various types of I/O streams (text, binary).
  • shutil: High-level file operations (copying, moving, archiving).
    • shutil.copyfile(src, dst): Copy a file.
    • shutil.move(src, dst): Move a file or directory.
  • csv: Reading and writing CSV (Comma Separated Values) files.
  • json: Working with JSON (JavaScript Object Notation) data.
    • json.dumps(obj): Convert a Python object to a JSON string.
    • json.loads(s): Convert a JSON string to a Python object.

3. Networking & Web

  • socket: Low-level networking interface.
  • http: HTTP-related modules (e.g., http.client for making HTTP requests).
  • urllib: Working with URLs. Includes modules for fetching data from the web.
    • urllib.request: Opening and reading URLs.
    • urllib.parse: Parsing URLs.
  • email: Creating and sending email messages.

4. Data Processing & Text Manipulation

  • re: Regular expressions. Powerful for pattern matching in strings.
  • string: String constants and utilities.
    • string.ascii_letters: String containing all ASCII letters.
    • string.digits: String containing all digits.
  • textwrap: Formatting text. Useful for wrapping long lines of text.

5. Other Useful Libraries

  • logging: Flexible event logging system. Important for debugging and monitoring.
  • argparse: Parsing command-line arguments. Makes it easy to create user-friendly command-line interfaces.
  • unittest: Unit testing framework. For writing and running tests to ensure code quality.
  • time: Time-related functions.
    • time.sleep(seconds): Pauses execution for a specified number of seconds.
    • time.time(): Returns the current time in seconds since the epoch.
  • copy: Shallow and deep copy operations. Useful for creating independent copies of objects.
  • pickle: Serializing and deserializing Python objects. Allows you to save and load Python data structures.

How to Import Modules

You import modules using the import statement:

import math

# Use functions from the math module
result = math.sqrt(16)
print(result)  # Output: 4.0

You can also import specific functions or classes from a module:

from datetime import datetime

# Use the datetime class directly
now = datetime.now()
print(now)

Or import a module with an alias:

import random as rnd

# Use the random module with the alias 'rnd'
random_number = rnd.randint(1, 10)
print(random_number)

Where to find more information:

This is not an exhaustive list, but it covers many of the most commonly used standard libraries in Python. Exploring the official documentation is highly recommended to discover the full range of capabilities available to you. Using the standard library effectively can significantly reduce development time and improve code maintainability.