Chapter 2: Learn Python for Data Analysis

Step 3: Install Jupyter (Recommended for Data Analysis)

**Theory:** Jupyter provides an interactive environment perfect for data exploration.

How to Perform (Terminal):

It's best practice to use virtual environments to manage project dependencies, but for simplicity now, we'll install globally (or use Anaconda which includes Jupyter).

# Install Jupyter Notebook and JupyterLab using pip (Python's package installer)
pip install notebook jupyterlab pandas matplotlib seaborn numpy scipy statsmodels scikit-learn 

# To start JupyterLab:
jupyter lab 

# To start the classic Jupyter Notebook:
jupyter notebook

These commands will open a new tab in your web browser showing a file navigator. You can create new "Notebooks" (`.ipynb` files) from there.

Theory & Task 2: Python Fundamentals

Let's cover the basic syntax you'll need.

Variables and Basic Data Types

**Theory:** Variables store data. Python is dynamically typed, meaning you don't explicitly declare the type; it's inferred.

How to Perform (Code Examples):

# Variables are assigned using =
message = "Hello, Python!" # String (str)
count = 10               # Integer (int)
price = 19.99            # Float (float)
is_valid = True          # Boolean (bool)

# You can check the type
print(type(message))     # Output: 

# Basic operations
total_price = price * count 
print(f"Total price is: {total_price}") # f-string for easy formatting

Data Structures: Lists and Dictionaries

**Theory:** Ways to store collections of data.

• **List:** Ordered, changeable sequence of items. Uses square brackets `[]`. Zero-indexed.
• **Dictionary (dict):** Unordered collection of key-value pairs. Uses curly braces `{}`. Keys must be unique and immutable (like strings or numbers).

How to Perform (Code Examples):

# List
fruits = ["apple", "banana", "cherry"]
print(fruits[0])      # Output: apple
fruits.append("orange") # Add item to the end
print(fruits)         # Output: ['apple', 'banana', 'cherry', 'orange']
print(len(fruits))    # Output: 4 (length of the list)

# Dictionary
student = {
    "name": "MSMAXPRO",
    "age": 20,
    "is_enrolled": True,
    "courses": ["Math", "Physics"]
}
print(student["name"]) # Access value by key -> Output: MSMAXPRO
student["age"] = 21   # Change a value
student["city"] = "Agra" # Add a new key-value pair
print(student) 

Control Flow: `if`/`else` and Loops

**Theory:** Controlling the order in which code executes.

• **`if`, `elif`, `else`:** Execute code based on conditions.
• **`for` loop:** Iterate over a sequence (like a list or range).

How to Perform (Code Examples):

# If/Else statement
score = 75
if score >= 90:
    print("Grade: A")
elif score >= 80:
    print("Grade: B")
elif score >= 70:
    print("Grade: C")
else:
    print("Grade: F")
# Output: Grade: C

# For loop iterating over a list
for fruit in fruits:
    print(f"I like {fruit}")

# For loop iterating over a range of numbers
# range(5) generates numbers 0, 1, 2, 3, 4
for i in range(5):
    print(f"Number: {i}") 

**Indentation is Crucial:** Python uses whitespace (indentation, typically 4 spaces) to define blocks of code (like what's inside an `if` statement or a `for` loop). Incorrect indentation will cause errors.

Functions: Reusable Code Blocks

**Theory:** Define blocks of code that perform a specific task and can be called multiple times.

How to Perform (Code Examples):

# Define a function
def greet(name):
  """This function greets the person passed in as a parameter.""" # Docstring explains the function
  print(f"Hello, {name}!")

# Call the function
greet("MSMAXPRO") # Output: Hello, MSMAXPRO!
greet("Data Analyst") # Output: Hello, Data Analyst!

# Function with a return value
def add_numbers(x, y):
  """Returns the sum of two numbers."""
  return x + y

result = add_numbers(5, 3)
print(result) # Output: 8

Theory & Task 3: Introduction to Core Data Analysis Libraries

While base Python is powerful, these libraries are the essential toolkit for any data analyst.

1. NumPy (Numerical Python)

**Theory:** The fundamental package for scientific computing in Python. Its core feature is the powerful N-dimensional **array** object, which is much more efficient for numerical operations than standard Python lists.

Key Features & How to Perform:

import numpy as np # Conventionally imported as 'np'

# Create a NumPy array from a list
my_list = [1, 2, 3, 4, 5]
my_array = np.array(my_list)
print(my_array)     # Output: [1 2 3 4 5]
print(type(my_array)) # Output: 

# Perform mathematical operations on the entire array easily
print(my_array * 2) # Output: [ 2  4  6  8 10]
print(np.mean(my_array)) # Output: 3.0 (calculate mean)
print(np.std(my_array))  # Output: 1.414... (calculate standard deviation)

# Create arrays with specific values
zeros = np.zeros(5) # Array of 5 zeros: [0. 0. 0. 0. 0.]
ones = np.ones(3)   # Array of 3 ones:  [1. 1. 1.]

2. Pandas (Python Data Analysis Library)

**Theory:** Built on top of NumPy, Pandas provides high-performance, easy-to-use data structures (primarily the **DataFrame**) and data analysis tools. It's the workhorse for data cleaning, manipulation, and exploration.

Key Features & How to Perform:

import pandas as pd # Conventionally imported as 'pd'

# Create a DataFrame (like a table) from a dictionary
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 22],
    'City': ['New York', 'London', 'Paris']
}
df = pd.DataFrame(data)
print(df)
# Output:
#       Name  Age       City
# 0    Alice   25   New York
# 1      Bob   30     London
# 2  Charlie   22      Paris

# Read data from a CSV file (very common)
# df_from_csv = pd.read_csv('your_data.csv') 

# Select columns (Series)
print(df['Name']) 
# Output: 
# 0      Alice
# 1        Bob
# 2    Charlie
# Name: Name, dtype: object

# Select rows (using index or conditions)
print(df.iloc[0]) # Select first row by index
print(df[df['Age'] > 25]) # Select rows where Age is greater than 25

# Basic data exploration
print(df.head())      # Show first 5 rows
print(df.info())      # Show column data types and non-null counts
print(df.describe())  # Get descriptive statistics for numerical columns

3. Matplotlib & Seaborn (Data Visualization)

**Theory:** Creating charts and graphs to understand and communicate insights from data.

• **Matplotlib:** The foundational plotting library. Highly customizable but can be verbose.
• **Seaborn:** Built on top of Matplotlib, provides a higher-level interface with beautiful default styles and common statistical plot types.

How to Perform (Code Examples in Jupyter Notebook):

import matplotlib.pyplot as plt # Convention for Matplotlib
import seaborn as sns           # Convention for Seaborn

# --- Using Matplotlib ---
plt.figure(figsize=(8, 5)) # Set figure size
plt.plot(df['Name'], df['Age'], marker='o') # Simple line plot (might not make sense here)
plt.title('Age Distribution (Matplotlib)')
plt.xlabel('Name')
plt.ylabel('Age')
plt.grid(True)
plt.show() # Display the plot

# --- Using Seaborn ---
plt.figure(figsize=(8, 5))
sns.barplot(x='Name', y='Age', data=df) # Create a bar plot easily
plt.title('Age Distribution (Seaborn)')
plt.show()

plt.figure(figsize=(8, 5))
sns.histplot(data=df, x='Age', kde=True) # Create a histogram with density curve
plt.title('Age Histogram (Seaborn)')
plt.show()

Conclusion: Your Data Toolkit is Ready! 🔧

You've now learned the essentials of Python syntax and have been introduced to the core libraries (NumPy, Pandas, Matplotlib, Seaborn) that form the foundation of data analysis in Python. This combination allows you to load, clean, manipulate, analyze, and visualize data effectively.

The next step is to dive deeper into these libraries, especially **Pandas** for data manipulation and cleaning, and **Matplotlib/Seaborn** for creating insightful visualizations. You'll also learn how to fetch data directly using **SQL** (Chapter 3), the standard language for interacting with relational databases.