7 Lesser-Known Pandas Functions That’ll Blow Your Mind

1. explode()=Turns list items into rows

import pandas as pd

df = pd.DataFrame({"Name": ["A", "B"], 
                   "Tags": [["x", "y"], ["p", "q"]]})
df.explode("Tags")

#source code --> clcoding.com

Output:

Name
Tags
0
A
x
0
A
y
1
B
p
1
B
q

2. query()- Filter rows using expression

df = pd.DataFrame({"Age":[20,25,30], "Score":[90,85,70]})
df.query("Age > 22 and Score > 80")

#source code --> clcoding.com
Output:
Age
Score
1
25
85
3. nlargets()- Get the top n rows

df=pd.DataFrame({"Name":["A","B","C"],"Marks":[50,95,80]})
df.nlargest(1,"Marks")
#source code --> clcoding.com
Output:
Name
Marks
1
B
95
4. nsmallest()- Get the lowest n rows

df=pd.DataFrame({"A":[10,3,7],"B":[4,9,1]})
df.nsmallest(2,"A")
#source code --> clcoding.com
Output:
A
B
1
3
9
2
7
1


5. pivot_table()- Create summary table automatically

df=pd.DataFrame({
    "City":["A","A","B","B"],
    "Sales": [10,20,30,5]
})
df.pivot_table(values="Sales",index="City",aggfunc="sum")

#source code --> clcoding.com
Output:
Sales
City
A
30
B
35
6. fillna(method="ffill")- Fills missing values forward

df = pd.DataFrame({"X":[1,None,None,4]})
df.fillna(method="ffill")

#source code --> clcoding.com
Output:
X
0
1.0
1
1.0
2
1.0
3
4.0
7. assign()- Adds new column cleanly

df = pd.DataFrame({"A":[1,2,3]})
df = df.assign(B=df.A * 10)
print(df)

#source code --> clcoding.com
Output:
   A   B
0  1  10
1  2  20
2  3  30

Read More

Python Coding Challenge - Question with Answer (01131125)

 

Explanation:

Create a List

nums = [2, 4, 6]

A list named nums is created with three integer elements: 2, 4, and 6.

This will be used to calculate the average of its elements later.

Initialize Loop Control Variables

i = 0

s = 0

i → Acts as a loop counter, starting from 0.

s → A sum accumulator initialized to 0.

It will store the running total of the numbers in the list.

Start the While Loop

while i < len(nums):

The loop runs as long as i is less than the length of the list nums.

Since len(nums) is 3, this means the loop will run while i = 0, 1, 2.

This ensures every element in the list is processed once.

Add the Current Element to the Sum

    s += nums[i]

At each loop iteration:

The element at index i is accessed: nums[i].

It is added to the sum s.

Example of how s changes:

When i=0: s = 0 + 2 = 2

When i=1: s = 2 + 4 = 6

When i=2: s = 6 + 6 = 12

Increment the Loop Counter

    i += 1

After processing one element, i increases by 1.

This moves to the next element of the list in the next iteration.

Print the Final Result

print(s // len(nums))

Once the loop ends, the total sum s is 12.

The expression s // len(nums) performs integer division:

12 // 3 = 4

Hence, it prints the average (integer form) of the list elements.

Final Output

4

Probability and Statistics using Python

Read More

Top 8 Python Libraries for Deep Learning in 2026

 

1 Tensorflow: The insdustry standard

import tensorflow as tf

x = tf.constant([[1.0, 2.0], [3.0, 4.0]])
y = tf.constant([[5.0, 6.0], [7.0, 8.0]])
result = tf.matmul(x, y)
print(result)

Output:

tf.Tensor(
[[19. 22.]
 [43. 50.]], shape=(2, 2), dtype=float32)

2. Pytocrh- Reasearchers favourite
import torch
x-torch.tensor([[1.,2.],[3.,4.]])
y=torch.tensor([[2.,0.],[0.,2.]])
print(torch.mm(x,y))
Output:
tensor([[2., 4.],
        [6., 8.]])


3. Kera- The beginner deep learning Friend
from tensorflow import keras
from tensorflow.keras import layers
model=keras.Sequential([
    keras.Input(shape=(3,)),
    layers.Dense(4,activation='relu'),
    layers.Dense(1)
])
model.summary()

Output:
Model: "sequential_2"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ dense_5 (Dense)                      │ (None, 4)                   │              16 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_6 (Dense)                      │ (None, 1)                   │               5 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘
 Total params: 21 (84.00 B)
 Trainable params: 21 (84.00 B)
 Non-trainable params: 0 (0.00 B)

4. JAX – High-Speed, GPU-Accelerated Computing

import jax.numpy as jnp
from jax import grad
def f(x):
    return x**2+3*x +2

df=grad(f)
print(df(5.0))

Output:
13.0

5. Optuna – Smart Hyperparameter Tuning

import optuna
optuna.logging.set_verbosity(optuna.logging.WARNING)

def objective(trial):
    x = trial.suggest_float('x', -10, 10)
    return (x - 3)**2

study = optuna.create_study(direction='minimize')
study.optimize(objective, n_trials=10)
print(study.best_params)

Output:
{'x': 1.9064779937795588}

6. Numpy– Foundation of All Deep Learning Math

import numpy as np
x=np.array([[1,2,3],[4,5,6]])

print("Mean:",x.mean())
print("Dot product:\n", np.dot(x,x.T))

Output:
Mean: 3.5
Dot product:
 [[14 32]
 [32 77]]

7. Pandas – Data Handling for Deep Learning

import pandas as pd

data = {'Feature1': [1, 2, 3, 4],
        'Feature2': [2, 3, 4, 5],
        'Target': [3, 5, 7, 9]}

df = pd.DataFrame(data)
print(df.head())
print("Mean of Target:", df['Target'].mean())

Output:
   Feature1  Feature2  Target
0         1         2       3
1         2         3       5
2         3         4       7
3         4         5       9
Mean of Target: 6.0


8. scikit-learn

from sklearn.linear_model import LinearRegression
import numpy as np
X=np.array([[1],[2],[3],[4]])
y=np.array([2,4,6,8])

model=LinearRegression().fit(X,y)
print("Prediction for 5:",model.predict([[5]]))

Output:
Prediction for 5: [10.]

Read More