DEV Community: HarshVardhan Jain

Benchmarking ChatGPT, Qwen, and DeepSeek on Real-World AI Tasks

HarshVardhan Jain — Mon, 03 Feb 2025 19:08:02 +0000

..................................
This article was originally published here: https://decodebuzzing.medium.com/qbenchmarking-chatgpt-qwen-and-deepseek-on-real-world-ai-tasks-75b4d7040742
...................................

The wealthy tech giants in the U.S. once dominated the AI market but DeepSeek’s release caused waves in the industry, sparking massive hype. However, as if that wasn’t enough, Qwen 2.5 emerged — surpassing DeepSeek in multiple areas. Like other reasoning models such as DeepSeek-R1 and OpenAI’s O1, Qwen 2.5-Max operates in a way that conceals its thinking process, making it harder to trace its decision-making logic

This article puts ChatGPT, Qwen, and DeepSeek through their paces with a series of key challenges ranging from solving calculus problems to debugging code. Whether you’re a developer hunting for the perfect AI coding assistant, a researcher tackling quantum mechanics, or a business professional, today I will try to reveal which model is the smartest choice for your needs (and budget)

Comparative Analysis of AI Model Capabilities:-

1. Chatgpt

ChatGPT, developed by OpenAI still remains a dominant force in the AI space, built on the powerful GPT-5 architecture and fine-tuned using Reinforcement Learning from Human Feedback (RLHF). It’s a reliable go-to for a range of tasks, from creative writing to technical documentation, making it a top choice for content creators, educators, and startups However, it’s not perfect. When it comes to specialized fields, like advanced mathematics or niche legal domains, it can struggle. On top of that, its high infrastructure costs make it tough for smaller businesses or individual developers to access it easily

ChatGPT, built with a hefty $3B+ investment, is a massive infrastructure model, while DeepSeek achieved similar performance with just $5.6M — classic China moment huh?

2. Deepseek

Out of nowhere, DeepSeek emerged as a dark horse in the AI race challenging established giants with its focus on computational precision and efficiency.

Unlike its competitors, it’s tailored for scientific and mathematical tasks and is trained on top datasets like arXiv and Wolfram Alpha, which helps it perform well in areas like optimization, physics simulations, and complex math problems. DeepSeek’s real strength is how cheap it is ( no china pun intended 😤). While models like ChatGPT and Qwen require massive resources, Deepseek does the job with way less cost. So yeah you don't need to get $1000 for a ChatGPT subscription

DeepSeek’s way of responding feels a bit robotic, and it doesn’t adapt well to tasks that aren’t too technical. It’s great for specific fields like math and research but not for casual or creative conversation

3. Qwen

After Deepseek who would’ve thought another Chinese AI would pop up and start taking over? Classic China move — spread something and this time it’s AI lol

Qwen is dominating the business game with its multilingual setup, excelling in places like Asia, especially with Mandarin and Arabic. It’s the go-to for legal and financial tasks, and it is not a reasoning model like DeepSeek R1, meaning you can’t see its thinking process. But just like DeepSeek, it’s got that robotic vibe, making it less fun for casual or creative work. If you want something more flexible, Qwen might not be the best hang

You can think of it like a team of specialists: if you ask a complex question about physics, only the experts in physics respond, while the rest of the team stays inactive

Testing Time: Comparing the 3 AI’s with Real-World Issues

To ensure fairness and through evaluation, let’s throw some of the most hyped challenges like tough math problems, wild physics stuff, coding tasks, and tricky real-world questions

— — — — — — — — — — — —

1. Physics: The Rotating Ball Problem

To kick things off, let’s dive into the classic “rotating ball in a box” problem, which has become a popular benchmark for testing how well different AI models handle complex task

Challenge: Simulate a ball bouncing inside a rotating box while obeying the laws of physics

Picture a 2d shape rotating in space. Inside, a ball bounces off the walls, staying within the boundaries and no external force. At first glance, it might seem simple, but accounting for gravity, constant rotation, and precise collision dynamics makes it a challenging simulation. You’d be surprised at how differently AI models tackle it

Prompt:-

Write a Python script that simulates a yellow ball bouncing inside a rotating square.
The ball should bounce realistically off the square’s edges, with the square rotating slowly over time
The ball must stay within the square's boundaries as the box rotates.

Box Rotation: The box should rotate continuously.
Ball Physics: The ball reacts to gravity and bounces off the box’s walls.
Ball Inside Boundaries: Make sure the ball doesn’t escape the box's boundaries, even as the box rotates.
Realistic Physics: Include proper collision detection and smooth animation
Use Python 3.x with Pygame or any similar library for rendering

Results:

1. ChatGPT’s Output: Fast but Flawed

With Chatgpt I had high expectations. But the results? Let’s just say they were… underwhelming. While DeepSeek took its time for accuracy, ChatGPT instantly spat out a clean-looking script. The ball didn’t bounce realistically. Instead, it glitched around the edges of the box, sometimes getting stuck in the corners or phasing through the walls. It is clear that ChatGPT prefers speed over depth, delivers a solution that works ****— but only in the most basic sense

Chatgpt’s Code:

import pygame
import math

# Initialize Pygame
pygame.init()

# Constants
WIDTH, HEIGHT = 600, 600
FPS = 60
GRAVITY = 0.2
BOUNCE_DAMPING = 0.8
ROTATION_SPEED = 0.5  # Degrees per frame
BALL_RADIUS = 10

# Colors
YELLOW = (255, 255, 0)
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)

# Screen setup
screen = pygame.display.set_mode((WIDTH, HEIGHT))
clock = pygame.time.Clock()

# Square properties
square_center = (WIDTH // 2, HEIGHT // 2)
square_size = 300
angle = 0

# Ball properties
ball_pos = [WIDTH // 2, HEIGHT // 2 - 50]
ball_velocity = [2, 0]

# Function to rotate a point around a center
def rotate_point(point, center, angle):
    x, y = point
    cx, cy = center
    radians = math.radians(angle)
    cos_a, sin_a = math.cos(radians), math.sin(radians)
    new_x = cos_a * (x - cx) - sin_a * (y - cy) + cx
    new_y = sin_a * (x - cx) + cos_a * (y - cy) + cy
    return new_x, new_y

# Main loop
running = True
while running:
    screen.fill(BLACK)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Apply gravity
    ball_velocity[1] += GRAVITY

    # Move ball
    ball_pos[0] += ball_velocity[0]
    ball_pos[1] += ball_velocity[1]

    # Compute rotated square corners
    half_size = square_size // 2
    square_corners = [
        (-half_size, -half_size), (half_size, -half_size),
        (half_size, half_size), (-half_size, half_size)
    ]
    rotated_corners = [rotate_point((square_center[0] + x, square_center[1] + y), square_center, angle)
                        for x, y in square_corners]

    # Check for collisions
    for i in range(4):
        p1, p2 = rotated_corners[i], rotated_corners[(i + 1) % 4]
        dx, dy = p2[0] - p1[0], p2[1] - p1[1]
        length = math.hypot(dx, dy)
        normal = (-dy / length, dx / length)  # Perpendicular normal

        # Distance from ball to edge
        projection = (ball_pos[0] - p1[0]) * normal[0] + (ball_pos[1] - p1[1]) * normal[1]
        if projection < BALL_RADIUS:  # Ball is colliding with edge
            # Reflect velocity
            dot = ball_velocity[0] * normal[0] + ball_velocity[1] * normal[1]
            ball_velocity[0] -= 2 * dot * normal[0]
            ball_velocity[1] -= 2 * dot * normal[1]

            # Apply bounce damping
            ball_velocity[0] *= BOUNCE_DAMPING
            ball_velocity[1] *= BOUNCE_DAMPING

            # Move ball out of collision
            ball_pos[0] += normal[0] * (BALL_RADIUS - projection)
            ball_pos[1] += normal[1] * (BALL_RADIUS - projection)

    # Rotate square
    angle += ROTATION_SPEED

    # Draw rotated square
    pygame.draw.polygon(screen, WHITE, rotated_corners, 2)

    # Draw ball
    pygame.draw.circle(screen, YELLOW, (int(ball_pos[0]), int(ball_pos[1])), BALL_RADIUS)

    # Update display
    pygame.display.flip()
    clock.tick(FPS)

pygame.quit()

Output:

2. Deepseek

DeepSeek’s output left me genuinely amazed. While ChatGPT was quick to generate code, DeepSeek took 200 seconds just to think about the problem. DeepSeek didn’t just write a functional script; it crafted a highly optimized, physics-accurate simulation that handled every edge case flawlessly

DeepSeek’s Code:

import pygame
import math

# Initialize Pygame
pygame.init()

# Constants
WIDTH, HEIGHT = 600, 600
SQUARE_SIZE = 400
SQUARE_HALF = SQUARE_SIZE // 2
BALL_RADIUS = 10
GRAVITY = 0.5
RESTITUTION = 0.8
ANGULAR_VELOCITY = 1  # Degrees per frame

# Setup display
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Bouncing Ball in Rotating Square")
clock = pygame.time.Clock()

# Initialize variables
square_center = (WIDTH//2, HEIGHT//2)
angle = 0

ball_pos = [WIDTH//2, HEIGHT//2]
ball_vel = [0, 0]

def rotate_point(point, center, angle):
    """Rotate a point around a center by given angle (degrees)"""
    theta = math.radians(-angle)
    ox, oy = center
    px, py = point

    qx = ox + math.cos(theta) * (px - ox) - math.sin(theta) * (py - oy)
    qy = oy + math.sin(theta) * (px - ox) + math.cos(theta) * (py - oy)
    return qx, qy

running = True
while running:
    dt = clock.tick(60) / 1000  # Delta time in seconds

    # Event handling
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Update square rotation
    angle = (angle + ANGULAR_VELOCITY) % 360

    # Apply physics
    ball_vel[1] += GRAVITY
    ball_pos[0] += ball_vel[0] * dt
    ball_pos[1] += ball_vel[1] * dt

    # Collision detection and response
    # Convert ball position to square's local coordinate system
    translated = (ball_pos[0] - square_center[0], 
                 ball_pos[1] - square_center[1])
    rotated = rotate_point((translated[0], translated[1]), (0, 0), -angle)

    collision = False
    new_local_x, new_local_y = rotated[0], rotated[1]

    # Check boundaries in local coordinates
    if rotated[0] < -SQUARE_HALF + BALL_RADIUS:
        new_local_x = -SQUARE_HALF + BALL_RADIUS
        collision = True
    elif rotated[0] > SQUARE_HALF - BALL_RADIUS:
        new_local_x = SQUARE_HALF - BALL_RADIUS
        collision = True

    if rotated[1] < -SQUARE_HALF + BALL_RADIUS:
        new_local_y = -SQUARE_HALF + BALL_RADIUS
        collision = True
    elif rotated[1] > SQUARE_HALF - BALL_RADIUS:
        new_local_y = SQUARE_HALF - BALL_RADIUS
        collision = True

    if collision:
        # Convert corrected position back to global coordinates
        corrected = rotate_point((new_local_x, new_local_y), (0, 0), angle)
        ball_pos[0] = corrected[0] + square_center[0]
        ball_pos[1] = corrected[1] + square_center[1]

        # Calculate reflection in local coordinates
        local_vel = rotate_point(ball_vel, (0, 0), -angle)

        if new_local_x != rotated[0]:  # X-axis collision
            local_vel = (-local_vel[0] * RESTITUTION, local_vel[1])
        if new_local_y != rotated[1]:  # Y-axis collision
            local_vel = (local_vel[0], -local_vel[1] * RESTITUTION)

        # Convert velocity back to global coordinates
        global_vel = rotate_point(local_vel, (0, 0), angle)
        ball_vel[0], ball_vel[1] = global_vel[0], global_vel[1]

    # Drawing
    screen.fill((0, 0, 0))

    # Draw rotating square
    square = pygame.Surface((SQUARE_SIZE, SQUARE_SIZE), pygame.SRCALPHA)
    pygame.draw.rect(square, (255, 0, 0), (0, 0, SQUARE_SIZE, SQUARE_SIZE), 2)
    rotated_square = pygame.transform.rotate(square, angle)
    screen.blit(rotated_square, rotated_square.get_rect(center=square_center))

    # Draw ball
    pygame.draw.circle(screen, (255, 255, 0), 
                      (int(ball_pos[0]), int(ball_pos[1])), BALL_RADIUS)

    pygame.display.flip()

pygame.quit()

Output:

3. Qwen’s Output: A Disappointing Attempt

If ChatGPT’s output was underwhelming, Qwen’s was downright disappointing. Given Qwen’s strong reputation for handling complex tasks, I really had high expectations for its performance. But when I ran its code for the rotating ball simulation, the results were far from what I expected. Like ChatGPT, Qwen generated code almost instantly — no deep thinking.

The ball was outside the box for most of the simulation, completely defying the laws of physics. The box itself was half out of frame, so only a portion of it was visible on the canvas

Qwen’s Code

import pygame
import math

# Initialize Pygame
pygame.init()

# Screen dimensions
WIDTH, HEIGHT = 600, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Bouncing Ball in Rotating Square")

# Colors
YELLOW = (255, 255, 0)
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)

# Clock for controlling frame rate
clock = pygame.time.Clock()
FPS = 60

# Box properties
box_size = 300
box_center = (WIDTH // 2, HEIGHT // 2)
angle = 0  # Initial rotation angle
rotation_speed = 1  # Degrees per frame

# Ball properties
ball_radius = 10
ball_pos = [box_center[0], box_center[1] - box_size // 4]  # Start near the top center of the box
ball_velocity = [4, 0]  # Initial velocity (x, y)
gravity = 0.2  # Gravity effect

# Function to rotate a point around another point
def rotate_point(point, angle, origin):
    ox, oy = origin
    px, py = point
    qx = ox + math.cos(math.radians(angle)) * (px - ox) - math.sin(math.radians(angle)) * (py - oy)
    qy = oy + math.sin(math.radians(angle)) * (px - ox) + math.cos(math.radians(angle)) * (py - oy)
    return qx, qy

# Main game loop
running = True
while running:
    screen.fill(BLACK)

    # Handle events
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Update ball physics
    ball_velocity[1] += gravity  # Apply gravity
    ball_pos[0] += ball_velocity[0]
    ball_pos[1] += ball_velocity[1]

    # Rotate the box
    angle += rotation_speed
    if angle >= 360:
        angle -= 360

    # Define the four corners of the square
    corners = [
        (-box_size / 2, -box_size / 2),
        (box_size / 2, -box_size / 2),
        (box_size / 2, box_size / 2),
        (-box_size / 2, box_size / 2)
    ]

    # Rotate the corners around the center
    rotated_corners = [rotate_point(corner, angle, box_center) for corner in corners]

    # Check collision with the edges of the box
    collided = False
    for i in range(4):
        p1 = rotated_corners[i]
        p2 = rotated_corners[(i + 1) % 4]

        # Line segment between p1 and p2
        x1, y1 = p1
        x2, y2 = p2

        # Closest point on the line to the ball
        dx = x2 - x1
        dy = y2 - y1
        t = max(0, min(1, ((ball_pos[0] - x1) * dx + (ball_pos[1] - y1) * dy) / (dx * dx + dy * dy)))
        closest_x = x1 + t * dx
        closest_y = y1 + t * dy

        # Distance between ball and closest point
        distance_sq = (closest_x - ball_pos[0]) ** 2 + (closest_y - ball_pos[1]) ** 2
        if distance_sq <= ball_radius ** 2:
            # Collision detected
            collided = True

            # Normal vector of the edge
            edge_length = math.hypot(dx, dy)
            nx = -dy / edge_length
            ny = dx / edge_length

            # Reflect the velocity vector
            dot_product = ball_velocity[0] * nx + ball_velocity[1] * ny
            ball_velocity[0] -= 2 * dot_product * nx
            ball_velocity[1] -= 2 * dot_product * ny

    # Ensure the ball stays inside the box
    if not collided:
        # Clamp the ball position within the box
        ball_pos[0] = max(box_center[0] - box_size / 2 + ball_radius, min(ball_pos[0], box_center[0] + box_size / 2 - ball_radius))
        ball_pos[1] = max(box_center[1] - box_size / 2 + ball_radius, min(ball_pos[1], box_center[1] + box_size / 2 - ball_radius))

    # Draw the rotating square
    pygame.draw.polygon(screen, WHITE, rotated_corners, 2)

    # Draw the ball
    pygame.draw.circle(screen, YELLOW, (int(ball_pos[0]), int(ball_pos[1])), ball_radius)

    # Update the display
    pygame.display.flip()

    # Cap the frame rate
    clock.tick(FPS)

# Quit Pygame
pygame.quit()

Output:

2. Comparing ChatGPT, Qwen, and DeepSeek’s Responses to a Classic Pursuit Puzzle

When it comes to solving real-world problems, not all AI models are created equal. To test their capabilities, I presented a classic pursuit problem:

“A valuable artifact was stolen. The owner began pursuit after the thief had already fled 45 km. After traveling 160 km, the owner discovered the thief remained 18 km ahead. How many additional kilometers must the owner travel to catch the thief?”

1. ChatGPT’s Response

ChatGPT took 3 attempts to arrive at the correct answer. Initially, it misinterpreted the problem but eventually corrected itself, demonstrating persistence though lacking efficiency in its first tries

2. DeepSeek’s Response

DeepSeek also answered correctly on the first try but took slightly longer than Qwen. It delivered a detailed, step-by-step solution with clear reasoning, proving its strength in deep thinking and accuracy

2. Qwen’s Response

Qwen answered correctly on the first try and did so faster than DeepSeek. It provided a concise and accurate solution without unnecessary steps, showcasing strong problem-solving speed and precision.

Conclusion

While all three AIs eventually answered correctly, Qwen stood out for its speed and efficiency, while DeepSeek showcased its methodical approach. ChatGPT required multiple attempts

Humanizing AI Content: The Human Side of AI

While speed and efficiency are often celebrated in AI, the real game-changer is emotional intelligence — the ability to understand, interpret, and respond to human emotions. While AI models like DeepSeek excel in precision and logic, and ChatGPT shines in creativity. Let’s test it out

— — — — — — — —
Prompt: Write a messy emotional love letter
— — — — — — — —

Chatgpt:

Deepseek:

Qwen:

Interestingly, when tested for human-like originality, all three models — ChatGPT, DeepSeek, and Qwen — struggled to break free from their AI-generated patterns. Note: all three began their responses with the same robotic line: “I don’t even know where to start”. Any how I had high expectations with Chatgpt but Qwen won!

Key Takeaways:
DeepSeek: The go-to for research and critical thinking, outperforming others in precision and depth.
Qwen: Matched DeepSeek in solving the classic riddle on the first try and won in humanized content, making it a strong all-rounder.
ChatGPT: Took multiple tries to solve the riddle but remains a top choice for creative tasks and human-like interactions.

Final Verdict: Who Should Use Which AI?
Researchers: DeepSeek
Engineers: DeepSeek
Writers: ChatGPT or Qwen
Lawyers: Qwen withchatgpt
Educators: ChatGPT
Content Creators: Qwen and deep-thinking from Deepseek

Conclusion:

I would love to hear your take in the comments and correct me If wrong. If you found this article helpful, clap, share, and share your views. Feel free to support me here or UPI: jainhvj@fam

I’m excited to keep learning and exploring this vast field. I appreciate your feedback and look forward to insightful discussions

Thank you!

Why You Should Rethink Your Python Toolbox in 2025

HarshVardhan Jain — Sat, 25 Jan 2025 21:20:17 +0000

Upgrade Your Python Toolbox for 2025: Discover the Essential Libraries You’re Missing Out On

This article was originally published here: https://medium.com/p/3616b07b6121

Python’s powerful, but your tools can make you a coding god or a frustrated mess. Don’t be that developer stuck using outdated tools while the rest of the world is speeding ahead

Many developers are still heavily reliant on libraries like Pandas, Requests, and BeautifulSoup, but these aren’t always the most efficient solutions for modern development needs. In this article, we’ll explore some of the top emerging Python libraries for 2025 that will supercharge your development process and help you stay ahead of the curve.

A) Outdated Libraries and Better Replacements

1. Ditch OS For File Operations: Use pathlib

The os module is often cumbersome for file and path handling due to issues like platform-specific path separators and verbose syntax. pathlib simplifies this with intuitive object-oriented methods like for joining paths, .exists(), and .is_file() for checks, making cross-platform compatibility seamless. With its cleaner syntax and built-in features, pathlib eliminates the need for manual adjustments, becoming the go-to solution for modern Python developers
Example:

from pathlib import Path

# Creating a file
file = Path("example.txt")
file.write_text("Hello, Pathlib!")

# Reading the file
print(file.read_text())

# Checking existence
if file.exists():
    print("File exists")

Why Switch?

pathlib just makes life easier. It’s more intuitive than os, with its object-oriented approach to working with files and paths. You won’t have to worry about platform-specific issues (like \ vs /) because pathlib handles all that for you. Plus, the syntax is cleaner and more readable.

It’s not a game-changer for tiny projects, but for anything serious, it’s definitely the way forward

2. Replace Requests with httpx: A Modern HTTP Client for Asynchronous and Synchronous Requests

HTTPS has emerged as a powerful alternative to requests, especially in 2025. Unlike requests, HTTPX also offers HTTP/2 support, which can dramatically reduce latency and improve request handling by allowing multiplexed connections. httpx—a modern alternative that supports async operations without sacrificing the simplicity and familiarity of the Requests API.

Example:

import httpx
import asyncio
# asyncio is used to enable asynchronous programming, 
# and it's integral to httpx for non-blocking HTTP requests.
# With httpx, you can use async/await syntax to run multiple HTTP requests concurrently.


# Demonstrating Asynchronous Requests with httpx
async def async_get_data():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://jsonplaceholder.typicode.com/posts/1')
        if response.status_code == 200:
            print("Async Response:", response.json())
        else:
            print(f"Error: {response.status_code}")

# Run the asynchronous request
asyncio.run(async_get_data())

# Asynchronous HTTP/2 Request with httpx
async def async_http2_request():
    async with httpx.AsyncClient(http2=True) as client:
        response = await client.get('https://http2.golang.org/reqinfo')
        if response.status_code == 200:
            print("HTTP/2 Response:", response.text)
        else:
            print(f"Error: {response.status_code}")

# Run the HTTP/2 request
asyncio.run(async_http2_request())

# Connection Pooling with httpx Client
def connection_pooling_example():
    with httpx.Client(keep_alive=True) as client:
        url = "https://jsonplaceholder.typicode.com/posts/1"
        # Multiple requests using connection pooling
        for _ in range(5):
            response = client.get(url)
            if response.status_code == 200:
                print("Response Content:", response.text)
            else:
                print(f"Error: {response.status_code}")

# Run the connection pooling example
connection_pooling_example()

Why Use `httpx`?

If you’re working on applications that demand high concurrency, such as web scraping or microservices, HTTPX’s support for asynchronous operations offers significant performance improvements.

Another key benefit of HTTPX is its connection pooling by default for every host, which reduces latency and resource consumption

Essentially, if you're working with a lot of I/O, httpx will save you a lot of headaches.

3. **Move Beyond Pandas: Use Polars

Pandasis perfect for small to mid-sized datasets, but when you throw larger datasets at it, the memory usage and performance starts to suffer.

Issues like slow memory consumption, inefficient column-based operations, and difficulties with data transformations such as .fillna() and .loc are common problems for many developers using Pandas

Polars is a modern, memory-efficient, and multi-threaded data processing Rust-based backend library that provides a faster alternative to Pandas for large datasets. Unlike Pandas, Polars supports parallel processing, which speeds up data manipulation tasks

Example:

import polars as pl

# Create a Polars DataFrame from a dictionary with sample data
data = pl.DataFrame({
    "name": ["Alice", "Bob", "Charlie", "David"],
    "age": [25, 30, 35, 40],
    "salary": [50000, 60000, 70000, 80000]
})

print("Original DataFrame:")
print(data)
# Output:
# shape: (4, 3)
# ┌─────────┬─────┬────────┐
# │ name    ┆ age ┆ salary │
# │ ---     ┆ --- ┆ ---    │
# │ str     ┆ i64 ┆ i64    │
# ╞═════════╪═════╪════════╡
# │ Alice   ┆ 25  ┆ 50000  │
# │ Bob     ┆ 30  ┆ 60000  │
# │ Charlie ┆ 35  ┆ 70000  │
# │ David   ┆ 40  ┆ 80000  │
# └─────────┴─────┴────────┘
# This shows the original DataFrame with 4 rows and 3 columns: "name", "age", "salary"

# Perform lazy evaluation to prepare for filtering, sorting, and selecting data
result = (
    data.lazy()  # Converts the DataFrame to a lazy query, operations will not be executed yet
    .filter(pl.col("age") > 30)  # Filter rows where age > 30 (Charlie, David)
    .sort("salary", reverse=True)  # Sort by salary in descending order (David first, Charlie second)
    .select(["name", "salary"])  # Select only "name" and "salary" columns
    .collect()  # Trigger computation and get the result
)

print("\nFiltered, Sorted, and Selected Data:")
print(result)
# Output:
# Filtered, Sorted, and Selected Data:
# shape: (2, 2)
# ┌─────────┬────────┐
# │ name    ┆ salary │
# │ ---     ┆ ---    │
# │ str     ┆ i64    │
# ╞═════════╪════════╡
# │ David   ┆ 80000  │
# │ Charlie ┆ 70000  │
# └─────────┴────────┘
# This output shows that only two rows ("Charlie" and "David") are left after filtering by age > 30.
# The rows are sorted by salary in descending order, with "David" (salary 80000) appearing first, followed by "Charlie" (salary 70000).

Why Polars?

So, if you’re dealing with large-scale data processing, need parallel execution, or want a memory-efficient solution, Polars is the superior choice for modern data science and analytics..Pandas might be your first love, but Polars is the one who can handle the heavy lifting.

4. Upgrade Your Testing Game: Replace unittest with pytest

unittest? Sure, it works, but come on, it’s 2025. You ain’t pulling any bitches with that. It’s like trying to impress someone with a flip phone when everyone’s rocking iPhones. Yeah, it works, but it’s a total hassle. pytest: it’s the cool, modern testing framework that makes writing and reading tests way easier.

Wait, What’s unittest?

For the uninitiated, unittest is Python's built-in testing framework, but it often feels outdated with verbose syntax and repetitive boilerplate. With, you get powerful features like flexible fixture management, automatic test discovery, and built-in parameterization (using @pytest.mark.parametrize) to easily run the same test with different inputs. It also supports parallel test execution via pytest-xdist, which boosts performance for large test suites.

Example:

# test_sample.py

# Importing pytest library for testing
import pytest

# Simple function to add two numbers
def add(x, y):
    return x + y  

# Test function to check if add(x, y) returns the correct result
def test_add():  # Note: function started with "test_"
    # Checking if 2 + 3 equals 5
    assert add(2, 3) == 5  # If the add function works, this should pass
    # No output is printed because pytest handles the test results automatically

# Expected output after running pytest:
# ===================== test session starts =====================
# collected 1 item
# 
# test_sample.py .                                        [100%]
# 
# ===================== 1 passed in 0.03 seconds =====================

Why test_?

By using the test_ prefix, you make it clear to pytest that these functions are supposed to be tests. It’s part of pytest's convention to discover and run the correct functions without any additional configuration.

In short, pytest replaces the clunky setup of unittest and makes testing more efficient, flexible, and scalable.

Libraries That Deserve More Attention in 2025

1. BeeWare for Cross-Platform Python App Development

BeeWare is an emerging Python framework that deserves more attention, especially in 2025. It allows Python developers to write native apps across multiple platforms (desktop, mobile, web) using the same codebase. Unlike traditional desktop frameworks like PyQt or Tkinter, BeeWare goes further by enabling deployment on Android, iOS, and even WebAssembly. One key feature of BeeWare is its cross-platform nature, so you can write an app once and run it everywhere.

— — — — — — — — — — — — — — — — -
Getting Started with BeeWare
Before running the examples, make sure you have BeeWare installed. Follow the official installation guide to set up your environment.

Once installed, you can start building cross-platform apps with BeeWare! Here is an example:

— — — — — — — — — — — — — — — — -
Example:

# Install BeeWare dependencies
# Follow this link to install: https://docs.beeware.org/en/latest/tutorial/tutorial-0.html#install-dependencies

# Example BeeWare Code: Simple App with Toga
import toga
from toga.style import Pack
from toga.style.pack import COLUMN, ROW

class MyApp(toga.App):
    def startup(self):
        # Create a simple button and label
        self.main_window = toga.MainWindow(self.name)
        self.label = toga.Label('Hello, BeeWare!',
                                style=Pack(padding=10))
        self.button = toga.Button('Click Me!',
                                  on_press=self.on_button_press,
                                  style=Pack(padding=10))

        # Create a Box to hold the button and label
        self.box = toga.Box(children=[self.label, self.button],
                            style=Pack(direction=COLUMN, padding=10))
        self.main_window.content = self.box
        self.main_window.show()

    def on_button_press(self, widget):
        self.label.text = 'Button Pressed!'

# Run the app
def main():
    return MyApp('My BeeWare App', 'org.beeware.helloworld')

if __name__ == '__main__':
    main().main_loop()

This is what BeeWare provides. Tools to help you write Python code with a rich, native user interface; and the libraries and support code necessary to get that code running on iOS, Android, macOS, Linux, Windows, tvOS, and more.

2. pydantic for Data Validation

Validating data can be a chore. pydanticis a Python library that validates and parses data based on type hints. If you’re dealing with messy or untrusted data—like API responses, user inputs, or configs—Pydantic ensures your data is clean, structured, and error-free.

from pydantic import BaseModel, ValidationError, Field
from typing import List, Optional

# Define a data model using Pydantic
class User(BaseModel):
    id: int  # Automatically validates that id must be an integer
    name: str  # Validates that name must be a string
    age: Optional[int] = None  # Optional field with default value of None
    email: str = Field(..., regex=r'^\S+@\S+\.\S+$')  # Ensures email follows proper format
    tags: List[str] = []  # Ensures 'tags' is a list of strings, default is an empty list

# Example usage
try:
    # Creating a valid user instance
    user = User(id=1, name="John Doe", age=30, email="john.doe@example.com", tags=["developer", "writer"])
    print(user)  # Output: id=1 name='John Doe' age=30 email='john.doe@example.com' tags=['developer', 'writer']
except ValidationError as e:
    # Handles validation errors
    print(e)  # This block won't execute for valid data

# Demonstrating validation
try:
    # Attempting to create a user with invalid email
    invalid_user = User(id="abc", name="Invalid User", email="not-an-email")
except ValidationError as e:
    print(e)
    """
    Output:
    1 validation error for User
    id
      value is not a valid integer (type=type_error.integer)
    email
      string does not match regex "^\\S+@\\S+\\.\\S+$" (type=value_error.str.regex; pattern=^\\S+@\\S+\\.\\S+$)
    """

# Demonstrating default values
user_without_age = User(id=2, name="Jane Doe", email="jane.doe@example.com")
print(user_without_age)
# Output: id=2 name='Jane Doe' age=None email='jane.doe@example.com' tags=[]

Why Use pydantic?

It automatically validates and converts data types without extensive custom configurations. Unlike Marshmallow, which requires explicit schema definitions, Pydantic integrates seamlessly with frameworks like FastAPI and offers better performance due to its Cython optimization, making it a go-to choice for APIs and data-driven projects.

3. Poetry FOR PACKAGING AND DEPENDENCY MANAGEMENT

Poetry is a modern Python tool for easy dependency management and project packaging.

It uses pyproject.toml and poetry.lock for version control, ensures reproducible builds, and simplifies publishing to PyPI. It improves transparency in dependency graphs, making it a powerful alternative to older tools like pip and setuptools.

Example:

# Create a new Poetry project
poetry new my_project

# Navigate into the project directory
cd my_project

# Add a dependency to the project
poetry add requests

# Add a dev dependency (e.g., pytest for testing)
poetry add pytest --group dev

# View installed dependencies
poetry show

# Install all dependencies listed in pyproject.toml
poetry install

# Remove a dependency
poetry remove requests

# Run the virtual environment shell
poetry shell

# Run a script inside the Poetry environment
poetry run python my_script.py

# Update dependencies to their latest versions
poetry update

# Publish the package to PyPI
poetry publish --build

Learn more about poetry here . It’s a great tool

Why Use poetry?

It stands out for its ease of use when adding, updating, or removing dependencies and its seamless publishing workflow to PyPI

4. fastapi for Modern APIs

FastApi is a high-performance Python framework commonly used as an alternative to Flask or Django REST Framework for building APIs. It is ideal for both small projects and large-scale applications due to its scalability and efficiency. FastAPI stands out because it integrates Python’s type hints for data validation and automatically generates OpenAPI documentation, making development faster and less error-prone

Example Integrating FastAPI and Pydantic:

from fastapi import FastAPI, Depends, HTTPException, Query
from pydantic import BaseModel, Field
from typing import Optional

app = FastAPI()

# Dependency Injection Example
def fake_db():
    return {"db": "Connected to database"}

# Data Validation with Pydantic
class Item(BaseModel):
    name: str = Field(..., example="Laptop", description="Name of the item")
    price: float = Field(..., gt=0, example=999.99, description="Price must be greater than 0")
    in_stock: bool = Field(default=True, example=True)

# API Endpoints
@app.post("/items/", tags=["Items"])
async def create_item(
    item: Item,
    db=Depends(fake_db),
    discount: Optional[float] = Query(0.0, ge=0, le=1, description="Discount between 0 and 1"),
):
    if not db.get("db"):
        raise HTTPException(status_code=500, detail="Database not connected")
    final_price = item.price * (1 - discount)
    return {
        "item": item,
        "final_price": final_price,
        "db_status": db["db"],
    }

# Async API Example
@app.get("/async-process/", tags=["Async"])
async def async_task():
    import asyncio
    await asyncio.sleep(2)  # Simulate a long-running task
    return {"message": "This endpoint is async!"}

# Automatic Interactive API Documentation
@app.get("/docs/", tags=["Docs"])
async def docs_info():
    return {"info": "Visit /docs for Swagger or /redoc for ReDoc documentation!"}

Why Use fastapi?

Its asynchronous capabilities, powered by Starlette and Pydantic, allow it to handle high-concurrency use cases, making it popular for modern microservices and API-first designs.

5. asyncpg for Database Operations

asyncpg is a highly performant, asynchronous PostgreSQL database driver for Python. Want fast queries in your Python app? Boom, no more slow, blocking calls that make your app crawl like you’re still running on dial-up internet. Unlike traditional synchronous libraries like psycopg2, asyncpg uses asynchronous programming to optimize database operations without blocking other tasks in the application, especially useful in modern web frameworks like FastAPI, Tornado, or Sanic.

Example:

import asyncpg
import asyncio

# Connect to the PostgreSQL database
async def connect_db():
    conn = await asyncpg.connect(user='your_user', password='your_password', database='your_db', host='localhost')
    return conn

# Create a table in the database
async def create_table():
    conn = await connect_db()
    await conn.execute('''
        CREATE TABLE IF NOT EXISTS users(
            id SERIAL PRIMARY KEY,
            name TEXT,
            age INT
        )
    ''')
    print("Table created successfully")
    await conn.close()

# Insert data into the table
async def insert_user(name: str, age: int):
    conn = await connect_db()
    await conn.execute('INSERT INTO users(name, age) VALUES($1, $2)', name, age)
    print(f"User {name} inserted")
    await conn.close()

# Fetch all users from the table
async def fetch_users():
    conn = await connect_db()
    users = await conn.fetch('SELECT * FROM users')
    for user in users:
        print(f"ID: {user['id']}, Name: {user['name']}, Age: {user['age']}")
    await conn.close()

# Main function to demonstrate usage
async def main():
    await create_table()
    await insert_user('Alice', 30)
    await fetch_users()

# Run the main function
asyncio.run(main())

Why Use asyncpg?

To wrap it up, asyncpg is a fast, asynchronous PostgreSQL driver for Python, offering non-blocking database operations. Unlike traditional libraries like psycopg2, it helps your app run more efficiently by preventing slow database queries from holding up other tasks. It’s perfect for high-performance web frameworks like FastAPI.

duckdb for In-Memory Analytics DuckDB is a fast, in-memory database designed for running complex analytical queries efficiently. Unlike traditional databases like PostgreSQL, DuckDB works directly with data in memory, allowing you to quickly process large datasets without needing external servers.

With features like vectorized query execution, support for formats like Parquet, Arrow, and Pandas, and efficient handling of JSON and semi-structured data, DuckDB is a top choice for analytics. It outshines tools like Spark by eliminating complex setups and offering unparalleled performance for SQL analytics and large-scale data queries, making it the go-to solution for developers and data engineers today

Example:

import duckdb

# Create a DuckDB in-memory database and a table to store some personal data
conn = duckdb.connect()

# Create a table to store user details
conn.execute("""
CREATE TABLE users (
    id INTEGER,
    name VARCHAR,
    medium_handle VARCHAR
);
""")

# Insert a record with Harshvardhan's details
conn.execute("""
INSERT INTO users VALUES (1, 'Harshvardhan', '@decodebuzzing');
""")

# Querying the database to fetch user details
result = conn.execute("SELECT * FROM users;").fetchall()

# Print the results
print(result)  # Output: [(1, 'Harshvardhan', '@decodebuzzing')]

# Perform a query to search by name
result_by_name = conn.execute("SELECT * FROM users WHERE name = 'Harshvardhan';").fetchall()

# Print the search result
print(result_by_name)  # Output: [(1, 'Harshvardhan', '@decodebuzzing')]

# Demonstrating SELECT with a WHERE clause and LIMIT
limited_result = conn.execute("SELECT * FROM users LIMIT 1;").fetchall()
print(limited_result)  # Output: [(1, 'Harshvardhan', '@decodebuzzing')]

# Demonstrating aggregation (count the number of users)
count_users = conn.execute("SELECT COUNT(*) FROM users;").fetchone()
print(count_users)  # Output: (1,)

# Join example: Joining two dummy tables for more complex queries (imagine having another table like posts)
conn.execute("""
CREATE TABLE posts (
    post_id INTEGER,
    user_id INTEGER,
    content VARCHAR
);
""")
conn.execute("""
INSERT INTO posts VALUES (1, 1, 'Exploring DuckDB with Python!');
""")

# Perform a JOIN to get posts by the user
joined_result = conn.execute("""
SELECT users.name, posts.content
FROM users
JOIN posts ON users.id = posts.user_id;
""").fetchall()

# Print the JOIN result
print(joined_result)  # Output: [('Harshvardhan', 'Exploring DuckDB with Python!')]

# Closing the connection
conn.close()

DuckDB is easy to install and deploy. It has zero external dependencies and runs in-process in its host application or as a single binary.

DuckDB — An in-process SQL OLAP database management system

Final Thoughts

In 2025, it’s time to rethink your Python toolbox. While classics like Requests and Pandas have their place, emerging libraries like httpx, Polars, rich, and duckdb can streamline your workflows.

Support My Work

If you found this article helpful, make sure to clap and share and share your views

Buy me a coffee:-

Feel free to support me here or use UPI: jainhvj@fam

I’m just 18 year old greenhorn in this subject, and with the years ahead, I can’t wait to learn more about this vast field and grow with all of you by my side

Thank you!

DEV Community: HarshVardhan Jain

Benchmarking ChatGPT, Qwen, and DeepSeek on Real-World AI Tasks

Comparative Analysis of AI Model Capabilities:-

1. Chatgpt

2. Deepseek

3. Qwen

Testing Time: Comparing the 3 AI’s with Real-World Issues

1. Physics: The Rotating Ball Problem

Challenge: Simulate a ball bouncing inside a rotating box while obeying the laws of physics

Prompt:-

1. ChatGPT’s Output: Fast but Flawed

Chatgpt’s Code:

Output:

2. Deepseek

DeepSeek’s Code:

Output:

3. Qwen’s Output: A Disappointing Attempt

Qwen’s Code

Output:

2. Comparing ChatGPT, Qwen, and DeepSeek’s Responses to a Classic Pursuit Puzzle

1. ChatGPT’s Response

2. DeepSeek’s Response

2. Qwen’s Response

Conclusion

Humanizing AI Content: The Human Side of AI

Chatgpt:

Deepseek:

Qwen:

Conclusion:

Thank you!

Why You Should Rethink Your Python Toolbox in 2025

Upgrade Your Python Toolbox for 2025: Discover the Essential Libraries You’re Missing Out On

This article was originally published here: https://medium.com/p/3616b07b6121

A) Outdated Libraries and Better Replacements

1. Ditch OS For File Operations: Use pathlib

Why Switch?

2. Replace Requests with httpx: A Modern HTTP Client for Asynchronous and Synchronous Requests

Why Use httpx?

3. **Move Beyond Pandas: Use Polars

Why Polars?

4. Upgrade Your Testing Game: Replace unittest with pytest

Wait, What’s unittest?

Why test_?

Libraries That Deserve More Attention in 2025

1. BeeWare for Cross-Platform Python App Development

2. pydantic for Data Validation

Why Use pydantic?

3. Poetry FOR PACKAGING AND DEPENDENCY MANAGEMENT

Why Use poetry?

4. fastapi for Modern APIs

Why Use fastapi?

5. asyncpg for Database Operations

Why Use asyncpg?

Final Thoughts

Support My Work

Buy me a coffee:-

Why Use `httpx`?