Python Exercises

Take two inputs from the user. One will be an integer. The other will be a float number. Then multiply them to display the output.

Hint: Use input() to take user input. By default, input returns a string. Use int() and float() to convert those inputs to numeric types, and then multiply them.


int_num = int(input("Give me an integer number: "))
float_num = float(input("Give me a float number: "))
result = int_num * float_num
print("Your result is: ", result)

Take two numbers from the users. Calculate the result of second number power of the first number.

Hint: To raise a number to a power, use two asterisks (**). For example, 4**3 gives you 64.


base_num = int(input('Give me the base number: '))
power_num = int(input('Give me the power number: '))
result = base_num ** power_num
print('Your result is: ', result)

Find the largest of the three numbers entered by the user.

Hint: Ask the user to enter three numbers. Then compare them. You can assume the first number is the largest and then check if the second or third number is larger. Alternatively, use the built-in max() function to simplify.


num1 = int(input("First number: "))
num2 = int(input("Second number: "))
num3 = int(input("Third number: "))

largest = max(num1, num2, num3)

print("Largest number you entered is: ", largest)

Take multiple numbers as input from the user in a single line and calculate the average.

Hint: Ask the user to input numbers separated by spaces. Use split() to convert the input string into a list. Then convert each element to a number using map() or a loop. Use len() to get the number of items and calculate the average by dividing the total by the count.


numbers = input("Enter numbers separated by spaces: ").split()
numbers = [float(num) for num in numbers]

total = sum(numbers)
count = len(numbers)
average = total / count

print("The average is:", average)

Take the lengths of the three sides of a triangle from the user and calculate the area of the triangle.

Hint: To calculate the area of a triangle when all three sides are known, use Heron's formula:

First calculate the semi-perimeter:
s = (a + b + c) / 2
Then use the formula:
area = √(s * (s - a) * (s - b) * (s - c))
You can use math.sqrt() to calculate the square root.


import math

a = float(input("Enter side a: "))
b = float(input("Enter side b: "))
c = float(input("Enter side c: "))

s = (a + b + c) / 2  # semi-perimeter

area = math.sqrt(s * (s - a) * (s - b) * (s - c))

print("The area of the triangle is:", area)

Take the principal amount (money borrowed), annual interest rate, and duration in years as input. Then, compute the compound interest.

Hint: Use the compound interest formula:
Amount = Principal * (1 + Rate/100) ^ Time
Then use:
Compound Interest = Amount - Principal
You can use ** to calculate the power, or use pow() function.


principal = float(input("Enter the principal amount: "))
rate = float(input("Enter the annual interest rate (in %): "))
time = float(input("Enter the duration in years: "))

amount = principal * (1 + rate / 100) ** time
compound_interest = amount - principal

print("Compound Interest is:", compound_interest)

Take marks and their corresponding weights as input from the user, and calculate the weighted average mark.

Hint: In a weighted average, each mark is multiplied by its weight.
Use the formula:
weighted_average = (mark₁ * weight₁ + mark₂ * weight₂ + ...) / (weight₁ + weight₂ + ...)
You can ask the user to input all marks and weights as space-separated numbers.


marks = input("Enter marks separated by spaces: ").split()
weights = input("Enter corresponding weights separated by spaces: ").split()

marks = [float(m) for m in marks]
weights = [float(w) for w in weights]

total_weighted_score = sum(m * w for m, w in zip(marks, weights))
total_weight = sum(weights)

weighted_average = total_weighted_score / total_weight

print("The weighted average mark is:", weighted_average)

You have three lists of words. Create all possible combinations of sentences by taking one element from each list—one from the first list, one from the second, and one from the third.

Hint: Use three nested loops to iterate through each list. In the innermost loop, combine one word from each list into a sentence.
You can use f-strings or join() to format the sentence.


list1 = ["I", "You"]
list2 = ["like", "love"]
list3 = ["Python", "programming"]

for word1 in list1:
    for word2 in list2:
        for word3 in list3:
            sentence = f"{word1} {word2} {word3}"
            print(sentence)

Generate a random password that contains at least one uppercase letter, one lowercase letter, one digit, and one special character. The total password length should be at least 8 characters, and the remaining characters should be randomly selected from all character types.

Hint: Use the random and string modules.
Steps:

Pick one character from each required type: string.ascii_uppercase, string.ascii_lowercase, string.digits, and string.punctuation.
Decide on the total length (e.g., 10 or more characters).
Fill the remaining characters with random choices from all combined sets.
Use random.shuffle() to mix the order for better randomness.


import random
import string

# Required character types
upper = random.choice(string.ascii_uppercase)
lower = random.choice(string.ascii_lowercase)
digit = random.choice(string.digits)
special = random.choice(string.punctuation)

# Define total password length
length = 10
remaining_length = length - 4

# Combine all characters for the rest
all_chars = string.ascii_letters + string.digits + string.punctuation
remaining_chars = random.choices(all_chars, k=remaining_length)

# Combine and shuffle
password_list = [upper, lower, digit, special] + remaining_chars
random.shuffle(password_list)

# Join into final password
password = ''.join(password_list)
print("Generated Password:", password)

Build a simple word completion game. The program will show an incomplete word with some missing letters (represented by underscores), and the user must guess the missing letters one by one. The game ends when the word is completed.

Hint:

Choose a secret word and display it with some letters replaced by underscores (e.g., _e__o for "hello").
Use a loop to allow the user to guess one letter at a time.
If the guessed letter is in the original word, reveal its position(s).
Use a list to keep track of correctly guessed letters and update the display accordingly.


secret_word = "hello"
guessed = ["_" if c != "e" else "e" for c in secret_word]  # example with some pre-filled letters

while "_" in guessed:
    print("Current word:", " ".join(guessed))
    guess = input("Guess a letter: ").lower()
    
    if guess in secret_word:
        for i, c in enumerate(secret_word):
            if c == guess:
                guessed[i] = guess
    else:
        print("Wrong guess. Try again!")

print("Congratulations! The word was:", secret_word)

Data Analysis Projects

Given a DataFrame of employee data, filter out rows where age is greater than 30 and salary is more than 70,000.

Hint: Use logical operators & with parentheses for combining multiple conditions in df[condition].


import pandas as pd

df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David'],
    'age': [25, 35, 45, 32],
    'salary': [50000, 80000, 90000, 72000]
})

filtered = df[(df['age'] > 30) & (df['salary'] > 70000)]
print(filtered)

Given a numeric column, replace values above the 95th percentile with the median of the column.

Hint: Use np.percentile() to get the threshold and df.loc to apply conditional replacement.


import pandas as pd
import numpy as np

df = pd.DataFrame({'score': [10, 20, 30, 1000, 25, 22, 21, 950]})

threshold = np.percentile(df['score'], 95)
median = df['score'].median()

df.loc[df['score'] > threshold, 'score'] = median
print(df)

Group a sales DataFrame by region and get both the total and average sales for each region.

Hint: Use groupby() followed by agg() with a dictionary or list of functions.


import pandas as pd 
df = pd.DataFrame({
    'region': ['North', 'South', 'North', 'South', 'East'],
    'sales': [100, 200, 150, 300, 250]
})

result = df.groupby('region')['sales'].agg(['sum', 'mean'])
print(result)

Convert a DataFrame of product sales into a pivot table showing total sales for each product by month.

Hint: Use pivot_table() with index, columns, and aggfunc.


import pandas as pd 
df = pd.DataFrame({
    'product': ['A', 'A', 'B', 'B'],
    'month': ['Jan', 'Feb', 'Jan', 'Feb'],
    'sales': [100, 200, 150, 250]
})

pivot = df.pivot_table(index='product', columns='month', values='sales', aggfunc='sum')
print(pivot)

Fill missing values in a DataFrame using forward fill method, and then fill remaining NaNs with the column median.

Hint: Use fillna(method='ffill') and then fillna(df.median()).


import pandas as pd 
df = pd.DataFrame({'a': [1, np.nan, np.nan, 4], 'b': [np.nan, 2, np.nan, 5]})
df = df.fillna(method='ffill')
df = df.fillna(df.median())
print(df)

Create a new column that labels each student as 'Pass' if their score is above 50, otherwise 'Fail'.

Hint: Use np.where() or df.apply() with a lambda function for conditional logic.

 
import pandas as pd 
df = pd.DataFrame({'name': ['Anna', 'Ben', 'Cara'], 'score': [45, 67, 52]})
df['result'] = np.where(df['score'] > 50, 'Pass', 'Fail')
print(df)

Detect duplicate rows in a DataFrame and count how many times each duplicate appears.

Hint: Use duplicated() with keep=False and groupby() with size().


import pandas as pd 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Alice', 'David', 'Bob'],
    'age': [25, 30, 25, 40, 30]
})

duplicates = df[df.duplicated(keep=False)]
count = duplicates.groupby(['name', 'age']).size().reset_index(name='count')
print(count)

Compute the correlation matrix for a DataFrame and extract only the pairs with a correlation above 0.8 (excluding self-correlation).

Hint: Use df.corr() followed by reshaping with stack() and filtering with conditions.


import pandas as pd 
df = pd.DataFrame(np.random.rand(5, 4), columns=['A', 'B', 'C', 'D'])
corr_matrix = df.corr().stack().reset_index()
corr_matrix.columns = ['Var1', 'Var2', 'Correlation']

filtered = corr_matrix[(corr_matrix['Var1'] != corr_matrix['Var2']) & (corr_matrix['Correlation'] > 0.8)]
print(filtered)

For each row in a DataFrame with columns 'math', 'english', and 'science', calculate the grade ('A', 'B', 'C') based on the average score.

Hint: Define a custom function and apply it row-wise using df.apply(..., axis=1).


import pandas as pd                       
def get_grade(row):
    avg = (row['math'] + row['english'] + row['science']) / 3
    if avg >= 80:
        return 'A'
    elif avg >= 60:
        return 'B'
    else:
        return 'C'

df = pd.DataFrame({
    'math': [90, 70, 50],
    'english': [85, 60, 40],
    'science': [88, 65, 45]
})

df['grade'] = df.apply(get_grade, axis=1)
print(df)

Given a time series DataFrame with daily stock prices, resample it to get the monthly average closing price.

Hint: Use pd.to_datetime() to convert the date column, set it as index, and apply resample('M').


import pandas as pd                       
df = pd.DataFrame({
    'date': pd.date_range(start='2024-01-01', periods=90, freq='D'),
    'close': np.random.uniform(100, 200, 90)
})

df['date'] = pd.to_datetime(df['date'])
df.set_index('date', inplace=True)

monthly_avg = df.resample('M').mean()
print(monthly_avg)