I have been wanting to try ChatGPT for a long time and finally thought to give it a try. So, I asked top 10 python libraries that all developers must know in 2023 and below is the list that ChatGPT gave. I must say that the results are pretty darn good!

Disclaimer: This list is not conclusive, as different libraries may be more suited for different tasks, and the popularity of libraries can change over time.

Top 10 Python Libraries

Before we begin, you should know that ChatGPT is written in Python. It is a language model that utilizes the open-source machine learning library, PyTorch. It uses the transformer architecture, which was introduced in the paper “Attention is All You Need” by Google researchers. The model is trained on a large dataset of text, such as books, articles and websites, and can generate human-like text based on the input it receives.

So without further delay let us look at the results.


TensorFlow is an open-source library for machine learning and deep learning developed by Google Brain Team. It allows developers to create and train various types of neural networks, including convolutional neural networks (CNNs), recurrent neural networks (RNNs), and long short-term memory (LSTM) networks, among others. TensorFlow also provides a variety of tools for visualizing and analyzing the performance of neural networks.

Here’s an example of how to use TensorFlow to train a simple neural network for image classification:

Copy codeimport tensorflow as tf

# Load the MNIST dataset
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# Normalize the data
x_train = tf.keras.utils.normalize(x_train, axis=1)
x_test = tf.keras.utils.normalize(x_test, axis=1)

# Create a model
model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Flatten())  # flatten input
model.add(tf.keras.layers.Dense(128, activation=tf.nn.relu))  # hidden layer
model.add(tf.keras.layers.Dense(10, activation=tf.nn.softmax))  # output layer

# Compile the model
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# Train the model
model.fit(x_train, y_train, epochs=3)

# Evaluate the model
val_loss, val_acc = model.evaluate(x_test, y_test)
print(val_loss, val_acc)

In this example, we use the TensorFlow library to load the MNIST dataset, which is a dataset of handwritten digits. We then normalize the data and create a simple neural network using the Sequential model and the Dense layer. We then compile the model, train it on the training data, and evaluate its performance on the test data.


NumPy is a library for the Python programming language, adding support for large, multi-dimensional arrays and matrices, along with a large collection of high-level mathematical functions to operate on these arrays.

Here’s an example of how to use NumPy to create a 2-dimensional array, perform some mathematical operations on it, and then index and slice it:

Copy codeimport numpy as np

# Create a 2-dimensional array
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Perform mathematical operations on the array
b = np.sin(a)
c = a + b

# Index and slice the array
print(c[1, 1])  # prints 5.7833270901
print(c[:, 1])  # prints [ 1.90929743  5.78332709  8.6569866 ]

In this example, we use the array function from NumPy to create a 2-dimensional array, and then perform some mathematical operations like sine and addition on it. we also access and slice the array by specifying the indices of the elements we want to access or slice.

NumPy is widely used in scientific computing, data manipulation, and data analysis. It can also be integrated with other libraries like pandas, scikit-learn, matplotlib etc.


Pandas is a library for the Python programming language for data manipulation and analysis. It provides data structures such as Series (1-dimensional) and DataFrame (2-dimensional) to handle and manipulate data in an easy and efficient way.

Here’s an example of how to use Pandas to load a CSV file, display the first few rows, and perform some basic data manipulation:

import pandas as pd

# Load a CSV file
data = pd.read_csv('data.csv')

# Display the first few rows

# Perform data manipulation
data['Total'] = data['Column1'] + data['Column2']
data.sort_values(by='Total', ascending=False, inplace=True)

# Display the updated data

In this example, we use the read_csv function from Pandas to load a CSV file into a DataFrame, then we display the first few rows of the DataFrame using head() function. Next, we perform some basic data manipulation, like adding a new column ‘Total’ and sorting the data based on ‘Total’ value in descending order.

Pandas is widely used in data analysis, data cleaning, and data manipulation tasks. It can also be integrated with other libraries like NumPy, Matplotlib, Scikit-learn, etc.


Matplotlib is a plotting library for the Python programming language. It provides an object-oriented API for embedding plots into applications using general-purpose GUI toolkits like Tkinter, wxPython, Qt, or GTK. It supports various types of plots like line plots, scatter plots, bar plots, histograms, etc.

Here’s an example of how to use Matplotlib to create a simple line plot:

import matplotlib.pyplot as plt
import numpy as np

# Generate some data
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Create a figure and axes
fig, ax = plt.subplots()

# Plot the data
ax.plot(x, y)

# Add labels and title
ax.set(xlabel='X-axis', ylabel='Y-axis', title='Simple Line Plot')

# Show the plot

In this example, we use the linspace function from NumPy to generate some data, then we create a figure and axes using plt.subplots(). Next, we plot the data using the plot function, add labels and title to the axes and finally we show the plot using plt.show().

Matplotlib can also be used to create more complex plots like histograms, scatter plots, bar plots, etc. It can also be integrated with other libraries like Pandas, Seaborn, etc. to create more advanced visualizations.


Scikit-learn (also known as sklearn) is a machine learning library for the Python programming language. It provides a variety of tools for tasks such as classification, regression, clustering, model selection, and pre-processing. Scikit-learn is built on top of NumPy and SciPy and is designed to interoperate with the Python numerical and scientific libraries.

Here’s an example of how to use scikit-learn to train a simple linear regression model:

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn import datasets
import numpy as np

# Load the diabetes dataset
X, y = datasets.load_diabetes(return_X_y=True)

# Split the data into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Create a linear regression model
model = LinearRegression()

# Train the model
model.fit(X_train, y_train)

# Make predictions
y_pred = model.predict(X_test)

# Evaluate the model
score = model.score(X_test, y_test)
print("R^2 score: ", score)

In this example, we use scikit-learn to load the diabetes dataset, split it into training and test sets, create a linear regression model, train the model, make predictions and evaluate it using R-squared score.

Scikit-learn also contains a wide variety of algorithms for classification, clustering, and regression, as well as tools for model selection and evaluation. It is widely used in industry and academia for machine learning tasks.


Seaborn is a library for the Python programming language for data visualization. It is built on top of Matplotlib, and provides a higher-level interface for creating statistical graphics. Seaborn provides a variety of plot types like line plots, scatter plots, bar plots, histograms, etc. and it also provides several built-in themes for making attractive, informative visualizations easily.

Here’s an example of how to use Seaborn to create a simple line plot:

import seaborn as sns
import matplotlib.pyplot as plt

# Create a random dataset
x = np.random.normal(size=100)

# Create a line plot

# Add labels and title
plt.title('Simple Line Plot')

# Show the plot

In this example, we use the lineplot function from seaborn to create a simple line plot of a random data that we created. Seaborn also provides a lot of built-in themes and color palettes that can be used to make the plot more attractive. You can customize the plot with different colors, styles, and themes.

Seaborn is widely used for data visualization tasks and it can also be integrated with other libraries like Pandas, Matplotlib, etc. It is particularly useful for creating more complex visualizations like heat maps, violin plots, and pair plots.


The Natural Language Toolkit (NLTK) is a library for the Python programming language for natural language processing (NLP). It provides tools for tasks such as tokenization, stemming, lemmatization, part-of-speech tagging, sentiment analysis, and more. It also includes a collection of texts and corpora, such as the popular “Brown Corpus” and the “Gutenberg Corpus”, which can be used for training and testing NLP models.

Here’s an example of how to use NLTK to tokenize a sentence:

import nltk

# Tokenize a sentence
sentence = "This is a simple sentence."
tokens = nltk.word_tokenize(sentence)
# Output: ['This', 'is', 'a', 'simple', 'sentence', '.']

In this example, we use the word_tokenize function from NLTK to tokenize a sentence into words. We also needed to download the ‘punkt’ package which contains the tokenizer algorithm.

NLTK is widely used in natural language processing tasks, such as text classification, text summarization, language translation, and more. It is also useful for more advanced tasks like named entity recognition, speech tagging, and parsing. It also includes several utilities like stemming, lemmatization, wordnet, stopwords, and many more.


Flask is a micro web framework for the Python programming language. It provides a lightweight and easy-to-use interface for building web applications. It is built on top of the Werkzeug WSGI library and the Jinja2 template engine, and is also compatible with many other libraries and extensions. Flask allows developers to define routes and handlers for requests, and to return responses to the client.

Here’s an example of how to use Flask to create a simple “Hello, World!” web application:

from flask import Flask
app = Flask(__name__)

def hello():
    return 'Hello, World!'

if __name__ == '__main__':

In this example, we import the Flask module and create a new web application using the Flask() constructor. We define a route using the @app.route() decorator, which tells Flask what URL should trigger our function. The function hello() is defined to return the string ‘Hello, World!’. And finally, we run the application using the app.run() method, with the debug=True argument to enable error messages in the browser.

Flask is very simple to use, yet it provides a lot of functionality. It is widely used for building small to medium-sized web applications and web services. Flask is also compatible with many popular libraries and extensions, such as SQLAlchemy for databases, and the Flask-RESTful extension for building RESTful APIs.


PyTorch is an open-source machine learning library for the Python programming language, developed and maintained by Facebook’s AI research lab. It is similar to TensorFlow in terms of functionality and provides a dynamic computational graph, which allows for building and training of neural networks on the fly. PyTorch also includes support for CUDA, which allows for the use of GPUs to accelerate computations.

Here’s an example of how to use PyTorch to train a simple neural network for image classification:

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# Define a simple neural network
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.conv2_drop = nn.Dropout2d()
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)

    def forward(self, x):
        x = F.relu(F.max_pool2d(self.conv1(x), 2))
        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
        x = x.view(-1, 320)
        x = F.relu(self.fc1(x))
        x = F.dropout(x, training=self.training)
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)

# Load the MNIST dataset
train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('data', train=True, download=True,
                       transforms.Normalize((0.1307,), (0.3081,))
    batch_size=64, shuffle=True)

# Define loss function and optimizer
model = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

# Train the model
for epoch in range(10):
    for data, target in train_loader:
        output = model(data)
        loss = criterion(output, target)

print("Training complete!")

In this example, we define a simple convolutional neural network using PyTorch’s nn module, and train it on the MNIST dataset. We use the CrossEntropyLoss loss function and the SGD optimizer to train the model for 10 epochs. PyTorch provides a lot of flexibility when it comes to building and training neural networks, and it also has a large and active community that develops and maintains various libraries and extensions.


Django is a high-level web framework for the Python programming language, developed and maintained by the Django Software Foundation. It is designed to help developers take applications from concept to completion as quickly as possible. It is a Model-View-Controller (MVC) framework that follows the “Don’t Repeat Yourself” (DRY) principle, which encourages the reuse of code by keeping logic separate from presentation.

Here’s an example of how to use Django to create a simple “Hello, World!” web application:

# mysite/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.hello, name='hello'),

# mysite/views.py
from django.http import HttpResponse

def hello(request):
    return HttpResponse("Hello, World!")

In this example, we create a simple Django project “mysite” and create a new file called urls.py, which contains a list of URL patterns for the application. We define a single route for the root URL, which maps to the hello view function. The hello function simply returns the string “Hello, World!” as a response to the client. To run this application we have to start the Django development server and visit the root URL of the application in the browser, it will display the “Hello, World!” on the screen.

Django is widely used for building web applications, and it’s highly customizable and scalable. It has a large and active community, and it provides a lot of useful features out-of-the-box such as authentication, database management, and caching. It also has a built-in administrative interface that is useful for managing the data of the application.


Python is a very powerful programming language and used in almost all tech companies. If you are looking for job opportunities in tech, Python is a must know language. ChatGPT is a testament to how powerful Python as a development language and the open sourced libraries are.

Author: Ralph Bryant is a tech enthusiast who is always curious to learn new tech. You can connect with him on LinkedIn.