Python Data Science Basics (Pandas, Numpy) Exercises

The np.array() function creates a NumPy array from a Python list. NumPy arrays are more efficient for numerical computations than Python lists because they support vectorized operations and broadcasting.

Example:

import numpy as np

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

• Option 2 (np.list) and Option 3 (numpy.array_list) do not exist.
• Option 4 (np.ndarray) can create arrays but requires a different initialization method.
• Using np.array() is the standard approach for data analysis and numerical computations in Python.

The pd.DataFrame() constructor can take a dictionary where keys are column names and values are lists of column data. This is the standard method to create DataFrames for data analysis.

Example:

import pandas as pd

data = {"A": [1, 2], "B": [3, 4]}
df = pd.DataFrame(data)
print(df)
# Output:
#    A  B
# 0  1  3
# 1  2  4

• Option 1 (from_dict with incorrect syntax) is invalid.
• Option 2 (DataFrame.dict) and Option 3 (create_dataframe) do not exist in Pandas.
• Using pd.DataFrame(dictionary) is simple and readable, widely used in data science pipelines.

The np.zeros() function generates an array filled with zeros. It is commonly used to initialize arrays for computations where the initial value should be 0.

Example:

import numpy as np

arr = np.zeros((3, 4))
print(arr)
# Output:
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

• Option 2 (ones) creates an array of ones.
• Option 3 (empty) creates an uninitialized array, which may contain random values.
• Option 4 (full) can fill with zeros but is less direct.

Using np.zeros() is the standard approach for creating zero-initialized arrays in data analysis or machine learning preprocessing.

In Pandas, you can access a column using df['column_name']. This returns a Series representing the column. It is the most common and readable way to access data in DataFrames.

Example:

import pandas as pd

data = {"A": [1, 2], "B": [3, 4]}
df = pd.DataFrame(data)
print(df['A'])
# Output:
# 0    1
# 1    2
# Name: A, dtype: int64

• Option 1 (df.column()) and Option 3 (get_column()) do not exist.
• Option 4 (iloc[:,0:1]) also works but returns a DataFrame, not a Series.
• Using df['A'] is preferred for simplicity and readability in data analysis workflows.

The np.linspace(start, stop, num) function creates num evenly spaced numbers between start and stop (inclusive). It is often used in plotting, simulations, or generating test datasets.

Example:

import numpy as np

arr = np.linspace(0, 10, 5)
print(arr)
# Output: [ 0.   2.5  5.   7.5 10. ]

• Option 1 (arange) creates numbers with a step size, not a fixed number of values.
• Option 2 generates 10 values instead of 5.
• Option 3 (space) does not exist.
• Using np.linspace() is standard for creating numerical sequences with a specific number of points.

In Pandas, boolean indexing allows filtering rows by a condition. Using df['A'] > 10 returns a boolean Series, which is then used to filter rows.

Example:

import pandas as pd

df = pd.DataFrame({"A": [5, 12, 15], "B": [1, 2, 3]})
filtered = df[df['A'] > 10]
print(filtered)
# Output:
#     A  B
# 1  12  2
# 2  15  3

• Option 1 filters rows less than 10, not greater.
• Options 3 and 4 are invalid syntax.
• Using boolean indexing is efficient and readable for data filtering in Pandas.

Using the * operator on NumPy arrays performs element-wise multiplication, multiplying each element in a by the corresponding element in b. This differs from np.dot() or @, which perform matrix multiplication.

Example:

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
result = a * b
print(result)  # Output: [ 4 10 18]

• Options 1 (np.dot) and 3 (np.matmul) perform dot product or matrix multiplication, not element-wise multiplication.
• Option 2 (@) is another syntax for matrix multiplication.
• Using * is standard for vectorized operations in NumPy, which is faster than looping through elements manually.

The mean() method on a Pandas Series calculates the average value of the series. Accessing df['B'] returns a Series, so calling .mean() gives the mean of that column.

Example:

import pandas as pd

df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
mean_b = df['B'].mean()
print(mean_b)  # Output: 5.0

• Option 1 (df.mean('B')) calculates mean across all columns, not a specific column.
• Option 2 (mean(df['B'])) is invalid unless you imported Python’s statistics.mean, but .mean() is preferred in Pandas.
• Option 4 (df.col('B').average()) does not exist.

Using df['B'].mean() is efficient, readable, and widely used in data analysis tasks.

The np.nonzero() function returns a tuple of arrays, each containing the indices of non-zero elements along each dimension. It’s often used for filtering or locating specific elements efficiently.

Example:

import numpy as np

arr = np.array([0, 2, 0, 5])
indices = np.nonzero(arr)
print(indices)  # Output: (array([1, 3]),)

• Option 2 (np.where(arr == 0)) returns indices of zero elements, not non-zero.
• Option 3 (arr.indices()) does not exist.
• Option 4 (np.find) is not a valid NumPy function.

Using np.nonzero()

The fillna() method is used to replace missing values (NaN) in a DataFrame. Passing 0 replaces all NaN entries with zero, which is commonly used in data cleaning and preprocessing before analysis or modeling.

Example:

import pandas as pd
import numpy as np

df = pd.DataFrame({"A": [1, np.nan, 3], "B": [4, 5, np.nan]})
df_filled = df.fillna(0)
print(df_filled)
# Output:
#      A    B
# 0  1.0  4.0
# 1  0.0  5.0
# 2  3.0  0.0

• Option 1 (fillna(value=None)) does not replace values.
• Option 3 (replace(NaN, 0)) requires importing np.nan and is less commonly used.
• Option 4 (nan_to_num()) is a NumPy function, not a DataFrame method.

Using df.fillna(0) ensures your dataset is ready for calculations and modeling without errors caused by missing values.

The reshape() method returns a new array with the specified shape without modifying the original array. This is crucial when preparing data for machine learning models or matrix computations.

Example:

import numpy as np

arr = np.arange(12)
matrix = arr.reshape(3, 4)
print(matrix)
# Output:
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

• Option 1 (resize) modifies the original array in-place.
• Option 2 (shape) is an attribute, not a method.
• Option 4 (np.reshape_array) does not exist.

Using reshape() allows flexible data manipulation while keeping the original array intact, which is often required in data pipelines.

The np.cumsum() function returns an array of the cumulative sums of the elements along a given axis. This is commonly used in time series analysis, finance, or data preprocessing to track running totals.

Example:

import numpy as np

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

• Option 1 (np.sum with cumulative) is invalid syntax.
• Option 3 (arr.sum(axis=0)) calculates the total sum, not cumulative.
• Option 4 (cumulative_sum()) does not exist.

Using np.cumsum() is efficient and avoids manual loops for running totals in large datasets.

The dropna() method removes all rows containing at least one NaN value. This is essential for data cleaning before performing computations or machine learning, as missing values can cause errors.

Example:

import pandas as pd
import numpy as np

df = pd.DataFrame({"A": [1, np.nan, 3], "B": [4, 5, np.nan]})
clean_df = df.dropna()
print(clean_df)
# Output:
#      A    B
# 0  1.0  4.0

• Options 2, 3, and 4 do not exist in Pandas.
• Using dropna() ensures that your data analysis and models work on complete datasets without missing value issues.

The merge() method in Pandas is used to combine two DataFrames based on a common column or index. It is similar to SQL joins and supports different join types like inner, outer, left, and right.

Example:

import pandas as pd

df1 = pd.DataFrame({"id": [1, 2], "A": [10, 20]})
df2 = pd.DataFrame({"id": [1, 2], "B": [30, 40]})
merged_df = df1.merge(df2, on='id')
print(merged_df)
# Output:
#    id   A   B
# 0   1  10  30
# 1   2  20  40

• Option 1 uses an incorrect how='join' syntax.
• Option 2 (pd.join) is invalid for this purpose.
• Option 3 (combine) does not work on column keys.
• Using merge() is readable and efficient for combining datasets, which is a common task in data science workflows.

The pd.melt() function converts a wide DataFrame to a long format, keeping specified id_vars fixed and unpivoting value_vars into a single column. This is useful for visualization, aggregation, and analysis.

Example:

import pandas as pd

df = pd.DataFrame({
    "id": [1, 2],
    "A": [10, 20],
    "B": [30, 40]
})
long_df = pd.melt(df, id_vars=['id'], value_vars=['A','B'])
print(long_df)
# Output:
#    id variable  value
# 0   1        A     10
# 1   2        A     20
# 2   1        B     30
# 3   2        B     40

• Option 1 (stack()) can partially reshape, but is less flexible.

• Option 2 (transpose()) swaps rows and columns.
• Option 4 (pivot_long) does not exist.
• Using pd.melt() ensures data is in a tidy long format, which is ideal for plotting libraries and group-based analysis.

The pd.melt() function converts a wide DataFrame to a long format, keeping specified id_vars fixed and unpivoting value_vars into a single column. This is useful for visualization, aggregation, and analysis.

Example:

import pandas as pd

df = pd.DataFrame({
    "id": [1, 2],
    "A": [10, 20],
    "B": [30, 40]
})
long_df = pd.melt(df, id_vars=['id'], value_vars=['A','B'])
print(long_df)
# Output:
#    id variable  value
# 0   1        A     10
# 1   2        A     20
# 2   1        B     30
# 3   2        B     40

• Option 1 (stack()) can partially reshape, but is less flexible.

• Option 2 (transpose()) swaps rows and columns.
• Option 4 (pivot_long) does not exist.
• Using pd.melt() ensures data is in a tidy long format, which is ideal for plotting libraries and group-based analysis.

Here, arr % 2 == 0 creates a boolean mask selecting even numbers (2 and 4). Using this mask on arr gives [2, 4], and raising to the power of 2 results in [4, 16].

• Boolean indexing in NumPy is powerful for selecting and transforming elements without loops.
• This technique is widely used in data preprocessing or feature engineering in data science pipelines.

The dropna(how='all') method removes rows where all columns are NaN. Rows with partial NaN values are kept.

Example:

print(result)
# Output:
#      A    B
# 0  1.0  4.0
# 1  NaN  5.0
# 2  3.0  NaN
# 3  NaN  7.0

• Option 1 would require dropna(how='any').
• Option 2 is incorrect; rows with at least one valid value are retained.
• Option 4 is wrong; the DataFrame is not empty.

This method is useful in data cleaning when you want to remove completely empty rows but retain partially filled data for analysis.

Here, a[:, None] converts a from shape (3,) to (3,1), enabling broadcasting with b of shape (2,). NumPy automatically expands dimensions and performs element-wise addition:

[[1+4, 1+5],
 [2+4, 2+5],
 [3+4, 3+5]] 
=> [[5, 6], [6, 7], [7, 8]]

• Broadcasting in NumPy is powerful for vectorized operations, avoiding explicit loops.
• This technique is widely used in linear algebra, machine learning, and feature engineering.

The apply() method applies a function column-wise by default. Here, the lambda function squares the values only if the column name is 'B', leaving column 'A' unchanged.

Example:

print(result)
# Output:
#    A   B
# 0  1  16
# 1  2  25
# 2  3  36

• Option 1 is incorrect; column 'A' is not squared.
• Option 2 and 3 are wrong because only column 'B' is modified.
• Using apply() with x.name allows conditional transformations on specific columns, a common trick in data preprocessing and feature engineering.

The map() function applies a function to each element of a Pandas Series. Here, the lambda returns x only if it’s even, otherwise None.

Example:

print(result)
# Output:
# 0    None
# 1       2
# 2    None
# 3       4
# Name: num, dtype: object

• Option 1 is incorrect; odd numbers are replaced with None.
• Option 3 is wrong; map does not filter elements, it transforms them.
• Option 4 is incorrect; no error occurs.

Using map() with conditional logic is common in data cleaning and feature engineering, allowing selective transformations without loops.