NLP Tutorial: Natural Language Processing with Python Code

NLP Tutorial

Learning Natural Language Processing (NLP) with practical Python examples is a great way to understand how machines can work with human language. NLP combines artificial intelligence, machine learning, and linguistics to help computers process, analyze, and understand text.

This tutorial provides a practical roadmap for learning NLP with Python. It starts with basic text processing and gradually moves toward named entity recognition, sentiment analysis, text classification, word embeddings, and transformer-based models.

Complete Advance AI Topics: Click Here
SQL Tutorial: Click Here

Set Up Your Environment

Before starting with NLP, install the required Python libraries. The following command installs the main packages used throughout this tutorial:

pip install numpy pandas nltk spacy tensorflow textblob transformers gensim

These libraries provide tools for text processing, machine learning, deep learning, sentiment analysis, word embeddings, and modern transformer-based NLP applications.

1. Basic Text Processing with NLTK

NLTK (Natural Language Toolkit) is one of the commonly used Python libraries for learning and working with natural language data. It provides tools for tasks such as tokenization and stemming.

In the following example, the sentence is divided into individual words using tokenization. The Porter Stemmer is then used to reduce words to their stemmed forms.

import nltk
from nltk.tokenize import word_tokenize
from nltk.stem import PorterStemmer

nltk.download('punkt')

text = "Learning NLP is exciting!"
words = word_tokenize(text)

stemmer = PorterStemmer()
stemmed_words = [stemmer.stem(w) for w in words]

print(stemmed_words)

This is a useful starting point for understanding how NLP systems process raw text before applying more advanced techniques.

2. Named Entity Recognition with SpaCy

Named Entity Recognition (NER) is an NLP technique used to identify important entities within text. These entities can include organizations, people, locations, dates, and other categories depending on the model being used.

SpaCy provides an easy way to perform NER using a pre-trained language model. The following example identifies entities from a sentence:

import spacy

nlp = spacy.load("en_core_web_sm")

doc = nlp("Apple is a tech company headquartered in Cupertino.")

for ent in doc.ents:
    print(ent.text, ent.label_)

The model processes the sentence and returns the detected entities along with their corresponding labels.

3. Sentiment Analysis with TextBlob

Sentiment analysis is used to determine the general sentiment expressed in a piece of text. It can be useful for analyzing customer feedback, product reviews, social media content, and other types of written communication.

TextBlob provides a simple way to experiment with sentiment analysis in Python. In the example below, the polarity score indicates the sentiment of the given sentence.

from textblob import TextBlob

blob = TextBlob("I love this product! It is amazing.")

print(blob.sentiment.polarity)  # > 0 = positive

A positive polarity indicates positive sentiment, while negative values generally indicate negative sentiment.

4. Text Classification with TensorFlow

Text classification is an important NLP task where text is assigned to predefined categories. It can be used for applications such as sentiment classification, spam detection, and document categorization.

TensorFlow can be used to build deep learning models for text classification. The following example demonstrates a basic model using an embedding layer, an LSTM layer, and a dense output layer:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense

model = Sequential([
    Embedding(vocab_size, 64, input_length=max_len),
    LSTM(128),
    Dense(1, activation='sigmoid')
])

model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

model.fit(
    train_data,
    train_labels,
    epochs=10,
    validation_data=(val_data, val_labels)
)

The LSTM layer allows the model to process sequences of text, while the sigmoid output can be used for binary classification tasks.

5. Word Embeddings with Word2Vec

Word embeddings represent words as numerical vectors that can capture useful relationships between words. Word2Vec is a popular approach for creating these representations.

With Gensim, you can train a Word2Vec model using a collection of sentences. The following example creates a simple model:

from gensim.models import Word2Vec

sentences = [
    ["I", "love", "NLP"],
    ["Natural", "Language", "Processing"]
]

model = Word2Vec(
    sentences,
    vector_size=100,
    window=5,
    min_count=1,
    sg=0
)

print(model.wv["NLP"])

The resulting vector represents the word NLP in the learned embedding space.

6. Transformers with Hugging Face

Transformer models have become an important part of modern NLP. They can be used for a wide range of language tasks, including sentiment analysis, text generation, question answering, translation, and classification.

The Hugging Face Transformers library provides convenient interfaces for working with pre-trained transformer models. For example, a sentiment-analysis pipeline can be created with just a few lines of Python:

from transformers import pipeline

nlp_pipeline = pipeline("sentiment-analysis")

print(nlp_pipeline("I'm having a great day!"))

This example uses a pre-trained model to analyze the sentiment of the provided sentence. Transformer pipelines make it easier for beginners to experiment with modern NLP models without building a complete model from scratch.

YT:- DecodeIT

Conclusion

Natural Language Processing with Python provides a practical path toward building applications that can work with human language. Beginners can start with fundamental text-processing techniques using NLTK and then move toward more advanced tasks such as named entity recognition and sentiment analysis.

As your understanding grows, deep learning frameworks such as TensorFlow can be introduced for text classification, while Word2Vec provides an introduction to numerical word representations. Finally, transformer models through Hugging Face can help you explore modern NLP applications.

By following this roadmap and practicing each concept with Python code, you can gradually build a strong foundation in NLP and move toward more advanced artificial intelligence applications.

Keywords

nlp python tutorial, natural language processing python, NLTK tutorial, SpaCy NLP, Hugging Face Transformers tutorial, sentiment analysis Python, Word2Vec Python, NLP roadmap 2026, Python NLP, natural language processing tutorial, NLP with Python, AI NLP tutorial,Natural Language Processing