Python Libraries

To create this Series, first we need to import numpy to create the ndarray.
Then we create the Series with the given indices.
Here is the correct Python program:

import numpy as np
import pandas as pd data = np.array([10, 20, 30, 40, 50])
index_labels = ['A', 'B', 'C', 'D', 'E'] series = pd.Series(data, index=index_labels)
print(series)

Explanation:
1. We import numpy for creating the ndarray.
2. We create an ndarray with the numbers 10, 20, 30, 40, 50.
3. We define a list of labels for the index.
4. We pass the ndarray and the index list to pd.Series() to create the labelled Series.
5. Finally, we print the Series to display it in the desired format.
This produces the output exactly as given in the question.

To create this DataFrame using a Dictionary of Series, we can define each column as a Series first and then combine them into a DataFrame.
Here is the correct Python code:

import pandas as pd city_series = pd.Series(['Mumbai', 'Dehradun', 'Bengaluru', 'Hyderabad'])
state_series = pd.Series(['Maharashtra', 'Uttarakhand', 'Karnataka', 'Telangana']) data = {'City': city_series, 'State': state_series} df = pd.DataFrame(data)
print(df)

Explanation:
1. We first import pandas and alias it as pd.
2. We create two Series: one for the City column and one for the State column.
3. We store these Series in a dictionary where keys are column names.
4. We pass the dictionary to pd.DataFrame() to create the DataFrame.
5. Finally, we print the DataFrame to display the output in tabular form.
This produces the required DataFrame exactly as shown.

Corrected code:

import pandas as pd data = [50, 15, 40] series = pd.Series(data, index=['x', 'y', 'z']) print(series)

Corrections made:
1. Added `as pd` to properly alias the pandas library so `pd` can be used.
2. Changed `series` to `Series` — class names in pandas start with a capital letter.
3. Changed `Index` to `index` — parameter names must be lowercase.
4. Changed `Print` to `print` — Python built-in functions use lowercase letters.
These corrections ensure the Series is created correctly with index labels and the output is displayed without error.

Completed code:

import pandas as pd data = [ {'COLOUR': 'Red', 'NAME': 'Apple', 'QTY': 10}, {'COLOUR': 'Blue', 'NAME': 'Berry', 'QTY': 15}, {'COLOUR': 'Green', 'NAME': 'Guava', 'QTY': 20}
] df = pd.DataFrame(data)
print(df)

Corrections made:
1. Filled the first blank with `pandas` to import the library.
2. Added `'COLOUR': 'Green'` for the third dictionary to ensure all rows have the same keys.
3. Used `data` inside `pd.DataFrame()` to create the DataFrame.
4. Printed the DataFrame with `print(df)` to display the output as given.
This ensures the DataFrame matches the required structure and prints the correct table.

In Pandas, slicing is a way to access a range of elements from a Series by using start and end index positions.
The syntax for slicing is similar to slicing in Python lists and arrays.
When we slice a Series, we use square brackets with start and end index: Series[start:end].
The start index is included but the end index is excluded in the result.
For example, consider a Series named s with values [5, 10, 15, 20, 25].
If we write s[1:4], it will return elements from index 1 to index 3.
So the output will be [10, 15, 20].
Slicing is useful for selecting a subset of data for further analysis.
You can also use negative indices to slice from the end of the Series.
For example, s[-3:] will return the last three elements of the Series.
Slicing keeps the index labels intact which makes it easy to work with labelled data.
In summary, slicing is a powerful feature to quickly access multiple elements from a Series without loops.

In Python Pandas, Series and DataFrame are the two most commonly used data structures for handling data.
A Series is a simple one-dimensional labelled array that holds a sequence of values and an associated index for each value.
It is similar to a single column of data and can contain integers, floats, strings, or any data type.
A DataFrame, on the other hand, is a two-dimensional labelled data structure with both rows and columns.
It can be seen as a table with multiple columns, where each column is like a separate Series.
One major difference is that Series can hold only a single list of data, while a DataFrame can hold multiple Series side by side.
Another key point is that a Series has only one axis (the index) but a DataFrame has two axes — row index and column labels.
A DataFrame also allows heterogeneous data — different columns can store different data types.
For example, one column can store integers while another can store strings.
This makes DataFrame much more suitable for complex tabular data manipulation, like joining, grouping, or pivoting.
In summary, Series is for handling one-dimensional data with simple operations,
whereas DataFrame is designed for structured two-dimensional data with multiple columns and more powerful operations.

In Pandas, the loc[] indexer is used to select rows and columns by label.
This means you can use loc[] to access data using the explicit index or column labels rather than their integer positions.
For example, if you have a DataFrame df, you can use df.loc[5] to get the row with index label 5.
Or you can use df.loc[5, 'Name'] to get the value in the 'Name' column for the row where the index is 5.
Option label does not exist as an indexer.
index refers to the index object itself but is not used as an indexing method.
labeindex is not a valid syntax.
Therefore, the correct answer for label-based indexing is loc.

In Python’s pandas library, the simplest way to select a single element from a Series using its index label is with square bracket notation.
ser[points] selects the element in the Series ser whose index matches points.
- ser.element() and ser.select() are not valid pandas methods for direct indexing.
- ser.show[] is not a valid attribute or method either.
Therefore, the correct and standard syntax is ser[points].

In Python’s Pandas library, the basic data structures are Series and DataFrame.
- A Series is a one-dimensional labelled array that can hold any data type — integers, floats, strings, etc.
- It is similar to a column in an Excel sheet or a single column in a DataFrame.
- A DataFrame is a two-dimensional labelled data structure with columns of potentially different types.
Therefore, for storing one-dimensional labelled data, Series is the correct structure.
An Integer is just a single numeric value, not a structure.
A Dictionary is a key-value pair structure in Python but is not a Pandas Series.
So, the correct answer is Series.

(i) Print the last three rows of the DataFrame:
To view the last three rows, use the tail() function.

print(Doctor.tail(3))

Explanation: The tail() method displays the last n rows. Here, n is 3.
(ii) Display the names of all doctors:
To display only the 'Name' column, use:

print(Doctor['Name'])

Explanation: This selects only the 'Name' column and prints it.
(iii) Add a new column 'Discount':
To add a new column with the same value for all rows, use:

Doctor['Discount'] = 200

Explanation: This creates a new column named 'Discount' and assigns 200 to every row.
(iv) Display rows with index 2 and 3:
To select specific rows by index, use the loc indexer with a list of index labels.

print(Doctor.loc[[2, 3]])

Explanation: The loc method is label-based indexing for rows.
(v) Delete the column 'Department':
To drop a column from a DataFrame, use drop with axis=1.

Doctor = Doctor.drop('Department', axis=1)

Explanation: The drop() function removes the specified column and updates the DataFrame.

(i) The required module to create plots is matplotlib.pyplot.
So the correct import statement is:

import matplotlib.pyplot as plt

This imports the pyplot module and gives it the alias plt.
(ii) To create a line plot, we use the `plot` function.
So the correct statement is:

plt.plot(days, temp)

This plots temperature values against days as a line graph.
(iii) The label for the x-axis, based on the graph, should be Days.
So the statement is:

plt.xlabel('Days')

This correctly labels the x-axis on the graph.
(iv) The title of the chart should be “Temperature Over 5 Days” as shown.
So the statement is:

plt.title('Temperature Over 5 Days')

This displays the chart title above the plot.
Together, these statements complete the line plot code properly.