DEV Community: Ridwan Ahmed Arman

Revise Python in 15 days for ML (2025) : Day 5 (Dic)

Ridwan Ahmed Arman — Thu, 15 May 2025 17:50:39 +0000

Revise Python in 15 days for ML (2025) : Day 5 (List)

Ridwan Ahmed Arman — Wed, 14 May 2025 05:12:05 +0000

Welcome to Day 5 of our Python journey! If you missed Day 4 where we explored loops, be sure to check it out before diving into today's content!

🔑 Introduction to Data Structures

Today we start our exploration of Python's data structures, beginning with one of the most versatile and commonly used: Lists!

Data structures are like specialized containers that organize and store data in ways that make it easy to access and modify. Think of them as different types of toolboxes, each designed for specific kinds of jobs.

📚 Lists: Python's Swiss Army Knife

A list is a collection of items stored in a specific order. Lists are incredibly versatile and are one of the most frequently used data structures in Python.

✨ Key Characteristics of Lists

Lists have three fundamental properties that make them special:

🔢 Ordered: Items maintain their position - the 1st item stays 1st unless you change it
🔄 Mutable: You can change, add, or remove items after creating the list
🔁 Allow Duplicates: The same value can appear multiple times in a list

💡 Remember: Order matters in lists! The sequence of elements is preserved.

🛠️ Creating and Accessing Lists

Basic Syntax

list_name = [item1, item2, item3, item4]

# Example
list_1 = [1, 2, 3, 4, 5]
print(list_1[0])  # Output: 1

🔍 How Indexing Works

Lists use zero-based indexing - the first element is at position 0
You access elements using square brackets []
Negative indices count from the end: list_1[-1] gets the last element

🧰 Essential List Operations

Adding Elements

There are multiple ways to add elements to a list:

# Create an empty list and add elements
list_2 = []
for i in range(5):
    list_2.append(int(input()))  # Adds user input to the end of the list
print(list_2)

Removing Elements

list_1 = [1, 2, 3, 4, 5]
list_1.pop()  # Removes the last element
print(list_1)  # Output: [1, 2, 3, 4]

🔧 List Methods: Your Toolkit for Manipulation

Python lists come with many built-in methods that make working with them a breeze:

Method	Description	Example
`count()`	Counts occurrences of an element	`list_3.count(3)`
`index()`	Returns position of first occurrence	`list_3.index(3)`
`reverse()`	Reverses the list in-place	`list_3.reverse()`
`sort()`	Sorts the list in-place	`list_3.sort()`
`extend()`	Adds elements from another iterable	`list_3.extend([6,7,8])`
`insert()`	Inserts element at specific position	`list_3.insert(2,9)`
`remove()`	Removes first occurrence of value	`list_3.remove(9)`
`append()`	Adds element to end of list	`list_3.append(9)`
`pop()`	Removes element at position (default last)	`list_3.pop()`
`clear()`	Removes all elements	`list_3.clear()`

Let's see these methods in action:

list_3 = [1, 2, 3, 4, 5]

# Finding information
print(list_3.count(3))    # Output: 1 (count of element 3)
print(list_3.index(3))    # Output: 2 (position of element 3)
print(list_3[-1])         # Output: 5 (last element)

# Changing order
list_3.reverse()
print("After reverse", list_3)  # Output: After reverse [5, 4, 3, 2, 1]

list_3.sort() 
print("After sort", list_3)     # Output: After sort [1, 2, 3, 4, 5]

# Adding elements
list_3.extend([6, 7, 8])
print("After extend", list_3)   # Output: After extend [1, 2, 3, 4, 5, 6, 7, 8]

list_3.insert(2, 9)
print("After insert", list_3)   # Output: After insert [1, 2, 9, 3, 4, 5, 6, 7, 8]

# Removing elements
list_3.remove(9)
print("After remove", list_3)   # Output: After remove [1, 2, 3, 4, 5, 6, 7, 8]

list_3.append(9)
print(list_3)                   # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

list_3.pop()
print(list_3)                   # Output: [1, 2, 3, 4, 5, 6, 7, 8]

list_3.clear()
print(list_3)                   # Output: []

📝 Copying Lists: A Critical Distinction

There are two ways to copy a list, but they behave very differently:

Method 1: Using the `copy()` method

list_4 = [1, 2, 3, 4, 5]
list_5 = list_4.copy()
print(list_5)  # Output: [1, 2, 3, 4, 5]

Method 2: Using assignment (`=`)

list_1 = [1, 'hello', 3, 4, 5]
list_2 = list_1            # Creates a reference, not a new list
list_3 = list_1.copy()     # Creates a new independent list

⚠️ The Crucial Difference

Watch what happens when we modify the original list:

list_1[0] = 10             # Changed value in list_1
print(list_2)              # Output: [10, 'hello', 3, 4, 5] - list_2 changed!
print(list_3)              # Output: [1, 'hello', 3, 4, 5] - list_3 remains unchanged

🔍 What's happening? When you use =, you're creating a reference to the same list in memory. When you use copy(), you're creating a brand new list with the same values.

🧩 Append vs. Extend: Another Important Distinction

These two methods might seem similar, but they behave quite differently:

# Using append with a list
list_1 = [1, 2, 3, 4, 5]
list_2 = [6, 7, 8]
list_1.append(list_2)
print(list_1)  # Output: [1, 2, 3, 4, 5, [6, 7, 8]]

# Using extend with a list
list_3 = [1, 2, 3, 4, 5]
list_4 = [6, 7, 8]
list_3.extend(list_4)
print(list_3)  # Output: [1, 2, 3, 4, 5, 6, 7, 8]

💡 Key difference:

append() adds the entire object as a single element

extend() adds each element of the iterable individually

✨ List Comprehensions: The Pythonic Superpower

List comprehensions are a concise way to create lists. They're one of Python's most powerful features and can often replace loops for list creation.

Basic Syntax:

list_name = [expression for item in iterable if condition]

Simple Example:

# Creating a list of squares from 0 to 9
squares = [x**2 for x in range(10)]
print(squares)  
# Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

🌟 Advanced Example: Creating a Matrix

# Creating a 5×3 matrix using nested list comprehension
matrix = [[i for i in range(3)] for j in range(5)]
print(matrix)
# Output: [[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]

📊 When to Use Lists?

Lists are perfect when you need:

Ordered collection of items
Flexible modification - adding, removing, or changing elements
Sequence operations like slicing, concatenation, etc.
Mixed data types in one collection

🧠 List Performance Considerations

Understanding list performance helps you use them more effectively:

Accessing elements by index: O(1) - Lightning fast!
Searching (without knowing the index): O(n) - Must check each element
Insertion/deletion at beginning/middle: O(n) - Must shift elements
Insertion/deletion at end: O(1) - Very fast when using append()/pop()

💪 Practice Exercises

Try these exercises to strengthen your understanding:

Create a list of the first 10 prime numbers using a loop
Write a function that takes two lists and returns a new list with common elements
Use list comprehension to create a list of all even numbers between 1 and 50
Create a function that flattens a nested list (hint: use extend)

🔍 Common Mistakes to Avoid

Forgetting that lists start at index 0, not 1
Using = instead of copy() when you need an independent copy
Confusing append() and extend() when adding elements
Modifying a list while iterating through it (can cause unexpected behavior)

🚀 Tomorrow: Tuples

Tomorrow we'll explore tuples - Python's immutable, ordered sequences. We'll see how they differ from lists and when to use each one.

🔗 Resources

← Day 4: Mastering Loops | Day 5: Python Lists | [Day 6: Tuples →]

What's your favorite list method? Share in the comments below! 💬

Revise Python in 15 days for ML (2025) : Day 4 (Loop)

Ridwan Ahmed Arman — Tue, 13 May 2025 10:59:35 +0000

Welcome to Day 4 of our Python journey! If you missed Day 3 where we explored operators and conditionals, make sure to check it out first!

🔁 What Are Loops?

Loops are like having a super-efficient assistant who can repeat the same task multiple times without getting tired. Instead of writing the same code over and over, we can wrap it in a loop and let Python handle the repetition!

Today we'll master two powerful loop types:

🔢 For loops - when you know exactly how many times you want to repeat something
⏱️ While loops - when you want to keep going until a condition changes

🔢 For Loops: The Counting Champion

A for loop works like this:

Specify what you want to iterate through
For each item, execute the indented code block
Move to the next item and repeat until you've gone through everything

💫 Magic of Iteration: Three Ways to Use For Loops

1️⃣ Iterating Through Each Character

name = "Ridwan"
for i in name:
    print(i, 'i')

Output:

R i
i i
d i
w i
a i
n i

What's happening?

Python takes each character from "Ridwan" one by one
It temporarily stores each character in the variable i
Then it runs the indented code (printing the character and 'i')
It automatically moves to the next character

2️⃣ Using Range and Indexing

name = "Rid wan"
for i in range(len(name)):
    print(name[i], 'i')

Output:

R i
i i
d i
  i
w i
a i
n i

What's happening?

range(len(name)) creates a sequence: 0, 1, 2, 3, 4, 5, 6
Each number is stored in i during each loop iteration
We use i as an index to access each character with name[i]

💡 Pro Tip: This approach gives you the index position, which can be really useful when you need to know where you are in the sequence!

3️⃣ Processing List Items

L = [1, 2, 3, 4, 5]
sum = 0
for i in L:
    sum += i
    print(i, sum)
print('sum is = ', sum)

Output:

1 1
2 3
3 6
4 10
5 15
sum is = 15

What's happening?

Python takes each number from the list one by one
It temporarily stores each number in the variable i
It adds i to our running total sum
It prints both the current number and the running total

⏱️ While Loops: The Patient Guardian

While loops work differently:

Check if a condition is True
If True, execute the code block
Check the condition again
Keep repeating until the condition becomes False

name = "Rid wan"
i = 0
while i < len(name):
    print(name[i], 'i')
    i += 1

Output:

R i
i i
d i
  i
w i
a i
n i

What's happening?

We start with i = 0
The loop checks if i < len(name) (which is 7)
If True, it prints the character at position i
Then it increases i by 1 with i += 1
This process repeats until i reaches 7, at which point the condition is False

🎭 For Loops vs While Loops: The Key Differences

Feature	For Loop	While Loop
Best Used When	You know exactly how many iterations you need	You don't know in advance how many iterations you need
Counter	Managed automatically	You must initialize and update yourself
Typical Use Cases	Iterating through collections	Validating user input, processing until a condition is met
Risk	Less prone to infinite loops	Can create infinite loops if condition never becomes False

⚠️ Warning! Always make sure your while loop condition will eventually become False, or your program will run forever!

🌀 Nested Loops: Loops Inside Loops

Nested loops are like wheels within wheels - an inner loop runs completely for each iteration of the outer loop.

🧩 Basic Nested Loop

for i in range(1, 5):
    for j in range(1, 5):
        print(i, j)
    print()

Output:

What's happening?

The outer loop runs 4 times (i = 1, 2, 3, 4)
For each value of i, the inner loop runs 4 times (j = 1, 2, 3, 4)
That's a total of 16 print statements!
The empty print() adds a blank line after each inner loop completes

🧮 Practical Example: Multiplication Table

for i in range(1, 5):
    for j in range(1, 5):
        print(i, '*', j, '=', i*j)
    print()

Output:

Visualization of nested loops:

Outer loop (i=1) → Inner loop (j=1,2,3,4) → Print blank line
Outer loop (i=2) → Inner loop (j=1,2,3,4) → Print blank line
Outer loop (i=3) → Inner loop (j=1,2,3,4) → Print blank line
Outer loop (i=4) → Inner loop (j=1,2,3,4) → Print blank line

🛠️ Practical Loop Applications

For loops are great for:

Processing each item in a list, tuple, string, or dictionary
Executing code a specific number of times
Iterating with precise control over the sequence

While loops excel at:

Processing user input until it's valid
Reading file data until end-of-file
Running games until the player quits
Implementing algorithms that run until convergence

🧠 Loop Selection Guide

Choose a for loop when:

You can count the iterations in advance
You're working with a collection (list, string, etc.)
You need automatic iteration

Choose a while loop when:

The number of iterations depends on user input
You need to check a condition before each iteration
You might need to skip iterations or break early based on conditions

🚀 Challenge Yourself!

Try these exercises to cement your understanding:

Create a program that uses a for loop to find all even numbers between 1 and 20
Write a while loop that asks for names until the user enters "quit"
Build a nested loop to create a simple pattern of asterisks forming a triangle

🔗 Resources

🔮 Coming Up Next...

Tomorrow we'll dive into Python data structures - the fundamental building blocks for organizing and storing your data efficiently!

← Day 3: Operators & Conditionals | Day 4: Mastering Loops | [Day 5: Data Structures →]

Which loop do you find more useful in your coding projects? Share your thoughts in the comments below! 💬

Revise Python in 15 days for ML (2025): Day 3 (Operators & Conditions)

Ridwan Ahmed Arman — Sun, 11 May 2025 20:14:16 +0000

Welcome back, Python explorers! This is Day 3 of our coding journey. Missed Day 2? Catch up before diving in today!

🔧 The Power Tools: Python Operators

Think of operators as Python's Swiss Army knife - small symbols that perform powerful actions. Let's unlock them one by one!

➕ Arithmetic Operators: Math Made Easy

print(3 + 4)   # 7 (Addition)
print(3 - 4)   # -1 (Subtraction)
print(3 * 4)   # 12 (Multiplication)
print(3 / 4)   # 0.75 (Division)
print(2 ** 4)  # 16 (Exponentiation - 2 raised to power 4)
print(3 // 4)  # 0 (Floor division - divides and rounds down)
print(3 % 4)   # 3 (Modulus - returns remainder after division)

Quick Tips:

Use ** for powers (faster than importing math.pow)
// gives you clean integers when you don't need decimals
% is perfect for checking divisibility or creating cycles

🔍 Identity Operators: The Memory Detectives

x = 3
y = 4
print(x is y)      # False
print(x is not y)  # True

💡 Key Insight: is checks if two variables reference the same object in memory - not just the same value!

⚠️ The `==` vs `is` Trap:

x = [1, 2, 3] 
y = [1, 2, 3]

print(x == y)  # True (values are equal)
print(x is y)  # False (different objects in memory)

But wait! Numbers and strings can behave differently:

x = 10
y = 10
print(x is y)  # True (Python optimizes by reusing same object)

🧮 Bitwise Operators: Binary Magic

print(3 & 4)   # 0 (Bitwise AND)
print(3 | 4)   # 7 (Bitwise OR)
print(3 ^ 4)   # 7 (Bitwise XOR)
print(~4)      # -5 (Bitwise NOT)
print(3 << 4)  # 48 (Left shift)
print(3 >> 4)  # 0 (Right shift)

Visual breakdown: When we do 3 & 4:

3 in binary = 011
4 in binary = 100
011 & 100 = 000 (0 in decimal)

⚖️ Comparison Operators: Decision Makers

print(3 == 4)  # False (Equal to)
print(3 != 4)  # True (Not equal to)
print(3 > 4)   # False (Greater than)
print(3 < 4)   # True (Less than)
print(3 >= 4)  # False (Greater than or equal to)
print(3 <= 4)  # True (Less than or equal to)

Remember: These always return Boolean values (True or False) - the foundation of conditional logic!

✏️ Assignment Operators: Elegant Shortcuts

x = 3      # Basic assignment
x += 4     # x = x + 4 (now x is 7)

More shortcuts you'll love:

-= for subtraction
*= for multiplication
/= for division
**= for exponentiation
//= for floor division
%= for modulus

🔎 Membership Operators: The Finders

x = [1, 2, 3]
print(3 in x)       # True
print(4 not in x)   # True

Pro tip: These work on any iterable - lists, tuples, strings, dictionaries, and sets!

🧠 Conditional Statements: The Decision Trees

⚡ Basic if-elif-else Structure

x = 10
if x == 10:
    print("x is 10")
elif x == 20:
    print("x is 20")
else:
    print("x is neither 10 nor 20")

Flow visualization:

Check if x is 10
- If TRUE → Print message and exit
- If FALSE → Continue to next check
Check if x is 20
- If TRUE → Print message and exit
- If FALSE → Execute else block

🌳 Nested Conditionals: Complex Decision Trees

num = int(input("Enter a number: "))
if num % 2 == 0:
    if num % 3 == 0:
        print("The number is divisible by both 2 and 3.")
    else:
        print("The number is divisible by 2 but not by 3.")
else:
    if num % 3 == 0:
        print("The number is not divisible by 2 but divisible by 3.")
    else:
        print("The number is not divisible by either 2 or 3.")

Decision chart:

Is num divisible by 2?
- YES → Is num divisible by 3?
- YES → "Divisible by both 2 and 3"
- NO → "Divisible by 2 but not by 3"
- NO → Is num divisible by 3?
- YES → "Not divisible by 2 but divisible by 3"
- NO → "Not divisible by either 2 or 3"

🏆 Challenge Yourself!

Put your new skills to use:

Create a program that determines if a year is a leap year
Build a simple calculator that uses all arithmetic operators
Write a script to check if a number is prime

🔗 Resources

🔮 Coming Up Next...

Tomorrow we'll explore loops and iteration - the tools that let your programs repeat tasks efficiently!

← Day 2: Python Data Types | Day 3: Operators & Conditionals | [Day 4: Coming Soon →]

Drop a comment below with your favorite Python operator and why you love it! Let's learn together! 💬

Revise Python in 15 days for ML (2025): Day 2 (Data Types)

Ridwan Ahmed Arman — Sun, 11 May 2025 09:21:16 +0000

Hey everyone! Welcome back to my 14-Day Python Revision Challenge for Machine Learning! 🎉 I’m on Day 2 today, and I’m super excited to share what I’ve learned. We’re diving into Data Types in Python—specifically numeric data, sequence data (like lists, tuples, ranges, arrays), sets, and dictionaries. I’ll break it all down in a simple, friendly way with examples, so it’s easy to follow. Let’s get started! 😊

Day 1 is here Day 1

Day 2: Python Data Types - The Building Blocks 🧱

Data types are like the different kinds of containers you use to store stuff in Python. Today, I explored a bunch of them, and I’ll explain each one step by step with examples.

1. Numeric Data - Numbers in Python 🔢

Python handles different kinds of numbers: integers (whole numbers), floats (decimals), and complex numbers.

Integers, Floats, and Complex Numbers:

x = 10          # Integer (whole number)
y = 10.8        # Float (decimal number)
z = 10 + 2j     # Complex number (has real and imaginary parts)
print(type(x))  # Output: <class 'int'>
print(type(y))  # Output: <class 'float'>
print(type(z))  # Output: <class 'complex'>

type() tells you what kind of data you’re working with.
isinstance(y, int) checks if y is an integer. Here, it’s False because y is a float.

Converting Between Types

Trying to convert a complex number to an integer doesn’t work

z = int(z)  # Error: You can’t convert a complex number to an integer

Working with Complex Numbers:

n = complex(input("Enter number: "))  # Input: 10
print(type(n))  # Output: <class 'complex'>
print(n)        # Output: (10+0j)
print(n.real)   # Output: 10.0 (real part)
print(n.imag)   # Output: 0.0 (imaginary part)

You can create a complex number from user input using complex().
n.real and n.imag let you access the real and imaginary parts.

2. Sequence Data - Ordered Collections 📋

Sequences are data types that store items in a specific order. Let’s look at lists, tuples, ranges, and arrays.

Lists

L = [1, 2, 3, 4, 5]  # Lists use square brackets []
print(L)      # Output: [1, 2, 3, 4, 5]
print(L[1])   # Output: 2 (index 1)
print(L[-1])  # Output: 5 (last item)

Lists are like a shopping list—you can change them anytime.
Access items using their index (position), starting from 0. Negative indices count from the end.

Tuples

T = (1, 2, 3, 4, 5)  # Tuples use parentheses ()
print(T)      # Output: (1, 2, 3, 4, 5)
print(T[1])   # Output: 2 (index 1)
print(T[-1])  # Output: 5 (last item)
print(T[1:4]) # Output: (2, 3, 4) (slicing from index 1 to 3)
print(type(T))# Output: <class 'tuple'>

Tuples are like a sealed envelope—once created, you can’t change them.
You can access items the same way as lists, including slicing (like T[1:4]).

Ranges:

x = range(5, 12, 2)  # Start at 5, go up to (but not including) 12, step by 2
print(x)  # Output: range(5, 12, 2)
for i in x:
    print(i)  # Output: 5, 7, 9, 11 (one per line)
print(list(x))  # Output: [5, 7, 9, 11]

range(start, stop, step) generates a sequence of numbers.
You can loop over it with a for loop or convert it to a list

Arrays:

import array as ar
a = ar.array('i', [1, 2, 3, 4, 5])  # 'i' means integer type
print(a)  # Output: array('i', [1, 2, 3, 4, 5])
b = ar.array('f', [1.5, 2, 3, 4, 5])  # 'f' means float type
print(b)  # Output: array('f', [1.5, 2.0, 3.0, 4.0, 5.0])

Arrays are like lists but more strict—you need to specify the data type ('i' for integers, 'f' for floats).
They’re not used as often as lists, but good to know for ML when working with numerical data.

3. Sets - Unique Collections 🗳️

Sets store unique items—no duplicates allowed.

s = {1, 2, 3, 4, 5}
print(s)  # Output: {1, 2, 3, 4, 5}

Sets use curly braces {}.
If you try to add duplicates (like s = {1, 1, 2}), it’ll only keep one copy: {1, 2}.

4. Dictionaries - Key-Value Pairs 📖

Dictionaries store data as key-value pairs, like a phonebook.

d = {"name": "ridwan", "age": 20}
print(d)           # Output: {'name': 'ridwan', 'age': 20}
print(d["name"])   # Output: ridwan
print(d.get("name"))  # Output: ridwan
print(d.keys())    # Output: dict_keys(['name', 'age'])
print(d.values())  # Output: dict_values(['ridwan', 20])
print(d.items())   # Output: dict_items([('name', 'ridwan'), ('age', 20)])

Dictionaries use curly braces {} with key: value pairs.
Access values using the key (d["name"]) or with d.get("name").
keys(), values(), and items() give you the keys, values, or both as pairs.

Quick Comparison: Lists, Tuples, and Sets 🤔

Here’s a simple breakdown of the differences between lists, tuples, and sets:

Lists: Ordered, changeable, allows duplicates. Example: [1, 2, 2, 3].
Tuples: Ordered, unchangeable, allows duplicates. Example: (1, 2, 2, 3).
Sets: Unordered, changeable, no duplicates. Example: {1, 2, 3} (no repeats).

I’ll dive deeper into these three topics on another day, so stay tuned for more on that! 😄

Day 2 Wrap-Up 🌟

Today was all about understanding Python’s data types:

Numeric Data: Integers, floats, and complex numbers—great for math in ML.
Sequence Data: Lists, tuples, ranges, and arrays for ordered collections.
Sets: Perfect for unique items.
Dictionaries: Handy for key-value data like a mini-database.

Day 1 is here Day 1

I’m feeling more confident already! Tomorrow, I’ll probably tackle some control flow stuff like loops and conditionals. If you’re following along, try playing with these data types in your own Python editor—it really helps to experiment! Let me know how you’re doing in the comments. See you for Day 3! 🚀

Revise Python in 15 days for ML (2025) : Day 1

Ridwan Ahmed Arman — Sun, 11 May 2025 04:24:43 +0000

Yo, what's good, bros? I'm stoked to kick off my 14-day Python revision challenge for machine learning, and today’s Day 1! I’m going to break down some basic Python concepts in a way that’s super chill and easy to get. We’re talking about basic output, variables, and strings today. Let’s keep it real simple, with clean bullet points and examples, so everyone can vibe with it. Ready? Let’s dive in!

Day 1: Python Basics for ML - Let’s Get It! 💪

I’m starting with the fundamentals. These are the building blocks you need before you start slaying those ML models. Here’s what I covered today:

1. Basic Output with print() 🗣️

print("hello world", "I am ridwan", sep=" & ", end="?")

Output: hello world & I am ridwan?
sep=" & " adds “ & ” between the words.
end="?" slaps a question mark at the end instead of a new line.

2. Variables - Your Data’s Home 🏠

Variables are like your backpack—you store stuff in them to use later. Let’s break it down:

What’s Inside a Variable?

var = "rdwan"
print(id(var))  # Outputs a unique ID (memory address) for the   # Memory address
import sys
print(sys.getrefcount(var))  # How many references point to this object
print(sys.getsizeof(var))  # Size of the object in bytes

id(var) gives you the memory address of var. Think of it as the variable’s home address.
sys.getrefcount(var) tells you how many things are pointing to it (kinda nerdy, but cool).
sys.getsizeof(var) shows how much space it takes in memory.

Fun Fact: Same Object, Same Address:

x = 100
y = 100
print(id(x))  # Same address
print(id(y))  # Same address
print(x == y)  # True

Python’s smart. If x and y are the same small number (like 100), they point to the same object in memory. Saves space

Invalid Variable Names:

These won’t work: _name, 1name, name@, var-1
Good ones: name1, my_var, coolVariable

Multiple Variables in One Line:

x, y, z = 10, 20, 30
print(x, y, z)  # Output: 10 20 30

Assign multiple variables at once. Clean and quick.

3. Strings - Playing with Words ✍️

Strings are just text, like your WhatsApp messages. Python’s got a ton of tricks to mess with ‘em.

Input and Type Shenanigans

x = input()  # You type: 10
y = input()  # You type: 20
print(type(x))  # Output: <class 'str'>
print(x + y)  # Output: 1020 (strings get concatenated)
print(int(x) + int(y))  # Output: 30 (convert to numbers first)

input() always gives you a string, even if you type numbers.
Want to add numbers? Convert strings to integers with int().

String Methods - Your Text Toolkit

x = "hello world"
print(x.upper())  # HELLO WORLD
print(x.lower())  # hello world
print(x.split())  # ['hello', 'world']
print(x.split("l"))  # ['he', '', 'o wor', 'd']
print(x.__len__())  # 11 (length of string)
print(x.count("l"))  # 3 (how many 'l's)
print(x.find("l"))  # 2 (first 'l' at index 2)
print(x.find("ll"))  # 2 (first 'll' at index 2)
print(x.find("l", 10))  # -1 (no 'l' after index 10)
print(x.capitalize())  # Hello world
print(x.title())  # Hello World
print(x.swapcase())  # HELLO WORLD
print(x.isdigit())  # False (not all digits)
print(x.isalpha())  # False (not all letters)
print(x.isalnum())  # False (has a space)
print(x.center(20))  # '    hello world     '
print(x.ljust(20))  # 'hello world         '
print(x.rjust(20))  # '         hello world'
print(x.replace("l", "L"))  # heLLo worLd

These methods are like filters for your text. Uppercase, lowercase, split it, count stuff, find stuff, align it—whatever you need, Python’s got you.

Day 1 Vibe Check ✅

Today was all about getting comfy with Python’s basics. I’m feeling pumped! Here’s the game plan:

Output: Printing stuff with print() is your first step to flexing in Python.
Variables: They’re your storage units. Know their IDs and sizes for extra nerd points.
Strings: Text is powerful, and Python’s string methods let you slice and dice it like a pro.

Tomorrow, I’m diving deeper—maybe some lists, loops, or conditionals. Stay tuned, bros! If you’re following along, drop a comment on my blog. Let’s learn this ML stuff together! 😎

Pro Tip Want to try this yourself? Fire up a Python editor (like VS Code or Jupyter Notebook) and mess around with the code snippets above. It’s the best way to lock this stuff in.

Peace out, and catch ya on Day 2! ✌️

Become a Part of My ML Journey 2025 : From Bangladesh

Ridwan Ahmed Arman — Sat, 10 May 2025 16:02:03 +0000

I'm not an expert (yet!). I'm a recent graduate figuring things out, just like many of you. By sharing what works and what doesn't, we can learn together and create a resource that addresses our unique challenges.
Whether you're a fellow CSE graduate looking for job preparation tips, someone interested in machine learning, or just curious about tech education in Bangladesh – I invite you to follow along and grow with me.
Let's bridge the gap between our academic education and what the industry actually demands.

What topic would you like me to cover first? Drop a comment below!

DEV Community: Ridwan Ahmed Arman

Revise Python in 15 days for ML (2025) : Day 5 (Dic)

Revise Python in 15 days for ML (2025) : Day 5 (List)

🔑 Introduction to Data Structures

📚 Lists: Python's Swiss Army Knife

✨ Key Characteristics of Lists

🛠️ Creating and Accessing Lists

Basic Syntax

🔍 How Indexing Works

🧰 Essential List Operations

Adding Elements

Removing Elements

🔧 List Methods: Your Toolkit for Manipulation

📝 Copying Lists: A Critical Distinction

Method 1: Using the copy() method

Method 2: Using assignment (=)

⚠️ The Crucial Difference

🧩 Append vs. Extend: Another Important Distinction

✨ List Comprehensions: The Pythonic Superpower

Basic Syntax:

Simple Example:

🌟 Advanced Example: Creating a Matrix

📊 When to Use Lists?

🧠 List Performance Considerations

💪 Practice Exercises

🔍 Common Mistakes to Avoid

🚀 Tomorrow: Tuples

🔗 Resources

Revise Python in 15 days for ML (2025) : Day 4 (Loop)

🔁 What Are Loops?

🔢 For Loops: The Counting Champion

💫 Magic of Iteration: Three Ways to Use For Loops

1️⃣ Iterating Through Each Character

2️⃣ Using Range and Indexing

3️⃣ Processing List Items

⏱️ While Loops: The Patient Guardian

🎭 For Loops vs While Loops: The Key Differences

🌀 Nested Loops: Loops Inside Loops

🧩 Basic Nested Loop

🧮 Practical Example: Multiplication Table

🛠️ Practical Loop Applications

🧠 Loop Selection Guide

🚀 Challenge Yourself!

🔗 Resources

🔮 Coming Up Next...

Revise Python in 15 days for ML (2025): Day 3 (Operators & Conditions)

🔧 The Power Tools: Python Operators

➕ Arithmetic Operators: Math Made Easy

🔍 Identity Operators: The Memory Detectives

⚠️ The == vs is Trap:

🧮 Bitwise Operators: Binary Magic

⚖️ Comparison Operators: Decision Makers

✏️ Assignment Operators: Elegant Shortcuts

🔎 Membership Operators: The Finders

🧠 Conditional Statements: The Decision Trees

⚡ Basic if-elif-else Structure

🌳 Nested Conditionals: Complex Decision Trees

🏆 Challenge Yourself!

🔗 Resources

🔮 Coming Up Next...

Revise Python in 15 days for ML (2025): Day 2 (Data Types)

Day 2: Python Data Types - The Building Blocks 🧱

1. Numeric Data - Numbers in Python 🔢

Integers, Floats, and Complex Numbers:

Converting Between Types

Working with Complex Numbers:

2. Sequence Data - Ordered Collections 📋

Lists

Tuples

Ranges:

Arrays:

3. Sets - Unique Collections 🗳️

4. Dictionaries - Key-Value Pairs 📖

Quick Comparison: Lists, Tuples, and Sets 🤔

Day 2 Wrap-Up 🌟

Revise Python in 15 days for ML (2025) : Day 1

Day 1: Python Basics for ML - Let’s Get It! 💪

1. Basic Output with print() 🗣️

2. Variables - Your Data’s Home 🏠

Fun Fact: Same Object, Same Address:

Method 1: Using the `copy()` method

Method 2: Using assignment (`=`)

⚠️ The `==` vs `is` Trap: