Creating DataFrames from files (CSV, JSON, Parquet) in Apache Spark - Practice Exercises

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of reading CSV with header option

What will be the output schema of the DataFrame after running this code snippet in Apache Spark?

Apache Spark

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('Test').getOrCreate()
df = spark.read.csv('data.csv', header=True, inferSchema=True)
df.printSchema()

A

root
 |-- column1: string (nullable = true)
 |-- column2: integer (nullable = true)

B

root
 |-- _c0: integer (nullable = true)
 |-- _c1: integer (nullable = true)

C

root
 |-- _c0: string (nullable = true)
 |-- _c1: string (nullable = true)

D

root
 |-- column1: integer (nullable = true)
 |-- column2: string (nullable = true)

💡 Hint

Check the effect of header=True and inferSchema=True when reading CSV files.

When header=True, Spark uses the first row as column names. inferSchema=True lets Spark detect data types automatically. So columns get proper names and types.

❓ data_output

intermediate

DataFrame content after reading JSON file

Given a JSON file with records [{"name":"Alice","age":30},{"name":"Bob","age":25}], what will be the output of df.show() after reading it with spark.read.json('people.json')?

Apache Spark

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('Test').getOrCreate()
df = spark.read.json('people.json')
df.show()

A

+-----+---+
| name|age|
+-----+---+
|  30 |Alice|
|  25 | Bob|
+-----+---+

B

+-----+---+
| name|age|
+-----+---+
|Alice| 30|
|  Bob| 25|
+-----+---+

C

+-----+---+
| name|age|
+-----+---+
|Alice|"30"|
|  Bob|"25"|
+-----+---+

D

+-----+---+
| name|age|
+-----+---+
|Alice|null|
|  Bob|null|
+-----+---+

💡 Hint

Spark reads JSON and infers schema and types automatically.

Spark reads JSON records and infers the schema with correct types. Numbers remain integers, strings remain strings.

❓ visualization

advanced

Visualizing Parquet file schema

You load a Parquet file with spark.read.parquet('data.parquet'). Which Spark method will show a tree-like schema visualization of the DataFrame?

Apache Spark

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('Test').getOrCreate()
df = spark.read.parquet('data.parquet')
# Which method to call next?

A df.schemaTree()

B df.showSchema()

C df.printSchema()

D df.displaySchema()

💡 Hint

The method name is printSchema, not showSchema or others.

printSchema() prints the schema in a tree format. Other options do not exist or cause errors.

🔧 Debug

advanced

Error when reading CSV without header option

What error or issue will occur if you run this code and the CSV file has a header row but you do NOT specify header=True? from pyspark.sql import SparkSession spark = SparkSession.builder.appName('Test').getOrCreate() df = spark.read.csv('data.csv') df.show()

Apache Spark

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('Test').getOrCreate()
df = spark.read.csv('data.csv')
df.show()

A The DataFrame will be empty because header is not read.

B Spark will raise a FileNotFoundError because header is missing.

C Spark will raise a ValueError about missing header option.

D The first row will be treated as data, not header, so column names will be _c0, _c1, etc.

💡 Hint

By default, header=False, so first row is data.

Without header=True, Spark treats the first row as data and assigns default column names like _c0, _c1.

🚀 Application

expert

Choosing file format for large dataset with nested data

You have a large dataset with nested JSON structures and want to store it efficiently for fast queries in Spark. Which file format should you choose?

A Parquet, because it supports nested data and is columnar for fast queries

B CSV, because it is simple and widely supported

C JSON, because it preserves nested structures naturally

D TXT, because it is easy to read and write

💡 Hint

Think about file format efficiency and support for nested data.

Parquet is a columnar storage format that supports nested data and compression, making it efficient for large datasets and fast queries.