Learn Python Coding

# Use a hash map for O(1) key lookups and a doubly linked list to manage recency.

III. Stacks & Queues • Largest Rectangle in Histogram:

# Use a monotonic increasing stack to track indices of bars.

• Car Fleet: Calculate the number of car fleets that will arrive at the destination.

# Sort cars by position. Use a stack to merge fleets based on arrival time.

• Asteroid Collision:

# Use a stack to simulate collisions, handling different sizes and directions.

• Decode String (e.g., 3[a2[c]]):

# Use a stack to keep track of counts and previous strings.

• Simplify Path (Unix-style):

# Split by '/' and use a stack to handle '..' and '.'.

• Moving Average from Data Stream:

# Use a `collections.deque` with a fixed `maxlen` to efficiently calculate the sum.

• Basic Calculator II: Implement a calculator with +, -, *, /.

# Use a stack to handle operator precedence, processing `*` and `/` immediately.

IV. Trees & Graphs • Binary Tree Zigzag Level Order Traversal:

# BFS with a deque. Alternate the direction of appending to the level result list.

• Construct Binary Tree from Preorder and Inorder Traversal:

# Use preorder to find the root and inorder to find the left/right subtrees. Recurse.

• Populating Next Right Pointers in Each Node:

# Use level-order traversal (BFS) or a clever DFS/recursive approach.

• Binary Tree Maximum Path Sum:

# Recursive DFS. At each node, return the max path down, but update a global max with the full path through that node.

• Balanced Binary Tree Check:

# DFS. For each node, get the height of left/right subtrees. If diff > 1, it's unbalanced.

• Symmetric Tree: Check if a tree is a mirror of itself.

# Use a recursive helper function that compares two nodes `is_mirror(t1, t2)`.

• Path Sum II: Find all root-to-leaf paths that sum to a target.

# Backtracking (DFS) with a path list and current sum.

• Validate IP Address:

# String parsing with careful checks for IPv4 (numeric ranges) and IPv6 (hex, length).

• Find Leaves of Binary Tree: Collect leaves, remove them, repeat.

# Use a modified DFS that returns the height of a node. Group nodes by height.

• Graph Valid Tree: Check if a graph is a valid tree.

# A valid tree has `n-1` edges and is fully connected (no cycles). Use DFS/BFS or Union-Find.

• Pacific Atlantic Water Flow:

# Start DFS/BFS from all cells on the ocean borders and find the intersection of reachable cells.

• Redundant Connection: Find a redundant edge in a graph that makes a cycle.

# Use Union-Find. The first edge that connects two nodes already in the same set is redundant.

• Network Delay Time: Find the time for a signal to reach all nodes.

# Dijkstra's algorithm to find the shortest path from the source to all other nodes.

• Cheapest Flights Within K Stops:

# Modified Dijkstra's or Bellman-Ford, keeping track of the number of stops.

• Alien Dictionary: Find the order of characters from a sorted list of words.

# Build a dependency graph, then perform a topological sort.

V. Dynamic Programming & Recursion • Decode Ways: Number of ways to decode a string of digits.

# DP: `dp[i]` is the number of ways to decode `s[:i]`. Consider one and two-digit decodings.

• Partition Equal Subset Sum:

# DP (knapsack variation). Check if a subset sums to `total_sum / 2`.

• Best Time to Buy and Sell Stock II: You can buy and sell multiple times.

💡 Top 90 Python Coding Interview Questions (Set 2) (Note: These are distinct from the first set, covering more variations, design questions, and advanced topics. Code snippets are conceptual.) I. Arrays & Matrices • 3Sum: Find all unique triplets that sum to zero.

# Sort the array, then use a two-pointer approach for each element.

• Rotate Image: Rotate an NxN matrix by 90 degrees in-place.

# Transpose the matrix, then reverse each row.

• Set Matrix Zeroes: If an element is 0, set its entire row and column to 0.

# Use the first row/col as markers to avoid extra space.

• Spiral Matrix: Traverse a matrix in a spiral order.

# Use four pointers for boundaries (top, bottom, left, right) and shrink them inward.

• Sort Colors (Dutch National Flag problem): Sort an array of 0s, 1s, and 2s.

# Use three pointers (low, mid, high) to partition in a single pass.

• Find Peak Element: Find an element that is greater than its neighbors.

# Use binary search. Compare mid with its right neighbor to decide which way to go.

• Maximum Product Subarray: Find the max product of a contiguous subarray.

# Track current max and min product because two negatives make a positive.

• Longest Consecutive Sequence: Find the length of the longest run of consecutive numbers.

# Use a hash set for O(1) lookups. Only start counting from the beginning of a sequence.

• Insert Interval: Insert a new interval into a list of non-overlapping intervals.

# Iterate through intervals, add non-overlapping ones, merge with overlapping ones.

• Merge Intervals: Merge all overlapping intervals.

# Sort intervals by start time, then iterate and merge.

• Jump Game: Can you reach the last index?

# Greedy approach. Keep track of the maximum reachable index.

• Next Permutation: Find the next lexicographically greater permutation.

# Find the first decreasing element from the right, swap it with the next largest, then reverse the rest.

• Find the Duplicate Number: Array n+1 integers from 1 to n. Find the one duplicate.

# Use Floyd's Tortoise and Hare (cycle detection) algorithm.

• Word Search: Find a word in a 2D grid of characters.

# Backtracking (DFS) from each cell. Mark visited cells to avoid reuse.

• Task Scheduler: Schedule tasks with a cooling period.

# Greedy approach using a frequency map or a max-heap.

• Is Subsequence: Check if one string is a subsequence of another.

# Simple two-pointer approach.

• Dot Product of Two Sparse Vectors:

# Store non-zero elements in a hash map or list of pairs to optimize.

II. Linked Lists • Remove Duplicates from Sorted List II: Delete all nodes that have duplicate numbers.

# Use a sentinel/dummy head and a predecessor pointer.

• Rotate List: Rotate the list to the right by k places.

# Find length, connect tail to head to make a cycle, then break at the new tail.

• Partition List: Partition around a value x.

# Use two pointers to build two separate lists (less than `x` and >= `x`), then link them.

• Swap Nodes in Pairs: Swap every two adjacent nodes.

# Use careful pointer manipulation with a dummy head.

• Odd Even Linked List: Group odd nodes followed by even nodes.

# Use two pointers, one for the odd list tail and one for the even list tail.

• Flatten a Multilevel Doubly Linked List:

# Use DFS. When a child is found, insert its flattened list between the current node and its next.

• LRU Cache: Design a Least Recently Used cache.

✨ zero-shot learning | AI Coding Glossary ✨ 📖 A machine learning setting where a model handles classes or tasks that were not encountered during training. 🏷️ #Python

✨ inference | AI Coding Glossary ✨ 📖 The phase where a trained model processes new inputs to produce outputs. 🏷️ #Python

• Fetch related ForeignKey objects in the same query.

entries = Entry.objects.select_related('author').all()

• Fetch related ManyToManyField objects in a separate efficient query.

entries = Entry.objects.prefetch_related('tags').all()

• Load only specific model fields.

entries = Entry.objects.only('headline')

• Defer loading of specific model fields.

entries = Entry.objects.defer('body_text')

• Execute raw, unmanaged SQL.

authors = Author.objects.raw('SELECT * FROM myapp_author')

• Get results as a list of tuples.

Entry.objects.values_list('headline', 'pub_date')

XV. Transactions • Import the transaction module.

from django.db import transaction

• Run a block of code within a database transaction.

with transaction.atomic():
    # All database operations here are either committed together or rolled back.
    author.save()
    entry.save()

XVI. Managers & Model Methods • Create a custom Manager for common queries.

class PublishedEntryManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(status='published')

• Add a custom method to a QuerySet via its Manager.

Entry.objects.get_queryset().by_author("John Doe")

• Add a custom method to a model for object-specific logic.

class Entry(models.Model):
    #...
    def is_recent(self):
        return self.pub_date > timezone.now() - timedelta(days=1)

#Python #Django #ORM #Database #Backend ━━━━━━━━━━━━━━━ By: @DataScience4 ✨

entry = Entry.objects.get(pk=1)
entry.rating = 5
entry.save()

• Update multiple objects in a single query.

Entry.objects.filter(pub_date__year=2022).update(rating=0)

• Remove an object from a ManyToManyField.

entry.tags.remove(tag1)

VII. Deleting Objects • Delete a single object.

entry = Entry.objects.get(pk=1)
entry.delete()

• Delete multiple objects in a single query.

Entry.objects.filter(rating=0).delete()

VIII. Spanning Relationships • Filter based on a related model's field.

Entry.objects.filter(author__name="John Doe")

• Use a field lookup on a related model.

Entry.objects.filter(author__name__startswith="John")

• Access related objects from the "one" side of a relationship.

author = Author.objects.get(name="John Doe")
authors_entries = author.entry_set.all()

IX. Aggregation (Requires from django.db.models import ...) • Calculate aggregate values over an entire queryset.

from django.db.models import Avg
avg_rating = Entry.objects.aggregate(Avg('rating'))

• Average (Avg).

Entry.objects.aggregate(average_rating=Avg('rating'))

• Sum (Sum).

Entry.objects.aggregate(total_ratings=Sum('rating'))

• Maximum (Max) and Minimum (Min).

Entry.objects.aggregate(max_r=Max('rating'), min_r=Min('rating'))

• Count (Count).

Entry.objects.aggregate(num_entries=Count('pk'))

• Count distinct values.

Entry.objects.aggregate(num_authors=Count('author', distinct=True))

X. Annotation • Add a calculated field to each object in a queryset.

from django.db.models import Count
authors = Author.objects.annotate(entry_count=Count('entry'))

• Access an annotated value.

for author in authors:
    print(author.name, author.entry_count)

• Get results as a list of dictionaries.

Entry.objects.values('headline', 'author__name')

XI. F() Expressions • Import F() expressions.

from django.db.models import F

• Update a field based on its own value.

Entry.objects.filter(pk=1).update(rating=F('rating') + 1)

• Filter by comparing two fields on the same model.

Entry.objects.filter(rating__gt=F('author__rating'))

XII. Q() Objects • Import Q() objects for complex queries.

from django.db.models import Q

• Create an OR query.

Entry.objects.filter(Q(headline__startswith='A') | Q(headline__startswith='B'))

• Create a NOT query.

Entry.objects.filter(~Q(headline__icontains='boring'))

XIII. QuerySet Evaluation • Get the count of objects efficiently.

count = Entry.objects.count()

• Check if any objects exist efficiently.

exists = Entry.objects.filter(rating=5).exists()

• Get the count (evaluates the full queryset).

count = len(Entry.objects.all())

• Check for existence (evaluates the full queryset).

if Entry.objects.filter(rating=5): # True if queryset is not empty
    ...

• Iteration (evaluates the queryset).

for entry in Entry.objects.all():
    print(entry.headline)

XIV. Optimization

💡 Top 70 Django ORM Operations I. Model Definition (in models.py) • Define a character field.

from django.db import models
name = models.CharField(max_length=100)

• Define a foreign key relationship (many-to-one).

author = models.ForeignKey('Author', on_delete=models.CASCADE)

• Define a many-to-many relationship.

tags = models.ManyToManyField('Tag')

• Define a model's Meta class for default ordering.

class Meta:
    ordering = ['-pub_date']

• Define the string representation of an object.

def __str__(self):
    return self.headline

II. Creating Objects • Create and save an object in one step.

entry = Entry.objects.create(headline="New Title", author=some_author)

• Create an instance and save it separately.

new_author = Author(name="John Doe")
new_author.save()

• Create multiple objects in a single query.

Author.objects.bulk_create([Author(name="A"), Author(name="B")])

• Add an object to a ManyToManyField.

entry.tags.add(tag1, tag2)

III. Retrieving Objects (Basic QuerySets) • Retrieve all objects.

all_entries = Entry.objects.all()

• Retrieve a single object by a unique constraint (e.g., PK).

entry = Entry.objects.get(pk=1)

• Filter objects that match criteria.

entries = Entry.objects.filter(pub_date__year=2023)

• Exclude objects that match criteria.

entries = Entry.objects.exclude(headline__startswith="Old")

• Get the first object from a queryset.

first_entry = Entry.objects.order_by('pub_date').first()

• Get the last object from a queryset.

last_entry = Entry.objects.order_by('pub_date').last()

• Get an object, or create it if it doesn't exist.

obj, created = Author.objects.get_or_create(name="Unique Name")

IV. Field Lookups for Filtering • Exact match (case-sensitive).

Entry.objects.filter(headline__exact="Hello World")

• Case-insensitive exact match.

Entry.objects.filter(headline__iexact="hello world")

• Case-sensitive contains.

Entry.objects.filter(headline__contains="World")

• Case-insensitive contains.

Entry.objects.filter(headline__icontains="world")

• Match against a list of values.

Entry.objects.filter(pk__in=[1, 3, 5])

• Greater than (__gt) or greater than or equal (__gte).

Entry.objects.filter(rating__gt=4)

• Less than (__lt) or less than or equal (__lte).

Entry.objects.filter(rating__lte=3)

• Starts with or ends with a string.

Entry.objects.filter(headline__startswith="The")

• Match within a range.

Entry.objects.filter(pub_date__range=["2023-01-01", "2023-03-31"])

• Filter by a date component.

Entry.objects.filter(pub_date__year=2023, pub_date__month=5)

• Check if a field is NULL.

Entry.objects.filter(pub_date__isnull=True)

V. Slicing & Ordering QuerySets • Slice a queryset (similar to Python lists).

first_ten = Entry.objects.all()[:10]

• Order results in ascending order.

Entry.objects.order_by('headline')

• Order results in descending order.

Entry.objects.order_by('-pub_date')

• Order results randomly.

Entry.objects.order_by('?')

VI. Modifying Objects • Update a single object's fields.

@app.post("/uploadfile/")
async def create_upload_file(file: UploadFile = File(...)):
    return {"filename": file.filename, "content_type": file.content_type}

• Set a response cookie.

from fastapi import Response
@app.post("/cookie/")
def create_cookie(response: Response):
    response.set_cookie(key="fakesession", value="fake-cookie-session-value")
    return {"message": "Cookie set"}

• Read a request cookie.

from fastapi import Cookie
@app.get("/read-cookie/")
def read_cookie(fakesession: Optional[str] = Cookie(None)):
    return {"session": fakesession}

X. Error Handling & Advanced Responses • Handle HTTPException.

from fastapi import HTTPException
@app.get("/items/{item_id}")
def read_item(item_id: str):
    if item_id not in items_db:
        raise HTTPException(status_code=404, detail="Item not found")

• Return a custom JSONResponse.

from fastapi.responses import JSONResponse
@app.get("/custom/")
def custom_response():
    return JSONResponse(status_code=202, content={"message": "Accepted"})

• Return an HTMLResponse.

from fastapi.responses import HTMLResponse
@app.get("/page", response_class=HTMLResponse)
def read_page():
    return "<h1>Hello World</h1>"

• Define a WebSocket endpoint.

from fastapi import WebSocket
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    await websocket.send_text("Hello from WebSocket")
    await websocket.close()

• Handle a path operation that may not exist.

@app.get("/{full_path:path}")
def read_catch_all(full_path: str):
    return {"path": full_path}

• Mount a static files directory.

from fastapi.staticfiles import StaticFiles
app.mount("/static", StaticFiles(directory="static"), name="static")

• Add a custom exception handler.

from fastapi import Request
from fastapi.responses import JSONResponse

class MyCustomException(Exception): pass

@app.exception_handler(MyCustomException)
async def custom_exception_handler(request: Request, exc: MyCustomException):
    return JSONResponse(status_code=418, content={"message": "I'm a teapot"})

• Read a request header.

from fastapi import Header
@app.get("/headers/")
async def read_headers(user_agent: Optional[str] = Header(None)):
    return {"User-Agent": user_agent}

• Get a raw Request object.

from fastapi import Request
@app.get("/request-info")
def get_request_info(request: Request):
    return {"client_host": request.client.host}

#Python #FastAPI #API #WebDevelopment #Pydantic ━━━━━━━━━━━━━━━ By: @DataScience4 ✨

• Define a simple function dependency.

from fastapi import Depends
async def common_parameters(q: Optional[str] = None):
    return {"q": q}

• Inject a dependency into an endpoint.

@app.get("/users/")
async def read_users(commons: dict = Depends(common_parameters)):
    return commons

• Create a dependency with yield (for setup/teardown).

async def get_db():
    db = DBSession()
    try:
        yield db
    finally:
        db.close()

• Use a class as a dependency.

class CommonQueryParams:
    def __init__(self, q: Optional[str] = None):
        self.q = q

@app.get("/search/")
async def search(commons: CommonQueryParams = Depends()):
    return commons

VI. Security • Setup OAuth2 password flow.

from fastapi.security import OAuth2PasswordBearer
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

• Protect an endpoint with a security dependency.

@app.get("/users/me")
async def read_users_me(token: str = Depends(oauth2_scheme)):
    return {"token": token}

• Get the current authenticated user.

async def get_current_user(token: str = Depends(oauth2_scheme)):
    # logic to get user from token
    return user

@app.get("/users/me")
async def read_users_me(current_user: User = Depends(get_current_user)):
    return current_user

VII. Advanced Routing • Create an APIRouter.

from fastapi import APIRouter
router = APIRouter()
@router.get("/users/")
def get_users():
    return [{"username": "user1"}]

• Include a router in the main app.

app.include_router(router, prefix="/api/v1", tags=["users"])

• Add tags to endpoints for documentation.

@app.get("/items/", tags=["items"])

• Add a summary and description to an endpoint.

@app.get("/", summary="Root Endpoint", description="Returns a welcome message.")

• Deprecate an endpoint.

@app.get("/old-path", deprecated=True)

VIII. Middleware, Events & Background Tasks • Create an app startup event.

@app.on_event("startup")
async def startup_event():
    print("Application startup")

• Create an app shutdown event.

@app.on_event("shutdown")
def shutdown_event():
    print("Application shutdown")

• Add custom middleware.

from fastapi import Request
@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

• Define a background task.

from fastapi import BackgroundTasks
def write_notification(email: str, message=""):
    # send email logic
    pass

• Add a background task to an endpoint.

@app.post("/send/{email}")
def send_notification(email: str, background_tasks: BackgroundTasks):
    background_tasks.add_task(write_notification, email, message="some notification")
    return {"message": "Notification sent"}

IX. Handling Forms, Files & Cookies • Handle form data.

from fastapi import Form
@app.post("/login/")
def login(username: str = Form(...), password: str = Form(...)):
    return {"username": username}

• Handle file uploads.

from fastapi import File, UploadFile
@app.post("/files/")
async def create_file(file: bytes = File(...)):
    return {"file_size": len(file)}

• Handle UploadFile (better for large files).

💡 Top 50 FastAPI Operations in Python I. Basic App & Routing • Create a FastAPI instance.

from fastapi import FastAPI
app = FastAPI()

• Define a GET endpoint.

@app.get("/")
def read_root():
    return {"Hello": "World"}

• Define a POST endpoint.

@app.post("/items/")
def create_item(item: dict):
    return item

• Define a path parameter.

@app.get("/items/{item_id}")
def read_item(item_id: int):
    return {"item_id": item_id}

• Define a query parameter.

@app.get("/search/")
def search_items(q: str):
    return {"query": q}

• Define an optional query parameter.

from typing import Optional
@app.get("/list/")
def list_items(skip: int = 0, limit: Optional[int] = None):
    return {"skip": skip, "limit": limit}

II. Request Body & Pydantic Models • Create a Pydantic model for request body.

from pydantic import BaseModel
class Item(BaseModel):
    name: str
    price: float

• Use a Pydantic model in a POST request.

@app.post("/items/")
def create_item(item: Item):
    return item

• Use a Pydantic model with a path parameter.

@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    return {"item_id": item_id, **item.dict()}

• Define a nested Pydantic model.

class User(BaseModel):
    username: str
class FullItem(Item):
    owner: User

III. Data Validation & Metadata • Add validation to a query parameter.

from fastapi import Query
@app.get("/items/")
def read_items(q: str = Query(..., min_length=3, max_length=50)):
    return {"q": q}

• Add validation to a path parameter.

from fastapi import Path
@app.get("/users/{user_id}")
def read_user(user_id: int = Path(..., gt=0, le=1000)):
    return {"user_id": user_id}

• Add metadata (title, description) to a parameter.

q: str = Query(None, title="Search Query", description="Query string")

• Provide an example for a Body field.

from fastapi import Body
item: Item = Body(..., example={"name": "Foo", "price": 35.4})

• Use an alias for a model field.

from pydantic import Field
class Item(BaseModel):
    item_name: str = Field(..., alias="itemName")

IV. Response Models & Status Codes • Set a response status code.

from fastapi import status
@app.post("/items/", status_code=status.HTTP_201_CREATED)
def create_item(item: Item):
    return item

• Use response_model to filter output.

class ItemOut(BaseModel):
    name: str
@app.post("/items/", response_model=ItemOut)
def create_item(item: Item):
    return item

• Exclude fields from response_model.

# Returns all fields from Item model except 'price'
@app.get("/items/{item_id}", response_model=Item, response_model_exclude={"price"})

• Return a direct Response.

from fastapi import Response
@app.get("/legacy/")
def get_legacy_data():
    return Response(content="<data>some legacy xml</data>", media_type="application/xml")

V. Dependencies

✨ A Close Look at a FastAPI Example Application ✨ 📖 Set up an example FastAPI app, add path and query parameters, and handle CRUD operations with Pydantic for clean, validated endpoints. 🏷️ #intermediate #api #web-dev

✨ Quiz: A Close Look at a FastAPI Example Application ✨ 📖 Practice FastAPI basics with path parameters, request bodies, async endpoints, and CORS. Build confidence to design and test simple Python web APIs. 🏷️ #intermediate #api #web-dev

✨ vector database | AI Coding Glossary ✨ 📖 A data system optimized for storing and retrieving embedding vectors. 🏷️ #Python

✨ embedding | AI Coding Glossary ✨ 📖 A learned vector representation that maps discrete items, such as words, sentences, documents, images, or users, into a continuous space. 🏷️ #Python

✨ LlamaIndex | AI Coding Tools ✨ 📖 A high-level framework for building RAG and agentic applications. 🏷️ #Python

from nltk.corpus import stopwords
# nltk.download('stopwords') # Run once
stop_words = set(stopwords.words('english'))
filtered = [w for w in words if not w.lower() in stop_words]

VII. Word Normalization (Stemming & Lemmatization) • Stemming (reduce words to their root form).

from nltk.stem import PorterStemmer
ps = PorterStemmer()
stemmed = ps.stem("running") # 'run'

• Lemmatization (reduce words to their dictionary form).

from nltk.stem import WordNetLemmatizer
# nltk.download('wordnet') # Run once
lemmatizer = WordNetLemmatizer()
lemma = lemmatizer.lemmatize("better", pos="a") # 'good'

VIII. Advanced NLP Analysis (Requires pip install spacy and python -m spacy download en_core_web_sm) • Part-of-Speech (POS) Tagging.

import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("Apple is looking at buying a U.K. startup.")
for token in doc: print(token.text, token.pos_)

• Named Entity Recognition (NER).

for ent in doc.ents:
    print(ent.text, ent.label_) # Apple ORG, U.K. GPE

• Get word frequency distribution.

from nltk.probability import FreqDist
fdist = FreqDist(word_tokenize("this is a test this is only a test"))

IX. Text Formatting & Encoding • Format strings with f-strings.

name = "Alice"
age = 30
message = f"Name: {name}, Age: {age}"

• Pad a string with leading zeros.

number = "42".zfill(5) # '00042'

• Encode a string to bytes.

byte_string = "hello".encode('utf-8')

• Decode bytes to a string.

original_string = byte_string.decode('utf-8')

X. Text Vectorization (Requires pip install scikit-learn) • Create a Bag-of-Words (BoW) model.

from sklearn.feature_extraction.text import CountVectorizer
corpus = ["This is the first document.", "This is the second document."]
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(corpus)

• Get feature names (the vocabulary).

print(vectorizer.get_feature_names_out())

• Create a TF-IDF model.

from sklearn.feature_extraction.text import TfidfVectorizer
tfidf_vectorizer = TfidfVectorizer()
tfidf_matrix = tfidf_vectorizer.fit_transform(corpus)

XI. More String Utilities • Center a string within a width.

centered = "Hello".center(20, '-') # '-------Hello--------'

• Check if a string is in title case.

"This Is A Title".istitle() # True

• Find the highest index of a substring.

"test test".rfind("test") # Returns 5

• Split from the right.

"path/to/file.txt".rsplit('/', 1) # ['path/to', 'file.txt']

• Create a character translation table.

table = str.maketrans('aeiou', '12345')
vowels_to_num = "hello".translate(table) # 'h2ll4'

• Remove a specific prefix.

"TestCase".removeprefix("Test") # 'Case'

• Remove a specific suffix.

"filename.txt".removesuffix(".txt") # 'filename'

• Check for unicode decimal characters.

"½".isdecimal() # False
"123".isdecimal() # True

• Check for unicode numeric characters.

"½".isnumeric() # True
"²".isnumeric() # True

#Python #TextProcessing #NLP #RegEx #NLTK ━━━━━━━━━━━━━━━ By: @DataScience4 ✨

💡 Top 50 Operations for Text Processing in Python I. Case & Whitespace Manipulation • Convert to lowercase.

text = "Hello World"
lower_text = text.lower()

• Convert to uppercase.

upper_text = text.upper()

• Capitalize the first letter of the string.

capitalized = "hello world".capitalize()

• Convert to title case (each word starts with a capital).

title_text = "hello world".title()

• Swap character case.

swapped = "Hello World".swapcase()

• Remove leading and trailing whitespace.

padded_text = "  hello  "
stripped_text = padded_text.strip()

• Remove leading whitespace.

left_stripped = padded_text.lstrip()

• Remove trailing whitespace.

right_stripped = padded_text.rstrip()

II. Searching, Replacing & Counting • Find the first index of a substring.

index = "hello world".find("world") # Returns 6

• Check if a string starts with a substring.

starts_with_hello = text.startswith("Hello") # True

• Check if a string ends with a substring.

ends_with_world = text.endswith("World") # True

• Replace a substring with another.

new_text = text.replace("World", "Python")

• Count occurrences of a substring.

count = "hello hello".count("hello") # Returns 2

III. Splitting & Joining • Split a string into a list of words.

words = text.split(' ') # ['Hello', 'World']

• Join a list of strings into a single string.

word_list = ["Hello", "Python"]
joined_text = " ".join(word_list)

• Split a string into lines.

multiline = "line one\nline two"
lines = multiline.splitlines()

• Partition a string at the first occurrence of a separator.

parts = "user@domain.com".partition('@') # ('user', '@', 'domain.com')

IV. Character & String Checks • Check if all characters are alphabetic.

"HelloWorld".isalpha() # True

• Check if all characters are digits.

"12345".isdigit() # True

• Check if all characters are alphanumeric.

"Python3".isalnum() # True

• Check if all characters are whitespace.

"  \t\n".isspace() # True

V. Regular Expressions (re module) • Find the first match of a pattern.

import re
match = re.search(r'\d+', 'There are 10 apples.')

• Find all matches of a pattern.

numbers = re.findall(r'\d+', '10 apples and 20 oranges')

• Substitute a pattern with a replacement string.

no_digits = re.sub(r'\d', '#', 'My pin is 1234')

• Split a string by a regex pattern.

items = re.split(r'[,;]', 'apple,banana;cherry')

VI. Basic NLP - Tokenization & Cleaning (Requires pip install nltk) • Sentence Tokenization.

from nltk.tokenize import sent_tokenize
# nltk.download('punkt') # Run once
text = "Hello Mr. Smith. How are you?"
sentences = sent_tokenize(text)

• Word Tokenization.

from nltk.tokenize import word_tokenize
words = word_tokenize("Hello, how are you?")

• Remove punctuation.

import string
text = "A string with... punctuation!"
clean = text.translate(str.maketrans('', '', string.punctuation))

• Remove stop words.