Python Programming For Data Science

🧠 Why Python Programming for Data Science?

Python is one of the most loved languages for data science because:

• It’s simple and readable, even for beginners
• It has a massive library ecosystem (NumPy, pandas, matplotlib)
• It allows interactive coding through tools like Jupyter Notebooks
• It has a huge global community that supports and contributes to its development

Want to learn about Data Science in detail? Follow this tutorial.

🔤 Python Basics Refresher (Before Jumping to Data Science)

1. Dynamic Typing – You don’t need to declare variable types.
   • x = 10 # Python knows x is an integer
2. Indentation – Python uses indentation instead of curly braces to structure code.
   • if x > 5: print("Greater than 5")
3. Simple Syntax – Clean and easy to write/read.
   • name = "Kunal" print("Hello", name)

🔧 Must-Know Libraries for Data Science

🧪 Why JupyterLab and Anaconda?

In case you don’t have Anaconda installed so watch this tutorial below that will guide you on how to install Anaconda on Windows and Mac both:

✅ You can visualize graphs, see outputs below code cells, and even export your work to PDF or HTML.

💼 Real-World Companies Using Python

🧑‍🏫 Final Summary for You:

“Python is the backbone of modern data science. Its simplicity, flexibility, and huge support ecosystem make it the go-to tool for analyzing data, building models, and creating powerful applications.”

📘 Python Basics: Variables, Data Types & Typecasting (For Data Science Beginners)

When learning Python for Data Science, mastering variables, data types, and typecasting is essential. Here’s a beginner-friendly guide to help you understand it clearly.

✅ What Are Variables?

Think of variables like labeled containers that store data. You don’t need to declare the type in advance—Python figures it out on its own.

name = "Alice"
age = 25
is_student = True

• name holds a string (text)
• age holds a number
• is_student holds a boolean (True/False)

📊 Common Python Data Types

🔄 What is Typecasting?

Typecasting means converting one data type into another using Python’s built-in functions.

Example Conversions:

x = int("10")       # "10" → 10 (string to int)
y = str(25)         # 25 → "25" (int to string)
z = int(3.9)        # 3.9 → 3 (float to int, truncates not rounds)
lst = list("abc")   # "abc" → ['a', 'b', 'c'] (string to list)

⚠️ Be careful: not all conversions work.

("hello")  # ❌ Will raise a ValueError

💡 Quick Tips:

• Use type(variable) to check the data type.
• Always ensure compatibility before typecasting to avoid errors.

🧵 String & String Methods in Python – Beginner’s Guide

In Python, strings are one of the most commonly used data types, especially in data science, web scraping, automation, and more. This lesson dives into what strings are and the most useful string methods for beginners.

🔤 What is a String?

A string is a sequence of characters enclosed in:

• Single quotes → 'Hello'
• Double quotes → "Hello"

Example:

name = "Alice"
greeting = 'Hello'

📜 Multiline Strings

To write strings that span multiple lines, use triple quotes:

message = """This is 
a multiline 
string."""

🧮 String Indexing and Slicing

• Python indexes start from 0
• You can access individual characters or a slice (subset) of a string

Example:

text = "Python"
text[0]      # 'P'
text[-1]     # 'n'
text[0:2]    # 'Py'
text[:3]     # 'Pyt'
text[3:]     # 'hon'

🚫 String Immutability

Strings in Python are immutable. This means once created, they can’t be changed.

Wrong:

text[0] = 'J'  # ❌ This will throw an error

If you want to “change” a string, create a new one.

🧰 Common String Methods

🧪 Examples

"hello".upper()           # 'HELLO'
" Hello ".strip()         # 'Hello'
"hello world".split()     # ['hello', 'world']
"-".join(["2025", "04", "14"])   # '2025-04-14'
"python".find("th")       # 2

🔧 String Formatting (f-Strings)

Use f-strings to create dynamic messages easily:

name = "Alice"
age = 30
f"Hello, {name}. You are {age} years old."  
# 'Hello, Alice. You are 30 years old.'

💡 Quick Recap:

• Strings are powerful text containers.
• They support indexing, slicing, and immutability.
• Use string methods to clean, search, or format data.
• f-Strings make it super easy to embed variables inside text.

📋 What Are Operators in python programming for data science?

Operators are special symbols used to perform operations on variables and values in Python. They help you manipulate data and make decisions in your code.

1️⃣ Arithmetic Operators

Used for basic mathematical calculations.

2️⃣ Comparison Operators

Compare values and return True or False.

3️⃣ Logical Operators

Combine multiple conditions.

4️⃣ Bitwise Operators

Perform operations at the binary level.

5️⃣ Assignment Operators

Assign values to variables with operations.

6️⃣ Membership & Identity Operators

Check for existence and object identity.

Hope you have understood about python programming for data science

🧠 Taking Input from the User in Python – Easy Explanation

In Python, the input() function is used to collect information from the user. It allows you to make your programs interactive. For example, you can ask the user their name, age, or any data—and then use that info in your code.

✅ Basic Syntax:

name = input("Enter your name: ")
print("Hello", name)

• input() displays the prompt message inside the quotation marks.
• Whatever the user types is stored as a string.

🔁 Type Conversion (Typecasting)

Since input() always returns data as string, we need to convert it to other types like integers or floats when needed.

✅ Example:

age = int(input("Enter your age: "))     # Converts input to integer
price = float(input("Enter the price: "))  # Converts input to float

• int() converts input into whole numbers.
• float() converts input into decimal numbers.

If the user types something that cannot be converted (e.g. letters instead of numbers), Python will throw an error.

🔎 Key Notes for Students:

• input() is always a string by default.
• Use int() or float() for numeric inputs.
• This helps make programs dynamic and user-friendly.
• Always consider using type conversion when working with numbers.

👨‍🏫 Real-World Example:

name = input("What’s your name? ")
age = int(input("How old are you? "))

print(f"{name} will be {age + 1} years old next year!")

🎯 Operator Precedence in Python: What Runs First?

When you’re solving a math problem in Python, how does Python know which part to calculate first?

Just like in school math, Python follows a specific order of operations known as PEMDAS:

✅ What is PEMDAS?

PEMDAS stands for:

1. Parentheses ( ) – Always done first.
2. Exponents ** – Powers come next.
3. Multiplication *, Division /, Floor Division //, and Modulus % – Left to right.
4. Addition +, Subtraction - – Done last, from left to right.

🧠 Why Operator Precedence Matters?

If you write something like:

result = 10 + 2 * 3

Python first multiplies 2 * 3 = 6, then adds 10 + 6 = 16.

But if you add parentheses:

result = (10 + 2) * 3

Python calculates 10 + 2 = 12 first, then 12 * 3 = 36.

🧪 Examples You Can Show Students:

# Without parentheses
result = 10 + 2 * 3     # Output: 16

# With parentheses
result = (10 + 2) * 3   # Output: 36

# Right-to-left for exponentiation
result = 2 ** 3 ** 2     # 3**2 = 9, then 2**9 = 512

💡 Quick Summary for Students:

• Always use parentheses to control what runs first.
• Exponentiation ** is right-associative, meaning it runs from right to left.
• Multiplication/Division/Modulus run before Addition/Subtraction.

🧠 Understanding if, else, and elif in Python

Conditional statements are used to make decisions in your Python code. Just like how we decide things in real life (“if it rains, I’ll take an umbrella”), Python also allows you to execute different code based on whether a condition is true or false.

✅ Basic if Statement

The if statement runs a block of code only if the condition is true.

x = 10
if x > 5:
    print("x is greater than 5")

• If x > 5 is true, the print statement runs.
• If it’s false, nothing happens.

🔁 if-else Statement

When you want to handle both true and false cases, use if-else.

x = 3
if x > 5:
    print("x is greater than 5")
else:
    print("x is not greater than 5")

• If x > 5, the first message is printed.
• Otherwise, the else block executes.

🔄 if-elif-else Statement

Use this when you have multiple conditions to check.

x = 5
if x > 10:
    print("x is greater than 10")
elif x > 5:
    print("x is greater than 5 but not more than 10")
elif x == 5:
    print("x is exactly 5")
else:
    print("x is less than 5")

• Conditions are checked from top to bottom.
• The first true condition executes, and the rest are skipped.

📊 Real-Life Use Case in Data Science

Example 1: Categorizing Data

age = 25
if age < 18:
    category = "Minor"
elif age < 65:
    category = "Adult"
else:
    category = "Senior Citizen"

print("Category:", category)

You can use such logic to group users based on age.

Example 2: Conditional Logic on DataFrame

import pandas as pd

data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Score': [85, 40, 75]}
df = pd.DataFrame(data)

df['Result'] = df['Score'].apply(lambda x: 'Pass' if x >= 50 else 'Fail')
print(df)

This is extremely useful for filtering and labeling data automatically.

📝 Summary for Students

• if: Runs when the condition is True.
• if-else: Adds an alternative when condition is False.
• if-elif-else: Lets you check multiple conditions in sequence.
• Essential in data cleaning, filtering, and decision-making.

🧠 Understanding if, else, and elif in Python

Conditional statements are used to make decisions in your Python code. Just like how we decide things in real life (“if it rains, I’ll take an umbrella”), Python also allows you to execute different code based on whether a condition is true or false.

✅ Basic if Statement

The if statement runs a block of code only if the condition is true.

x = 10
if x > 5:
    print("x is greater than 5")

• If x > 5 is true, the print statement runs.
• If it’s false, nothing happens.

🔁 if-else Statement

When you want to handle both true and false cases, use if-else.

x = 3
if x > 5:
    print("x is greater than 5")
else:
    print("x is not greater than 5")

• If x > 5, the first message is printed.
• Otherwise, the else block executes.

🔄 if-elif-else Statement

Use this when you have multiple conditions to check.

x = 5
if x > 10:
    print("x is greater than 10")
elif x > 5:
    print("x is greater than 5 but not more than 10")
elif x == 5:
    print("x is exactly 5")
else:
    print("x is less than 5")

• Conditions are checked from top to bottom.
• The first true condition executes, and the rest are skipped.

📊 Real-Life Use Case in Data Science

Example 1: Categorizing Data

age = 25
if age < 18:
    category = "Minor"
elif age < 65:
    category = "Adult"
else:
    category = "Senior Citizen"

print("Category:", category)

You can use such logic to group users based on age.

Example 2: Conditional Logic on DataFrame

import pandas as pd

data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Score': [85, 40, 75]}
df = pd.DataFrame(data)

df['Result'] = df['Score'].apply(lambda x: 'Pass' if x >= 50 else 'Fail')
print(df)

This is extremely useful for filtering and labeling data automatically.

📝 Summary for Students

• if: Runs when the condition is True.
• if-else: Adds an alternative when condition is False.
• if-elif-else: Lets you check multiple conditions in sequence.
• Essential in data cleaning, filtering, and decision-making.

🧠 What is match-case in Python?

Now what is match-case Python Programming For Data Science

Introduced in Python 3.10, match-case is Python’s version of switch-case from other languages. It allows pattern matching to simplify conditional branching — making code easier to read and manage.

✍️ Syntax Example:

def http_status(code):
    match code:
        case 200:
            return "OK"
        case 400:
            return "Bad Request"
        case 404:
            return "Not Found"
        case 500:
            return "Internal Server Error"
        case _:
            return "Unknown Status"

✅ case _: acts like a default fallback if no other case matches.

💡 Features of match-case:

• Clean alternative to long if-elif-else chains.
• case _ works as a default case.
• Supports patterns like literals, variables, and structural patterns (e.g., tuples).

📦 Real Use Case: Matching Data Structures

point = (3, 4)

match point:
    case (0, 0):
        print("Origin")
    case (x, 0):
        print(f"X-Axis at {x}")
    case (0, y):
        print(f"Y-Axis at {y}")
    case (x, y):
        print(f"Point at ({x}, {y})")

This pattern checks for a point’s location and provides a response based on its position.

📝 Blog Notes for Students:

• match-case is only available in Python 3.10 and above.
• Helps avoid messy nested conditions.
• It’s excellent for checking HTTP status codes, menu selections, input categories, or anything with fixed outcomes.
• Great for clean readable code, especially in data processing or automation tasks.
• Always include a case _: block to handle unknown or unexpected values.

🧵 String Formatting in Python: A Beginner’s Guide to format() and f-Strings

In Python, strings are everywhere—from printing messages to displaying results. When it comes to inserting values into strings, Python gives you powerful formatting tools. In this guide, you’ll learn two popular ways:

1. Using .format() method
2. Using f-Strings (Recommended)

📌 1. Using .format() Method

You can insert variables inside a string using curly {} brackets and the .format() method.

✍️ Example:

name = "Alice"
age = 25
print("My name is {} and I am {} years old.".format(name, age))

➡️ Output: My name is Alice and I am 25 years old.

🔄 Positional vs Keyword Arguments:

print("{} is learning {}".format("Alice", "Python"))  # Positional
print("{name} is learning {language}".format(name="Alice", language="Python"))  # Keyword

✅ 2. Using f-Strings (Python 3.6+)

f-Strings are cleaner, faster, and more readable. Just add an f before the string and insert variables inside {}.

✍️ Example:

name = "Alice"
age = 25
print(f"My name is {name} and I am {age} years old.")

➡️ Output: My name is Alice and I am 25 years old.

🧮 Expressions Inside f-Strings

You can also run expressions directly inside {}:

a = 5
b = 10
print(f"Sum of {a} and {b} is {a + b}")

➡️ Output: Sum of 5 and 10 is 15

🔢 Formatting Numbers

Control how numbers appear using format specifiers:

pi = 3.14159
print(f"Pi rounded to 2 decimal places: {pi:.2f}")

➡️ Output: Pi rounded to 2 decimal places: 3.14

📐 Padding and Alignment

Align text using :<, :>, and :^ inside f-Strings.

print(f"{'Python':<10}")  # Left-align
print(f"{'Python':>10}")  # Right-align
print(f"{'Python':^10}")  # Center-align

➡️ Output:

Python    
    Python
  Python  

💡 Here 10 is the total space, and the symbols decide alignment.

🧠 Why Use f-Strings?

• Cleaner syntax
• Easier to read
• Supports inline expressions
• Great for formatting numbers and text

🎓 Summary for Students

• Use .format() when working with older Python versions.
• Prefer f-strings for simplicity and performance.
• Practice inserting variables and expressions into strings.
• Use formatting for clean output in reports, dashboards, etc.

🌀 Loops in Python: Explained for Beginners

Loops are a powerful feature in Python that let you execute a block of code repeatedly. Whether you’re processing a list of data, printing numbers, or automating a task, loops are essential in every Python program.

Python offers two main types of loops:

• for loop
• while loop

Let’s explore both with examples and tips.

🔁 1. For Loop

A for loop is used when you want to iterate over a sequence (like a list, tuple, or string).

Example:

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

📌 Output:

apple
banana
cherry

You can also loop over a sequence of numbers using the range() function:

for i in range(3):
    print(i)

📌 Output:

0
1
2

🔄 2. While Loop

A while loop keeps running as long as the condition is True.

Example:

count = 0
while count < 3:
    print(count)
    count += 1

📌 Output:

0
1
2

⛔ 3. Loop Control Statements

Sometimes, you need to control how and when a loop should stop or skip. Here’s how:

Example using break:

for i in range(5):
    if i == 3:
        break
    print(i)

📌 Output:

0
1
2

✨ Bonus Tip: Use Cases of Loops

• ✅ Repeating actions (e.g., sending emails in bulk)
• ✅ Reading files line-by-line
• ✅ Processing each item in a dataset
• ✅ Performing automation tasks

✅ Summary

• Use for loops for known number of iterations or over collections.
• Use while loops for uncertain or conditional repetition.
• break, continue, and pass offer fine control over your loops.

List and List Methods in Python Programming for Data Science

In Python, a list is an ordered, mutable collection used to store multiple items. Lists are incredibly flexible and powerful — you can store different data types (integers, strings, booleans, even other lists) in a single list.

✅ Creating a List

# Empty list
my_list = []

# List with integers
numbers = [1, 2, 3, 4, 5]

# List with mixed data types
mixed_list = [1, "Hello", 3.14, True]

🛠️ Common List Methods

🧪 Example Usage

fruits = ["apple", "banana", "cherry"]
fruits.append("orange")
print(fruits)
# Output: ['apple', 'banana', 'cherry', 'orange']

fruits.sort()
print(fruits)
# Output: ['apple', 'banana', 'cherry', 'orange']

💡 Quick Tips

• Lists are mutable — you can change, delete, and add elements anytime.
• Always use append() when adding one item and extend() for multiple items.
• Use copy() if you want to duplicate the list without changing the original.
• pop() is great for removing items and using their values right away.

🧠 Tuples and Tuple Methods in Python — Beginner Notes

Tuples are one of Python’s basic data structures. They are just like lists but immutable — which means you can’t change their values once created. This makes them super useful for fixed data, like days of the week, coordinates, or records.

✅ What is a Tuple?

A tuple is an ordered, immutable collection of items. Think of it like a list, but locked after creation.

# Creating a tuple
my_tuple = (1, 2, 3, 4)

✔ Tuples are written using parentheses ()
✔ They can contain mixed data types (numbers, strings, booleans)

🛠 Creating Tuples

empty_tuple = ()  # Empty tuple
numbers = (1, 2, 3, 4, 5)  # Tuple with integers
mixed_tuple = (1, "Hello", 3.14, True)  # Mixed data types
single_element = (42,)  # Single element tuple - must have a comma!

Note: If you forget the comma in a one-item tuple, Python won’t treat it as a tuple.

📚 Tuple Methods

Tuples have fewer methods than lists because they’re immutable.

⚡ Tuple Characteristics

• 🔒 Immutable: You can’t add, remove, or change elements once defined.
• 🚀 Faster than lists: Tuple access is faster because of immutability.
• 🧠 Can be used as dictionary keys: Lists can’t be used as keys, but tuples can.

🔍 Accessing Tuple Elements

You can access tuple elements just like lists — using indexing and slicing.

my_tuple = (10, 20, 30, 40)

print(my_tuple[1])     # Output: 20
print(my_tuple[1:3])   # Output: (20, 30)

📦 Tuple Packing and Unpacking

Packing = putting multiple values into one tuple.
Unpacking = extracting them back into variables.

# Packing
person = ("Alice", 25, "Engineer")

# Unpacking
name, age, profession = person
print(name)  # Alice
print(age)   # 25

🕒 When to Use Tuples?

Use a tuple when:

• ✅ You need an unchangeable set of items (e.g. days of the week)
• ✅ You want a faster alternative to lists
• ✅ You’re storing heterogeneous data (like records)

🔹 Sets & Set Methods in Python – Beginner’s Notes

🔍 What is a Set in Python?

A set is:

• Unordered: No indexing or slicing.
• Mutable: You can add/remove items.
• Unique: No duplicate values allowed.

It’s perfect when you want to store a group of distinct items—like tags, IDs, or filtered results.

🛠 Creating a Set

empty_set = set()
numbers = {1, 2, 3, 4, 5}
mixed_set = {1, "Hello", 3.14, True}
unique_numbers = set([1, 2, 2, 3, 4, 4, 5])

Output: {1, 2, 3, 4, 5} — duplicates removed automatically!

✅ Common Set Methods

🧮 Set Operations

🔄 Example Usage

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

print(set1 | set2)     # Union → {1, 2, 3, 4, 5, 6}
print(set1 & set2)     # Intersection → {3, 4}
print(set1 - set2)     # Difference → {1, 2}
print(set1 ^ set2)     # Symmetric Difference → {1, 2, 5, 6}

📌 Key Properties of Sets

• ❌ No indexing or slicing
• ✅ Duplicates removed automatically
• 🔄 Mutable – you can update it anytime

💡 When to Use Sets?

• You want a collection of unique items
• You need fast membership checks
• You want to eliminate duplicates from data