Data Analysis Fundamentals final test: 25 free questions

Q1 / 25

How does a DataFrame constructor combine a dictionary of Series with different indexes?

1. AIt combines values strictly by their current positions
2. BIt discards every label absent from the first Series
3. CIt aligns by labels and uses the union of indexes
4. DIt requires all Series labels to be identical first

Q2 / 25

Which window family computes over a moving fixed-count or time-offset partition?

1. AAn exponentially weighted window
2. BAn expanding window
3. CA categorical grouping window
4. DA fixed-count or time-offset rolling window

Q3 / 25

Several DataFrames are stacked by rows. What does the `keys` argument add to the result?

1. AA sequential index that erases input labels
2. BA left-style restriction to the first index
3. CAn intersection filter for input columns
4. DAn outer MultiIndex level tied to input pieces

Q4 / 25

Monthly `PeriodIndex` data must become daily-resolution timestamps placed at each span's last representable point. Which conversion expresses both choices?

1. AUse `to_timestamp('D', how='end')`
2. BUse `asfreq('D', how='start')` and keep periods
3. CUse `to_timestamp('D', how='start')`
4. DUse `to_period('D', how='end')`

Q5 / 25

Which representation is a documented candidate for low-cardinality text currently stored as `object`?

1. AUse `timedelta64[ns]` values
2. BUse `complex128` numbers
3. CUse `datetime64[ns]` values
4. DConvert the column to `category`

Q6 / 25

A financial table uses CSS classes to give negative cells a red background, and that supported cell property must survive Excel export. What should change?

1. AReturn `background-color: red` directly from `.map()` before `.to_excel()`
2. BKeep `.set_td_classes()` and add the classes through `.set_table_styles()`
3. CMove the negative-value rule into a table-wide hover pseudo-selector
4. DFormat the values as strings with `.format()` and export the same CSS classes

Q7 / 25

Identifiers look like `region-team-member`, but the region and team may themselves contain hyphens. The analyst must isolate only the final member token and retain the unsplit prefix as one field. Which operation meets both constraints?

1. A`s.str.rsplit("-", n=1, expand=True)`
2. B`s.str.split("-", n=1, expand=True)`
3. C`s.str.replace("-", "", regex=False)`
4. D`s.str.split("-", expand=True)`

Q8 / 25

A table has columns `store`, `day`, and `sales`. Each observation is identified by the pair `(store, day)`, and both identifiers must remain available as data columns. Which setup fits?

1. A`df.set_index(['store', 'day'], drop=False)`
2. B`df.drop_duplicates(['store', 'day'])`
3. C`df.reset_index(['store', 'day'], drop=False)`
4. D`df.set_index('store', drop=True)`

Q9 / 25

How can a Parquet reader avoid materializing unneeded columns?

1. APass the required names through `columns`
2. BPass the required names through `partition_cols`
3. CPass the required names through `compression`
4. DPass the required names through `index`

Q10 / 25

What index condition applies when a rolling window is defined by a time offset?

1. AThe corresponding time-based index must be monotonic
2. BThe corresponding time-based index must contain unique days
3. CThe time-based index must have equal intervals
4. DThe corresponding time-based index must be categorical

Q11 / 25

What does `validate="one_to_one"` check before a merge?

1. AThat input indexes become result columns
2. BThat merge keys are unique on both sides
3. CThat overlapping value columns have suffixes
4. DThat unmatched keys exist on both sides

Q12 / 25

How should a datetime-like Series named `events` expose its hour values without scalar iteration?

1. AUse `events.hour.dt`
2. BUse `events.dt.hour`
3. CUse `events.astype('object').hour`
4. DUse `events.index.hour`

Q13 / 25

Which pandas operation is associated with the documented thread-safety concern?

1. AComparing one local Series with a scalar
2. BCopying DataFrames shared among threads
3. CChecking one local DataFrame with `empty`
4. DReducing one local Boolean Series with `any()`

Q14 / 25

Which pandas plotting arguments map two named DataFrame columns to the horizontal and vertical axes?

1. APass the column names through `layout` and `subplots`
2. BPass columns through `xerr` and `yerr`
3. CPass the column names through `style` and `label`
4. DPass the column names through `x` and `y`

Q15 / 25

What happens to an input value that is absent from an explicitly declared category set?

1. AIt is appended to the category set automatically
2. BIt is preserved as an unordered object value in the same column
3. CIt replaces first declared category
4. DIt becomes a missing categorical value

Q16 / 25

Inside `DataFrame.query()`, an index and a column are both named `a`. What does the expression `a > 2` use?

1. AThe index named `a`
2. BThe column named `a`
3. CBoth objects combined positionally
4. DNeither object because the name is rejected

Q17 / 25

A pipe-delimited file has no header, `NA?` is its sole missing marker, and `account_id` must remain text. Only three named columns are needed. Which ingestion design satisfies all constraints?

1. ASet `sep="|"`, explicit `names`, `header=None`, `usecols`, text dtype for `account_id`, `na_values=["NA?"]`, and `keep_default_na=False`
2. BUse `read_json(orient="records")` and treat each pipe-delimited line as a JSON object
3. CSet `header=0`, keep every column, and rely on the default missing-marker set
4. DUse default `read_csv()` inference, then rename columns and convert all values to floats

Q18 / 25

What happens if a string passed to `groupby()` matches both a column name and an index-level name?

1. Apandas raises a `ValueError` because the key is ambiguous
2. Bpandas groups by the column because columns take precedence
3. Cpandas combines both matches into a two-key grouping
4. Dpandas groups by the index because levels take precedence

Q19 / 25

A Series represents one observation and its index matches the target DataFrame columns. How should it be appended as a row?

1. AConvert it to a DataFrame and concatenate without transposing
2. BConvert it to a DataFrame, transpose it, then concatenate
3. CDiscard its index and use the values as provenance keys
4. DConcatenate it directly with `axis=1` and preserve labels

Q20 / 25

How should numeric values measured in seconds be parsed as elapsed times?

1. AUse `pd.to_timedelta(values)` with no unit
2. BConvert the numbers to strings, then use `pd.to_timedelta(values, unit='s')`
3. CUse `pd.to_timedelta(values, unit='s')`
4. DUse `pd.to_timedelta(values, unit='D')`

Q21 / 25

A nonempty nullable `amount` column must pass only when every value is present and greater than zero. Which condition fits?

1. A`df["amount"].gt(0).all(skipna=False)`
2. B`df["amount"].gt(0).all()`
3. C`df["amount"].gt(0).any()`
4. D`(df["amount"].notna() & df["amount"].gt(0)).all()`

Q22 / 25

What is the main analytical benefit of formatting values through Styler?

1. AIt recalculates the DataFrame whenever the style renders
2. BIt replaces underlying values with formatted strings
3. CIt converts every DataFrame into a JSON representation
4. DIt changes displayed strings while preserving underlying values

Q23 / 25

`price` and `units` are numeric columns of `df`. Which expression calculates each row's total with direct vectorized arithmetic?

1. A`df.apply(lambda row: row["price"] * row["units"], axis=1)`
2. B`pd.Series([p * u for p, u in zip(df["price"], df["units"])])`
3. C`df["price"] * df["units"].sum()`
4. D`df["price"] * df["units"]`

Q24 / 25

Why is `df['foo'].replace(1, 5, inplace=True)` unsafe under Copy-on-Write?

1. AIt invokes an inplace method on an intermediate selected column
2. B`replace()` can operate only on whole DataFrames
3. CThe column selector automatically removes `foo` from `df`
4. DCopy-on-Write forbids replacing numeric values

Q25 / 25

What is the difference between `engine="pyarrow"` and `dtype_backend="pyarrow"` on a supported reader?

1. AThe engine chooses parsing; the dtype backend chooses Arrow-backed result types
2. BThe engine writes Parquet; the dtype backend writes JSON records
3. CThe engine selects SQL queries; the dtype backend selects database tables
4. DThe engine chooses returned row and column labels; the dtype backend chooses which source rows are read