Corrects tables and indents

Author: steam-bell-92

docs/Pandas/pd_data_analysis.md

@@ -7,7 +7,6 @@ Once you have loaded your data into a DataFrame, Pandas offers simple and powerf
 Before performing any analysis, you must first understand the structure and quality of your dataset.
 This step helps identify data types, missing values, and potential anomalies.
 
-```markdown
 |Method|Description|
 |:-----|:----------|
 |`df.head()`|Displays the first n rows (default 5) for a quick look at the data.|
@@ -17,53 +16,48 @@ This step helps identify data types, missing values, and potential anomalies.
 |`df.shape`|Returns a tuple (rows, columns).|
 |`df.dtypes`|Displays data types of all columns.|
 
-```
 
 2. **Handling Missing Data (NaN)**
 
 Real-world data often has missing or incomplete entries.
 Handling them correctly is essential to avoid biased or invalid results.
 
-```markdown
 |Method|Description|
 |:-----|:----------|
 |`df.isnull().sum()`|Counts missing (NaN) values per column.|
 |`df.dropna()`|Removes rows with missing values.|
 |`df.fillna(value)`|Fills missing values with a specific value.|
 |`df.fillna(df.mean())`|Fills missing values with the mean (for numeric columns).|
-```
+
 
 3. **Data Selection and Filtering**
 
 Once the data is clean, you often need to focus on specific rows or columns to analyze relevant subsets.
 
-```markdown
 |Method|Description|
 |:-----|:----------|
 |`df['col']`|Selects a single column (returns a Series).|
 |`df[['col1','col2']]`|Selects multiple columns.|
 |`df.loc[row_labels, col_labels]`|Selects by label (rows and columns).|
 |`df.iloc[row_index, col_index]`|Selects by integer index position.|
 |`df[df['col'] > value]`|Filters rows based on a condition.|
-```
+
 
 4. **Grouping and Aggregation**
 
 After filtering, you often need to summarize or compare groups within your data.
 
-```markdown
 |Method|Description|
 |:-----|:----------|
 |`df.groupby('col').agg()`|Groups data by the specified column, then applies an aggregate function (e.g., `mean()`, `sum()`, `count()`).|
 |`df.describe()`|Generates descriptive statistics (mean, std, min, max, etc.) for numerical columns.|
 |`df['col'].value_counts()`|Counts the frequency of unique values in a column.|
-```
+
 
 5. **Data Transformation & Cleaning**
 
 Data transformation involves reshaping, reformatting, or correcting data to make it more consistent and analysis-ready.
 
-```markdown
 |Method|Description|
 |:-----|:----------|
 |`df.rename(columns={'old':'new'})`|Renames columns.|
@@ -72,19 +66,17 @@ Data transformation involves reshaping, reformatting, or correcting data to make
 |`df.astype('type')`|Changes the data type of a column.|
 |`df.sort_values(by='col')`|Sorts rows by column values.|
 |`df.reset_index(drop=True)`|Resets the DataFrame index.|
-```
+
 
 ***Quick Statistics***
 
 Once the data is ready, you can compute summary statistics to get insights about its distribution and relationships.
 
-```markdown
 |Method|Description|
 |:-----|:----------|
 |`df.rename(columns={'old':'new'})`|Renames columns.|
 |`df.drop(columns=['col'])`|Removes one or more columns.|
 |`df.replace(old, new)`|Replaces specific values.|
 |`df.astype('type')`|Changes the data type of a column.|
 |`df.sort_values(by='col')`|Sorts rows by column values.|
-|`df.reset_index(drop=True)`|Resets the DataFrame index.|
-```
+|`df.reset_index(drop=True)`|Resets the DataFrame index.|

docs/Pandas/pd_dataframes.md

@@ -1,4 +1,4 @@
-## Key Data Structures: Series and DataFrame
+# Key Data Structures: Series and DataFrame
 
 Pandas introduces two primary data structures: the Series and the DataFrame. Understanding these is crucial, as they form the basis of nearly all operations in the library.
 

docs/Pandas/pd_input_output.md

@@ -1,18 +1,17 @@
-# Data Input/Output (I/O)
+# Data Input/Output
 
 One of the greatest strengths of Pandas is its ability to effortlessly read data into and write data out of a DataFrame from various file formats. This is achieved primarily through the functions prefixed with `pd.read_` and the methods prefixed with `df.to_`.
 
 ## Reading Data into a DataFrame
 To load data into a Pandas DataFrame, you use the appropriate `pd.read_...()` function. The most common input format is CSV.
 
-```
 |Function|File Type|Example Usage|
 |:-------|:--------|:------------|
 |`pd.read_csv()`|Comma-Separated Values (Text files)|`df = pd.read_csv('data.csv')`|
 |`pd.read_excel()`|Microsoft Excel files|`df = pd.read_excel('data.xlsx')`|
 |`pd.read_json()`|JavaScript Object Notation|`df = pd.read_json('data.json')`|
 |`pd.read_sql()`|SQL database tables|`df = pd.read_sql(query, connection)`|
-```
+
 
 **Example**: Reading a CSV File
 
@@ -27,13 +26,12 @@ df_sales = pd.read_csv('sales_data.csv')
 
 After you've cleaned, transformed, or analyzed your data, you'll use a `.to_...()` method on the DataFrame object to save the results.
 
-```
 |Method|File Type|Example Usage|
 |:-----|:--------|:------------|
 |`df.to_csv()`|Comma-Separated Values|`df.to_csv('cleaned_data.csv', index=False)`|
 |`df.to_excel()`|Microsoft Excel files|`df.to_excel('analysis.xlsx', sheet_name='Summary')`|
 |`df.to_json()`|JavaScript Object Notation|`df.to_json('data_output.json')`|
-```
+
 
 **Example**: Writing to a CSV File
 

docs/Pandas/pd_intro.md

@@ -6,9 +6,7 @@ Pandas is a powerful, open-source Python library essential for data analysis and
 At its core, Pandas is designed to make working with labeled and relational data (like data found in spreadsheets or SQL tables) both intuitive and fast. It is built on top of the NumPy library and is the standard tool used by data professionals for critical tasks such as:
 
 - Data Cleaning: Handling missing data, filtering, and correcting errors.
-
 - Data Transformation: Grouping, merging, reshaping, and pivoting datasets.
-
 - Data Exploration: Calculating descriptive statistics and inspecting data structure.
 
 ### Installation and Setup 🛠️
@@ -44,5 +42,4 @@ print(pd.__version__)
 It's helpful for users to know that Pandas is deeply integrated with the wider Python data science ecosystem:
 
 - Built on NumPy: Internally, Pandas relies heavily on the NumPy library for fast array-based computation, which is why it performs complex operations so quickly.
-
 - Data Visualization: Pandas data structures work seamlessly with popular visualization libraries like Matplotlib and Seaborn.