The New York City Department of Education collects data on school bus delays and breakdowns to identify recurring issues and improve routes. You have data from the file bus.csv containing the following information:
School_Year: The year of the record.
Run_Type: Category of bus service where a delay or breakdown occurred.
Bus_No: Bus number.
Route_Number: Route number.
Reason: Reason for the delay or breakdown.
Occurred_On: Date of the incident.
Number_Of_Students_On_The_Bus: Number of students on the bus.
Exercise Objectives:
Data Loading and DataFrame Creation:
Q-Load the data from the text file and create a DataFrame.
Oky thirs i use colab as my notebook to work with this using pyspark and this basically 
The path of the data 
path="/content/bus.csv"




1- first we need to import the needed it packages 
2- instance a spark session as our entry point to work with spark 
2- next just read it the data as it’s and dislay a sample of first 5 lines of it oky 
Give the code to do it 
     # 1. Import necessary packages
from pyspark.sql import SparkSession
from pyspark.sql.types import *

# 2. Create a SparkSession
spark = SparkSession.builder.appName("BusDataAnalysis").getOrCreate()

# Define the schema (optional but recommended for better performance and data integrity)
schema = StructType([
    StructField("School_Year", StringType(), True),
    StructField("Run_Type", StringType(), True),
    StructField("Bus_No", StringType(), True),  # Bus_No can contain alphanumeric characters
    StructField("Route_Number", StringType(), True), # Route_Number may contain non-numeric characters
    StructField("Reason", StringType(), True),
    StructField("Occurred_On", StringType(), True),  # Initially load as String, will convert to Date later
    StructField("Number_Of_Students_On_The_Bus", IntegerType(), True),
])


# 3. Read the CSV data with the defined schema and specified options
path = "/content/bus.csv" 
df = spark.read.csv(path, header=True, schema=schema, inferSchema=False, multiLine=True, escape='"') #escape handles quotes within fields


# Display the first 5 rows
df.show(5,truncate=False) # truncate=False to show the full contents of longer strings


#  Further data cleaning and transformation (e.g., date parsing) can be done after this initial loading step.
# Example: Convert Occurred_On to DateType
# from pyspark.sql.functions import to_date
# df = df.withColumn("Occurred_On", to_date(df["Occurred_On"], "M/d/yyyy")) # Adapt date format if needed
   
content_copy Use code with caution.Python
Explanation and Improvements:
Schema Definition: Defining the schema upfront significantly improves performance, especially with larger datasets, because Spark doesn't need to infer the schema. I've made Bus_No and Route_Number StringTypes to accommodate potential non-numeric entries or inconsistencies.
inferSchema=False: This is crucial when you provide a schema. It tells Spark to use your provided schema, not try to infer one itself.
multiLine=True and escape: The multiLine=True option is added to handle potential multi-line fields within the CSV if they exist (e.g., Reason field having line breaks). The escape parameter is also added to correctly handle quotes within fields, which is a common cause of parsing errors. This assumes double quotes (") are used as escape characters. Adjust if a different escape character is used.
Date Handling: I've initially loaded Occurred_On as a StringType and then shown how to convert it to a DateType using to_date() in a commented-out section. This is best practice as it allows you to handle any date format inconsistencies more effectively after loading the data. Adapt the date format string (e.g., "M/d/yyyy" or "yyyy-MM-dd") according to the format in your CSV.
truncate=False: This is added to the show() function so you can see the full content of any potentially long string fields.
This improved code addresses potential data quality issues, provides more efficient processing, and prepares the DataFrame for further analysis and transformations. Remember to uncomment and adjust the date conversion code as needed for your specific date format.
Q- and this is the output oky ? 
+-----------+-----------------+------+------------+------------------+-------------------+------------------------------+
|School_Year|Run_Type         |Bus_No|Route_Number|Reason            |Occurred_on        |Number_Of_Strudents_On_The_Bus|
+-----------+-----------------+------+------------+------------------+-------------------+------------------------------+
|2015-2016  |Special Ed AM Run|48186 |N758        |Other             |2015-09-02T06:27:00|0                             |
|2015-2016  |Special Ed AM Run|2518  |L530        |Mechanical Problem|2015-09-02T06:24:00|0                             |
|2015-2016  |Special Ed AM Run|235   |K168        |Other             |2015-09-02T06:45:00|0                             |
|2015-2016  |Special Ed AM Run|2102  |K216        |Other             |2015-09-02T06:55:00|1                             |
|2015-2016  |Special Ed AM Run|48162 |N861        |Mechanical Problem|2015-09-02T06:55:00|0                             |
+-----------+-----------------+------+------------+------------------+-------------------+------------------------------+
only showing top 5 rows


Analysis of Delay/Breakdown Reasons:
Q-Identify the most common reasons for bus delays or breakdowns.
Oky so the question is asking us to find the most common reasons for the bus delays or breakdowns 
—> i think we need we need to count the number of delays or breakdowns by reason and sorting them by decreasing order 
→ then return the first row that represent the this information oky 

Here's the formatted version:

---

### Identifying the Most Common Reasons for Bus Delays or Breakdowns Using PySpark

To analyze the most common reasons for bus delays or breakdowns, we'll use the following steps:

1. **Group the Data by Reason**: Aggregate the data to count the number of incidents for each reason.
2. **Sort the Results in Descending Order**: This helps identify the most frequent reasons.
3. **Display the Top Reasons**: Show the top N reasons based on your requirement (e.g., top 5).

### PySpark Code:

```python
# 1. Import necessary packages
from pyspark.sql import SparkSession
from pyspark.sql.types import *
from pyspark.sql.functions import desc

# 2. Create a SparkSession
spark = SparkSession.builder.appName("BusDataAnalysis").getOrCreate()

# Define the schema
schema = StructType([
    StructField("School_Year", StringType(), True),
    StructField("Run_Type", StringType(), True),
    StructField("Bus_No", StringType(), True),
    StructField("Route_Number", StringType(), True),
    StructField("Reason", StringType(), True),
    StructField("Occurred_On", StringType(), True),
    StructField("Number_Of_Students_On_The_Bus", IntegerType(), True),
])

# 3. Read the CSV data
path = "/content/bus.csv" 
df = spark.read.csv(path, header=True, schema=schema, inferSchema=False, multiLine=True, escape='"')

# Display the first 5 rows
df.show(5, truncate=False)

# 4. Group by 'Reason' and count the occurrences
reason_counts = df.groupBy("Reason").count()

# 5. Sort the counts in descending order
sorted_reason_counts = reason_counts.orderBy(desc("count"))

# 6. Show the top 5 most common reasons
sorted_reason_counts.show(5, truncate=False)
```

### Explanation of the Code:

- **Importing Functions**:
    - `from pyspark.sql.functions import desc`: Allows sorting the data in descending order.

- **Grouping and Counting**:
    - `groupBy("Reason")`: Groups the DataFrame by the 'Reason' column.
    - `.count()`: Counts the number of occurrences for each group.

- **Sorting the Results**:
    - `orderBy(desc("count"))`: Sorts the grouped counts in descending order, showing the most common reasons first.

- **Displaying the Top Reasons**:
    - `.show(5, truncate=False)`: Displays the top 5 reasons without truncating the text, showing full descriptions.

### Example Output:

```text
+----------------------+-----+
|Reason                |count|
+----------------------+-----+
|Mechanical Problem    |1500 |
|Driver Delay          |1200 |
|Traffic Congestion    |800  |
|Weather Conditions    |600  |
|Other                 |400  |
+----------------------+-----+
```

*(Note: The above numbers are illustrative. Your actual output will depend on the data in `bus.csv`.)*

### Additional Insights:
For further analysis, you can explore:
- **Data Cleaning**: Ensure the 'Reason' field is standardized (e.g., merge similar phrases like "Mechanical Issue" vs. "Mechanical Problem").
- **Time-Based Analysis**: Identify if certain reasons are more prevalent during specific times of the year.
- **Route and Bus Analysis**: Discover if certain routes or buses are more prone to delays or breakdowns.

If you have any questions or need further assistance with these steps, feel free to ask!

Q- this my output 
+------------------+------+
|Reason            |count |
+------------------+------+
|Heavy Traffic     |170660|
|Other             |37019 |
|Mechanical Problem|27821 |
|Won`t Start       |12172 |
|Flat Tire         |8307  |
+------------------+------+
only showing top 5 rows

Q-Filter to select only incidents of type "Delay".

So the seek of reason this my approach to solve this question it may be correct or incorrect oky 

We have to filter the “Reason” column by allow the display only of incidents of type “Delay” (or word start with Delay because it my not 100 % integrity in the data oky ) 

– so we apply the filter transformation , the filter condition will be “Reason” that start with the worl “Delay” oky 

Give your feabac about my thinking process here and then given your actual pesudoCode and finalt the actual code right 
Your thinking process is on the right track, aiming to filter the dataset to focus specifically on "Delay" incidents. However, based on the information provided and the sample data, there are a few considerations to ensure the filtering is accurate and aligns with the dataset's structure. Let's break down the analysis and provide a refined approach.
Understanding the Dataset
From your description and the sample data, the CSV file (bus.csv) contains the following columns:
School_Year: The year of the record.
Run_Type: Category of bus service where a delay or breakdown occurred (e.g., "Special Ed AM Run").
Bus_No: Bus number.
Route_Number: Route number.
Reason: Reason for the delay or breakdown (e.g., "Heavy Traffic", "Mechanical Problem").
Occurred_On: Date and time of the incident.
Number_Of_Students_On_The_Bus: Number of students on the bus.
From the sample output:
+------------------+------+
|Reason            |count |
+------------------+------+
|Heavy Traffic     |170660|
|Other             |37019 |
|Mechanical Problem|27821 |
|Won't Start       |12172 |
|Flat Tire         |8307  |
+------------------+------+


We observe that Reason includes specific causes for incidents, such as "Heavy Traffic" and "Mechanical Problem." However, there's no explicit column indicating whether an incident is a "Delay" or a "Breakdown."
Feedback on Your Approach
Filtering the Reason Column by "Delay":
Issue: The Reason column contains specific causes of incidents, not the type of incident (i.e., "Delay" vs. "Breakdown"). Filtering Reason for entries that start with "Delay" might not yield the desired results because, based on your sample data, reasons like "Heavy Traffic" or "Mechanical Problem" don't start with "Delay."
Solution: Instead of filtering the Reason column for the word "Delay," you should identify and categorize reasons that implicitly indicate a delay. For example, "Heavy Traffic" typically causes delays, whereas "Mechanical Problem" might indicate a breakdown.
Identifying Delay-Related Reasons:
Approach: Create a list of reasons that are indicative of delays. Then, filter the DataFrame based on whether the Reason column matches any of these delay-related reasons.
Considerations:
Data Consistency: Ensure that the reasons are standardized (e.g., "Heavy Traffic" vs. "heavy traffic").
Comprehensive List: The list should cover all possible delay-related reasons present in the dataset.
Refined Approach
To accurately filter and analyze "Delay" incidents, follow these steps:
Define Delay-Related Reasons:
Identify all the unique reasons that correspond to delays. From the sample data, "Heavy Traffic" is a clear delay cause. Other possible delay-related reasons might include "Weather Conditions," "Accident on Route," etc.
Create a list of these reasons for filtering.
Filter the DataFrame:
Use the isin() function to filter rows where the Reason is in the list of delay-related reasons.
Optional - Categorize Incidents:
For better analysis, you can create a new column indicating whether an incident is a "Delay" or "Breakdown" based on the Reason.
Pseudo-Code
Below is the pseudo-code outlining the steps:
Import Packages and Initialize SparkSession
Define Schema
Load Data into DataFrame
Display Sample Data
Identify Delay-Related Reasons
Filter DataFrame for Delays
Display Filtered Data
PySpark Implementation
Here's the actual PySpark code implementing the refined approach:
# 1. Import necessary packages
from pyspark.sql import SparkSession
from pyspark.sql.types import *
from pyspark.sql.functions import desc, col

# 2. Create a SparkSession
spark = SparkSession.builder.appName("BusDataAnalysis").getOrCreate()

# 3. Define the schema
schema = StructType([
    StructField("School_Year", StringType(), True),
    StructField("Run_Type", StringType(), True),
    StructField("Bus_No", StringType(), True),
    StructField("Route_Number", StringType(), True),
    StructField("Reason", StringType(), True),
    StructField("Occurred_On", StringType(), True),
    StructField("Number_Of_Students_On_The_Bus", IntegerType(), True),
])

# 4. Read the CSV data
path = "/content/bus.csv" 
df = spark.read.csv(
    path, 
    header=True, 
    schema=schema, 
    inferSchema=False, 
    multiLine=True, 
    escape='"'
)

# Display the first 5 rows
df.show(5, truncate=False)

# 5. Group by 'Reason' and count the occurrences
reason_counts = df.groupBy("Reason").count()

# Sort the counts in descending order
sorted_reason_counts = reason_counts.orderBy(desc("count"))

# Show the top 5 most common reasons
sorted_reason_counts.show(5, truncate=False)

# 6. Define a list of delay-related reasons
delay_reasons = [
    "Heavy Traffic",
    "Weather Conditions",
    "Accident on Route",
    "Road Construction",
    "Traffic Signal Malfunction",
    "School Event Delays",
    # Add other delay-related reasons as identified
]

# 7. Filter the DataFrame for Delay incidents
delay_df = df.filter(col("Reason").isin(delay_reasons))

# Optional: If you want to include partial matches or case-insensitive matches
# from pyspark.sql.functions import lower, startswith

# delay_df = df.filter(
#     lower(col("Reason")).startswith("delay") | 
#     # Add other conditions if needed
# )

# 8. Display the first 5 rows of Delay incidents
delay_df.show(5, truncate=False)

# 9. (Optional) Further Analysis on Delay Incidents
# For example, find the top reasons for delays
delay_reason_counts = delay_df.groupBy("Reason").count().orderBy(desc("count"))
delay_reason_counts.show(5, truncate=False)


Explanation of the Code
Importing Packages:
SparkSession: Entry point to interact with Spark.
StructType, StructField, StringType, IntegerType: Define the schema for the DataFrame.
desc, col: Functions for sorting and column reference.
Creating SparkSession:
Initiates a Spark session named "BusDataAnalysis."
Defining Schema:
Explicitly defines the data types for each column to ensure data integrity and improve performance.
Loading Data:
Reads the CSV file with specified options to handle headers, define schema, manage multi-line fields, and handle escaped characters.
Displaying Data:
df.show(5, truncate=False): Displays the first five rows without truncating long string fields.
sorted_reason_counts.show(5, truncate=False): Shows the top five most common reasons for incidents.
Defining Delay-Related Reasons:
Create a comprehensive list (delay_reasons) containing all reasons that indicate a delay. This list should be based on domain knowledge or further exploration of the dataset.
Filtering for Delays:
Uses the isin() function to filter rows where the Reason column matches any of the delay-related reasons.
Optional Enhancements:
Partial or Case-Insensitive Matching: If the Reason column contains variations like "delay due to..." or different casing, you can use functions like lower() and startswith() to create more flexible filters.
Further Analysis: After filtering, you can perform additional analyses, such as identifying the most common delay reasons or analyzing delays over time.
Additional Recommendations
Data Exploration:
Before defining delay_reasons, explore the unique values in the Reason column to ensure all relevant delay-related reasons are captured.
df.select("Reason").distinct().show(truncate=False)


Handling Data Inconsistencies:
Case Sensitivity: Ensure that the reasons are case-consistent. If not, convert them to a standard case (e.g., lower case) before filtering.
Typographical Errors: Address any typos or inconsistencies in the Reason entries to ensure accurate filtering.
Dynamic Reason Identification:
If "Delay" is explicitly mentioned in the Reason for delay-related incidents, you can use pattern matching.
from pyspark.sql.functions import lower

delay_df = df.filter(lower(col("Reason")).startswith("delay"))


Adding an Incident Type Column:
For easier analyses in the future, consider adding a new column categorizing each incident as a "Delay" or "Breakdown" based on the Reason.
delay_df = df.withColumn(
    "Incident_Type", 
    when(col("Reason").isin(delay_reasons), "Delay").otherwise("Breakdown")
)


Performance Optimization:
Caching: If you plan to perform multiple operations on the filtered DataFrame, consider caching it.
delay_df.cache()


Validating the Filter:
Ensure that the filtered DataFrame (delay_df) accurately represents delay incidents by cross-verifying with sample data.
Conclusion
Your initial approach to filter the Reason column for "Delay" is conceptually correct but requires refinement based on the dataset's structure. By identifying and listing all reasons that implicitly indicate a delay, you can accurately filter the dataset to focus on delay incidents. Ensure thorough data exploration and handling of any inconsistencies to achieve precise and meaningful analysis.
If you have further questions or need assistance with specific parts of the analysis, feel free to ask!


Q- like you thinking process about the last question ? 
But as we see in this output 
df.select("Reason").distinct().show(truncate=False)
+---------------------------+
|Reason                     |
+---------------------------+
|Problem Run                |
|Weather Conditions         |
|Other                      |
|Flat Tire                  |
|Mechanical Problem         |
|Delayed by School          |
|Won`t Start                |
|Late return from Field Trip|
|Accident                   |
|Heavy Traffic              |
|NULL                       |
+---------------------------+
n ? 

We have what we called “|Delayed by School “ 

And this the target filter condition 
So now reapate the same filter function but now using ‘Delayed by School “
Condition oky 

Route and Bus Analysis:
Q-Identify the five route numbers most affected by delays or breakdowns.
→  oky we need to find a solution that find the first 5 rows of Route_No based on the number of affecfeced delays or breakdowns 

This process is similar to a previous question where we need first to group them by number of affected delays or breakdowns 
1- group and count the Route number by number of delays or breakdonws affected in this Route 
2- sort it based on decreasing order 
3- show the first 5 rows oky which represent the five route numbers most affected by delays or breakdowns 

Your thinking process is logical and well-structured. Let's break down your approach and provide the necessary PySpark code to achieve your objectives effectively.

### 1. Filtering Incidents with Reason "Delayed by School"
#### Feedback on Your Approach:
You correctly identified that the `Reason` column contains specific causes for incidents, rather than categorizing them explicitly as "Delay" or "Breakdown." Initially, you considered filtering the `Reason` column for entries that start with "Delay," but later discovered that "Delayed by School" is an actual reason in your dataset.

By focusing on "Delayed by School," you ensure that only pertinent delay incidents are selected, which aligns with your analysis goals.

#### PySpark Implementation:
Here's how you can filter the DataFrame to include only incidents where the `Reason` is "Delayed by School":

```python
# 1. Import necessary packages
from pyspark.sql import SparkSession
from pyspark.sql.types import *
from pyspark.sql.functions import desc, col

# 2. Create a SparkSession
spark = SparkSession.builder.appName("BusDataAnalysis").getOrCreate()

# 3. Define the schema
schema = StructType([
    StructField("School_Year", StringType(), True),
    StructField("Run_Type", StringType(), True),
    StructField("Bus_No", StringType(), True),
    StructField("Route_Number", StringType(), True),
    StructField("Reason", StringType(), True),
    StructField("Occurred_On", StringType(), True),
    StructField("Number_Of_Students_On_The_Bus", IntegerType(), True),
])

# 4. Read the CSV data
path = "/content/bus.csv" 
df = spark.read.csv(path, header=True, schema=schema, inferSchema=False, multiLine=True, escape='"')

# Display the first 5 rows
df.show(5, truncate=False)

# 5. Filter the DataFrame for incidents with Reason "Delayed by School"
delay_df = df.filter(col("Reason") == "Delayed by School")

# Display the first 5 rows of Delay incidents
delay_df.show(5, truncate=False)

# Optional: Verify the count of delay incidents
delay_count = delay_df.count()
print(f"Total number of 'Delayed by School' incidents: {delay_count}")
```

### Explanation of the Code:
- **Importing Packages**: Includes Spark functions and types necessary for the operation.
- **Creating SparkSession**: Initializes the Spark session.
- **Schema Definition**: Defines the structure of the dataset.
- **Data Loading**: Loads the CSV file with the specified schema.
- **Filtering**: Selects rows where `Reason` equals "Delayed by School."
- **Display/Count**: Displays the filtered results and optionally counts them.

---

### 2. Identifying the Five Route Numbers Most Affected by Delays or Breakdowns
#### Feedback on Your Approach:
To identify the top five most affected routes, you plan to group data by `Route_Number`, count incidents, sort by count, and select the top five.

#### PySpark Implementation:
Here's how you can implement this using PySpark:

```python
# Group by 'Route_Number' and count the number of incidents
route_counts = df.groupBy("Route_Number").count()

# Sort the counts in descending order
sorted_route_counts = route_counts.orderBy(desc("count"))

# Show the top 5 most affected routes
sorted_route_counts.show(5, truncate=False)
```

#### Explanation of the Code:
- **Grouping**: Groups the DataFrame by `Route_Number` and counts incidents.
- **Sorting**: Orders the results by count in descending order.
- **Displaying**: Shows the top 5 routes.

---

### 3. Complete PySpark Code Combining Both Objectives:
Here's the complete PySpark code that includes both filtering for "Delayed by School" incidents and identifying the top five most affected routes:

```python
# 1. Import necessary packages
from pyspark.sql import SparkSession
from pyspark.sql.types import *
from pyspark.sql.functions import desc, col

# 2. Create a SparkSession
spark = SparkSession.builder.appName("BusDataAnalysis").getOrCreate()

# 3. Define the schema
schema = StructType([
    StructField("School_Year", StringType(), True),
    StructField("Run_Type", StringType(), True),
    StructField("Bus_No", StringType(), True),
    StructField("Route_Number", StringType(), True),
    StructField("Reason", StringType(), True),
    StructField("Occurred_On", StringType(), True),
    StructField("Number_Of_Students_On_The_Bus", IntegerType(), True),
])

# 4. Read the CSV data
path = "/content/bus.csv" 
df = spark.read.csv(path, header=True, schema=schema, inferSchema=False, multiLine=True, escape='"')

# Display the first 5 rows
df.show(5, truncate=False)

# 5. Filter the DataFrame for incidents with Reason "Delayed by School"
delay_df = df.filter(col("Reason") == "Delayed by School")

# Display the first 5 rows of Delay incidents
delay_df.show(5, truncate=False)

# Optional: Verify the count of delay incidents
delay_count = delay_df.count()
print(f"Total number of 'Delayed by School' incidents: {delay_count}")

# 6. Identify the top five Route_Numbers most affected by "Delayed by School"

# Group by 'Route_Number' and count the number of delay incidents
route_delay_counts = delay_df.groupBy("Route_Number").count()

# Sort the counts in descending order
sorted_route_delay_counts = route_delay_counts.orderBy(desc("count"))

# Show the top 5 most affected routes by delays
sorted_route_delay_counts.show(5, truncate=False)
```

This code filters the data for "Delayed by School" incidents and identifies the top 5 most affected routes.

Q - the output of the frivous two questions are 


expand_less

[1]
35s
!pip install pyspark

Collecting pyspark
  Downloading pyspark-3.5.3.tar.gz (317.3 MB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 317.3/317.3 MB 5.5 MB/s eta 0:00:00
  Preparing metadata (setup.py) ... done
Requirement already satisfied: py4j==0.10.9.7 in /usr/local/lib/python3.10/dist-packages (from pyspark) (0.10.9.7)
Building wheels for collected packages: pyspark
  Building wheel for pyspark (setup.py) ... done
  Created wheel for pyspark: filename=pyspark-3.5.3-py2.py3-none-any.whl size=317840625 sha256=cb75f12ba1f201a7ad003b3242d07b16fe2e0a0a62a7df6350772a1aaa808af0
  Stored in directory: /root/.cache/pip/wheels/1b/3a/92/28b93e2fbfdbb07509ca4d6f50c5e407f48dce4ddbda69a4ab
Successfully built pyspark
Installing collected packages: pyspark
Successfully installed pyspark-3.5.3


[2]
7s
# 1. Import necessary packages 
from pyspark.sql import SparkSession
from pyspark.sql.types import * 

# 2. Create a SparkSession 
spark = SparkSession.builder.appName("Tp1-Spark").getOrCreate()


[3]
0s
# Define the schema (optional but recommended for better perfermance and data integrity )
scheam=StructType([
    StructField("School_Year",StringType(),True),
    StructField("Run_Type",StringType(),True),
    StructField("Bus_No",StringType(),True),
    StructField("Route_Number",StringType(),True),
    StructField("Reason",StringType(),True),
    StructField("Occurred_on",StringType(),True),
    StructField("Number_Of_Strudents_On_The_Bus",IntegerType(),True )
])

[7]
5s
path="/content/bus.csv"
df=spark.read.csv(path,header=True,schema=scheam,inferSchema=False,multiLine=True)
df.show(5,truncate=False)
+-----------+-----------------+------+------------+------------------+-------------------+------------------------------+
|School_Year|Run_Type         |Bus_No|Route_Number|Reason            |Occurred_on        |Number_Of_Strudents_On_The_Bus|
+-----------+-----------------+------+------------+------------------+-------------------+------------------------------+
|2015-2016  |Special Ed AM Run|48186 |N758        |Other             |2015-09-02T06:27:00|0                             |
|2015-2016  |Special Ed AM Run|2518  |L530        |Mechanical Problem|2015-09-02T06:24:00|0                             |
|2015-2016  |Special Ed AM Run|235   |K168        |Other             |2015-09-02T06:45:00|0                             |
|2015-2016  |Special Ed AM Run|2102  |K216        |Other             |2015-09-02T06:55:00|1                             |
|2015-2016  |Special Ed AM Run|48162 |N861        |Mechanical Problem|2015-09-02T06:55:00|0                             |
+-----------+-----------------+------+------------+------------------+-------------------+------------------------------+
only showing top 5 rows



[8]
2s
from pyspark.sql.functions import desc
# 4. Group by 'Reason' and count the occurrences 
reason_counts = df.groupBy("Reason").count()
# 5. sort the counts in descending order 
sorted_reason_counts = reason_counts.orderBy(desc("count"))
# 6. Show the top 5 most common reasons 
sorted_reason_counts.show(5, truncate=False)

+------------------+-----+
|Reason            |count|
+------------------+-----+
|Heavy Traffic     |7732 |
|Other             |2363 |
|Weather Conditions|1283 |
|Mechanical Problem|1259 |
|Won`t Start       |576  |
+------------------+-----+
only showing top 5 rows



[9]
0s
df.select("Reason").distinct().show(truncate=False)

+---------------------------+
|Reason                     |
+---------------------------+
|Problem Run                |
|Weather Conditions         |
|Other                      |
|Flat Tire                  |
|Mechanical Problem         |
|Delayed by School          |
|Won`t Start                |
|Late return from Field Trip|
|Accident                   |
|Heavy Traffic              |
+---------------------------+



[10]
1s
from pyspark.sql.functions import col 

delay_df=df.filter(col("Reason")=="Delayed by School")
delay_df.show(5,truncate=False)
delay_count=delay_df.count()
print(f"Total number of 'Delayed by School' incidents: {delay_count}")
+-----------+-----------------+------+------------+-----------------+-------------------+------------------------------+
|School_Year|Run_Type         |Bus_No|Route_Number|Reason           |Occurred_on        |Number_Of_Strudents_On_The_Bus|
+-----------+-----------------+------+------------+-----------------+-------------------+------------------------------+
|2015-2016  |Special Ed AM Run|2404  |Q069        |Delayed by School|2015-09-11T08:00:00|6                             |
|2015-2016  |General Ed PM Run|1642  |K9764       |Delayed by School|2015-09-16T14:40:00|0                             |
|2015-2016  |Special Ed AM Run|2657  |M492        |Delayed by School|2015-09-18T14:56:00|1                             |
|2015-2016  |Special Ed AM Run|202   |K507        |Delayed by School|2015-09-18T14:50:00|6                             |
|2015-2016  |Special Ed PM Run|1818  |L001        |Delayed by School|2015-09-11T12:14:00|1                             |
+-----------+-----------------+------+------------+-----------------+-------------------+------------------------------+
only showing top 5 rows

Total number of 'Delayed by School' incidents: 309


arrow_upward
arrow_downward
link
comment
settings
delete
more_vert
[14]
1s
""" 
-Identifying the Five Route Numbers Most Affected by Delays or Breakdowns
"""
route_counts = df.groupBy("Route_Number").count()
sorted_route_counts=route_counts.orderBy(desc("count"))
sorted_route_counts.show(5,truncate=False)
+------------+-----+
|Route_Number|count|
+------------+-----+
|1           |3416 |
|2           |2622 |
|5           |2354 |
|3           |2300 |
|4           |1386 |
+------------+-----+
only showing top 5 rows



Q-Display the total number of incidents for each bus.
We need to display the the totla number of incident by bus 
Is like sql select count(Accident ) , bus_no from data groupBy bus_no 
Q- before you solve this using pyspark using a sample of  15 syntatic data using the same schema and go through you thinking process with hands on manuala execution of your logic