🚀 𝗪𝗵𝗶𝗰𝗵 𝗧𝗲𝗰𝗵 𝗦𝗸𝗶𝗹𝗹 𝗪𝗶𝗹𝗹 𝗬𝗼𝘂 𝗠𝗮𝘀𝘁𝗲𝗿 𝗶𝗻 𝟮𝟬𝟮𝟲?

Want to build apps, uncover insights, or create AI solutions? Explore certification courses that match your career goals! 🎯

💻 𝗙𝘂𝗹𝗹 𝗦𝘁𝗮𝗰𝗸 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗺𝗲𝗻𝘁
👉 https://pdlink.in/3SuUeuD

📊 𝗗𝗮𝘁𝗮 𝗔𝗻𝗮𝗹𝘆𝘁𝗶𝗰𝘀
👉 https://pdlink.in/45vk5ph

💫𝗔𝗜 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴
👉 https://pdlink.in/4fWJVID

🔥 Choose your path, sharpen your skills, and take the next step towards your tech career!

📌 Save this post & share it with a friend planning to upskill.

📊 Power BI Learning Roadmap — Part 4

Topic 9: Pivot, Unpivot & Transpose in Power Query

These three transformations are extremely useful when your source data is arranged in a way that isn't ideal for analysis.

A common Power BI problem isn't that the data is incorrect — it's that the structure of the data is not suitable for a data model.

1. Pivot Columns

Pivoting converts values from rows into separate columns.

Suppose your data looks like this:

Region | Month | Sales

West | Jan | 50,000

West | Feb | 60,000

South | Jan | 40,000

South | Feb | 45,000

You could pivot the Month column to create:

Region | Jan | Feb

West | 50,000 | 60,000

South | 40,000 | 45,000

Now the values from the Month column have become separate columns.

When is Pivot useful?

Pivot can be useful when the business specifically requires a wide format.

For example: Region | Jan | Feb | Mar | Apr might be useful for a particular reporting output.

However, a wide structure isn't always the best structure for a Power BI data model.

2. Unpivot Columns

Unpivot does the opposite. It converts multiple columns into rows.

Suppose your source looks like this:

Region | Jan | Feb | Mar

West | 50,000 | 60,000 | 55,000

South | 40,000 | 45,000 | 48,000

You can unpivot the month columns to create:

Region | Month | Sales

West | Jan | 50,000

West | Feb | 60,000

West | Mar | 55,000

South | Jan | 40,000

South | Feb | 45,000

South | Mar | 48,000

Now Month is a column containing values rather than separate columns.

3. Why Unpivot Is So Important

Imagine a company provides a monthly report like this:

Employee | Jan | Feb | Mar | Apr | May

Rahul | 20 | 22 | 18 | 25 | 21

Priya | 18 | 20 | 24 | 23 | 26

Next month, they add: Jun

The source structure keeps changing because every month becomes another column.

After unpivoting, the structure becomes:

Employee | Month | Hours

Rahul | Jan | 20

Rahul | Feb | 22

Rahul | Mar | 18

Priya | Jan | 18

Priya | Feb | 20

Priya | Mar | 24

When June arrives, June simply becomes another value in the Month column.

4. Unpivot Other Columns

Suppose your table contains:

Employee | Department | Jan | Feb | Mar

Rahul | Finance | 20 | 22 | 18

Priya | HR | 18 | 20 | 24

You want to preserve Employee and Department and convert the remaining columns into rows.

Unpivot Other Columns is particularly useful here. You select the columns you want to keep, and Power Query unpivots the remaining columns.

5. Attribute and Value Columns

After unpivoting, Power Query generally creates two important columns.

Attribute: Contains the names of the columns that were unpivoted.

Example: Jan, Feb, Mar

Value: Contains the corresponding values. Example: 20, 22, 18

You can rename these to something more meaningful.

For example: Attribute → Month, Value → Hours.

6. Transpose

Transpose is different from Pivot and Unpivot. Transpose essentially turns rows into columns and columns into rows.

Suppose your data is:

Name | Rahul | Priya | Amit

Sales | 80,000 | 70,000 | 60,000

Region | West | South | North

After transposing, the orientation changes.

Transpose changes the physical orientation of the table.

7. Pivot vs Unpivot vs Transpose

Pivot: Turns values into columns. Rows → Columns

Unpivot: Turns columns into rows. Columns → Rows

Transpose: Flips the orientation of the entire table. Rows ↔ Columns

🎯 Real-World Example

Imagine an organization sends you this monthly sales report:

Region | Jan | Feb | Mar | Apr

West | 80 | 90 | 95 | 100

South | 60 | 65 | 70 | 75

North | 50 | 55 | 58 | 62

You could unpivot the month columns:

Region | Month | Sales

West | Jan | 80

West | Feb | 90

West | Mar | 95

West | Apr | 100

South | Jan | 60

South | Feb | 65

Now you can easily analyze: Monthly trends, Regional performance, Month-over-month changes, Yearly comparisons.

⚠️ Common Mistake

Don't assume that every dataset should be unpivoted. The correct transformation depends on: What the data represents, How the source is structured, How the data will be analyzed, Whether the columns represent actual attributes or repeated categories.

🎯 Practical Exercise

Take a dataset structured like:

Product | Jan | Feb | Mar | Apr

Laptop | 100 | 120 | 140 | 150

Monitor | 80 | 90 | 110 | 125

Keyboard | 50 | 60 | 70 | 75

Try the following in Power Query:

1. Unpivot the month columns.

2. Rename Attribute to Month.

3. Rename Value to Sales.

4. Observe the resulting structure.

5. Try pivoting the data back.

6. Create a small table and experiment with Transpose.

💡 Key takeaway: Pivot, Unpivot, and Transpose aren't just buttons to memorize. They are tools for changing the structure of your data so that it better matches the way you need to analyze it.

Double Tap ❤️ For More

𝗧𝗢𝗣 𝗙𝗥𝗘𝗘 𝗖𝗢𝗨𝗥𝗦𝗘𝗦 𝗧𝗢 𝗕𝗢𝗢𝗦𝗧 𝗬𝗢𝗨𝗥 𝗦𝗞𝗜𝗟𝗟𝗦 𝗜𝗡 𝟮𝟬𝟮𝟲!

Explore FREE online learning resources to develop in-demand skills and improve your career opportunities!

🎓 Why Explore These Courses?
✅ Learn valuable professional skills
✅ Improve your resume
✅ Build practical knowledge
✅ Learn at your own pace

𝗘𝘅𝗽𝗹𝗼𝗿𝗲 𝗙𝗥𝗘𝗘 𝗖𝗼𝘂𝗿𝘀𝗲𝘀 𝗛𝗲𝗿𝗲👇

https://pdlink.in/3VBdt6V

💡 Learn New Skills → Build Confidence → Unlock Career Opportunities!

📊 Power BI Learning Roadmap — Part 4

Topic 10: Merge Queries and Append Queries in Power Query

When working with real-world data, you rarely get everything in one table.

You may have:

• Sales data in one table

• Product information in another

• Customer information in another

• Monthly sales in separate files

Power Query provides two important features to combine these datasets:

1. Merge Queries

2. Append Queries

The key difference is simple:

• Merge Queries = add columns from another table

• Append Queries = add rows from another table

1. Merge Queries

Merge Queries is used when you want to combine two tables based on a common column.

It is similar to a JOIN in SQL or a lookup such as XLOOKUP in Excel.

Example

Sales table:

ProductID Quantity Sales

P101 10 5000

P102 5 3000

P103 8 6400

Products table:

ProductID ProductName Category

P101 Laptop Electronics

P102 Mouse Accessories

P103 Keyboard Accessories

Both tables contain ProductID. We can merge them using ProductID.

After merging and expanding:

ProductID Quantity Sales ProductName Category

P101 10 5000 Laptop Electronics

P102 5 3000 Mouse Accessories

P103 8 6400 Keyboard Accessories

2. How to Merge Queries

In Power Query:

1. Select the first table.

2. Go to Home.

3. Select Merge Queries.

4. Select the second table.

5. Select the matching column in both tables.

6. Choose the Join Kind.

7. Click OK.

8. A new column containing a table will appear.

9. Click the Expand button.

10. Select the columns you want to bring into the first table.

3. Join Keys

The column used to match two tables is called a key.

For example:

ProductID

Both tables should have compatible data types. If one table has ProductID = Text and the other has ProductID = Number, the merge may not work as expected.

Always check the data type before merging.

4. Types of Joins

Left Outer

Keeps every row from the first table and brings matching rows from the second table. This is one of the most commonly used joins.

Inner

Keeps only rows that have a match in both tables.

Right Outer

Keeps all rows from the second table and matching rows from the first table.

Full Outer

Keeps all rows from both tables. Matching rows are combined, while unmatched rows are also retained.

Left Anti

Returns rows from the first table that do NOT have a match in the second table. This is extremely useful for finding missing records.

Example: If Sales has P101, P102, P103, P104 and Products has P101, P102, P103, Left Anti identifies P104.

Right Anti

The opposite of Left Anti. It identifies records that exist in the second table but not in the first.

5. A Very Important Problem: Duplicate Keys

Suppose your Products table contains:

P101 Laptop

P101 Laptop - New

And your Sales table contains P101 5000

If you merge these tables, Power Query may produce multiple rows for P101. This can unintentionally increase your row count. So before merging, understand whether your key is unique.

6. Append Queries

Append is completely different from Merge. Append combines tables by stacking rows.

Example:

January Sales: Laptop 5000, Mouse 2000

February Sales: Laptop 6000, Mouse 2500

After Append: All rows stacked vertically.

7. Append Two Queries

If you have two tables: January Sales and February Sales

Use: Home → Append Queries → Append Queries as New

Then select the two queries.

8. Append Three or More Queries

You can also append more than two tables, for example January to June. All can be combined into one Sales table. This is useful when monthly data is stored separately.

9. What If Column Names Are Different?

Suppose January contains Product Sales and February contains Product Revenue. Power Query treats Sales and Revenue as different columns, resulting in null values. So before appending, make sure equivalent columns have consistent names.

10. Merge vs Append

Merge

You have Sales (ProductID | Sales) and Products (ProductID | ProductName | Category). You want ProductID | Sales | ProductName | Category. You are adding columns. Use Merge.

Append

You have January Sales (Product | Sales) and February Sales (Product | Sales). You want one larger table containing all records. You are adding rows. Use Append.

11. Real-World Example

Imagine you work for a bank. You receive transaction files every month: Jan_Transactions.csv, Feb_Transactions.csv, Mar_Transactions.csv.

Each file contains Transaction ID, Account ID, Date, Amount, Currency. You can append all three files into one transaction table.

Then you have a separate Account Master table with Account ID, Customer Name, Region, Account Type.

You can merge the Account Master into the transaction table using Account ID.

12. Common Mistakes

Mistake 1: Choosing the wrong key

Using Customer Name instead of Customer ID can create unreliable matches. Prefer stable identifiers such as CustomerID, AccountID, ProductID.

Mistake 2: Different data types

Text and Number columns cannot reliably match. Check the data type before merging.

Mistake 3: Duplicate keys

Duplicate keys in the lookup table can multiply rows. Always investigate unexpected row-count increases.

Mistake 4: Wrong Join Kind

Choosing Inner instead of Left Outer can cause unmatched records to disappear.

Mistake 5: Appending inconsistent columns

If one file calls a column Sales and another calls it Revenue, Power Query treats them as separate columns. Standardize column names before appending.

🧪 Practical Exercise

Create these three tables.

Sales: P101 5000, P102 3000, P103 7000

Products: P101 Laptop Electronics, P102 Mouse Accessories, P103 Keyboard Accessories

January: P101 5000, P102 3000

February: P101 6000, P102 3500

Try to:

1. Merge Sales with Products.

2. Bring ProductName and Category into Sales.

3. Append January and February.

4. Check the final row count.

5. Try a Left Anti join and identify products missing.

🎯 Double Tap ❤️ For More

𝗗𝗮𝘁𝗮 𝘀𝗰𝗶𝗲𝗻𝗰𝗲 𝗖𝗲𝗿𝘁𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝗪𝗶𝘁𝗵 𝗔𝗜😍

Future Ready Data Science and AI Skills You Build

->Build Python, Machine Learning, and AI Skills
->Get Mentored by Industry Experts
->Practice with Mock Interviews
->Ace Your Placements & Land Dream Tech Job

🤝 500+ Partner Companies |🎓 2000+ Students Placed

🔗 𝗥𝗲𝗴𝗶𝘀𝘁𝗲𝗿 𝗡𝗼𝘄 👇 :-

https://pdlink.in/47pezFz

📲 Save & Share with Friends Preparing for Data Science & AI Jobs!

𝗜𝗕𝗠 𝗙𝗥𝗘𝗘 𝗧𝗘𝗖𝗛 𝗖𝗢𝗨𝗥𝗦𝗘𝗦 𝟮𝟬𝟮𝟲! 🎓

Explore IBM Cognitive Class and build in-demand tech skills without spending money on course fees!

📚 𝗧𝗼𝗽 𝗙𝗥𝗘𝗘 𝗖𝗼𝘂𝗿𝘀𝗲𝘀 𝘁𝗼 𝗘𝘅𝗽𝗹𝗼𝗿𝗲:-

💫 Artificial Intelligence & Machine Learning
🔥Python for Data Science
📊 Data Science Fundamentals
☁️ Cloud Computing & Big Data

🔗 𝗦𝘁𝗮𝗿𝘁 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴 𝗛𝗲𝗿𝗲 👇

https://pdlink.in/4zGswuX

📲 Save & Share with friends preparing for tech careers! 🔥

📊 Power BI Learning Roadmap — Part 4

Topic 12: Power Query M Language

Until now, we have mostly used the Power Query interface to clean and transform data.

But behind almost every transformation you perform in Power Query, there is code.

That language is called M.

Understanding M doesn't mean you need to become a programmer. You just need to understand how Power Query represents the transformations you perform.

1. What is M Language?

M is the language used by Power Query for data transformation.

For example, when you:

• Remove columns

• Filter rows

• Change data types

• Rename columns

• Add custom columns

• Merge queries

• Append queries

• Group data

Power Query creates M code for those actions.

You can see this code in:

View → Advanced Editor

2. A Simple M Example

Suppose your table contains:

Product Sales

Laptop 10000

Mouse 3000

Keyboard 5000

If you filter Sales greater than 4000, Power Query generates an M expression similar to:

Table.SelectRows(Source, each [Sales] > 4000)

This means:

Take the Source table and keep rows where Sales is greater than 4000.

You don't have to memorize this immediately.

The goal is to understand what the code is doing.

3. Power Query Steps Are M Code

When you perform transformations, Power Query creates individual steps.

For example:

Source

Changed Type

Removed Columns

Filtered Rows

Renamed Columns

Each step represents a transformation.

The formula bar can show the M expression behind the selected step.

This is one of the easiest ways to learn M.

Instead of starting with programming syntax, perform a transformation and observe the code Power Query generates.

4. The let and in Structure

A typical Power Query query looks like:

let
    Source = Excel.Workbook(File.Contents("Sales.xlsx")),
    SalesData = Source{[Item="Sales"]}[Data],
    ChangedType = Table.TransformColumnTypes(
        SalesData,
        {{"Sales", type number}}
    )
in
    ChangedType

Don't worry about every part yet.

The important idea is:

let
    Step 1,
    Step 2,
    Step 3
in
    Final Step

Power Query performs the steps in sequence and returns the step specified after in.

5. Understanding a Step

Consider:

FilteredRows =
    Table.SelectRows(Source, each [Sales] > 5000)

There are two important parts.

Step name

FilteredRows

This is the name of the step.

Transformation

Table.SelectRows(Source, each [Sales] > 5000)

This tells Power Query what transformation to perform.

6. Common M Functions

You will frequently encounter functions such as:

Table.SelectRows

Used to filter rows.

Table.SelectRows(Source, each [Sales] > 5000)

Table.RemoveColumns

Used to remove columns.

Table.RemoveColumns(Source, {"Region"})

Table.RenameColumns

Used to rename columns.

Table.RenameColumns(Source, {{"Sales", "Revenue"}})

Table.AddColumn

Used to create a new column.

Table.AddColumn(Source, "Profit", each [Sales] - [Cost])

These functions become much easier to understand once you recognize the pattern.

7. The each Keyword

You will see each frequently in Power Query.

For example:

each [Sales] > 5000

It means the expression should be evaluated for each row.

Another example:

each [Quantity] * [Price]

This calculates the result for every row.

If:

Quantity = 10

Price = 500

then:

10 × 500 = 5000

8. Column References

In M, a column can commonly be referenced like:

[Sales]

For example:

each [Sales] * 1.18

This calculates a value using the Sales column.

For column names containing spaces or special characters, you may see syntax such as:

[#"Sales Amount"]

You don't need to memorize this immediately. Power Query usually generates the correct syntax for you.

9. M Is Case-Sensitive

M language is case-sensitive.

For example:

Sales

and

sales

are not necessarily treated as the same identifier.

Similarly, function names need to be written correctly.

This is one reason copying and modifying existing M code is often easier than writing everything from scratch.

10. Editing M Code

You can modify M code directly using:

View → Advanced Editor

For example, you might change:

[Sales] > 5000

to:

[Sales] > 10000

This changes the filtering condition.

However, don't edit M code blindly.

If you change a step incorrectly, later steps may stop working.

11. Why Learn M If Power Query Has a GUI?

The interface is enough for many common transformations.

But M becomes useful when:

• A transformation isn't easily available through the interface

• You need dynamic logic

• You want to reuse code

• You need parameters

• You want to create custom functions

• You need more control over transformations

• You want to troubleshoot query errors

Think of the GUI as the easy way to build transformations.

M gives you deeper control over those transformations.

12. M vs DAX

This is an important distinction.

Power Query M

Used mainly for:

• Extracting data

• Cleaning data

• Transforming data

• Combining data

• Preparing data before loading

DAX

Used mainly for:

• Measures

• Calculated columns

• Calculations within the data model

• Analysis and reporting

For example:

Removing unnecessary columns:

Use Power Query.

Creating:

Total Sales = SUM(Sales[SalesAmount])

Use DAX.

🧪 Practical Exercise

Take a simple Sales table containing:

Product Quantity Price

Laptop 2 50000

Mouse 5 1000

Keyboard 3 2000

In Power Query:

1. Change the data types.

2. Add a Revenue column.

3. Filter Revenue greater than 5000.

4. Rename the Revenue column.

5. Open the formula bar.

6. Look at the M code generated for each step.

7. Open Advanced Editor.

8. Identify the let and in sections.

🎯 Key Takeaway

M is the language behind Power Query transformations.

You don't need to learn all of M at once.

Start by performing transformations through the interface, then study the M code Power Query generates.

This approach makes M much easier to learn because you already understand what the code is supposed to accomplish.

Double Tap ❤️ For More

𝟰 𝗙𝗥𝗘𝗘 𝗖𝗼𝘂𝗿𝘀𝗲𝘀 𝗧𝗼 𝗠𝗮𝘀𝘁𝗲𝗿 𝗖𝗼𝗱𝗶𝗻𝗴 𝗙𝗼𝗿 𝗙𝗥𝗘𝗘😍

✅ 100% FREE YouTube Learning
✅ Beginner-Friendly Programming Tutorials
✅ Learn Popular & In-Demand Tech Skills
✅ Study at Your Own Pace
✅ Build a Strong Foundation for Coding Interviews

🔗 𝗔𝗰𝗰𝗲𝘀𝘀 𝗔𝗟𝗟 𝟰 𝗙𝗥𝗘𝗘 𝗖𝗼𝘂𝗿𝘀𝗲𝘀 👇:-

https://pdlink.in/3WcuMvi

⚡ Your coding journey can start today—completely FREE!

𝗧𝗔𝗧𝗔 𝗙𝗥𝗘𝗘 𝗠𝗜𝗖𝗥𝗢-𝗜𝗡𝗧𝗘𝗥𝗡𝗦𝗛𝗜𝗣𝗦 𝟮𝟬𝟮𝟲! 🎓

✅ 100% FREE Learning Experience
✅ Short Programs — Approximately 4–6 Hours
✅ Practical, Real-World Tasks
✅ Self-Paced & Online
✅ Certificate Opportunities for Your Resume & LinkedIn
✅ No Traditional Interview Process

🔗 𝗘𝘅𝗽𝗹𝗼𝗿𝗲 𝗧𝗔𝗧𝗔 𝗙𝗥𝗘𝗘 𝗠𝗶𝗰𝗿𝗼-𝗜𝗻𝘁𝗲𝗿𝗻𝘀𝗵𝗶𝗽𝘀👇:-

https://pdlink.in/4yWgaPn

⚡ Don't wait for your first job to start gaining practical experience!

📊 Power BI Learning Roadmap — Part 4

Topic 13: Custom M Functions

After learning the basics of M language, the next important concept is Custom Functions.

Custom functions allow you to write a transformation once and reuse it multiple times.

This becomes very useful when you have many files or tables that need the same transformation logic.

1. What Is a Custom Function?

A custom function is a reusable piece of M code that accepts an input and returns an output.

For example, suppose you frequently need to calculate:

Price + 18% GST

Instead of writing the calculation separately for every query, you can create a function.

Conceptually:

Input: Price

Function: Price × 1.18

Output: Price including GST

If the input is ₹1,000:

1000 × 1.18 = 1180

2. Why Use Custom Functions?

Imagine you receive 12 monthly files.

Every file requires the same transformations:

• Remove unnecessary columns

• Change data types

• Clean product names

• Calculate revenue

• Standardize dates

You could repeat the same steps manually.

But with a custom function, you can define the transformation once and apply it to each input.

This saves time and makes your Power Query solution easier to maintain.

3. Basic Function Structure

A simple M function can look like:

(price as number) as number =>
    price * 1.18

Here:

price is the input.

as number specifies the input data type.

price * 1.18 is the calculation.

The final as number specifies the output type.

4. Using the Function

Suppose your function is called:

AddGST

You could use it like:

AddGST(1000)

Result:

1180

Another example:

AddGST(5000)

Result:

5900

The same logic can be reused with different values.

5. Functions Can Accept Multiple Inputs

A function doesn't have to accept only one parameter.

For example:

(price as number, taxRate as number) as number =>
    price * (1 + taxRate)

Now you can provide both the price and tax rate.

For example:

CalculatePrice(1000, 0.18)

Result:

1180

And:

CalculatePrice(1000, 0.05)

Result:

1050

The function becomes more flexible.

6. Custom Functions with Tables

Custom functions become especially powerful when working with tables.

Imagine you receive these files:

January.xlsx

February.xlsx

March.xlsx

April.xlsx

Each file contains raw sales data.

You want every file to go through the same cleaning process.

You can create a function such as:

TransformSalesFile

The function can:

1. Receive a file.

2. Extract the required table.

3. Remove unnecessary columns.

4. Rename columns.

5. Change data types.

6. Clean the data.

7. Return the transformed table.

You can then apply the function to multiple files.

7. Custom Function Workflow

A common workflow is:

Files → Function → Cleaned Tables → Combined Dataset

For example:

Jan.xlsx

Feb.xlsx

Mar.xlsx

Each file is passed through the same transformation function.

The result is a consistent dataset ready for analysis.

This is one of the most useful applications of custom functions in Power Query.

8. Creating a Function from an Existing Query

Power Query can also help you create a function from an existing query.

A common approach is:

1. Build the transformation for one sample file.

2. Turn the query into a function.

3. Define the input parameter.

4. Apply the function to other files.

This is much easier than manually writing the entire function from scratch.

9. Function vs Parameter

These two concepts can sometimes be confused.

Parameter

A parameter stores a value that can change.

Example:

MinimumSales = 5000

Function

A function performs an operation using one or more inputs.

Example:

CalculateProfit(Sales, Cost)

So:

Parameter = value

Function = reusable logic

10. Real-World Example

Suppose your company receives employee files from different branches.

Each file contains:

Name Salary Department

Rahul 50000 Sales

Priya 60000 HR

Every file needs the same cleaning:

• Remove blank rows

• Standardize department names

• Change Salary to number

• Trim employee names

Instead of repeating these steps for every branch, create:

CleanEmployeeFile

Then apply that function to every branch file.

If you later modify the cleaning logic, you can update the function rather than rebuilding the transformation for every file.

11. Important: Functions Need Consistent Inputs

A custom function works best when the input structure is predictable.

For example, if your function expects:

• Name

• Salary

• Department

but one file contains:

• EmployeeName

• Pay

• Team

the function may fail.

Therefore, when working with multiple files, make sure the files have a consistent structure or build logic to handle differences.

12. Common Mistakes

Mistake 1: Creating a function for everything

Not every transformation needs a custom function.

Use functions when the same logic needs to be reused.

Mistake 2: Wrong input data type

If your function expects a number but receives text, the function may produce an error.

Mistake 3: Inconsistent file structures

Different column names or missing columns can break a function.

Mistake 4: Not testing the function

Always test your function with a few inputs before applying it to hundreds of files.

🧪 Practical Exercise

Create a simple function that calculates profit margin.

Use:

• Sales

• Cost

Formula:

(Sales - Cost) / Sales

For example:

Sales = ₹10,000

Cost = ₹7,000

Profit Margin:

(10000 - 7000) / 10000

= 0.30

= 30%

Then test your function with different Sales and Cost values.

After that, think about how you could use the same concept to transform multiple monthly files.

🎯 Key Takeaway

Custom M Functions allow you to write transformation logic once and reuse it many times.

They are particularly valuable when working with multiple files that require the same cleaning and transformation steps.

Double Tap ❤️ For More

𝗠𝗜𝗖𝗥𝗢𝗦𝗢𝗙𝗧 𝗙𝗥𝗘𝗘 𝗗𝗔𝗧𝗔 𝗦𝗖𝗜𝗘𝗡𝗖𝗘 𝗥𝗘𝗦𝗢𝗨𝗥𝗖𝗘𝗦 𝟮𝟬𝟮𝟲! 🎓

Microsoft offers valuable FREE learning resources to help you develop in-demand technical skills! 💻

✅ 100% FREE Learning Resources
✅ Beginner-Friendly Tutorials
✅ Self-Paced Learning
✅ Practical Skills for Real-World Projects
✅ Useful for Data Analytics & Data Science Career Preparation

🔗 𝗔𝗰𝗰𝗲𝘀𝘀 𝗔𝗟𝗟 𝟰 𝗙𝗥𝗘𝗘 𝗥𝗲𝘀𝗼𝘂𝗿𝗰𝗲𝘀 👇:-

https://pdlink.in/4k6ylNq

⚡ Your Data Science journey can start today — completely FREE!

𝗗𝗮𝘁𝗮 𝗦𝗰𝗶𝗲𝗻𝗰𝗲 & 𝗠𝗮𝗰𝗵𝗶𝗻𝗲 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴 𝗙𝗥𝗘𝗘 𝗢𝗻𝗹𝗶𝗻𝗲 𝗠𝗮𝘀𝘁𝗲𝗿𝗰𝗹𝗮𝘀𝘀 📊

Build a strong foundation in Data Science .Explore Machine Learning and Deep Learning

Eligibility :- Students • Freshers • Working Professionals

📅 Date:- 23 October 2026
⏰ Time:- 7:00 PM–9:00 PM IST
💻 Mode:- Online

🔗 𝗥𝗲𝗴𝗶𝘀𝘁𝗲𝗿 𝗙𝗼𝗿 𝗙𝗥𝗘𝗘👇 :-

https://pdlink.in/4i8MKGn

📢 Share this opportunity with your friends and classmates.

🚀𝗠𝗔𝗦𝗧𝗘𝗥 𝗘𝗫𝗖𝗘𝗟 𝗙𝗢𝗥 𝗙𝗥𝗘𝗘 𝗜𝗡 𝟮𝟬𝟮𝟲! 📊

Discover 4 FREE Websites to learn Microsoft Excel from beginner to advanced level! 🎓

🔥 FREE Learning Resources
🔥 Beginner to Advanced Tutorials
🔥 Practical Examples & Exercises
🔥 Learn Anytime, Anywhere

🔗 𝗟𝗶𝗻𝗸👇:-

https://pdlink.in/4jDfcCP

⚡ One powerful skill can open doors to multiple career opportunities!