Understanding partitions in Apache Spark - Hands-On Activity

Understanding partitions

📖 Scenario: You are working with a large dataset of sales records in a Spark environment. To improve performance, you want to understand how Spark divides data into partitions.

🎯 Goal: Learn how to check the number of partitions in a Spark DataFrame and how to change it.

📋 What You'll Learn

Create a Spark DataFrame with sample sales data

Create a variable to hold the desired number of partitions

Repartition the DataFrame using the variable

Print the number of partitions before and after repartitioning

💡 Why This Matters

🌍 Real World

Data scientists and engineers often need to manage how data is split across machines to optimize processing speed and resource use.

💼 Career

Understanding partitions is key for working efficiently with big data tools like Apache Spark in roles such as data engineer, data scientist, and big data analyst.

1

Create a Spark DataFrame with sales data

Create a Spark DataFrame called sales_df with these exact rows: (1, '2023-01-01', 100), (2, '2023-01-02', 150), (3, '2023-01-03', 200). Use columns named 'id', 'date', and 'amount'.

Apache Spark

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName('PartitionsExample').getOrCreate()
# Create sales_df DataFrame with the specified rows and columns
# Your code here

Hint

Use spark.createDataFrame() with a list of tuples and a list of column names.

2

Set the desired number of partitions

Create a variable called num_partitions and set it to 2.

Apache Spark

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName('PartitionsExample').getOrCreate()
sales_data = [(1, '2023-01-01', 100), (2, '2023-01-02', 150), (3, '2023-01-03', 200)]
sales_df = spark.createDataFrame(sales_data, ['id', 'date', 'amount'])
# Create num_partitions variable and set it to 2
# Your code here

Hint

Just create a variable named num_partitions and assign the number 2.

3

Repartition the DataFrame

Create a new DataFrame called repartitioned_df by repartitioning sales_df using num_partitions.

Apache Spark

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName('PartitionsExample').getOrCreate()
sales_data = [(1, '2023-01-01', 100), (2, '2023-01-02', 150), (3, '2023-01-03', 200)]
sales_df = spark.createDataFrame(sales_data, ['id', 'date', 'amount'])
num_partitions = 2
# Repartition sales_df using num_partitions and assign to repartitioned_df
# Your code here

Hint

Use the repartition() method on sales_df with num_partitions.

4

Print the number of partitions before and after repartitioning

Print the number of partitions in sales_df using rdd.getNumPartitions(). Then print the number of partitions in repartitioned_df the same way.

Apache Spark

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName('PartitionsExample').getOrCreate()
sales_data = [(1, '2023-01-01', 100), (2, '2023-01-02', 150), (3, '2023-01-03', 200)]
sales_df = spark.createDataFrame(sales_data, ['id', 'date', 'amount'])
num_partitions = 2
repartitioned_df = sales_df.repartition(num_partitions)
# Print number of partitions in sales_df and repartitioned_df
# Your code here

Hint

Use print(sales_df.rdd.getNumPartitions()) and print(repartitioned_df.rdd.getNumPartitions()).

Practice

1. What is the main purpose of partitions in Apache Spark?

easy

A. To compress data to save space

B. To split data into smaller chunks for parallel processing

C. To encrypt data for security

D. To store data permanently on disk

Solution

1. Step 1: Understand what partitions do in Spark

   Partitions divide data into smaller parts so Spark can process them at the same time.

2. Step 2: Compare options with this purpose

   Only To split data into smaller chunks for parallel processing matches this purpose; others describe unrelated tasks.

3. Final Answer:

   To split data into smaller chunks for parallel processing -> Option B

4. Quick Check:

   Partitions = split data for parallelism [OK]

Hint: Partitions split data to run tasks in parallel [OK]

Common Mistakes:

• Confusing partitions with data storage
• Thinking partitions encrypt data
• Assuming partitions compress data

2. Which of the following is the correct way to set the number of partitions when creating an RDD in Spark?

easy

A. sc.parallelize(data, 4)

B. sc.parallelize(data, numPartitions=4)

C. sc.parallelize(data).setPartitions(4)

D. sc.parallelize(data).partitions(4)

Solution

1. Step 1: Recall the syntax of sc.parallelize

   The method sc.parallelize takes data and an optional second argument for number of partitions as a positional argument.

2. Step 2: Check which option matches this syntax

   sc.parallelize(data, 4) uses sc.parallelize(data, 4) which is correct. sc.parallelize(data, numPartitions=4) uses a keyword argument which is invalid. Options C and D use non-existent methods.

3. Final Answer:

   sc.parallelize(data, 4) -> Option A

4. Quick Check:

   sc.parallelize(data, 4) sets partitions [OK]

Hint: Use second positional argument to set partitions [OK]

Common Mistakes:

• Using keyword argument numPartitions (not supported)
• Trying to set partitions after creation with wrong methods
• Confusing method names for partition setting

3. Given the following Spark code, what will be the number of partitions after execution?

rdd = sc.parallelize(range(10), 3)
rdd2 = rdd.repartition(5)
print(rdd2.getNumPartitions())

medium

A. 3

B. 1

C. 10

D. 5

Solution

1. Step 1: Understand initial partitioning

   The RDD is created with 3 partitions using sc.parallelize(range(10), 3).

2. Step 2: Analyze repartition call

   Calling rdd.repartition(5) changes the number of partitions to 5.

3. Final Answer:

   5 -> Option D

4. Quick Check:

   repartition(5) sets partitions to 5 [OK]

Hint: repartition changes partitions to given number [OK]

Common Mistakes:

• Assuming repartition keeps original partition count
• Confusing repartition with coalesce
• Thinking getNumPartitions returns data size

4. Identify the error in the following Spark code snippet:

rdd = sc.parallelize([1, 2, 3, 4])
rdd2 = rdd.repartition(-2)
print(rdd2.getNumPartitions())

medium

A. parallelize requires at least 2 partitions

B. repartition method does not exist

C. Negative number of partitions is invalid

D. getNumPartitions cannot be called on rdd2

Solution

1. Step 1: Check repartition argument

   repartition requires a positive integer for number of partitions. Negative values are invalid.

2. Step 2: Verify other method usages

   repartition exists, parallelize accepts any positive partition count, getNumPartitions works on RDDs.

3. Final Answer:

   Negative number of partitions is invalid -> Option C

4. Quick Check:

   Partitions must be positive [OK]

Hint: Partitions count must be positive integer [OK]

Common Mistakes:

• Using negative or zero partitions
• Thinking repartition method is missing
• Assuming getNumPartitions is invalid

5. You have a large dataset with 100 partitions, but your cluster has only 10 cores. Which Spark operation is best to optimize performance by reducing the number of partitions without causing a full shuffle?

hard

A. Use coalesce(10) to reduce partitions

B. Use repartition(100) to keep partitions same

C. Use repartition(10) to reduce partitions

D. Use mapPartitions to manually split partitions

Solution

1. Step 1: Understand cluster resources and partitions

   Having more partitions than cores can cause overhead. Reducing partitions to match cores improves efficiency.

2. Step 2: Choose operation that reduces partitions without full shuffle

   coalesce reduces partitions efficiently without full shuffle, unlike repartition which causes shuffle.

3. Final Answer:

   Use coalesce(10) to reduce partitions -> Option A

4. Quick Check:

   coalesce reduces partitions without shuffle [OK]

Hint: Use coalesce to reduce partitions without shuffle [OK]

Common Mistakes:

• Using repartition causes expensive shuffle
• Not matching partitions to cluster cores
• Trying manual partition splitting unnecessarily