import numpy as np  # Import NumPy with alias 'np' (convention)

Creating different types of arrays: various methods to initialize NumPy arrays
arr1 = np.array([1, 2, 3, 4, 5])           # Create array from Python list (most common method)
arr2 = np.zeros(5)                          # Create array of 5 zeros: [0., 0., 0., 0., 0.] (float type)
arr3 = np.ones(3)                           # Create array of 3 ones: [1., 1., 1.] (float type)
arr4 = np.arange(0, 10, 2)                  # Create array with step: [0, 2, 4, 6, 8] (like range() but returns array)
arr5 = np.linspace(0, 1, 5)                 # Create 5 evenly spaced values: [0., 0.25, 0.5, 0.75, 1.] (inclusive endpoints)

Vectorized operations: apply operations to entire arrays at once (much faster than loops)
print(arr1 + 2)      # Element-wise addition: [3, 4, 5, 6, 7] (adds 2 to each element)
print(arr1 * 2)      # Element-wise multiplication: [2, 4, 6, 8, 10] (multiplies each element by 2)
print(arr1 ** 2)     # Element-wise exponentiation: [1, 4, 9, 16, 25] (squares each element)

Multi-dimensional arrays: working with 2D and 3D data structures
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])  # Create 2D array (3x3 matrix) from nested lists
print(matrix.shape)  # Output: (3, 3) - shows dimensions (rows, columns) as tuple

Creating special matrices for different purposes: common matrix initialization patterns
zeros_matrix = np.zeros((3, 3))    # 3x3 matrix filled with zeros (useful for initialization)
identity_matrix = np.eye(3)        # 3x3 identity matrix (1s on diagonal, 0s elsewhere) - useful for linear algebra
random_matrix = np.random.rand(3, 3)  # 3x3 matrix with random values between 0 and 1 (uniform distribution)

Indexing and slicing multi-dimensional arrays: accessing specific elements and subarrays
print(matrix[0, 1])      # Access element at row 0, column 1: 2 (zero-based indexing)
print(matrix[0, :])      # Get entire first row: [1, 2, 3] (colon means "all columns")
print(matrix[:, 1])      # Get entire second column: [2, 5, 8] (colon means "all rows")

arr = np.array([1, 2, 3, 4, 5])  # Sample array for statistical operations

Basic statistical operations on arrays: common mathematical functions
print(np.mean(arr))      # Calculate arithmetic mean: 3.0 (sum of all elements divided by count)
print(np.std(arr))       # Calculate standard deviation: 1.414... (measure of data spread)
print(np.sum(arr))       # Calculate sum of all elements: 15 (total of all values)
print(np.max(arr))       # Find maximum value: 5 (highest value in array)
print(np.min(arr))       # Find minimum value: 1 (lowest value in array)

Matrix operations: working with 2D arrays for linear algebra
A = np.array([[1, 2], [3, 4]])  # First 2x2 matrix for demonstration
B = np.array([[5, 6], [7, 8]])  # Second 2x2 matrix for demonstration
print(A + B)             # Element-wise addition (adds corresponding elements position by position)
print(A * B)             # Element-wise multiplication (multiplies corresponding elements position by position)
print(np.dot(A, B))      # Matrix multiplication (dot product) - proper matrix multiplication
print(A @ B)             # Matrix multiplication using @ operator (Python 3.5+) - same as np.dot()

Broadcasting: NumPy's ability to perform operations on arrays of different shapes automatically
arr = np.array([1, 2, 3, 4, 5])                    # 1D array with 5 elements
matrix = np.array([[1, 2, 3], [4, 5, 6]])          # 2D array (2x3 matrix)
print(arr + 10)          # Broadcasting: scalar 10 is added to each element: [11, 12, 13, 14, 15] (scalar expands to match array)
print(matrix * 2)        # Broadcasting: scalar 2 multiplies each element: [[2, 4, 6], [8, 10, 12]] (scalar expands to match matrix)

import pandas as pd  # Import pandas with alias 'pd' (convention)

Creating different types of Series (1D labeled arrays): various initialization methods
s1 = pd.Series([1, 2, 3, 4, 5])                        # Series with default numeric index (0, 1, 2, 3, 4)
s2 = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])  # Series with custom string index
s3 = pd.Series({'a': 1, 'b': 2, 'c': 3})               # Series from dictionary (keys become index automatically)

Statistical operations on Series: built-in methods for data analysis
print(s1.mean())         # Calculate mean: 3.0 (arithmetic average of all values)
print(s1.std())          # Calculate standard deviation: 1.581... (measure of data variability)
print(s1.describe())     # Generate comprehensive summary statistics (count, mean, std, min, 25%, 50%, 75%, max)

Creating DataFrame from dictionary (most common method): structured data container
data = {
    'Name': ['Alice', 'Bob', 'Charlie', 'Diana'],      # Column 1: names (string data)
    'Age': [25, 30, 35, 28],                           # Column 2: ages (integer data)
    'City': ['NYC', 'LA', 'Chicago', 'Boston'],        # Column 3: cities (string data)
    'Salary': [50000, 60000, 70000, 55000]             # Column 4: salaries (integer data)
}
df = pd.DataFrame(data)  # Create DataFrame from dictionary (keys become column names)

Basic DataFrame operations and information: essential methods for data exploration
print(df.head())         # Display first 5 rows of DataFrame (quick preview of data)
print(df.info())         # Show DataFrame structure and data types (memory usage and non-null counts)
print(df.describe())     # Generate statistical summary of numeric columns (count, mean, std, min, 25%, 50%, 75%, max)

Reading data from different file formats: pandas supports many data sources
df = pd.read_csv('data.csv')      # Read data from CSV file (most common format for tabular data)
df = pd.read_excel('data.xlsx')   # Read data from Excel file (requires openpyxl or xlrd package)
df = pd.read_json('data.json')    # Read data from JSON file (nested data structures)

Writing data to different file formats: export DataFrames to various formats
df.to_csv('output.csv', index=False)    # Save as CSV (index=False excludes row numbers from output)
df.to_excel('output.xlsx', index=False) # Save as Excel file (requires openpyxl package)
df.to_json('output.json')               # Save as JSON file (preserves data structure)

Data selection and filtering operations: accessing and subsetting data
names = df['Name']                    # Select single column (returns Series object)
subset = df[['Name', 'Age']]          # Select multiple columns (returns DataFrame with specified columns)

Filtering data based on conditions: boolean indexing for row selection
young_people = df[df['Age'] < 30]     # Filter rows where Age is less than 30 (boolean mask)
high_salary = df[df['Salary'] > 60000] # Filter rows where Salary is greater than 60000 (boolean mask)

Sorting data: arrange rows based on column values
df_sorted = df.sort_values('Age', ascending=False)  # Sort by Age in descending order (oldest first)

Grouping and aggregation: split data into groups and apply functions
grouped = df.groupby('City')['Salary'].mean()  # Group by City and calculate mean salary for each city

Handling missing data (NaN values) in DataFrames: essential for data cleaning
print(df.isnull().sum())  # Count missing values in each column (returns Series with column names and counts)

Filling missing values with appropriate strategies: different approaches for different scenarios
df['Age'].fillna(df['Age'].mean(), inplace=True)  # Fill missing ages with mean age (inplace=True modifies original DataFrame)
df.dropna(inplace=True)  # Remove rows that contain any missing values (inplace=True modifies original DataFrame)

Creating another DataFrame for demonstration of merging operations: combining data from multiple sources
df2 = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Eve'],           # Names (some overlap with df for demonstration)
    'Department': ['IT', 'HR', 'Marketing']    # Department information (new data to merge)
})

Different types of joins between DataFrames: SQL-like operations for combining data
merged = pd.merge(df, df2, on='Name', how='inner')      # Inner join: only rows that exist in both DataFrames
left_merged = pd.merge(df, df2, on='Name', how='left')  # Left join: all rows from left DataFrame (df), matching rows from right DataFrame (df2)