DEV Community: Hardik Jariwala

Python Lists vs Tuples vs Sets vs Dictionaries A Beginner-Friendly Guide

Hardik Jariwala — Sat, 05 Sep 2026 07:07:47 +0000

Python Lists vs Tuples vs Sets vs Dictionaries 🐍

If you're learning Python, you've probably run into these four data structures again and again:

List
Tuple
Set
Dictionary

They all store collections of data, but each one has its own personality. Picking the right one makes your code cleaner, faster, and easier to understand.

Let's break them down one by one, with simple examples and real-world analogies no jargon overload. 🚀

1. List 📝 The Flexible To-Do List

A list is an ordered collection that can hold multiple items, and you can change it anytime (add, remove, update).

Think of it like a shopping list you can add items, cross them off, or rearrange them.

fruits = ["apple", "banana", "cherry"]

# Access by index
print(fruits[0])       # apple

# Add an item
fruits.append("mango")
print(fruits)           # ['apple', 'banana', 'cherry', 'mango']

# Update an item
fruits[1] = "blueberry"
print(fruits)           # ['apple', 'blueberry', 'cherry', 'mango']

# Remove an item
fruits.remove("cherry")
print(fruits)           # ['apple', 'blueberry', 'mango']

Key traits:

Ordered (keeps insertion order)
Mutable (changeable)
Allows duplicate values
Written with square brackets [ ]

Use it when: you need an editable, ordered collection like a list of tasks, scores, or usernames.

2. Tuple 🔒 The Locked Box

A tuple looks like a list, but once created, it cannot be changed. It's like a sealed box great for data that should stay constant.

Think of it like your date of birth it shouldn't change once it's set.

coordinates = (10, 20)

print(coordinates[0])   # 10

# This will raise an error!
# coordinates[0] = 15   ❌ TypeError: 'tuple' object does not support item assignment

Key traits:

Ordered
Immutable (cannot be changed after creation)
Allows duplicate values
Written with parentheses ( )
Slightly faster than lists (good for performance-critical code)

Use it when: you want to protect data from accidental changes like GPS coordinates, RGB colors, or fixed configuration values.

3.Set 🎯 The No-Duplicates Club

A set is an unordered collection of unique items. Duplicates are automatically removed.

Think of it like a guest list where no one can enter twice even if you try to add the same name again, it just won't duplicate.


numbers = {1, 2, 3, 3, 2, 1}
print(numbers)           # {1, 2, 3}  → duplicates removed automatically

# Add an item
numbers.add(4)
print(numbers)           # {1, 2, 3, 4}

# Check membership (very fast!)
print(2 in numbers)      # True

# Set operations
a = {1, 2, 3}
b = {3, 4, 5}

print(a | b)   # Union → {1, 2, 3, 4, 5}
print(a & b)   # Intersection → {3}
print(a - b)   # Difference → {1, 2}

Key traits:

Unordered (no guaranteed order, no indexing)
Mutable, but items inside must be immutable (no lists inside sets)
No duplicates allowed
Written with curly braces { }
Super fast for checking "does this exist?"

Use it when: you need to remove duplicates or quickly check membership like unique visitor IDs or tags.

4. Dictionary 📖 The Labeled Drawer System

A dictionary stores data as key-value pairs. Instead of accessing items by position, you access them by a meaningful key.

Think of it like a real dictionary you look up a word (key) to get its meaning (value).


student = {
    "name": "Riya",
    "age": 21,
    "course": "Computer Science"
}

# Access value by key
print(student["name"])     # Riya

# Add a new key-value pair
student["grade"] = "A"
print(student)

# Update a value
student["age"] = 22

# Remove a key-value pair
del student["course"]

print(student)   # {'name': 'Riya', 'age': 22, 'grade': 'A'}

Key traits:

Ordered (insertion order preserved since Python 3.7+)
Mutable
Keys must be unique and immutable (strings, numbers, tuples); values can be anything
Written with curly braces { } and key: value pairs
Extremely fast lookups by key

Use it when: you need labeled, structured data like user profiles, JSON-like data, or configuration settings.

🔍 Quick Comparison Table

Feature	List `[ ]`	Tuple `( )`	Set `{ }`	Dictionary `{k: v}`
Ordered	✅ Yes	✅ Yes	❌ No	✅ Yes (Python 3.7+)
Mutable	✅ Yes	❌ No	✅ Yes	✅ Yes
Duplicates	✅ Allowed	✅ Allowed	❌ Not allowed	❌ Keys unique (values can repeat)
Indexing	✅ By position	✅ By position	❌ Not supported	✅ By key
Syntax	`[1, 2, 3]`	`(1, 2, 3)`	`{1, 2, 3}`	`{"a": 1, "b": 2}`
Best for	Editable, ordered data	Fixed/constant data	Unique items, fast lookup	Labeled key-value data

🧠 How to Choose the Right One

Ask yourself these questions:

1. Do I need to change the data later?
- Yes → List, Set, or Dictionary
- No → Tuple
Does the order of items matter?
- Yes → List, Tuple, or Dictionary
- No → Set
Do I need to look things up by a name/label instead of position?
- Yes → Dictionary
Do I need to eliminate duplicates or do fast membership checks?
- Yes → Set

🎬 Wrapping Up

Here's the one-line summary you can keep in your back pocket:

List → An editable, ordered collection → ["a", "b", "c"]
Tuple → A locked, ordered collection → ("a", "b", "c")
Set → A collection of unique items, no order → {"a", "b", "c"}
Dictionary → A collection of key-value pairs → {"key": "value"}

🚀 Redis Caching in .NET (Memurai on Windows + Docker Recommended)

Hardik Jariwala — Tue, 24 Mar 2026 16:55:43 +0000

Caching is essential for improving performance and scalability in modern applications. This guide shows how to use Redis caching in .NET, including how to run it on Windows using Memurai (without Docker).

🔴 What is Redis?

Redis is an in-memory data store used to cache frequently accessed data, making applications faster by reducing database calls. It serves data instantly on a cache hit and stores new data on a cache miss, improving performance and scalability.

Why use it?
⚡ Fast (RAM-based)
📉 Reduces DB load
🌍 Works across multiple servers
⏱ Supports expiration (TTL)

🧠 How It Works (Cache Aside Pattern)

Request → Check Cache → Return (if found) 
                     ↓ 
                  DB → Save in Cache → Return

📦 Required Packages (.NET)

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis 
dotnet add package Newtonsoft.Json

⚙️ Redis Configuration

builder.Services.AddStackExchangeRedisCache(options => 
{ 
     options.Configuration = "localhost:6379"; 
     options.InstanceName =  "MyApp:";
});

🔥 Caching Implementation (Service Layer)

public class ProductService 
{ 
     private readonly IDistributedCache _cache; 
     public ProductService(IDistributedCache cache) 
     { 
          _cache = cache; 
     } 
     public async Task<List<Product>> GetProducts() 
     { 
         string cacheKey = "product_list"; 
         var cacheData = await _cache.GetStringAsync(cacheKey);
         if (cacheData != null) 
         { 
             Console.WriteLine("Data from Redis");
             return JsonConvert.DeserializeObject<List<Product>>   
(cacheData);
         } 
         Console.WriteLine("Data from DB"); 
         var data = FakeDb.GetProducts(); // Replace with real DB 
         var options = new DistributedCacheEntryOptions 
         { 
             AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5) 
         }; 
         await _cache.SetStringAsync( cacheKey, JsonConvert.SerializeObject(data), options ); 
          return data; 
     } 
}

Run Redis WITHOUT Docker (Windows)

Use Memurai:

Install Memurai
Start service:

Win + R → services.msc → Start "Memurai"

Verify:

memurai-cli ping
Output: `PONG`

Runs on:localhost:6379

🐳 Recommended: Use Docker

Docker (best for production)

docker run -d -p 6379:6379 redis

🔄 Cache Invalidation (Important)

Remove cache manually:

await _cache.RemoveAsync("product_list");

Use expiration:

AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5)

Clear all cache (dev):

memurai-cli flushall

🧠 Best Practices With...

Always set expiry
Use meaningful keys (product_101)
Invalidate cache on update/delete
Avoid caching sensitive data

📡 Real-Time Communication with SignalR in ASP.NET Core Complete Setup Guide

Hardik Jariwala — Tue, 27 May 2025 18:06:14 +0000

Want to build a real-time chat app or push live notifications? In this blog, I’ll walk you through setting up SignalR from scratch using ASP.NET Core and a .NET console client. Perfect for beginners or those revisiting SignalR.

🔧 Step 1: Create the SignalR Server Project

Create an ASP.NET Core Web API project and add package

dotnet add package Microsoft.AspNetCore.SignalR

🧠 Step 2: Create a SignalR Hub

Create a new class ChatHub.cs inside the project:

using Microsoft.AspNetCore.SignalR;

public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

🌐 Step 3: Configure the SignalR Hub in `Program.cs`

Update Program.cs to register the SignalR service and endpoint:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSignalR();
builder.Services.AddControllers();
var app = builder.Build();

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

// Add this line to map the hub
app.MapHub<ChatHub>("/chatHub");

app.Run();

🧪 Step 4: Run the Server

dotnet run

📥 Step 5: Create a .NET Console Client

Create a new console app and add SignalR client package

dotnet add package Microsoft.AspNetCore.SignalR.Client

🧑‍💻 Step 6: Build the Client Logic

Replace Program.cs content with:

using Microsoft.AspNetCore.SignalR.Client;

var connection = new HubConnectionBuilder()
    .WithUrl("https://<your localhost>/chatHub") your server
    .WithAutomaticReconnect()
    .Build();

// Receive messages
connection.On<string, string>("ReceiveMessage", (user, message) =>
{
    Console.WriteLine($"{user}: {message}");
});

try
{
    await connection.StartAsync();
    Console.WriteLine("Connected to SignalR Hub.");
}
catch (Exception ex)
{
    Console.WriteLine($"Connection failed: {ex.Message}");
    return;
}

// Sending messages
while (true)
{
    Console.Write("Enter your name: ");
    var user = Console.ReadLine();

    Console.Write("Enter your message: ");
    var message = Console.ReadLine();

    try
    {
        await connection.InvokeAsync("SendMessage", user, message);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error sending message: {ex.Message}");
    }
}

✅ Step 7: Test the Communication

Run the server project:

cd ../SignalRServer
dotnet run

Run the client project in a new terminal:

cd ../SignalRClient
dotnet run

Type your name and message in the console. If everything is set up correctly, you’ll see the message echoed back from the hub.

🧪 Test Multiple Clients

Open two terminals and run the client in each. You’ll see real-time communication between both.

🐳 Dockerize Your Angular App: A Beginner’s Guide

Hardik Jariwala — Sun, 20 Apr 2025 07:24:35 +0000

What is Docker?🧠

Imagine shipping your entire application including its OS, environment, dependencies, and code as one neatly packaged box. That’s Docker in a nutshell.
Docker is a platform that allows you to create, deploy, and run applications in isolated environments called containers. These containers ensure your app works the same across development, testing, staging, and production regardless of the host OS.

Why Docker for Angular?📦

No more “but it works on my machine!” bugs
Clean, reproducible dev environments
Easy deployment to cloud platforms
Lightweight and fast compared to VMs(Virtual Machines)

Getting Started with Docker🚀

✅ Install Docker

Make sure Docker is installed and running on your machine.
Install Docker Desktop
Verify via terminal:

docker --version

Essential Docker Commands🛠️

docker build -t your-app-name .
docker run -p 3000:3000 your-app-name
docker ps        # list running containers
docker stop <container-id>

Dockerizing an Angular 17+ Project 🧑‍💻

Step 1: Build Your Angular App 🏗️

ng build --configuration production

Output will go to: dist/your-app-name/browser

Step 2: Create a Dockerfile 📁

# Build stage
FROM node:18 AS build

WORKDIR /app

# Copy package.json and package-lock.json to leverage Docker cache
COPY package*.json ./

# Install dependencies
RUN npm install --legacy-peer-deps 

# Install additional dependencies
RUN npm install ngx-bootstrap google-libphonenumber --legacy-peer-deps

# Copy project files
COPY . .

# Build the Angular application with production configuration
RUN npm run build -- --configuration production

# Serve stage
FROM node:18-slim

# Install a lightweight static server
RUN npm install -g serve

WORKDIR /app/dist/your-app-name/browser

# Copy the built Angular app from the previous stage
COPY --from=build /app/dist/your-app-name/browser .

# Expose the default serve port
EXPOSE 3000

# Run the app with serve
CMD ["serve", "-s", ".", "-l", "3000"]

🔁 Replace your-app-name with the actual folder name inside dist.

Step 3: Build and Run the Container 🚀

Build the Docker image

docker build -t angular-demo .

Run the container

docker run -p 3000:3000 angular-demo

Open in browser

Go to 👉 http://localhost:3000

Bonus: Docker for Development (Optional) 🎁

Want live-reloading while developing?
Mount your project folder as a volume
Use Angular CLI inside the container
Use ng serve --host 0.0.0.0

Conclusion 🧾

Docker and Angular make a powerful combo for modern web development. Whether you're deploying to the cloud or just keeping your local dev environment tidy, containers are the way to go. With Angular 17’s new standalone module system and enhanced performance, it's the perfect time to containerize your app and scale your skills.

🚀 Mastering Angular 17+ Fundamentals : A Dev’s Guide to Modern Angular

Hardik Jariwala — Wed, 16 Apr 2025 17:18:39 +0000

Angular has evolved into a powerful and modern framework for building scalable web applications. With the advent of standalone components, reactive primitives, and deferrable views, Angular is more streamlined than ever.

In this post, we’ll walk through core Angular concepts every modern developer should know, complete with theory and code examples. Whether you’re a beginner or brushing up, this guide is your Angular fundamentals crash course.

Table of Contents📚

Routing
Standalone Components
Forms
Property Binding
Event Handling
Conditional Rendering
For Loops in Angular
Passing Data Between Components
Deferrable Views

Routing🧭

Routing lets you navigate between views and components in Angular apps.

// app.routes.ts
import { Routes } from '@angular/router';
import { HomeComponent } from './home.component';
import { AboutComponent } from './about.component';

export const routes: Routes = [
  { path: '', component: HomeComponent },
  { path: 'about', component: AboutComponent },
];

// main.ts
bootstrapApplication(AppComponent, {
  providers: [provideRouter(routes)],
});

Standalone Components🧩

Standalone components don’t need an NgModule. They promote simpler architecture.

@Component({
  standalone: true,
  selector: 'app-hello',
  template: `<h1>Hello, Angular!</h1>`,
})
export class HelloComponent {}

Forms📝

Angular supports template-driven and reactive forms.
Template-driven Form:

<form #form="ngForm" (ngSubmit)="submit(form.value)">
  <input name="username" ngModel />
  <button type="submit">Submit</button>
</form>

Property Binding🔗

Bind values from component to template using [property].

<img [src]="imageUrl" alt="Dynamic Image" />

Event Handling🖱️

Use (event) to listen for DOM events

<button (click)="handleClick()">Click Me</button>

handleClick() {
  console.log('Button clicked!');
}

Conditional Rendering🔄

Show/hide elements with *ngIf.

<p *ngIf="isLoggedIn">Welcome back!</p>

isLoggedIn = true;

For Loops in Angular🔁

Use *ngFor to loop through lists.

<ul>
  <li *ngFor="let user of users">{{ user.name }}</li>
</ul>

users = [{ name: 'Alice' }, { name: 'Bob' }];

Passing Data Between Components🔄

Use @Input and @Output to communicate.

Parent to Child:

<app-user [name]="userName"></app-user>

@Input() name!: string;

Child to Parent:

<app-user (notify)="onNotify()"></app-user>

@Output() notify = new EventEmitter<void>();

Deferrable Views💤

Optimize performance by deferring part of the UI until needed.

<ng-container *ngIf="isLoaded(); else loading">
  <app-heavy-component />
</ng-container>
<ng-template #loading>
  <p>Loading...</p>
</ng-template>

Final Thoughts🧠

Angular’s modernization journey with features like standalone components and signals makes it more intuitive, reactive, and leaner than ever. Mastering these fundamentals sets you up for building robust, scalable applications.

Feel free to share your thoughts or ask questions in the comments. Happy coding! 🔥

DEV Community: Hardik Jariwala

Python Lists vs Tuples vs Sets vs Dictionaries A Beginner-Friendly Guide

Python Lists vs Tuples vs Sets vs Dictionaries 🐍

1. List 📝 The Flexible To-Do List

2. Tuple 🔒 The Locked Box

3.Set 🎯 The No-Duplicates Club

4. Dictionary 📖 The Labeled Drawer System

🔍 Quick Comparison Table

🧠 How to Choose the Right One

🎬 Wrapping Up

🚀 Redis Caching in .NET (Memurai on Windows + Docker Recommended)

🔴 What is Redis?

🧠 How It Works (Cache Aside Pattern)

📦 Required Packages (.NET)

⚙️ Redis Configuration

Run Redis WITHOUT Docker (Windows)

🐳 Recommended: Use Docker

🔄 Cache Invalidation (Important)

🧠 Best Practices With...

📡 Real-Time Communication with SignalR in ASP.NET Core Complete Setup Guide

🔧 Step 1: Create the SignalR Server Project

🧠 Step 2: Create a SignalR Hub

🌐 Step 3: Configure the SignalR Hub in Program.cs

🧪 Step 4: Run the Server

📥 Step 5: Create a .NET Console Client

🧑‍💻 Step 6: Build the Client Logic

✅ Step 7: Test the Communication

🧪 Test Multiple Clients

🐳 Dockerize Your Angular App: A Beginner’s Guide

What is Docker?🧠

Why Docker for Angular?📦

Getting Started with Docker🚀

Essential Docker Commands🛠️

Dockerizing an Angular 17+ Project 🧑‍💻

Step 1: Build Your Angular App 🏗️

Step 2: Create a Dockerfile 📁

Step 3: Build and Run the Container 🚀

Bonus: Docker for Development (Optional) 🎁

Conclusion 🧾

🚀 Mastering Angular 17+ Fundamentals : A Dev’s Guide to Modern Angular

Table of Contents📚

Routing🧭

Standalone Components🧩

Forms📝

Property Binding🔗

Event Handling🖱️

Conditional Rendering🔄

For Loops in Angular🔁

Passing Data Between Components🔄

Deferrable Views💤

Final Thoughts🧠

🌐 Step 3: Configure the SignalR Hub in `Program.cs`