What We’re Building

This project is a ready FastAPI server that integrates OpenAI’s Agents SDK with Groq’s free high-performance models.

Here’s what you’ll get:

✅ AI-Powered Chat Endpoint — Send messages and get intelligent responses
✅ Multiple Tools — Weather lookup and mathematical calculations
✅ Streaming Support — Real-time response streaming for better UX
✅ Docker Ready — Containerized for instant cloud deployment
✅ CORS Enabled — Works seamlessly with any frontend
✅ Health Checks — Built-in monitoring endpoints

Part 1: Prerequisites & Setup

Before we start, gather these three essentials:

1. Create a Hugging Face Account

Head to huggingface.co/join and sign up. This is where we’ll deploy our Space (basically a free container for our app).

2. Get a Groq API Key

Visit console.groq.com/keys and create an API key. Groq provides fast, free access to LLMs like LLAMA 3 and GPT OSS. Copy this key, you’ll need it later.

3. Generate a Hugging Face Access Token

This is crucial for pushing code to Hugging Face Spaces:

• Go to Settings → Access Tokens
• Click “Create new token”
• Name it spaces-deploy
• Select “Write” permissions
• Click “Create token” and copy it immediately (you’ll use it as your password)

⚠️ Important: Never use your Hugging Face login password for Git authentication. Always use the Access Token.

Part 2: Creating Your Hugging Face Space

Step 1: Initialize Your Space

1. Navigate to huggingface.co/new-space
2. Fill in the form:

• Space Name: fastapi-agents (or your preferred name)
• License: MIT
• SDK: Select Docker (important!)
• Space Hardware: CPU Basic (free tier is perfect for this)
• Click “Create Space”

You’ll be redirected to your new Space page, which initially is empty. That’s fine, we’ll populate it next.

Part 3: Deploying Your Code

You have two options: CLI (recommended for developers) or Web UI (easiest).

Option A: Command Line (Recommended)

This is the developer-friendly approach. Open your terminal and run these commands in the project folder:

Initialize Git:

git init
git checkout -B main
git add .
git config --global user.email "you@example.com"
git config --global user.name "Your Name"
git commit -m "Initial deploy"

Add the Hugging Face Remote:

Look at your Space’s URL. It should look like:

https://huggingface.co/spaces/YOUR_USERNAME/fastapi-agents

Now run:

git remote add space https://huggingface.co/spaces/YOUR_USERNAME/fastapi-agents

Push Your Code:

git push --force space main

When prompted:

• Username: Your Hugging Face username
• Password: Paste the Access Token you created earlier (NOT your password)

That’s it! Your code is now in Hugging Face Spaces.

Option B: Web UI (No Git Required)

If you’re not comfortable with Git:

1. Go to your Space’s “Files” tab
2. Click “Add file” → “Upload files”
3. Drag and drop these files:

• Dockerfile
• main.py
• pyproject.toml
• uv.lock
• .env.example
• In the commit message, type “Initial deploy”
• Click “Commit changes to main”

Note: Skip .env, .git, and __pycache__ folders.

Part 4: Configuring Environment Variables

Your app needs the Groq API key to run.

Here’s how to add it:

1. Go to your Space’s “Settings” tab
2. Scroll down to “Variables and secrets”
3. Click “New secret” (top-right of that section)
4. Enter:

• Name: GROQ_API_KEY
• Value: Your Groq API key (starts with gsk_... )
• Click “Save”

Your Space will automatically restart and rebuild. This usually takes 2–3 minutes.

Part 5: Verifying Your Deployment

Once the build completes:

1. Click the “App” tab
2. You should see this JSON response:

{
  "name": "FastAPI + OpenAI Agents SDK",
  "version": "1.0.0",
  "endpoints": {
    "POST /chat": "Send a message to the agent",
    "GET /health": "Health check"
  }
}

If something went wrong:

• Click the “Logs” button to see error messages
• Most common issue: Missing or invalid GROQ_API_KEY

Part 6: Using Your API

Once deployed, your API is live at:

https://YOUR_USERNAME-fastapi-agents.hf. space

Testing with Swagger UI

The easiest way to test:

1. Visit: https://YOUR_USERNAME-fastapi-agents.hf.space/docs
2. You’ll see an interactive API explorer
3. Click on the /chat endpoint
4. Click “Try it out”
5. Enter a message: "What is 25 * 4? "
6. Click “Execute”

The agent will use its calculator tool and respond with the answer.

Testing with cURL

curl -X POST https://YOUR_USERNAME-fastapi-agents.hf.space/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "What is the weather in San Francisco?"}'

Available Agent Tools

Your agent comes with two built-in tools:

1. Calculator

Message: "What is 144 / 12?" Response: "12"

2. Weather Lookup

Message: "What's the weather in London?" Response: "Weather information for London retrieved..."

Streaming Responses

For real-time responses, use the streaming endpoint:

curl -X POST https://YOUR_USERNAME-fastapi-agents.hf.space/chat/stream \
  -H "Content-Type: application/json" \
  -d '{"message":  "Explain machine learning"}' \
  -N  # Unbuffered output for real-time streaming

Part 7: Understanding the Architecture

Let’s peek under the hood:

Core Components

main.py: — The Heart of the Application

# Initialize the Groq client (OpenAI-compatible)
external_client = AsyncOpenAI(
    api_key=groq_api_key,
    base_url="https://api.groq.com/openai/v1",
)

# Create the AI agent with tools
assistant_agent = Agent(
    name="Assistant",
    instructions="You are a helpful assistant.. .",
    model=groq_model,
    tools=[get_weather, calculate],
)

Dockerfile — Production Containerization

The Dockerfile uses a multi-stage build for efficiency:

• Stage 1: Installs dependencies using uv (a fast Python package manager)
• Stage 2: Creates a minimal production image with just the essentials

This results in a small, fast container that deploys instantly.

The Agent Pattern

The OpenAI Agents SDK uses an agentic pattern:

1. User sends a message
2. Agent decides which tool(s) to use
3. Tools execute and return results
4. Agent formulates a response
5. Response sent back to user

This is similar to how ChatGPT plugins work — intelligent tool selection!

Part 8: Customizing Your Agent

Want to add your own tools? Here’s how:

Adding a New Tool

from agents import function_tool

@function_tool
def get_stock_price(symbol: str) -> str:
    """Get the current stock price for a symbol."""
    # Your implementation here
    return f"Stock price for {symbol}"

# Add to agent
assistant_agent = Agent(
    name="Assistant",
    instructions="You are a financial advisor...",
    model=groq_model,
    tools=[get_weather, calculate, get_stock_price],  # Add your tool
)

Modifying Agent Instructions

Customize the agent’s personality and behavior:

assistant_agent = Agent(
    name="Assistant",
    instructions="""You are a helpful Python coding assistant.  You can help with:
- Writing Python code
- Explaining concepts
- Performing calculations
- Answering questions

Always provide clear, concise explanations.""",
    model=groq_model,
    tools=[calculate],
)

Part 9: Local Development (Optional)

Want to test locally before deploying?

Prerequisites

• Python 3.12+
• uv package manager: curl -LsSf https://astral. sh/uv/install.sh | sh

Setup

# Install dependencies
uv sync

# Copy the example env file
cp .env.example .env

# Edit .env and add your GROQ_API_KEY
# Then run:
uv run main.py

Your API will be available at http://localhost:7860

Part 10: Troubleshooting

| Issue | Solution |
|-------|----------|
| **Build fails** | Check Space logs; usually missing `GROQ_API_KEY` |
| **API returns 500 error** | Verify `GROQ_API_KEY` is valid and not expired |
| **Swagger UI shows 503** | Space is still building; wait 2-3 minutes |
| **Tools not working** | Check agent instructions include tool names |
| **Slow responses** | Groq servers may be under load; retry in 30 seconds |

Advanced Features

CORS Configuration

The app includes CORS middleware, allowing requests from any origin:

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

Health Checks

Built-in monitoring endpoint:

curl https://YOUR_USERNAME-fastapi-agents.hf. space/health
# Returns: {"status": "ok", "model": "openai/gpt-oss-20b", "provider": "groq"}

Error Handling

All endpoints include proper exception handling and return meaningful error messages.

Conclusion

You’ve successfully deployed a production-ready AI API!

Here’s what we accomplished:

✅ Created a Hugging Face Space
✅ Deployed FastAPI with OpenAI Agents SDK
✅ Configured Groq for free LLM inference
✅ Tested the API with multiple tools
✅ Understood the underlying architecture

Resources

• 📦 Repository: github.com/DanielHashmi/fastapi-openai-agents-sdk
• 🚀 Hugging Face Spaces: huggingface. co/spaces
• 🔑 Groq Console: console.groq.com
• 📚 FastAPI Docs: fastapi.tiangolo.com
• 🤖 OpenAI Agents SDK: platform.openai.com/docs/guides/agents

Happy coding! 🎉

If you have questions or run into issues, feel free to open an issue on the GitHub repository or reach out on social media.

🤖 Building AI-Powered APIs with FastAPI and OpenAI Agents SDK: Deployment on Hugging Face was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

Prerequisites

• Qwen CLI installed and authenticated
• Node.js v18+ installed

Step 1: Install Claude, Claude Code Router and Qwen Code

npm install -g @qwen-code/qwen-code@latest

npm install -g @anthropic-ai/claude-code @musistudio/claude-code-router

Step 2: Extract Your Access Token

Replace PC_USER with your Windows username.

Open C:\Users\PC_USER\.qwen\oauth_creds.json:

It should look something like this:

{
  "access_token": "YOUR_QWEN_ACCESS_TOKEN_HERE",
  "token_type": "Bearer",
  "refresh_token": "YOUR_QWEN_REFRESH_TOKEN_HERE",
  "resource_url": "portal.qwen.ai",
  "expiry_date": 1764876220290
}

Copy the access_token value.

Step 3: Create the Folders

Paste this into PowerShell:

New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.claude-code-router", "$env:USERPROFILE\.claude"

Step 4: Create the Config File

Paste this command to create and populate the config file:

@"
{  
  "LOG": true,  
  "LOG_LEVEL": "info",  
  "HOST": "127.0.0.1",  
  "PORT": 3456,  
  "API_TIMEOUT_MS": 600000,  
  "Providers": [  
    {  
      "name": "qwen",  
      "api_base_url": "https://portal.qwen.ai/v1/chat/completions",  
      "api_key": "YOUR_QWEN_ACCESS_TOKEN_HERE",  
      "models": [  
        "qwen3-coder-plus",  
        "qwen3-coder-plus",  
        "qwen3-coder-plus"  
      ]  
    }  
  ],  
  "Router": {  
    "default": "qwen,qwen3-coder-plus",  
    "background": "qwen,qwen3-coder-plus",  
    "think": "qwen,qwen3-coder-plus",  
    "longContext": "qwen,qwen3-coder-plus",  
    "longContextThreshold": 60000,  
    "webSearch": "qwen,qwen3-coder-plus"  
  }  
}
"@ | Out-File -FilePath "$env:USERPROFILE\.claude-code-router\config.json" -Encoding UTF8

To open the config file, use the following command:

notepad "$env:USERPROFILE\.claude-code-router\config.json"

Replace YOUR_QWEN_ACCESS_TOKEN_HERE with your actual access token from Step 2:

Step 5: Start Using

Restart the router server:

ccr restart

Run Claude Code with Qwen models:

ccr code

Test with:

> hi

Token Refresh (When you get 401 errors)

Your OAuth token expires. Refresh it by:

1. Re-authenticating your QWEN CODE CLI: If already logged in and the access_token matches in both config.json and oauth_creds.json, delete the oauth_creds.json file and run qwen to initiate re-authentication.
2. Update the api_key in your config.json with the new access_token:

• notepad “$env:USERPROFILE\.claude-code-router\config.json”

3. Restart: ccr restart

If using WSL: wsl setup

Hopefully this will help you learn claude code for Free💖

Below are 60 multiple-choice questions (MCQs) designed to be challenging

1. What is a key characteristic of a Python list?
   a) Immutable
   b) Unordered
   c) Mutable
   d) Hashable
   Answer: c) Mutable
2. How can you correctly create a list with mixed data types?
   a) [“apple”, 42, 3.14, True]
   b) (“apple”, 42, 3.14, True)
   c) {“apple”: 42, “value”: 3.14}
   d) set([“apple”, 42])
   Answer: a) [“apple”, 42, 3.14, True]
3. What is the output of fruits = [“apple”, “banana”, “cherry”]; print(fruits[-1])?
   a) apple
   b) banana
   c) cherry
   d) TypeError
   Answer: c) cherry
4. What happens when you try to modify a list element at an invalid index?
   a) The list is extended
   b) An IndexError is raised
   c) The element is appended
   d) Nothing happens
   Answer: b) An IndexError is raised
5. What is the result of numbers = [1, 2, 3]; numbers.append(4); print(numbers)?
   a) [1, 2, 3]
   b) [1, 2, 3, 4]
   c) [4, 1, 2, 3]
   d) TypeError
   Answer: b) [1, 2, 3, 4]
6. What does the remove() method do if the specified value is not in the list?
   a) Removes the last element
   b) Raises a ValueError
   c) Does nothing
   d) Clears the list
   Answer: b) Raises a ValueError
7. What is the output of fruits = [“apple”, “banana”]; fruits.pop(); print(fruits)?
   a) [“apple”]
   b) [“banana”]
   c) []
   d) TypeError
   Answer: a) [“apple”]
8. What does numbers = [3, 1, 4]; numbers.sort(); print(numbers) output?
   a) [4, 3, 1]
   b) [1, 3, 4]
   c) [3, 1, 4]
   d) TypeError
   Answer: b) [1, 3, 4]
9. What is the result of words = [“cat”, “dog”, “bird”]; words.sort(key=len); print(words)?
   a) [“cat”, “dog”, “bird”]
   b) [“bird”, “cat”, “dog”]
   c) [“dog”, “cat”, “bird”]
   d) TypeError
   Answer: a) [“cat”, “dog”, “bird”]
10. What does the reverse() method do to a list?
    a) Sorts it in ascending order
    b) Reverses the order of elements
    c) Removes duplicates
    d) Clears the list
    Answer: b) Reverses the order of elements
11. What is the output of [x*2 for x in [1, 2, 3]]?
    a) [1, 2, 3]
    b) [2, 4, 6]
    c) [1, 4, 9]
    d) TypeError
    Answer: b) [2, 4, 6]
12. What does [x for x in [1, 2, 3, 4] if x > 2] produce?
    a) [1, 2]
    b) [3, 4]
    c) [1, 2, 3, 4]
    d) []
    Answer: b) [3, 4]
13. What is a key characteristic of a Python tuple?
    a) Mutable
    b) Unordered
    c) Immutable
    d) Dynamic size
    Answer: c) Immutable
14. Why can a tuple be used as a dictionary key?
    a) It is mutable
    b) It is hashable
    c) It is unordered
    d) It allows duplicates
    Answer: b) It is hashable
15. What happens when you try to modify a tuple element?
    a) The element is updated
    b) A TypeError is raised
    c) Nothing happens
    d) The tuple is cleared
    Answer: b) A TypeError is raised
16. What is the output of tuple1 = (“apple”, “banana”); print(tuple1.count(“apple”))?
    a) 0
    b) 1
    c) 2
    d) TypeError
    Answer: b) 1
17. What does tuple1 = (1, 2, 3); print(tuple1.index(2)) return?
    a) 0
    b) 1
    c) 2
    d) TypeError
    Answer: b) 1
18. What is the result of tuple1 = (1, 2); tuple2 = (3, 4); print(tuple1 + tuple2)?
    a) (1, 2, 3, 4)
    b) (1, 2)
    c) (3, 4)
    d) TypeError
    Answer: a) (1, 2, 3, 4)
19. What is the output of tuple1 = (1, 2); print(tuple1 * 2)?
    a) (1, 2)
    b) (1, 2, 1, 2)
    c) (2, 4)
    d) TypeError
    Answer: b) (1, 2, 1, 2)
20. What does a, b = (1, 2) do?
    a) Raises a TypeError
    b) Unpacks the tuple into variables a and b
    c) Creates a new tuple
    d) Modifies the tuple
    Answer: b) Unpacks the tuple into variables a and b
21. What is a key characteristic of a Python dictionary?
    a) Indexed by position
    b) Immutable
    c) Ordered (since Python 3.7)
    d) Allows duplicate keys
    Answer: c) Ordered (since Python 3.7)
22. How can you create a dictionary using the dict() constructor?
    a) dict(name=”John”, age=30)
    b) {“name”: “John”, “age”: 30}
    c) [(“name”, “John”), (“age”, 30)]
    d) dict([“name”, “John”])
    Answer: a) dict(name=”John”, age=30)
23. What does person = {“name”: “Alice”}; print(person.get(“age”, 25)) output?
    a) None
    b) 25
    c) KeyError
    d) “Alice”
    Answer: b) 25
24. What happens when you access a non-existent key with person[“age”]?
    a) Returns None
    b) Raises a KeyError
    c) Returns a default value
    d) Creates the key
    Answer: b) Raises a KeyError
25. What is the output of person = {“name”: “Alice”}; person[“name”] = “Bob”; print(person)?
    a) {“name”: “Alice”}
    b) {“name”: “Bob”}
    c) {“name”: “Alice”, “name”: “Bob”}
    d) TypeError
    Answer: b) {“name”: “Bob”}
26. What does person = {“name”: “Alice”}; del person[“name”]; print(person) output?
    a) {“name”: “Alice”}
    b) {}
    c) None
    d) KeyError
    Answer: b) {}
27. What is the result of person = {“name”: “Alice”}; person.pop(“name”); print(person)?
    a) {“name”: “Alice”}
    b) {}
    c) None
    d) KeyError
    Answer: b) {}
28. What does person = {“name”: “Alice”, “age”: 25}; print(person.keys()) return?
    a) [“name”, “age”]
    b) dict_keys([“name”, “age”])
    c) (“name”, “age”)
    d) TypeError
    Answer: b) dict_keys([“name”, “age”])
29. What is the output of person = {“name”: “Alice”}; person.update({“age”: 25}); print(person)?
    a) {“name”: “Alice”}
    b) {“name”: “Alice”, “age”: 25}
    c) {“age”: 25}
    d) TypeError
    Answer: b) {“name”: “Alice”, “age”: 25}
30. What does person = {“name”: “Alice”}; person.clear(); print(person) output?
    a) {“name”: “Alice”}
    b) {}
    c) None
    d) TypeError
    Answer: b) {}
31. What is the output of my_dict = {“a”: 1, “b”: 2}; print({k: v*2 for k, v in my_dict.items()})?
    a) {“a”: 1, “b”: 2}
    b) {“a”: 2, “b”: 4}
    c) {“a”: 1, “b”: 4}
    d) TypeError
    Answer: b) {“a”: 2, “b”: 4}
32. What is the result of celsius = [0, 10]; print({c: (c * 9/5) + 32 for c in celsius})?
    a) {0: 32.0, 10: 50.0}
    b) {0: 0, 10: 10}
    c) {0: 32, 10: 50}
    d) TypeError
    Answer: a) {0: 32.0, 10: 50.0}
33. Why are tuples thread-safe?
    a) They are mutable
    b) They are immutable
    c) They are ordered
    d) They allow duplicates
    Answer: b) They are immutable
34. What is the output of numbers = [1, 2, 3]; print(numbers[1:3])?
    a) [1, 2]
    b) [2, 3]
    c) [1, 2, 3]
    d) TypeError
    Answer: b) [2, 3]
35. What does fruits = [“apple”, “banana”]; fruits.extend([“cherry”]); print(fruits) output?
    a) [“apple”, “banana”]
    b) [“apple”, “banana”, “cherry”]
    c) [“cherry”, “apple”, “banana”]
    d) TypeError
    Answer: b) [“apple”, “banana”, “cherry”]
36. What is the output of words = [“apple”, “banana”]; words.sort(key=lambda x: x[-1]); print(words)?
    a) [“banana”, “apple”]
    b) [“apple”, “banana”]
    c) [“banana”, “apple”]
    d) TypeError
    Answer: a) [“banana”, “apple”]
37. What happens when you try to call tuple1 = (1, 2); tuple1.append(3)?
    a) (1, 2, 3) is created
    b) An AttributeError is raised
    c) Nothing happens
    d) The tuple is cleared
    Answer: b) An AttributeError is raised
38. What is the output of tuple1 = (1, 2, 2); print(tuple1.count(2))?
    a) 0
    b) 1
    c) 2
    d) TypeError
    Answer: c) 2
39. What does phonebook = {“Alice”: “123”}; print(“Alice” in phonebook) return?
    a) True
    b) False
    c) None
    d) KeyError
    Answer: a) True
40. What is the result of my_dict = {“a”: 1, “a”: 2}; print(my_dict)?
    a) {“a”: 1, “a”: 2}
    b) {“a”: 2}
    c) {“a”: 1}
    d) KeyError
    Answer: b) {“a”: 2}
41. What does my_dict = {“name”: “Alice”}; print(my_dict.values()) return?
    a) [“Alice”]
    b) dict_values([“Alice”])
    c) (“Alice”,)
    d) TypeError
    Answer: b) dict_values([“Alice”])
42. What is the output of my_dict = {“name”: “Alice”}; print(len(my_dict))?
    a) 0
    b) 1
    c) 2
    d) TypeError
    Answer: b) 1
43. What does my_dict = {“name”: “Alice”}; my_dict.copy(); print(my_dict) output?
    a) {}
    b) {“name”: “Alice”}
    c) None
    d) TypeError
    Answer: b) {“name”: “Alice”}
44. What is the result of nested_dict = {“person”: {“name”: “Alice”}}; print(nested_dict[“person”][“name”])?
    a) Alice
    b) {“name”: “Alice”}
    c) KeyError
    d) TypeError
    Answer: a) Alice
45. What is the output of for key in {“name”: “Alice”, “age”: 25}: print(key)?
    a) name, age
    b) Alice, 25
    c) (“name”, “Alice”), (“age”, 25)
    d) TypeError
    Answer: a) name, age
46. What does word_count = {}; word_count[“word”] = 1; print(word_count) output?
    a) {“word”: 1}
    b) {}
    c) None
    d) KeyError
    Answer: a) {“word”: 1}
47. What is the output of numbers = [1, 2, 3]; numbers.pop(1); print(numbers)?
    a) [1, 3]
    b) [1, 2]
    c) [2, 3]
    d) TypeError
    Answer: a) [1, 3]
48. What does tuple1 = (1, 2); print(tuple1[1:]) output?
    a) (1, 2)
    b) (2,)
    c) ()
    d) TypeError
    Answer: b) (2,)
49. What is the result of my_dict = {“a”: 1}; my_dict.update({“a”: 2}); print(my_dict)?
    a) {“a”: 1}
    b) {“a”: 2}
    c) {“a”: 1, “a”: 2}
    d) TypeError
    Answer: b) {“a”: 2}
50. What does sorted_word_count = dict(sorted({“a”: 2, “b”: 1}.items(), key=lambda x: x[1])); print(sorted_word_count) output?
    a) {“b”: 1, “a”: 2}
    b) {“a”: 2, “b”: 1}
    c) [“b”, “a”]
    d) TypeError
    Answer: a) {“b”: 1, “a”: 2}
51. What is the output of fruits = [“apple”, “banana”]; fruits[0:1] = [“cherry”]; print(fruits)?
    a) [“cherry”, “banana”]
    b) [“apple”, “banana”]
    c) [“cherry”, “apple”, “banana”]
    d) TypeError
    Answer: a) [“cherry”, “banana”]
52. What does tuple1 = (1, 2, 3); print(2 in tuple1) return?
    a) True
    b) False
    c) None
    d) TypeError
    Answer: a) True
53. What is the output of my_dict = {“name”: “Alice”, “age”: 25}; print(my_dict.items())?
    a) dict_items([(“name”, “Alice”), (“age”, 25)])
    b) [(“name”, “Alice”), (“age”, 25)]
    c) {“name”: “Alice”, “age”: 25}
    d) TypeError
    Answer: a) dict_items([(“name”, “Alice”), (“age”, 25)])
54. What does numbers = [1, 2, 3]; numbers.reverse(); print(numbers) output?
    a) [1, 2, 3]
    b) [3, 2, 1]
    c) [2, 1, 3]
    d) TypeError
    Answer: b) [3, 2, 1]
55. What is the result of tuple1 = (1, 2); tuple2 = (1, 2); print(id(tuple1) == id(tuple2))?
    a) True
    b) False
    c) TypeError
    d) None
    Answer: b) False
56. What does my_dict = {“a”: 1}; print(my_dict.pop(“b”, -1)) return?
    a) 1
    b) -1
    c) KeyError
    d) None
    Answer: b) -1
57. What is the output of [x**2 for x in [1, 2, 3] if x > 1]?
    a) [1, 4, 9]
    b) [4, 9]
    c) [1, 2, 3]
    d) TypeError
    Answer: b) [4, 9]
58. What does phonebook = {“Alice”: “123”}; phonebook[“Alice”] = “456”; print(phonebook) output?
    a) {“Alice”: “123”}
    b) {“Alice”: “456”}
    c) {“Alice”: “123”, “Alice”: “456”}
    d) KeyError
    Answer: b) {“Alice”: “456”}
59. What is the output of numbers = [1, 2, 3]; print(numbers.pop())?
    a) 1
    b) 2
    c) 3
    d) TypeError
    Answer: c) 3
60. What does my_dict = {“name”: “Alice”}; print(“name” in my_dict) return?
    a) True
    b) False
    c) None
    d) KeyError
    Answer: a) True

These MCQs should effectively prepare you for a deep understanding of Python lists, tuples, and dictionaries.

1. Introduction to NumPy 🤗

Who Created NumPy? 💡

• Background: NumPy is the successor to earlier array-handling libraries in Python such as Numeric and numarray.
• Key Contributor: Travis Oliphant was instrumental in combining and advancing these efforts into what we now know as NumPy. His work, along with the contributions of many community members, helped establish NumPy as the cornerstone of numerical computing in Python.

What is NumPy? 🔢

• Purpose & Scope: NumPy is a foundational library designed for efficient numerical computation. It provides support for large, multi-dimensional arrays and matrices, along with a collection of mathematical functions to operate on these data structures.
• Core Feature — ndarray: The heart of NumPy is its n-dimensional array object, or ndarray. This object allows for fast and efficient storage and manipulation of homogeneous data. Its design lets you perform vectorized operations, reducing the need for slow Python loops.

Why is it Called NumPy?

• Name Origin: “NumPy” stands for Numerical Python. The name emphasizes its focus on numerical data and operations, distinguishing it as a tool optimized for numerical computations rather than generic programming tasks.

Importing NumPy 💻

• Standard Practice:

import numpy as np

This common import statement loads NumPy into your Python environment and assigns it the alias “np”. This shorthand is widely used, making code more concise and readable.

2. NumPy Arrays: The Core Data Structure 🗃️

What is an ndarray? 🔎

• Definition: The ndarray is a powerful, multi-dimensional container for homogeneous data (all elements are of the same type).
• Key Attributes: Shape: A tuple indicating the size along each dimension (e.g., (3, 4) for 3 rows and 4 columns).
• dtype: The data type of the elements (e.g., int32, float64), ensuring consistency and enabling optimizations.
• ndim: The number of dimensions (e.g., 1 for a vector, 2 for a matrix).
• Size: The total number of elements in the array.
• Benefits: This structure allows for efficient, low-level computations and memory management, making it possible to perform operations on large datasets quickly.

Creating a Basic Array

• Example:

arr = np.array([1,  2,  3,  4])
print(arr)  # Output: [1 2 3 4]

Here, a standard Python list is converted into an ndarray. This conversion is the first step to taking advantage of NumPy’s vectorized operations and performance benefits.

3. Creating Arrays 🔧

Arrays Filled with Zeros and Ones

• Zeros

zeros = np.zeros((2,  3))

This creates a 2x3 array where every element is 0. You can also specify a data type with the dtype parameter.

• Ones:

ones = np.ones((2,  3))

Similarly, this creates a 2x3 array where every element is 1.

Using np.arange and np.linspace 🔢

• np.arange:

arange_array = np.arange(0,  10,  2)

Generates an array starting at 0, increasing in steps of 2, and stopping before 10. This is similar to Python’s built-in range, but returns an array.

• np.linspace:

linspace_array = np.linspace(0,  1,  5)

Produces 5 evenly spaced values between 0 and 1 (inclusive). By specifying endpoint=False, you can exclude the final value, which is useful in some applications like plotting or simulations.

Creating Arrays with Random Values 🎲

• Uniform Distribution:

random_array = np.random.rand(3,  3)

Generates a 3x3 array with random floats in the interval [0, 1).

• Random Integers:

rand_int = np.random.randint(0,  10,  size=(2,  2))

Produces a 2x2 array with random integers between 0 and 9.

• Normal Distribution:

normal_array = np.random.randn(3,  3)

Generates numbers drawn from the standard normal distribution (mean 0, variance 1).

• Reproducibility:

np.random.seed(42)

Setting a seed ensures that the same random numbers are generated each time, which is important for debugging and reproducible research.

4. Array Indexing and Slicing ✂️

Basic Indexing

• Accessing Elements:

print(arr[2])

NumPy arrays are zero-indexed. Here, arr[2] retrieves the third element of the array.

Slicing ✂️

• Extracting Subarrays:

sub_array = arr[1:3]

This extracts a slice from index 1 up to (but not including) index 3. For the array [1, 2, 3, 4], the result is [2, 3].

Multi-dimensional Indexing 📐

• Accessing Matrix Elements:

matrix = np.array([[1,  2,  3],  [4,  5,  6]])
print(matrix[1,  2])

In a 2D array, matrix[1, 2] accesses the element at the second row and third column. This direct indexing is both intuitive and efficient.

Boolean Indexing ✅

• Filtering Elements:

filtered = arr[arr >  2]

This returns a new array containing only the elements of arr that are greater than 2. Boolean indexing is a powerful tool for conditional data selection without needing explicit loops.

5. Array Operations and Broadcasting 📡

Element-wise Operations ➕

• Arithmetic on Arrays:

sum_array = arr +  5
product_array = arr *  2

These operations are applied element-by-element. For example, adding 5 to each element of [1, 2, 3, 4] results in [6, 7, 8, 9].

Broadcasting 📡

• Concept:

Broadcasting is NumPy’s ability to perform arithmetic operations on arrays of different shapes. It “stretches” the smaller array so that its shape becomes compatible with the larger array.

• Example:

a = np.array([1,  2,  3])
b = np.array([[10],  [20],  [30]])
broadcast_sum = a + b

Here, a is a 1D array and b is a 2D column vector. Broadcasting automatically expands a so that each row of b is added to it, resulting in a 3x3 array.

Universal Functions (ufuncs) 🔧

• Definition and Examples:

Universal functions (or ufuncs) like np.sin, np.exp, and np.log operate element-wise over arrays. They are implemented in C and optimized for performance, making them much faster than applying the corresponding Python math functions within a loop.

6. Array Manipulation 🔄

Reshaping Arrays 🔀

• Changing the Shape:

reshaped = np.reshape(arr,  (2,  2))

Reshaping rearranges the data in the array without altering the data itself. For example, [1, 2, 3, 4] can be reshaped into a 2x2 matrix:

[[1, 2], [3, 4]]

Flattening Arrays 📏

• One-dimensional Conversion:

flat = matrix.flatten()

This method converts a multi-dimensional array into a one-dimensional array. It is useful when you need a linear view of the data.

Transposing ↕️

• Swapping Axes:

transposed = matrix.T

Transposing flips the array over its diagonal, swapping rows with columns. This is especially useful in linear algebra and data analysis for aligning data structures.

7. Aggregation and Statistical Functions 📊

Basic Aggregations 🧮

• Summarizing Data:

sum_val = np.sum(arr)
mean_val = np.mean(arr)
min_val = np.min(arr)
max_val = np.max(arr)

These functions quickly compute summary statistics for the entire array, which is essential for data analysis.

Aggregations Across Axes 📐

• Axis-Specific Operations:

matrix_sum = np.sum(matrix,  axis=0)  # Sum across columns
row_mean = np.mean(matrix,  axis=1)  # Mean across rows

By specifying the axis parameter, you can perform computations along a specific dimension. This is useful when working with matrices or higher-dimensional arrays.

Other Statistical Functions 📈

• Advanced Metrics:

std_dev = np.std(arr)
variance = np.var(arr)
median_val = np.median(arr)
percentiles = np.percentile(arr,  [25,  50,  75])

• Standard Deviation & Variance: Measure the dispersion of data.
• Median: Identifies the central value in the sorted array.
• Percentiles: Indicate the values below which a given percentage of observations fall, providing insight into the distribution of data.

8. Linear Algebra with NumPy 🧮

Dot Product and Matrix Multiplication ✖️

• Dot Product:

dot_product = np.dot(a, a)

For vectors, the dot product multiplies corresponding elements and sums them up, which is a fundamental operation in linear algebra.

• Matrix Multiplication:

matrix_product = np.matmul(matrix, matrix.T)

Matrix multiplication combines rows and columns according to the rules of linear algebra. The @ operator is a shorthand for np.matmul, which enhances code readability.

Inverse and Determinant 🧮

• Inverse:

inverse_matrix = np.linalg.inv(matrix)

The inverse of a matrix is another matrix that, when multiplied with the original, yields the identity matrix. This operation is only defined for square matrices with a non-zero determinant.

• Determinant:

determinant = np.linalg.det(matrix)

The determinant is a scalar that can indicate if a matrix is invertible (a zero determinant means the matrix is singular).

• Additional Topics:
• Eigenvalues and Eigenvectors: These reveal intrinsic properties of a matrix, such as its axes of symmetry.
• Singular Value Decomposition (SVD): Breaks down a matrix into three component matrices, useful in many applications including signal processing and statistics.
• Solving Linear Systems:

A = np.array([[3,  1],  [1,  2]])
b = np.array([9,  8])
x = np.linalg.solve(A, b)

This solves the system of linear equations (Ax = b), a common problem in many scientific computations.

9. Saving and Loading Arrays 💾

Saving Arrays 💾

• Binary Format:

np.save('array.npy', arr)

Saves the array in a binary format that preserves its structure and data type.

Loading Arrays 📂

• Restoring Data:

loaded_arr = np.load('array.npy')

Loads the binary file back into an ndarray with its original properties intact.

Saving Multiple Arrays 📦

• Compressed Format:

np.savez('arrays.npz',  array1=arr,  array2=matrix)

This allows you to save several arrays into a single compressed file, making data management more convenient.

Working with Text Files 📝

• Human-Readable Format:

np.savetxt('array.txt', arr,  fmt='%d')
loaded_txt_arr = np.loadtxt('array.txt',  dtype=int)

These functions save arrays to a text file and load them back, which is useful when you need to inspect the data or share it with non-Python tools.

10. Advanced Techniques 🚀

Stacking and Splitting Arrays 🔀

• Stacking:

# Vertical stacking: Adds rows
stacked_v = np.vstack((arr, arr))
# Horizontal stacking: Adds columns (after reshaping, if necessary)
stacked_h = np.hstack((arr.reshape(4,  1), arr.reshape(4,  1)))

Stacking combines arrays along a new axis — either vertically (adding rows) or horizontally (adding columns).

• Splitting:

# Splitting along columns
split_arr = np.hsplit(stacked_v,  2)
# Splitting along rows
split_arr_v = np.vsplit(stacked_v,  2)

Splitting divides an array into multiple sub-arrays along a specified axis.

Copy vs. View

• copy():

copy_arr = arr.copy()

This creates a completely new array with its own memory. Modifications to the copy do not affect the original array.

• view():

view_arr = arr.view()

A view creates a new array object that references the same underlying data. Changes made through a view are reflected in the original array, so it’s important to use views carefully when you need independent copies.

11. Additional Advanced Topics 🧠

Fancy Indexing 🎯

• Definition:

Fancy indexing lets you select arbitrary items in an array using an array of indices or boolean values.

• Example:

indices =  [0,  2]
fancy = arr[indices]

This returns the elements at positions 0 and 2 from arr, which is especially useful when the elements you need are not contiguous.

Memory Layout and Performance ⚡

• Memory Orders:
• C Order (Row-major): Data is stored row by row. This is the default in NumPy and is optimal for many row-wise operations.
• F Order (Column-major): Data is stored column by column, which can be beneficial for certain linear algebra routines.
• Vectorization:

By replacing explicit Python loops with array operations, you can exploit low-level optimizations and achieve significant performance gains.

• In-place Operations:

Operations like arr += 1 update the array directly in memory, reducing overhead and memory usage compared to creating new arrays.

Other Useful Array Functions 🛠️

• Sorting and Searching:

sorted_arr = np.sort(arr)
indices_sorted = np.argsort(arr)

These functions allow you to sort an array and obtain the indices that would sort the array, which is useful in many data analysis tasks.

• Finding Unique Values:

unique_elements = np.unique(arr)

This returns the sorted unique elements of the array, helping to identify duplicates or categorize data.

• Resizing vs. Reshaping:
• np.resize: Can change the size of an array, repeating elements if necessary.
• np.reshape: Changes the dimensions of an array without altering the total number of elements.

Glossary of Key Jargons 📚

• ndarray: The core multi-dimensional array object in NumPy that stores elements of a single data type.
• dtype: Defines the data type (e.g., integers, floats) for the elements in an ndarray.
• Shape & ndim: Shape refers to the dimensions (e.g., rows and columns) of an array, and ndim indicates how many dimensions the array has.
• Size: The total number of elements in an array.
• Strides: Describe how many bytes to step in each dimension when traversing an array, impacting performance and memory layout.
• Vectorized Operations: Allow operations to be performed on entire arrays at once, rather than element by element in Python loops.
• Broadcasting: Automatically expands arrays with smaller dimensions to match larger arrays during arithmetic operations.
• ufuncs (Universal Functions): Optimized functions that perform element-wise operations on arrays (e.g., np.sin, np.exp).
• Axis: The dimension along which an operation is performed, such as summing or averaging.
• Aggregation: Functions like np.sum, np.mean, etc., that combine elements of an array to produce summary statistics.
• Dot Product & Matrix Multiplication: Fundamental operations in linear algebra — dot product is used for vectors, while matrix multiplication combines rows and columns of matrices.
• Inverse & Determinant: Concepts used in solving systems of linear equations and understanding matrix properties.
• Eigenvalues and Eigenvectors: Values and corresponding vectors that reveal important properties of a matrix.
• Singular Value Decomposition (SVD): A technique that decomposes a matrix into three simpler matrices to reveal useful properties of the original matrix.
• Linear System: A set of equations represented in matrix form that can be solved using functions like np.linalg.solve().
• Stacking and Splitting: Methods for combining arrays (stacking) and dividing an array into smaller parts (splitting).
• Copy: Creates a new, independent copy of an array.
• View: Creates a new array object that references the same data as the original array; modifications to the view may affect the original.
• Fancy Indexing: Accessing array elements using another array of indices.
• Memory Layout: Describes the way in which array data is stored in memory (e.g., row-major or column-major order).
• Vectorization: The practice of using NumPy’s array operations to replace explicit loops, thereby improving performance.
• In-place Operations: Modify arrays directly, which can save memory and improve performance.

This list covers the main terms and concepts mentioned in the cheat sheet.

“Originally published on DanielForgeChronicles”

🚀 1. Introduction to Pandas

Who Created Pandas?

The creator of pandas is Wes McKinney. He is an American software developer who developed the open-source Python library "pandas" for data analysis.

What is Pandas?

• Pandas is a powerful Python library for data analysis and manipulation.
• It provides tools to work with structured data like tables and spreadsheets.

Why is it called Pandas?

• The name Pandas comes from ‘Panel Data’ — a term in statistics referring to multi-dimensional data, This might be confusing so you can check it out on Wiki.

Importing Pandas

import pandas as pd

• Explanation: This line imports the pandas library into your project and gives it the alias pd. Using pd saves you from typing the full name “pandas” every time you call a function from the library. Although you can choose another name, pd is the standard convention.

📏 2. Pandas Data Structures

1D and 2D Data Structures

• Series (1D): Think of it as a single column in Excel, where each element has an index.
• DataFrame (2D): This is like a full table with rows and multiple columns.

Creating a Series

s = pd.Series([1, 2, 3, 4], name='Numbers', dtype='float64')
print(s)

• Explanation: This creates a Series with four values. The series is given a name (“Numbers”) and its data type is forced to be float64. This ensures all values are treated as floats, which can be important when doing mathematical operations.

Creating a DataFrame

data = [['Alice', 25], ['Bob', 30]]
df = pd.DataFrame(data, columns=['Name', 'Age'], index=['A', 'B'])
print(df)

• Explanation: This snippet creates a DataFrame using a list of lists. It assigns column names (“Name” and “Age”) and custom row labels (“A” and “B”). The DataFrame structure helps organize data in a table format, making it easier to perform operations on rows and columns.

📥 3. Importing and Exporting Data

Reading Files

pd.read_csv('file.csv', sep=';', header=0, skiprows=2)

• Explanation: This line reads a CSV file named file.csv. The sep=';' tells pandas that the file uses a semicolon as the delimiter. The parameter header=0 means the first row contains column names, and skiprows=2 tells pandas to ignore the first two rows after the header. This is useful if the file contains extra header information or notes you don’t need.

pd.read_excel('file.xlsx', sheet_name='Sheet2', usecols='A:C')

• Explanation: This reads an Excel file called file.xlsx. It specifically opens the sheet named “Sheet2” and loads only the columns from A to C. This helps when you only need a part of a large Excel file.

pd.read_sql('SELECT * FROM table', con=engine)

• Explanation: This command executes a SQL query on a connected database (using the connection engine) and loads the resulting data into a DataFrame. It’s a powerful way to directly manipulate database query results using pandas.

Writing Files

df.to_csv('file.csv', index=False, encoding='utf-8')

• Explanation: This exports the DataFrame to a CSV file named file.csv. The parameter index=False prevents pandas from writing row indices to the file, while encoding='utf-8' ensures the file supports a wide range of characters.

df.to_parquet('file.parquet', compression='snappy')

• Explanation: This saves the DataFrame as a Parquet file, which is a columnar storage format. The compression='snappy' parameter compresses the file efficiently, making it ideal for handling large datasets while saving space.

🔍 4. Exploring Data

df.sample(3)

• Explanation: This function returns 3 random rows from the DataFrame. It’s a quick way to inspect your data and get a feel for its content, especially useful when working with very large datasets.

df.nunique()

• Explanation: This counts the number of unique values in each column. It helps you understand the diversity of data in each column, which is useful for data cleaning and preparation.

df.corr()

• Explanation: This calculates the correlation matrix for all numeric columns in the DataFrame. It shows how strongly each pair of columns is related, which can be key in identifying trends or relationships in your data.

df.memory_usage(deep=True)

• Explanation: This displays the memory usage of each column, including the true size of objects like strings. It helps in identifying which parts of your data might be optimized for better performance.

🎯 5. Selecting Data

Advanced Selection

df.loc[df['Age'] > 25, 'Name']

• Explanation: This line uses label-based indexing to select rows where the ‘Age’ column is greater than 25, and then returns the corresponding ‘Name’ values. It makes filtering data based on column conditions straightforward and readable.

df.iloc[1:3, 0:2]

• Explanation: Here, integer-based indexing is used with iloc. It selects rows 1 and 2 (remember, Python indexing starts at 0 and the end index is not included) and columns in positions 0 and 1. This method is handy when you want to select data by its numerical position rather than by label.

Conditional Selection

df.query('Age > 25 & Salary < 70000')

• Explanation: The query method allows filtering using a string expression similar to SQL. This example returns rows where Age is greater than 25 and Salary is less than 70,000. It makes complex filtering conditions easier to write and understand.

🔧 6. Filtering Data

df[df['Name'].str.contains('li')]

• Explanation: This filters the DataFrame to include only rows where the ‘Name’ column contains the substring ‘li’. It’s useful for searching text within a column. Note that this search is case-sensitive unless you adjust the parameters.

df[df['Age'].between(20, 40)]

• Explanation: The between method filters rows to include only those where the ‘Age’ is between 20 and 40 (inclusive). This offers a concise way to apply a range filter on numeric data.

🔄 7. Sorting Data

df.sort_values(['Age', 'Salary'], ascending=[True, False])

• Explanation: This sorts the DataFrame first by the ‘Age’ column in ascending order, then by the ‘Salary’ column in descending order. Sorting your data can help in analyzing trends, such as identifying the highest salaries within age groups.

df.sort_index(ascending=False)

• Explanation: This command sorts the DataFrame by its index in reverse (descending) order. Sorting by index is useful when your index holds meaningful data, such as dates or unique identifiers.

🔀 8. Adding & Removing Data

Advanced Column Operations

df.assign(Bonus = df['Salary'] * 0.1)

• Explanation: The assign method creates a new column called ‘Bonus’ by calculating 10% of each value in the ‘Salary’ column. This operation is temporary and does not modify the original DataFrame unless you reassign it, making it great for testing new columns.

df.rename(columns={'Age': 'Years'}, inplace=True)

• Explanation: This permanently renames the ‘Age’ column to ‘Years’ in the DataFrame by using the rename method with inplace=True. Renaming columns can make the data clearer, especially if the current names are ambiguous.

Multi-Index Support

df.set_index(['Name', 'Age'])

• Explanation: This sets a hierarchical (multi-level) index using the ‘Name’ and ‘Age’ columns. A multi-index allows for more complex data grouping and easier access to subsets of your data.

📊 9. Aggregation & Grouping

df.groupby('Department').agg({'Salary': ['mean', 'max'], 'Age': 'median'})

• Explanation: This groups the DataFrame by the ‘Department’ column and then calculates several statistics for each group: the mean and maximum of ‘Salary’ and the median of ‘Age’. It helps summarize data within each group to find overall trends.

df.groupby('City')['Sales'].transform(lambda x: x - x.mean())

• Explanation: This groups data by ‘City’ and then centers the ‘Sales’ values by subtracting the average sales for each city. This transformation is useful for comparing individual sales to the city average.

Pivot Tables

df.pivot_table(values='Sales', index='Region', columns='Year', aggfunc='sum')

• Explanation: This creates a pivot table that summarizes sales data by region and year. It aggregates (sums) the sales values for each combination of ‘Region’ and ‘Year’, similar to pivot tables in Excel, which can be very useful for analysis.

🔥 10. Combining Data

Concatenation

pd.concat([df1, df2], axis=0)  # Stack vertically
pd.concat([df1, df2], axis=1)  # Stack horizontally

• Explanation: The concat function joins two DataFrames together. With axis=0, it stacks the DataFrames on top of each other (adding rows). With axis=1, it joins them side-by-side (adding columns). This is handy when you have related datasets you want to combine into a single DataFrame.

Merging Data

pd.merge(orders, customers, left_on='cust_id', right_on='id', how='left')

• Explanation: This command merges two DataFrames (orders and customers) based on matching values from cust_id in the orders DataFrame and id in the customers DataFrame. The how='left' parameter means all rows from the orders DataFrame will be kept, and matching rows from the customers DataFrame will be joined in. This is similar to performing a left join in SQL.

🔄 11. Handling Missing Data

df.interpolate(method='linear')

• Explanation: This fills in missing values in the DataFrame by calculating linear interpolations between known values. It’s particularly useful for time series data where you expect a smooth transition between points.

df.ffill(limit=1)

• Explanation: The ffill (forward fill) method replaces missing values with the last valid observation, but only for up to 1 row at a time. This helps fill small gaps without overly distorting your data.

df.replace(-999, np.nan)

• Explanation: This replaces a specific placeholder value (-999) with NaN (Not a Number), which is the standard marker for missing data in pandas. Converting these placeholders to NaN allows pandas functions to handle missing values appropriately.

📆 12. DateTime Operations

Convert to DateTime

df['Date'] = pd.to_datetime(df['Timestamp'], format='%Y-%m-%d')

• Explanation: This converts a column containing timestamp strings into datetime objects using the specified format. Converting to datetime enables you to use pandas’ powerful time-based functions for filtering and analysis.

Date Calculations

df['Year'] = df['Date'].dt.year
df['Days_Since'] = (pd.Timestamp.now() - df['Date']).dt.days

• Explanation: The first line extracts the year from each date, while the second calculates how many days have passed since each date. These operations are useful for breaking down date information and performing time-based comparisons.

Resampling

df.resample('M', on='Date')['Sales'].sum()

• Explanation: This resamples the DataFrame by month using the ‘Date’ column, then sums up the ‘Sales’ values for each month. Resampling helps in aggregating time series data to observe trends over different time periods.

✨ 13. Advanced Techniques

Method Chaining

(df.sort_values('Date')
   .assign(Total=lambda x: x['Price'] * x['Quantity'])
   .query('Total > 100'))

• Explanation: This method chain performs several operations in one go. It first sorts the DataFrame by the ‘Date’ column, then creates a new column ‘Total’ by multiplying ‘Price’ and ‘Quantity’, and finally filters the rows where ‘Total’ is greater than 100. Chaining makes your code concise and easier to read by linking operations together.

Optimizing Performance

df = df.astype({'Category': 'category', 'Price': 'float32'})

• Explanation: This converts the data types of the ‘Category’ and ‘Price’ columns to more memory-efficient types. Using the category data type for textual data and float32 for numerical data reduces memory usage, which is crucial for handling large datasets.

Working with Text

df['Name'] = df['Name'].str.upper().str.replace(' ', '_')

• Explanation: This line standardizes the text in the ‘Name’ column by converting all characters to uppercase and replacing spaces with underscores. Standardized text data can simplify further analysis and comparisons.

Hope this will definitely help you Master Pandas 💖

📌 Master Git with essential commands, workflows, pro techniques, and advanced tricks!

🌱 Getting Started with Git

• git init – Initialize a new Git repository
• git clone <repo_url> – Clone an existing repository
• git config --global user.name "Your Name" – Set Git username
• git config --global user.email "you@example.com" – Set Git email
• git config --list – Show all Git configurations

📌 Tracking & Staging Changes

• git status – Show the status of the working directory
• git add <file> – Stage a specific file
• git add . – Stage all changes
• git reset <file> – Unstage a file
• git reset . – Unstage all changes
• git reset --hard – Remove all changes (⚠ Irreversible!)

📜 Committing Changes

• git commit -m "message" – Commit staged changes
• git commit --amend -m "new message" – Edit the last commit message
• git commit -a -m "message" – Add & commit tracked files
• git log – View commit history
• git log --oneline – Short log format
• git diff – Show unstaged changes
• git diff --staged – Show staged changes

🌿 Branching & Merging

• git branch – List branches
• git branch <branch_name> – Create a new branch
• git checkout <branch_name> – Switch to another branch
• git checkout -b <branch_name> – Create & switch to a new branch
• git merge <branch_name> – Merge a branch into the current one
• git branch -d <branch_name> – Delete a branch
• git branch -D <branch_name> – Force delete a branch

🌍 Remote Repositories

• git remote -v – Show connected remotes
• git remote add origin <repo_url> – Connect local repo to remote
• git push -u origin <branch> – Push changes to remote repo
• git push – Push committed changes
• git pull origin <branch> – Pull latest changes from a branch
• git fetch – Fetch changes from remote without merging

🔄 Undo & Reset Changes

• git checkout -- <file> – Discard local changes in a file
• git reset --soft HEAD~1 – Undo last commit (keep changes)
• git reset --mixed HEAD~1 – Undo commit & unstage changes
• git reset --hard HEAD~1 – Undo commit & delete changes (⚠ Irreversible!)
• git revert <commit_hash> – Undo a commit by creating a new one
• git reflog – View history of HEAD movements

🕵️ Logs & History

• git log --graph --oneline --all – View a simple commit graph
• git blame <file> – See who last edited each line
• git show <commit_hash> – Show details of a specific commit
• git shortlog -sn – See contributors ranked by commits

🏷️ Tagging (Versioning)

• git tag <tag_name> – Create a tag
• git tag – List all tags
• git push --tags – Push tags to remote
• git tag -d <tag_name> – Delete a tag

🔀 Git Stashing (Temporary Save)

• git stash – Save changes without committing
• git stash push -m "message" – Save stash with a name
• git stash pop – Restore the last stash
• git stash list – View all saved stashes
• git stash show -p stash@{0} – View stash contents
• git stash drop – Delete the latest stash

🛠️ Advanced Git Commands

Rebasing & Rewriting History

• git rebase <branch> – Reapply commits on top of another branch
• git rebase -i HEAD~3 – Interactive rebase (edit last 3 commits)
• git cherry-pick <commit_hash> – Apply a commit from another branch
• git replace <bad_commit> <good_commit> – Temporarily replace a commit
• git filter-branch --tree-filter 'rm -rf secrets/' HEAD – Remove sensitive files from history (⚠ Dangerous)

Debugging & Fixing Issues

• git bisect start – Begin binary search for a bad commit
• git bisect bad – Mark current commit as bad
• git bisect good <commit> – Mark a known good commit
• git bisect reset – End bisecting

📦 Submodules & Subtrees (Multi-Repo Projects)

Submodules

• git submodule add <repo_url> – Add a submodule
• git submodule update --init --recursive – Clone & update all submodules
• git submodule foreach git pull origin main – Update all submodules

Subtrees

• git subtree add --prefix=<dir> <repo_url> <branch> – Add a repository as a subtree
• git subtree pull --prefix=<dir> <repo_url> <branch> – Pull latest changes from a subtree

🚀 Force & Safety Measures

• git push --force – Force push (⚠ Use with caution!)
• git push --force-with-lease – Safer force push (checks if no one else has pushed)

🔄 Syncing & Collaboration

• git pull --rebase – Pull latest changes and rebase instead of merge
• git push origin --delete <branch> – Delete a remote branch

🔥 Pro-Level Git Workflows

Feature Branch Workflow

• Use separate branches for each feature
• Merge only when the feature is complete

Git Flow (Popular for Teams)

• main – Stable production branch
• develop – Main development branch
• feature/* – Branches for new features
• release/* – Prepares for release
• hotfix/* – Emergency fixes

Forking Workflow (For Open-Source Contributions)

1. Fork the repo
2. Clone it locally
3. Create a new branch
4. Make changes and push
5. Submit a pull request

🧪 Git Hooks (Automate Workflows)

• .git/hooks/pre-commit – Runs before committing
• .git/hooks/pre-push – Runs before pushing
• .git/hooks/post-merge – Runs after merging

🔥 Git Aliases (Shortcuts to Save Time)

• git config --global alias.st status – Make git st show status
• git config --global alias.ci commit – Make git ci commit changes
• git config --global alias.unstage "reset HEAD --" – Make git unstage <file> remove from staging

☿ Quick Setup (Setting Up Git)

• git init
Initializes a new Git repository in your project directory.

• git add .
Stages all files in your project for commit.
Note: Be cautious when adding sensitive files, such as .env.local. You might want to add them to .gitignore to prevent them from being tracked.

• git commit -m 'message'
Commits the staged files with a descriptive message.
Example: git commit -m 'Initial commit'
Choose clear and concise commit messages for better version history tracking.

• git branch -M main
Renames the default branch to main. This is the new standard for Git repositories, replacing the older master branch.

• git remote add origin 'your-repo-link'
Links your local repository to a remote repository (e.g., GitHub, GitLab, Bitbucket).
Example: git remote add origin https://github.com/username/repository.git

• git pull origin main --allow-unrelated-histories
Pulls the latest changes from the remote main branch to your local repository, allowing for unrelated histories (useful when combining repositories or working with an existing repo).

• git push -u origin main
Pushes your local commits to the remote main branch. The -u flag sets up tracking, so in the future, you can simply use git push to push changes.

Let’s install UV Package Manager in your windows

Run this in your powershell

irm https://astral.sh/uv/install.ps1 | iex

• Press Win + R, type sysdm.cpl, and hit Enter.
• Go to the Advanced tab.
• Click Environment Variables
• Under User variables section, find and select Path, then click Edit.
• Click New, then enter:

C:\Users\"username"\.local\bin

• Make sure to replace "username" with your actual PC username
• Click OK on all windows to save changes.
• Restart your Powershell.

Run

uv --version

You should see something like this 🎉

uv 0.6.2 (6d3614eec 2025-02-19)

Let’s Test It

Install pyfiglet Package

uv pip install pyfiglet --system

Run this code

import pyfiglet

ascii_art = pyfiglet.figlet_format("Hello UV!")
print(ascii_art)

You should see Hello UV!

 _   _      _ _         _   ___     ___ 
| | | | ___| | | ___   | | | \ \   / / |
| |_| |/ _ \ | |/ _ \  | | | |\ \ / /| |
|  _  |  __/ | | (_) | | |_| | \ V / |_|
|_| |_|\___|_|_|\___/   \___/   \_/  (_)

Clap 👏 if it really helped! 🧡

Setup UV In Windows was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

1. Install Required Packages

To begin integrating Stripe, install the necessary dependencies:

npm install stripe @stripe/stripe-js react-stripe-js @stripe/react-stripe-js

2. Configure Environment Variables

Add the following environment variables in your .env.local file:

NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=pk_test_your_test_publishable_key
STRIPE_SECRET_KEY=sk_test_your_text_secret_key
NEXT_PUBLIC_BASE_URL=http://localhost:3000

• NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY: The publishable key from Stripe for the client-side.
• STRIPE_SECRET_KEY: The secret key from Stripe for server-side operations.
• NEXT_PUBLIC_BASE_URL: The base URL of your app.

3. Create Payment Intent API Route

Create app/api/payment-intent/route.ts to handle payment requests:

import { NextRequest, NextResponse } from "next/server";
import Stripe from "stripe";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY as string, {
  apiVersion: "2025-01-27.acacia",
});

export async function POST(request: NextRequest): Promise<NextResponse> {
  try {
    const { amount }: { amount: number } = await request.json();

    const paymentIntent = await stripe.paymentIntents.create({
      amount: amount,
      currency: "usd",
      automatic_payment_methods: { enabled: true },
    });

    return NextResponse.json({
      clientSecret: paymentIntent.client_secret,
      paymentIntentId: paymentIntent.id,
    });
  } catch (error) {
    console.error("Internal Error:", error);
    return NextResponse.json(
      { error: `Internal Server Error: ${error}` },
      { status: 500 }
    );
  }
}

Explanation:

• This route handles POST requests to create a payment intent.
• Uses the Stripe secret key to create a payment intent with the requested amount.
• Returns the clientSecret for further processing on the frontend.

4. Create the Stripe Payment Element

Create app/components/StripeElement/page.tsx

'use client'
import React, { useEffect, useState } from 'react'
import {
    useStripe,
    useElements,
    PaymentElement,
} from "@stripe/react-stripe-js";

const StripeElement = () => {
    const stripe = useStripe();
    const elements = useElements();
    const [errorMessage, setErrorMessage] = useState<string>();
    const [clientSecret, setClientSecret] = useState("");
    const [loading, setLoading] = useState(false);

    useEffect(() => {
        fetch(`${process.env.NEXT_PUBLIC_BASE_URL}/api/payment-intent`, {
            method: "POST",
            headers: { "Content-Type": "application/json" },
            body: JSON.stringify({ amount: 1500 }),
        })
            .then((res) => res.json())
            .then((data) => setClientSecret(data.clientSecret));
    }, []);

    const handleSubmit = async (e: React.FormEvent) => {
        e.preventDefault();
        try {
            setLoading(true);
            if (!stripe || !elements) return;

            const { error: submitError } = await elements.submit();
            if (submitError) {
                setErrorMessage(submitError.message);
                setLoading(false);
                return;
            }

            const { error } = await stripe.confirmPayment({
                elements,
                clientSecret,
                confirmParams: {
                    return_url: `${process.env.NEXT_PUBLIC_BASE_URL}/success`,
                },
            });
            setErrorMessage(error?.message);
            setLoading(false);
        } catch (err) {
            console.log(err);
        }
    }

    return (
        <div className="flex justify-center bg-[#f6f7f9] py-6 h-screen">
            <form className="w-full flex flex-col gap-6" onSubmit={handleSubmit}>
                <div className="bg-white p-6 rounded-xl flex flex-col gap-6">
                    {clientSecret ? <PaymentElement /> :
                        <div className='w-full bg-gray-200 h-10 animate-pulse'></div>
                    }
                    {errorMessage && <div className='text-xs text-red-600'>{errorMessage}</div>}

                    <button disabled={!stripe || loading} className="px-4 py-2 w-fit text-sm md:text-base bg-yellow-600 hover:bg-yellow-800 transition-all disabled:opacity-50 text-white rounded-md">
                        {!loading ? `Pay $${15}` : "Processing..."}
                    </button>
                </div>
            </form>
        </div>
    )
};
export default StripeElement;

• Fetches the payment intent clientSecret on component mount.
• Uses PaymentElement from react-stripe-js for UI rendering.
• Handles payment confirmation on form submission.

5. Use Stripe Element in the Payment Page

Modify app/page.tsx to include the payment element:

'use client'
import { Elements } from "@stripe/react-stripe-js";
import { loadStripe } from "@stripe/stripe-js";
import StripeElement from "./components/StripeElement/page";

if (process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY === undefined) {
  throw new Error("NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY is not defined");
}
const stripePromise = loadStripe(process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY);

const Home = () => {
  return (
    <Elements stripe={stripePromise} options={{ mode: "payment", amount: 1500, currency: "usd" }}>
      <StripeElement />
    </Elements>
  )
}
export default Home;

Explanation:

• Wraps StripeElement inside <Elements> for Stripe functionality.
• Uses loadStripe with the publishable key.

6. Create Success and Cancel Pages (Optional)

Success Page (app/success/page.tsx):

export default function SuccessPage() {
    return (
      <div className="flex flex-col gap-6 justify-center items-center h-screen text-center p-6">
        <h1 className='text-7xl text-yellow-600'>Payment Successful!</h1>
        <p className='font-bold text-xl'>Check your Stripe account for transaction history.</p>
      </div>
    );
}

Cancel Page (app/cancel/page.tsx):

export default function CancelPage() {
    return (
        <div className="flex flex-col gap-6 justify-center items-center h-screen text-center p-6">
            <h1 className='text-7xl text-red-600'>Payment Cancelled!</h1>
            <p className='font-bold text-xl'>Your payment was not completed. Please try again!</p>
        </div>
    );
}

Hope this guide helps you! 🧡

1. Routing in the App Router

In Next.js 15, routes are defined within the app directory. Each folder represents a route, and a page.tsx file within that folder corresponds to the route’s content.

File Structure:

app/
  ├─ about/
  │   └─ page.tsx
  └─ contact/
      └─ page.tsx

Example: app/about/page.tsx

export default function AboutPage() {
  return <h1>About Us</h1>;
}

Example: app/contact/page.tsx

export default function ContactPage() {
  return <h1>Contact Us</h1>;
}

Navigating to /about will render the AboutPage component, while /contact will render the ContactPage component.

2. Dynamic and Catch-All Routes

Next.js 15 allows dynamic and catch-all routes to create flexible routing structures.

• Dynamic routes use [slug] to represent URL parameters.
• Catch-all routes use [...param] to handle multiple path segments dynamically.

File Structure:

app/
  ├─ blog/
  │   ├─ [slug]/
  │   │   └─ page.tsx
  │   └─ [...categories]/
  │       └─ page.tsx

Example: app/blog/[slug]/page.tsx

interface BlogPostProps {
  params: Promise<{ slug: string }>;
}

export default async function BlogPost({ params }: BlogPostProps) {
  const { slug } = await params;
  return <h1>Blog Post: {slug}</h1>;
}

Example: app/blog/[...categories]/page.tsx

interface BlogCategoriesProps {
  params: Promise<{ categories: string[] }>;
}

export default async function BlogCategories({ params }: BlogCategoriesProps) {
  const { categories } = await params;
  return <h1>Categories: {categories.join(' > ')}</h1>;
}

• Visiting /blog/nextjs-routing will display “Blog Post: nextjs-routing”.
• Visiting /blog/tech/frontend/react will display “Categories: tech > frontend > react”.

3. Data Fetching Methods

In the App Router, data fetching can be performed inside Server Components using fetch().

Example: app/users/page.tsx

interface User {
  id: number;
  name: string;
}

export default async function UsersPage() {
  const res = await fetch('https://jsonplaceholder.typicode.com/users');
  const users: User[] = await res.json();

  return (
    <div>
      <h1>Users List</h1>
      <ul>
        {users.map((user) => (
          <li key={user.id}>{user.name}</li>
        ))}
      </ul>
    </div>
  );
}

This component fetches user data at build time and renders a list of users.

4. Incremental Static Regeneration (ISR)

ISR allows pages to update static content after a set time without needing a full rebuild. In the App Router, you use the revalidate property.

Example: app/posts/page.tsx

interface Post {
  id: number;
  title: string;
}

export const revalidate = 60; // Revalidate every 60 seconds

export default async function PostsPage() {
  const res = await fetch('https://jsonplaceholder.typicode.com/posts');
  const posts: Post[] = await res.json();

  return (
    <div>
      <h1>Blog Posts</h1>
      <ul>
        {posts.map((post) => (
          <li key={post.id}>{post.title}</li>
        ))}
      </ul>
    </div>
  );
}

This page will revalidate its data every 60 seconds, ensuring freshness without requiring a full deployment.

5. Client-Side Data Fetching

For client-side data fetching, Next.js recommends using libraries like SWR or React Query.

Example: app/profile/page.tsx

'use client';

import useSWR from 'swr';

interface Profile {
  name: string;
  email: string;
}

const fetcher = (url: string) => fetch(url).then((res) => res.json());

export default function ProfilePage() {
  const { data, error } = useSWR<Profile>('/api/profile', fetcher);

  if (error) return <div>Failed to load</div>;
  if (!data) return <div>Loading...</div>;

  return (
    <div>
      <h1>{data.name}'s Profile</h1>
      <p>Email: {data.email}</p>
    </div>
  );
}

This component fetches profile data on the client side, allowing for real-time updates without requiring a full page reload.

6. Middleware Usage

Middleware in Next.js allows you to run code before a request is completed, such as authentication or redirect logic.

Example: middleware.ts

import { NextResponse } from 'next/server';

export function middleware(request: Request) {
  const url = request.nextUrl.clone();
  
  // Redirect from '/old-path' to '/new-path'
  if (url.pathname === '/old-path') {
    url.pathname = '/new-path';
    return NextResponse.redirect(url);
  }

  return NextResponse.next(); // Proceed with the request if no redirect
}

This middleware intercepts requests to /old-path and redirects them to /new-path.

7. Image Optimization

Next.js provides the Image component to automatically optimize images, making them more efficient for performance.

Example: app/gallery/page.tsx

import Image from 'next/image';

export default function GalleryPage() {
  return (
    <div>
      <h1>Gallery</h1>
      <Image
        src="/images/photo.jpg"
        alt="Sample Photo"
        width={600}
        height={400}
      />
    </div>
  );
}

This component will automatically optimize the image for better performance, reducing load time.

8. Static Site Generation (SSG)

Pages are statically generated by default in Next.js 15. This means the page is pre-rendered at build time.

Example: app/products/page.tsx

interface Product {
  id: number;
  title: string;
}

export default async function ProductsPage() {
  const res = await fetch('https://fakestoreapi.com/products');
  const products: Product[] = await res.json();

  return (
    <div>
      <h1>Products</h1>
      <ul>
        {products.map((product) => (
          <li key={product.id}>{product.title}</li>
        ))}
      </ul>
    </div>
  );
}

This page will be statically generated at build time, fetching product data from an external API.

9. Server Components

Server Components in Next.js 15 allow rendering on the server by default, improving performance by reducing the load on the client.

Example: app/dashboard/page.tsx

interface Data {
  value: string;
}

export default async function DashboardPage() {
  const res = await fetch('https://api.example.com/data');
  const data: Data = await res.json();

  return (
    <div>
      <h1>Dashboard</h1>
      <p>Data: {data.value}</p>
    </div>
  );
}

This Server Component fetches the data on the server and renders it, resulting in a faster initial page load for the user.

10. Authentication Strategies

Next.js provides a simple way to implement authentication using NextAuth.js. This example shows how to authenticate using GitHub as the provider.

Installation:

npm install next-auth

app/api/auth/[...nextauth]/route.ts

import NextAuth from 'next-auth';
import GitHubProvider from 'next-auth/providers/github';

const handler = NextAuth({
  providers: [
    GitHubProvider({
      clientId: process.env.GITHUB_ID,
      clientSecret: process.env.GITHUB_SECRET,
    }),
  ],
});

export { handler as GET, handler as POST };

app/layout.tsx

'use client';

import { SessionProvider } from 'next-auth/react';

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html lang="en">
      <body>
        <SessionProvider>{children}</SessionProvider>
      </body>
    </html>
  );
}

app/page.tsx

'use client';

import { useSession, signIn, signOut } from 'next-auth/react';

export default function HomePage() {
  const { data: session } = useSession();

  if (session) {
    return (
      <div>
        <p>Welcome, {session.user?.name}</p>
        <button onClick={() => signOut()}>Sign out</button>
      </div>
    );
  } else {
    return (
      <div>
        <p>You are not signed in.</p>
        <button onClick={() => signIn()}>Sign in</button>
      </div>
    );
  }
}

This setup enables GitHub authentication in your Next.js application. It includes the NextAuth.js API route for authentication handling and session management in the UI.

11. API Routes and Middleware

Creating an API route with middleware in the App Router.

app/api/hello/route.ts

export async function GET(request: Request) {
  return new Response(JSON.stringify({ message: 'Hello, world!' }), {
    headers: { 'Content-Type': 'application/json' },
  });
}

This API route responds with a JSON message when a GET request is made to /api/hello.

middleware.ts

import { NextResponse } from 'next/server';

export function middleware(request: Request) {
  const { pathname } = request.nextUrl;

  if (pathname.startsWith('/api')) {
    // Add a custom header to all API responses
    const response = NextResponse.next();
    response.headers.set('X-Custom-Header', 'my-custom-header');
    return response;
  }

  return NextResponse.next();
}

This middleware adds a custom header (X-Custom-Header) to all API responses.

12. Styling Techniques

Tailwind CSS Setup

To style your application using Tailwind CSS, follow these steps:

Installation:

npm install -D tailwindcss postcss autoprefixer
npx tailwindcss init -p

tailwind.config.js

/** @type {import('tailwindcss').Config} */
module.exports = {
  content: [
    './app/**/*.{js,ts,jsx,tsx}',
    './components/**/*.{js,ts,jsx,tsx}',
  ],
  theme: {
    extend: {},
  },
  plugins: [],
};

app/globals.css

@tailwind base;
@tailwind components;
@tailwind utilities;

app/page.tsx

export default function HomePage() {
  return (
    <div className="flex items-center justify-center h-screen">
      <h1 className="text-4xl font-bold">Welcome to Next.js with Tailwind CSS</h1>
    </div>
  );
}

This setup integrates Tailwind CSS into your Next.js application, allowing you to use utility classes for styling.

13. Head Management

Managing document head elements using the head component.

app/page.tsx

import Head from 'next/head';

export default function HomePage() {
  return (
    <>
      <Head>
        <title>My Next.js App</title>
        <meta name="description" content="Welcome to my Next.js application" />
      </Head>
      <div>
        <h1>Home Page</h1>
      </div>
    </>
  );
}

This setup dynamically adds the title and meta description to the document head.

14. Internationalization (i18n)

Implementing internationalization (i18n) using the next-intl package.

Installation:

npm install next-intl

app/[locale]/page.tsx

import { useTranslations } from 'next-intl';

export default function HomePage() {
  const t = useTranslations('Index');

  return (
    <div>
      <h1>{t('title')}</h1>
      <p>{t('description')}</p>
    </div>
  );
}

This component renders text according to the current locale.

i18n.ts

import { NextIntlProvider } from 'next-intl';

export function withLocale(Component: React.FC) {
  return function LocaleWrapper(props: { messages: Record<string, string> }) {
    return (
      <NextIntlProvider messages={props.messages}>
        <Component {...props} />
      </NextIntlProvider>
    );
  };
}

This withLocale function wraps your component in the NextIntlProvider to provide the translation messages.

app/[locale]/layout.tsx

import { withLocale } from '../../i18n';

export default withLocale(function LocaleLayout({ children }: { children: React.ReactNode }) {
  return <>{children}</>;
});

This layout ensures that your app supports multiple languages by wrapping it with the internationalization context.

Here is the updated version with TypeScript, advanced Next.js features, and improvements for deployment and form handling:

15. Deployment Strategies — Vercel, Self-hosting, and CI/CD

Vercel Deployment Example:

Deploying your Next.js app to Vercel is straightforward. Simply follow these steps:

1. Install Vercel CLI:

npm install -g vercel

1. Deploy the App:

vercel

This will guide you through the deployment process, and your app will be live on Vercel.

CI/CD with GitHub Actions Example:

Set up GitHub Actions to automatically deploy your app to Vercel on every push to the main branch.

.github/workflows/deploy.yml

name: Deploy to Vercel

on:
  push:
   branches:
    - main

jobs:
  deploy:
   runs-on: ubuntu-latest
   steps:
    - uses: actions/checkout@v3
    - name: Deploy to Vercel
      run: vercel --prod
      env:
       VERCEL_TOKEN: ${{ secrets.VERCEL_TOKEN }}

This workflow will deploy your app to Vercel whenever you push changes to the main branch.

Self-Hosting

To deploy your Next.js app by self-hosting, follow these steps:

1. Build the project:

• npm run build

2. Start the server:

• npm run start

This will serve your app locally or on a server.

16. Handling Forms and Validations

This section demonstrates how to handle forms with basic validation in a Next.js app.

app/contact-form/page.tsx

'use client';

import { useState } from 'react';

export default function ContactForm() {
  const [name, setName] = useState('');
  const [error, setError] = useState('');

  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();
    if (name.trim() === '') {
      setError('Name is required');
      return;
    }
    setError('');
    // Process the form submission (e.g., call an API)
    alert(`Form submitted with name: ${name}`);
  };

  return (
    <form onSubmit={handleSubmit} className="p-4 max-w-md mx-auto">
      <label className="block mb-2 font-bold">Name:</label>
      <input
        type="text"
        value={name}
        onChange={(e) => setName(e.target.value)}
        className="border p-2 w-full"
      />
      {error && <p className="text-red-500 mt-1">{error}</p>}
      <button type="submit" className="mt-4 bg-blue-500 text-white p-2 rounded">
        Submit
      </button>
    </form>
  );
}

Key Concepts in This Example:

• State Management: The name and error state hooks manage the input field and validation errors.
• Form Validation: Simple validation checks if the name field is empty.
• Handling Form Submission: On form submission, it triggers an alert with the entered name (this could be replaced with an API call in real use cases).

17. Using Environment Variables in Next.js

Environment variables are critical for storing sensitive data or settings that vary between environments (e.g., development, staging, production). Variables prefixed with NEXT_PUBLIC_ are accessible in both server and client components.

Setting Up Environment Variables

Add your variables in a .env.local file to store them locally.

.env.local

NEXT_PUBLIC_API_URL=https://api.example.com

You can access these variables in your components:

app/api-config/page.tsx

export default function ConfigPage() {
  // Access environment variables on both server and client if prefixed with NEXT_PUBLIC_
  const apiUrl = process.env.NEXT_PUBLIC_API_URL;
  
  return (
    <div className="p-4">
      <h1>Configuration</h1>
      <p>API URL: {apiUrl}</p>
    </div>
  );
}

18. Caching Strategies and Performance Optimization

You can optimize performance by caching data in Server Components using revalidation options. This allows you to keep data fresh without repeatedly fetching it from the server.

app/api/cached-data/route.ts

export async function GET(request: Request) {
  // This fetch call instructs Next.js to revalidate the data every 300 seconds (5 minutes)
  const res = await fetch('https://api.example.com/data', {
    next: { revalidate: 300 }  // Revalidate every 5 minutes
  });
  const data = await res.json();

  return new Response(JSON.stringify(data), {
    headers: { 'Content-Type': 'application/json' },
  });
}

This ensures efficient data fetching and caching with periodic updates for fresh data.

19. State Management — Context API, Redux, and Zustand

A. Using the Context API

The Context API provides a way to pass data through the component tree without prop drilling.

app/context/CounterContext.tsx

'use client';
import { createContext, useContext, useState, ReactNode } from 'react';

const CounterContext = createContext<any>(null);

interface CounterProviderProps {
  children: ReactNode;
}

export function CounterProvider({ children }: CounterProviderProps) {
  const [count, setCount] = useState(0);
  const increment = () => setCount((prev) => prev + 1);
  
  return (
    <CounterContext.Provider value={{ count, increment }}>
      {children}
    </CounterContext.Provider>
  );
}

export function useCounter() {
  return useContext(CounterContext);
}

app/counter/page.tsx

'use client';
import { CounterProvider, useCounter } from '../context/CounterContext';

function CounterDisplay() {
  const { count, increment } = useCounter();
  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={increment}>Increment</button>
    </div>
  );
}

export default function CounterPage() {
  return (
    <CounterProvider>
      <CounterDisplay />
    </CounterProvider>
  );
}

B. Using Redux (with Redux Toolkit)

Redux is another popular state management tool for more complex scenarios.

store.ts

import { configureStore, createSlice } from '@reduxjs/toolkit';

const counterSlice = createSlice({
  name: 'counter',
  initialState: { count: 0 },
  reducers: {
    increment: (state) => { state.count += 1; },
  },
});

export const { increment } = counterSlice.actions;

export const store = configureStore({
  reducer: { counter: counterSlice.reducer },
});

app/redux-counter/page.tsx

'use client';
import { Provider, useDispatch, useSelector } from 'react-redux';
import { store, increment } from '../../store';

function ReduxCounter() {
  const count = useSelector((state: any) => state.counter.count);
  const dispatch = useDispatch();

  return (
    <div>
      <p>Redux Count: {count}</p>
      <button onClick={() => dispatch(increment())}>Increment</button>
    </div>
  );
}

export default function ReduxCounterPage() {
  return (
    <Provider store={store}>
      <ReduxCounter />
    </Provider>
  );
}

C. Using Zustand

Zustand is a small and simple state management library for React.

app/zustand-counter/page.tsx

'use client';
import create from 'zustand';

// Create a simple Zustand store
const useStore = create((set) => ({
  count: 0,
  increment: () => set((state) => ({ count: state.count + 1 })),
}));

export default function ZustandCounter() {
  const { count, increment } = useStore();
  return (
    <div>
      <p>Zustand Count: {count}</p>
      <button onClick={increment}>Increment</button>
    </div>
  );
}

20. Integrating Third-Party APIs (REST and GraphQL)

A. Integrating a REST API

You can fetch data from a REST API using the fetch method.

app/rest-api/page.tsx

export default async function RestApiPage() {
  // Fetch posts from a sample REST API
  const res = await fetch('https://jsonplaceholder.typicode.com/posts');
  const posts = await res.json();

  return (
    <div className="p-4">
      <h1>REST API Data</h1>
      <ul>
        {posts.slice(0, 5).map((post: { id: number; title: string }) => (
          <li key={post.id}>
            <strong>{post.title}</strong>
          </li>
        ))}
      </ul>
    </div>
  );
}

B. Integrating a GraphQL API

To use GraphQL, install a lightweight client like graphql-request:

npm install graphql-request

app/graphql/page.tsx

import { GraphQLClient, gql } from 'graphql-request';

export default async function GraphQLPage() {
  const endpoint = 'https://countries.trevorblades.com/';
  const client = new GraphQLClient(endpoint);
  
  const query = gql`
    {
      countries {
        code
        name
      }
    }
  `;
  
  const data = await client.request(query);
  const countries = data.countries;

  return (
    <div className="p-4">
      <h1>GraphQL API Data</h1>
      <ul>
        {countries.slice(0, 5).map((country: { code: string; name: string }) => (
          <li key={country.code}>
            {country.name} ({country.code})
          </li>
        ))}
      </ul>
    </div>
  );
}