π Welcome back to our AI Engineer Roadmap! β€οΈ
In the previous post, we learned about Recursion and how a function can call itself to solve smaller versions of a problem. Now let's move to one of the most commonly used data types in Python.
π Phase 1: Programming Fundamentals
π Topic 14: Strings
A String is a sequence of characters used to represent text. Names, sentences, email addresses, file paths, messages, and many other types of textual information are represented using strings.
Example:
Here, both "Alice" and "Welcome to Python!" are strings.
Why Do We Need Strings?
Strings are essential for:
β’ Storing text
β’ Processing user input
β’ Working with names and messages
β’ Reading and processing files
β’ Handling data from APIs
β’ Processing text for AI and NLP applications
1. Creating Strings
Strings can be created using single or double quotes.
Both are valid.
You can also use triple quotes for multi-line strings:
2. Accessing Characters
Every character in a string has an index. Python uses zero-based indexing, meaning the first character is at index 0.
The indexes look like this:
3. Negative Indexing
Python also supports negative indexes. The last character has index -1.
Indexing from the end looks like:
4. String Slicing
Slicing allows you to extract part of a string.
Syntax:
Example:
Because indexes 0, 1, and 2 are included, but index 3 is excluded.
Slicing with a Step
5. String Length
Use the
Spaces are also counted as characters.
6. Important String Methods
upper() β Converts text to uppercase.
lower() β Converts text to lowercase.
strip() β Removes leading and trailing whitespace.
replace() β Replaces part of a string.
split() β Splits a string into a list.
join() β Combines elements into a string.
7. Checking Content
You can check whether a substring exists using
8. Strings Are Immutable
One of the most important things to understand about Python strings is that they are immutable. This means you cannot directly change an individual character.
β This is not allowed:
In the previous post, we learned about Recursion and how a function can call itself to solve smaller versions of a problem. Now let's move to one of the most commonly used data types in Python.
π Phase 1: Programming Fundamentals
π Topic 14: Strings
A String is a sequence of characters used to represent text. Names, sentences, email addresses, file paths, messages, and many other types of textual information are represented using strings.
Example:
name = "Alice"
message = "Welcome to Python!"
Here, both "Alice" and "Welcome to Python!" are strings.
Why Do We Need Strings?
Strings are essential for:
β’ Storing text
β’ Processing user input
β’ Working with names and messages
β’ Reading and processing files
β’ Handling data from APIs
β’ Processing text for AI and NLP applications
1. Creating Strings
Strings can be created using single or double quotes.
name = "Alice"
city = 'Mumbai'
Both are valid.
You can also use triple quotes for multi-line strings:
message = """This is
a multi-line
string."""
2. Accessing Characters
Every character in a string has an index. Python uses zero-based indexing, meaning the first character is at index 0.
word = "Python"
print(word[0]) # P
print(word[1]) # y
print(word[5]) # n
The indexes look like this:
P y t h o n
0 1 2 3 4 5
3. Negative Indexing
Python also supports negative indexes. The last character has index -1.
word = "Python"
print(word[-1]) # n
print(word[-2]) # o
Indexing from the end looks like:
P y t h o n
-6 -5 -4 -3 -2 -1
4. String Slicing
Slicing allows you to extract part of a string.
Syntax:
string[start:end] β The end index is not included.Example:
word = "Python"
print(word[0:3]) # Pyt
Because indexes 0, 1, and 2 are included, but index 3 is excluded.
Slicing with a Step
word = "Python"
print(word[0:6:2]) # Pto
5. String Length
Use the
len() function to find the number of characters.text = "Python"
print(len(text)) # 6
Spaces are also counted as characters.
6. Important String Methods
upper() β Converts text to uppercase.
text = "hello"
print(text.upper()) # HELLO
lower() β Converts text to lowercase.
text = "HELLO"
print(text.lower()) # hello
strip() β Removes leading and trailing whitespace.
text = " Python "
print(text.strip()) # Python
replace() β Replaces part of a string.
text = "I like Java"
print(text.replace("Java", "Python")) # I like Python
split() β Splits a string into a list.
text = "Python is powerful"
words = text.split()
print(words) # ['Python', 'is', 'powerful']
join() β Combines elements into a string.
words = ["Python", "is", "powerful"]
text = " ".join(words)
print(text) # Python is powerful
7. Checking Content
You can check whether a substring exists using
in.text = "Python is easy"
print("Python" in text) # True
print("Java" not in text) # True
8. Strings Are Immutable
One of the most important things to understand about Python strings is that they are immutable. This means you cannot directly change an individual character.
β This is not allowed:
β€6
word = "Python"
word[0] = "J"
Instead, you create a new string:
word = "Python"
word = "J" + word[1:]
print(word) # Jython
9. String Concatenation
You can combine strings using
+.first_name = "Alice"
last_name = "Smith"
full_name = first_name + " " + last_name
print(full_name) # Alice Smith
10. f-Strings
f-strings provide a convenient way to insert variables into strings.
name = "Alice"
age = 25
message = f"My name is {name} and I am {age} years old."
print(message) # My name is Alice and I am 25 years old.
f-strings are widely used because they make formatted text easier to read.
11. Strings in AI and NLP
Strings become especially important when you move into Artificial Intelligence. AI systems frequently work with text such as: User questions, Chat messages, Documents, Reviews, Emails, Search queries, AI prompts.
Before text can be processed by many NLP and LLM systems, it often needs to be cleaned, transformed, tokenized, or converted into numerical representations.
For example:
text = " AI is AMAZING! "
cleaned_text = text.strip().lower()
print(cleaned_text) # ai is amazing!
This is a very simple example of text preprocessing.
Common Beginner Mistakes
β Forgetting that indexing starts at 0.
β Assuming the end index in slicing is included.
β Trying to modify an individual character.
β Confusing
split() with join().β Forgetting that spaces count toward string length.
Best Practices
β Use meaningful variable names.
β Use appropriate string methods instead of manually processing characters when possible.
β Use f-strings for readable string formatting.
β Remember that strings are immutable.
Key Takeaways
β’ A string is a sequence of characters.
β’ Python uses zero-based indexing.
β’ Negative indexing starts from -1.
β’ Slicing extracts portions of a string.
β’
len() returns the number of characters. β’ Strings are immutable.
β’ Methods such as
upper(), lower(), strip(), split(), and replace() are extremely useful. β’ Strings are fundamental to NLP, LLMs, and AI applications.
β‘οΈ Double Tap β€οΈ For More
2β€18π2
βοΈ Flight cancelled. Connection missed. What does your AI agent do?
Build the agent that checks flights, reads the policy and recommends the right option.
That's one of the capstone projects in the Certification in Agentic AI by Vishlesan i-Hub, IIT Patna.
β 4 Months | Online | 10 hrs/week | Live classes
β 6+ course projects, 15+ tools
β Learn Python, RAG, LangChain, LangGraph & FastAPI
β Placement assistance for 1 year, plus resume review & interview coaching by Masai*
π Qualifier Test: 25th Oct
Test fee: βΉ29
π https://tinyurl.com/aff-iitp-agai
*Eligibility: 7+ CGPA and 65% attendance
Build the agent that checks flights, reads the policy and recommends the right option.
That's one of the capstone projects in the Certification in Agentic AI by Vishlesan i-Hub, IIT Patna.
β 4 Months | Online | 10 hrs/week | Live classes
β 6+ course projects, 15+ tools
β Learn Python, RAG, LangChain, LangGraph & FastAPI
β Placement assistance for 1 year, plus resume review & interview coaching by Masai*
π Qualifier Test: 25th Oct
Test fee: βΉ29
π https://tinyurl.com/aff-iitp-agai
*Eligibility: 7+ CGPA and 65% attendance
π 5 Free Courses to Learn AI Engineering
1οΈβ£ Hugging Face LLM Course π€Learn Transf
ormers, tokenization, datasets, fine-tuning, and modern LLM workflows. Great for building a strong LLM foundation.
π https://huggingface.co/learn/llm-course
2οΈβ£ AI Engineer Notebooks π»Hands-on noteboo
ks covering RAG, AI agents, tool calling, evaluations, fine-tuning, LLMOps, and production AI engineering.
π https://github.com/calmrocks/ai-engineer-notebooks
3οΈβ£ DataTalksClub LLM Zoomcamp π§ Learn to build pract
ical LLM applications with RAG, vector search, agents, evaluation, monitoring, and production workflows.
π https://github.com/DataTalksClub/llm-zoomcamp
4οΈβ£ MLOps Zoomcamp β
οΈLearn how to take ML mod
els from development to production with MLflow, pipelines, deployment, monitoring, CI/CD, and more.
π https://github.com/DataTalksClub/mlops-zoomcamp
5οΈβ£ Maxime Labonne's LLM Course π₯Go deeper into open-source L
LMs, fine-tuning, QLoRA, quantization, model merging, inference optimization, and deployment.
π https://github.com/mlabonne/llm-course
π All 5 are free β save this post and start learning!
#AI #AICourses #AIEngineering #LLM #MachineLearning #RAG #AIAgents #MLOps
1οΈβ£ Hugging Face LLM Course π€Learn Transf
ormers, tokenization, datasets, fine-tuning, and modern LLM workflows. Great for building a strong LLM foundation.
π https://huggingface.co/learn/llm-course
2οΈβ£ AI Engineer Notebooks π»Hands-on noteboo
ks covering RAG, AI agents, tool calling, evaluations, fine-tuning, LLMOps, and production AI engineering.
π https://github.com/calmrocks/ai-engineer-notebooks
3οΈβ£ DataTalksClub LLM Zoomcamp π§ Learn to build pract
ical LLM applications with RAG, vector search, agents, evaluation, monitoring, and production workflows.
π https://github.com/DataTalksClub/llm-zoomcamp
4οΈβ£ MLOps Zoomcamp β
οΈLearn how to take ML mod
els from development to production with MLflow, pipelines, deployment, monitoring, CI/CD, and more.
π https://github.com/DataTalksClub/mlops-zoomcamp
5οΈβ£ Maxime Labonne's LLM Course π₯Go deeper into open-source L
LMs, fine-tuning, QLoRA, quantization, model merging, inference optimization, and deployment.
π https://github.com/mlabonne/llm-course
π All 5 are free β save this post and start learning!
#AI #AICourses #AIEngineering #LLM #MachineLearning #RAG #AIAgents #MLOps
β€10
Useful WhatsApp Channels You Should Know β
Finance: https://whatsapp.com/channel/0029Vax0HTt7Noa40kNI2B1P
Stock Marketing: https://whatsapp.com/channel/0029VatOdpD2f3EPbBlLYW0h
Forex: https://whatsapp.com/channel/0029VbDCOLxEgGfH5YZJqs3w
Trading: https://whatsapp.com/channel/0029VawmPj05a23woosCRb0d
Wealth: https://whatsapp.com/channel/0029Vb8xtRaDOQIfEZtcy41M
Financial Accounting: https://whatsapp.com/channel/0029Vb5zLmnK0IBeOkrqnL1S
Money: https://whatsapp.com/channel/0029VbE89YQJpe8ciDMTtC1j
Digital Marketing: https://whatsapp.com/channel/0029VbAuBjwLSmbjUbItjM1t
Earn Money Online: https://whatsapp.com/channel/0029Vb1U4wG9sBI22PXhSy0r
AI: https://whatsapp.com/channel/0029VbAWNue1iUxjLo2DFx2U
Tech: https://whatsapp.com/channel/0029VbBo9qY1t90emAy5P62s
ChatGPT: https://whatsapp.com/channel/0029VapThS265yDAfwe97c23
Thoughts: https://whatsapp.com/channel/0029Vb9FjK40rGiVgz7dlt19
Quotes: https://whatsapp.com/channel/0029VbBGEUx4tRrtFAHmUS3P
Fitness: https://whatsapp.com/channel/0029Vb6QGmi9RZAdCZiWlK40
Double Tap β€οΈ For More
Finance: https://whatsapp.com/channel/0029Vax0HTt7Noa40kNI2B1P
Stock Marketing: https://whatsapp.com/channel/0029VatOdpD2f3EPbBlLYW0h
Forex: https://whatsapp.com/channel/0029VbDCOLxEgGfH5YZJqs3w
Trading: https://whatsapp.com/channel/0029VawmPj05a23woosCRb0d
Wealth: https://whatsapp.com/channel/0029Vb8xtRaDOQIfEZtcy41M
Financial Accounting: https://whatsapp.com/channel/0029Vb5zLmnK0IBeOkrqnL1S
Money: https://whatsapp.com/channel/0029VbE89YQJpe8ciDMTtC1j
Digital Marketing: https://whatsapp.com/channel/0029VbAuBjwLSmbjUbItjM1t
Earn Money Online: https://whatsapp.com/channel/0029Vb1U4wG9sBI22PXhSy0r
AI: https://whatsapp.com/channel/0029VbAWNue1iUxjLo2DFx2U
Tech: https://whatsapp.com/channel/0029VbBo9qY1t90emAy5P62s
ChatGPT: https://whatsapp.com/channel/0029VapThS265yDAfwe97c23
Thoughts: https://whatsapp.com/channel/0029Vb9FjK40rGiVgz7dlt19
Quotes: https://whatsapp.com/channel/0029VbBGEUx4tRrtFAHmUS3P
Fitness: https://whatsapp.com/channel/0029Vb6QGmi9RZAdCZiWlK40
Double Tap β€οΈ For More
β€11π₯°2
In the previous post, we learned about Strings and how Python handles text. Now let's move to another fundamental data structure that you'll use constantly in Python, Data Science, and AI.
π Phase 1: Programming Fundamentals
π Topic 15: Lists
A List is an ordered and mutable collection of items in Python.
Lists allow you to store multiple values inside a single variable.
For example, instead of creating separate variables for every fruit:
fruit1 = "Apple"
fruit2 = "Banana"
fruit3 = "Mango"
You can use a list:
fruits = ["Apple", "Banana", "Mango"]
Why Do We Need Lists?
Lists are useful for:
β’ Storing multiple values
β’ Managing collections of data
β’ Iterating through items
β’ Adding and removing elements
β’ Sorting and organizing data
β’ Working with datasets
1. Creating a List
Lists are created using square brackets [].
numbers = [10, 20, 30, 40, 50]
A list can contain different data types:
data = ["Python", 25, 3.14, True]
Although Python allows mixed data types, it's usually better to keep a list logically consistent.
2. Accessing List Elements
Lists use zero-based indexing, just like strings.
fruits = ["Apple", "Banana", "Mango"]
print(fruits[0])
print(fruits[1])
print(fruits[2])
Output:
Apple
Banana
Mango
The indexes are: Apple 0, Banana 1, Mango 2
3. Negative Indexing
You can access elements from the end using negative indexes.
fruits = ["Apple", "Banana", "Mango"]
print(fruits[-1])
print(fruits[-2])
Output:
Mango
Banana
-1 always refers to the last element.
4. List Slicing
You can extract a portion of a list using slicing.
numbers = [10, 20, 30, 40, 50]
print(numbers[1:4])
Output:
[20, 30, 40]
Just like strings, the ending index is excluded.
5. Lists Are Mutable
One of the biggest differences between lists and strings is that lists are mutable.
This means you can change their elements.
fruits = ["Apple", "Banana", "Mango"]
fruits[1] = "Orange"
print(fruits)
Output:
['Apple', 'Orange', 'Mango']
6. Adding Elements
append() Adds an item to the end of the list.
fruits = ["Apple", "Banana"]
fruits.append("Mango")
print(fruits)
Output: ['Apple', 'Banana', 'Mango']
insert() Adds an item at a specific position.
fruits = ["Apple", "Mango"]
fruits.insert(1, "Banana")
print(fruits)
Output:
['Apple', 'Banana', 'Mango']
7. Removing Elements
remove() Removes the first matching value.
fruits = ["Apple", "Banana", "Mango"]
fruits.remove("Banana")
print(fruits)
Output: ['Apple', 'Mango']
pop() Removes an element using its index and returns that element.
fruits = ["Apple", "Banana", "Mango"]
removed = fruits.pop(1)
print(removed)
print(fruits)
Output:
Banana
['Apple', 'Mango']
If no index is provided, pop() removes the last element.
8. Finding the Length
Use len() to find the number of elements.
numbers = [10, 20, 30, 40]
print(len(numbers))
Output: 4
9. Checking if an Element Exists
Use in to check whether an item exists.
fruits = ["Apple", "Banana", "Mango"]
print("Mango" in fruits)
Output: True
10. Looping Through a List
Lists are commonly used with loops.
numbers = [10, 20, 30]
for number in numbers:
print(number)
Output: 10, 20, 30
11. Sorting a List
You can sort a list using sort().
numbers = [50, 10, 40, 20, 30]
numbers.sort()
print(numbers)
Output: [10, 20, 30, 40, 50]
For descending order:
numbers.sort(reverse=True)
12. Useful List Methods
Some commonly used methods are:
β’ append() Add an item to the end
β’ insert() Add an item at a specific position
β’ remove() Remove a specific value
β’ pop() Remove an item by index
β’ sort() Sort the list
β’ reverse() Reverse the list
β’ count() Count occurrences
β’ index() Find the position of an item
β’ clear() Remove all items
Double Tap β€οΈ For More
π Phase 1: Programming Fundamentals
π Topic 15: Lists
A List is an ordered and mutable collection of items in Python.
Lists allow you to store multiple values inside a single variable.
For example, instead of creating separate variables for every fruit:
fruit1 = "Apple"
fruit2 = "Banana"
fruit3 = "Mango"
You can use a list:
fruits = ["Apple", "Banana", "Mango"]
Why Do We Need Lists?
Lists are useful for:
β’ Storing multiple values
β’ Managing collections of data
β’ Iterating through items
β’ Adding and removing elements
β’ Sorting and organizing data
β’ Working with datasets
1. Creating a List
Lists are created using square brackets [].
numbers = [10, 20, 30, 40, 50]
A list can contain different data types:
data = ["Python", 25, 3.14, True]
Although Python allows mixed data types, it's usually better to keep a list logically consistent.
2. Accessing List Elements
Lists use zero-based indexing, just like strings.
fruits = ["Apple", "Banana", "Mango"]
print(fruits[0])
print(fruits[1])
print(fruits[2])
Output:
Apple
Banana
Mango
The indexes are: Apple 0, Banana 1, Mango 2
3. Negative Indexing
You can access elements from the end using negative indexes.
fruits = ["Apple", "Banana", "Mango"]
print(fruits[-1])
print(fruits[-2])
Output:
Mango
Banana
-1 always refers to the last element.
4. List Slicing
You can extract a portion of a list using slicing.
numbers = [10, 20, 30, 40, 50]
print(numbers[1:4])
Output:
[20, 30, 40]
Just like strings, the ending index is excluded.
5. Lists Are Mutable
One of the biggest differences between lists and strings is that lists are mutable.
This means you can change their elements.
fruits = ["Apple", "Banana", "Mango"]
fruits[1] = "Orange"
print(fruits)
Output:
['Apple', 'Orange', 'Mango']
6. Adding Elements
append() Adds an item to the end of the list.
fruits = ["Apple", "Banana"]
fruits.append("Mango")
print(fruits)
Output: ['Apple', 'Banana', 'Mango']
insert() Adds an item at a specific position.
fruits = ["Apple", "Mango"]
fruits.insert(1, "Banana")
print(fruits)
Output:
['Apple', 'Banana', 'Mango']
7. Removing Elements
remove() Removes the first matching value.
fruits = ["Apple", "Banana", "Mango"]
fruits.remove("Banana")
print(fruits)
Output: ['Apple', 'Mango']
pop() Removes an element using its index and returns that element.
fruits = ["Apple", "Banana", "Mango"]
removed = fruits.pop(1)
print(removed)
print(fruits)
Output:
Banana
['Apple', 'Mango']
If no index is provided, pop() removes the last element.
8. Finding the Length
Use len() to find the number of elements.
numbers = [10, 20, 30, 40]
print(len(numbers))
Output: 4
9. Checking if an Element Exists
Use in to check whether an item exists.
fruits = ["Apple", "Banana", "Mango"]
print("Mango" in fruits)
Output: True
10. Looping Through a List
Lists are commonly used with loops.
numbers = [10, 20, 30]
for number in numbers:
print(number)
Output: 10, 20, 30
11. Sorting a List
You can sort a list using sort().
numbers = [50, 10, 40, 20, 30]
numbers.sort()
print(numbers)
Output: [10, 20, 30, 40, 50]
For descending order:
numbers.sort(reverse=True)
12. Useful List Methods
Some commonly used methods are:
β’ append() Add an item to the end
β’ insert() Add an item at a specific position
β’ remove() Remove a specific value
β’ pop() Remove an item by index
β’ sort() Sort the list
β’ reverse() Reverse the list
β’ count() Count occurrences
β’ index() Find the position of an item
β’ clear() Remove all items
Double Tap β€οΈ For More
1β€15π₯1
In the previous post, we learned about Lists, one of Python's most useful and flexible data structures. Now let's understand another important collection type: Tuples.
π Phase 1: Programming Fundamentals
π Topic 16: Tuples
A Tuple is an ordered collection of items that is immutable, meaning its elements cannot be changed after the tuple is created.
Tuples are similar to lists, but the key difference is:
β’ List β Mutable
β’ Tuple β Immutable
Why Do We Need Tuples?
Tuples are useful when:
β’ Data should not be modified.
β’ You want to represent a fixed collection of values.
β’ You want to protect data from accidental changes.
β’ A function needs to return multiple values.
β’ You need a hashable collection that can be used as a dictionary key, provided its elements are hashable.
1. Creating a Tuple
Tuples are commonly created using parentheses
Another example:
Parentheses Are Not Actually Required
Python identifies a tuple primarily by the commas.
Output:
2. Creating a Single-Element Tuple
This is a common beginner trap.
β This is not a tuple:
It's simply an integer.
To create a one-element tuple, you need a trailing comma:
Output:
3. Accessing Tuple Elements
Tuples support indexing just like lists.
Output:
Python uses zero-based indexing.
4. Negative Indexing
You can access elements from the end.
Output:
-1 refers to the last element.
5. Tuple Slicing
Tuples also support slicing.
Output:
The ending index is excluded.
6. Tuples Are Immutable
Once a tuple is created, you cannot change an individual element.
β This produces an error:
Python raises a TypeError because tuples don't support item assignment.
If you need to modify the collection, you generally create a new tuple.
Output:
7. Tuple Unpacking
Tuple unpacking allows you to assign tuple elements to multiple variables.
Output:
The number of variables normally needs to match the number of elements.
8. Using
Python also allows extended unpacking.
Output:
Notice that middle becomes a list, even though the original collection is a tuple.
9. Useful Tuple Methods
Tuples have fewer methods than lists because they are immutable.
Counts how many times a value appears.
π Phase 1: Programming Fundamentals
π Topic 16: Tuples
A Tuple is an ordered collection of items that is immutable, meaning its elements cannot be changed after the tuple is created.
Tuples are similar to lists, but the key difference is:
β’ List β Mutable
β’ Tuple β Immutable
Why Do We Need Tuples?
Tuples are useful when:
β’ Data should not be modified.
β’ You want to represent a fixed collection of values.
β’ You want to protect data from accidental changes.
β’ A function needs to return multiple values.
β’ You need a hashable collection that can be used as a dictionary key, provided its elements are hashable.
1. Creating a Tuple
Tuples are commonly created using parentheses
().coordinates = (10, 20)
Another example:
student = ("Alice", 21, "Computer Science")Parentheses Are Not Actually Required
Python identifies a tuple primarily by the commas.
numbers = 1, 2, 3
print(type(numbers))
Output:
<class 'tuple'>
2. Creating a Single-Element Tuple
This is a common beginner trap.
β This is not a tuple:
value = (10)
It's simply an integer.
To create a one-element tuple, you need a trailing comma:
value = (10,)
print(type(value))
Output:
<class 'tuple'>
3. Accessing Tuple Elements
Tuples support indexing just like lists.
colors = ("Red", "Green", "Blue")
print(colors[0])
print(colors[2])Output:
Red
Blue
Python uses zero-based indexing.
4. Negative Indexing
You can access elements from the end.
colors = ("Red", "Green", "Blue")
print(colors[-1])Output:
Blue
-1 refers to the last element.
5. Tuple Slicing
Tuples also support slicing.
numbers = (10, 20, 30, 40, 50)
print(numbers[1:4])
Output:
(20, 30, 40)
The ending index is excluded.
6. Tuples Are Immutable
Once a tuple is created, you cannot change an individual element.
β This produces an error:
numbers = (10, 20, 30)
numbers[0] = 100
Python raises a TypeError because tuples don't support item assignment.
If you need to modify the collection, you generally create a new tuple.
numbers = (10, 20, 30)
numbers = (100, 20, 30)
print(numbers)
Output:
(100, 20, 30)
7. Tuple Unpacking
Tuple unpacking allows you to assign tuple elements to multiple variables.
person = ("Alice", 25, "Engineer")
name, age, profession = person
print(name)
print(age)
print(profession)Output:
Alice
25
Engineer
The number of variables normally needs to match the number of elements.
8. Using
* in UnpackingPython also allows extended unpacking.
numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers
print(first)
print(middle)
print(last)
Output:
1
[2, 3, 4]
5
Notice that middle becomes a list, even though the original collection is a tuple.
9. Useful Tuple Methods
Tuples have fewer methods than lists because they are immutable.
count()Counts how many times a value appears.
β€8π1
When Should You Use a Tuple?
Use a tuple when the collection represents data that should remain fixed.
For example:
The width and height form a fixed pair of values.
Tuples are also commonly used for coordinates:
11. Tuples in AI and Data Science
Tuples appear frequently in Python-based AI applications.
For example, a dataset might contain:
Here, the tuple can represent:
β’ File name
β’ Corresponding label
Tuples are also frequently encountered when working with functions that return multiple values, database results, coordinates, and fixed configurations.
β οΈ Important: Immutable Doesn't Always Mean Completely Unchangeable
A tuple itself is immutable, but it can contain mutable objects.
For example:
Output:
The tuple's elements cannot be replaced, but the list inside the tuple can still be modified.
This is an important distinction when working with nested data structures.
Common Beginner Mistakes
β’ β Trying to modify a tuple element.
β’ β Forgetting the comma when creating a single-element tuple.
β’ β Assuming tuples are always faster or better than lists.
β’ β Confusing tuple unpacking with indexing.
Best Practices
β’ β Use tuples when the collection represents a fixed set of values.
β’ β Use lists when the collection needs to change.
β’ β Choose the data structure based on the behavior you need rather than simply assuming one is better.
Key Takeaways
β’ A tuple is an ordered, immutable collection.
β’ Tuples use parentheses by convention, such as
β’ A single-element tuple requires a trailing comma:
β’ Tuples support indexing and slicing.
β’ Tuple unpacking makes it easy to assign elements to variables.
β’ Tuples have methods such as
β’ A tuple can contain mutable objects, even though the tuple itself is immutable.
β‘οΈ Double Tap β€οΈ For More
Use a tuple when the collection represents data that should remain fixed.
For example:
image_size = (1920, 1080)
The width and height form a fixed pair of values.
Tuples are also commonly used for coordinates:
point = (10, 25)
11. Tuples in AI and Data Science
Tuples appear frequently in Python-based AI applications.
For example, a dataset might contain:
sample = ("image_001.jpg", 1)Here, the tuple can represent:
β’ File name
β’ Corresponding label
Tuples are also frequently encountered when working with functions that return multiple values, database results, coordinates, and fixed configurations.
β οΈ Important: Immutable Doesn't Always Mean Completely Unchangeable
A tuple itself is immutable, but it can contain mutable objects.
For example:
data = ([1, 2], [3, 4])
data[0].append(5)
print(data)
Output:
([1, 2, 5], [3, 4])
The tuple's elements cannot be replaced, but the list inside the tuple can still be modified.
This is an important distinction when working with nested data structures.
Common Beginner Mistakes
β’ β Trying to modify a tuple element.
β’ β Forgetting the comma when creating a single-element tuple.
β’ β Assuming tuples are always faster or better than lists.
β’ β Confusing tuple unpacking with indexing.
Best Practices
β’ β Use tuples when the collection represents a fixed set of values.
β’ β Use lists when the collection needs to change.
β’ β Choose the data structure based on the behavior you need rather than simply assuming one is better.
Key Takeaways
β’ A tuple is an ordered, immutable collection.
β’ Tuples use parentheses by convention, such as
(1, 2, 3).β’ A single-element tuple requires a trailing comma:
(10,).β’ Tuples support indexing and slicing.
β’ Tuple unpacking makes it easy to assign elements to variables.
β’ Tuples have methods such as
count() and index().β’ A tuple can contain mutable objects, even though the tuple itself is immutable.
β‘οΈ Double Tap β€οΈ For More
β€7π2
In the previous topic, we learned about Sets β how they store unique values, perform set operations, and are useful for fast membership checking.
Now let's move to another extremely important Python data structure.
π Phase 1: Programming Fundamentals
π Topic 18: Dictionaries in Python ποΈ
A dictionary is a Python data structure used to store data in key-value pairs.
In Python:
Here:
"name" β key
"Alex" β value
"age" β key
21 β value
πΉ 1. Why Do We Need Dictionaries?
Suppose you have this list:
You need to remember that:
Index 0 = name
Index 1 = age
Index 2 = course
That's not very readable.
With a dictionary:
Output:
πΉ 2. Creating a Dictionary
Use curly braces
You can also create an empty dictionary:
β οΈ Remember:
πΉ 3. Dictionary Keys and Values
A dictionary contains: Key β Value
Keys: name, salary, department
Values: Sam, 50000, IT
You can get them using:
πΉ 4. Accessing Dictionary Values
Using a key:
You can also use
What is the difference?
If the key doesn't exist:
But:
You can also provide a default value:
πΉ 5. Adding New Items
Simply assign a value to a new key:
πΉ 6. Updating Values
If the key already exists, assignment changes its value:
You can also use
πΉ 7. Removing Items
πΉ 8. Checking Whether a Key Exists
Use the
Important:
πΉ 9. Looping Through a Dictionary
Loop through keys:
Loop through values:
Loop through both:
This is one of the most commonly used patterns when working with dictionaries.
πΉ 10. Dictionary Length
Use
πΉ 11. Nested Dictionaries
A dictionary can contain another dictionary.
Nested dictionaries are extremely common when working with structured data and APIs.
πΉ 12. Dictionary Comprehension
Now let's move to another extremely important Python data structure.
π Phase 1: Programming Fundamentals
π Topic 18: Dictionaries in Python ποΈ
A dictionary is a Python data structure used to store data in key-value pairs.
In Python:
student = {
"name": "Alex",
"age": 21,
"course": "Python"
}
Here:
"name" β key
"Alex" β value
"age" β key
21 β value
πΉ 1. Why Do We Need Dictionaries?
Suppose you have this list:
student = ["Alex", 21, "Python"]
You need to remember that:
Index 0 = name
Index 1 = age
Index 2 = course
That's not very readable.
With a dictionary:
student = {
"name": "Alex",
"age": 21,
"course": "Python"
}
print(student["name"])
Output:
Alex
πΉ 2. Creating a Dictionary
Use curly braces
{} with key-value pairs:person = {
"name": "John",
"age": 25,
"city": "Delhi"
}
You can also create an empty dictionary:
data = {}
# Or
data = dict()
β οΈ Remember:
{} creates an empty dictionary, not an empty set. For an empty set: set()πΉ 3. Dictionary Keys and Values
A dictionary contains: Key β Value
employee = {
"name": "Sam",
"salary": 50000,
"department": "IT"
}
Keys: name, salary, department
Values: Sam, 50000, IT
You can get them using:
employee.keys()
employee.values()
employee.items()
πΉ 4. Accessing Dictionary Values
Using a key:
student = {
"name": "Alex",
"age": 21
}
print(student["name"]) # Alex
You can also use
.get():print(student.get("name")) # Alex
What is the difference?
If the key doesn't exist:
student["city"] β Raises KeyError.But:
student.get("city") β
Returns: NoneYou can also provide a default value:
student.get("city", "Unknown") # Output: Unknown
πΉ 5. Adding New Items
Simply assign a value to a new key:
student = {
"name": "Alex",
"age": 21
}
student["city"] = "Delhi"
print(student)
# {'name': 'Alex', 'age': 21, 'city': 'Delhi'}
πΉ 6. Updating Values
If the key already exists, assignment changes its value:
student["age"] = 22
You can also use
.update():student.update({
"age": 23,
"city": "Mumbai"
})
πΉ 7. Removing Items
pop() - Removes a specific key and returns its value.student.pop("age")
del removes a specific key:del student["city"]
popitem() - Removes and returns the last inserted key-value pair.student.popitem()
clear() - Removes everything:student.clear()
πΉ 8. Checking Whether a Key Exists
Use the
in operator:student = {
"name": "Alex",
"age": 21
}
print("name" in student) # Output: True
Important:
"name" in student checks keys, not values.πΉ 9. Looping Through a Dictionary
Loop through keys:
for key in student:
print(key)
Loop through values:
for value in student.values():
print(value)
Loop through both:
for key, value in student.items():
print(key, value)
This is one of the most commonly used patterns when working with dictionaries.
πΉ 10. Dictionary Length
Use
len():student = {
"name": "Alex",
"age": 21,
"course": "Python"
}
print(len(student))
# Output: 3
len() counts the number of key-value pairs.πΉ 11. Nested Dictionaries
A dictionary can contain another dictionary.
students = {
"student1": {
"name": "Alex",
"age": 21
},
"student2": {
"name": "Sam",
"age": 22
}
}
print(students["student1"]["name"]) # Output: Alex
Nested dictionaries are extremely common when working with structured data and APIs.
πΉ 12. Dictionary Comprehension
β€2
Just like list comprehensions, Python supports dictionary comprehensions.
πΉ 13. Dictionary Keys Must Be Hashable
Dictionary keys must be hashable.
Valid examples:
β A list cannot be used as a key.
data = {
[1, 2]: "numbers"
} # TypeError
Because lists are mutable and therefore unhashable.
πΉ 14. Can Dictionary Values Be Mutable?
Yes! Values can be almost any Python object.
data = {
"numbers": [1, 2, 3],
"info": {"age": 21}
}
So:
Keys β must be hashable
Values β can be mutable or immutable
π€ Dictionaries in AI & Data Science
Dictionaries are everywhere in AI applications.
API responses
response = {
"status": "success",
"score": 0.94,
"model": "classifier"
}
Configuration
config = {
"learning_rate": 0.001,
"epochs": 10,
"batch_size": 32
}
Feature mapping
features = {
"age": 25,
"income": 60000,
"experience": 3
}
JSON data - JSON objects map naturally to Python dictionaries.
This makes dictionaries particularly important when working with REST APIs, machine learning pipelines, LLM APIs, and configuration files.
β οΈ Common Beginner Mistakes
β Mistake 1: Using an index
- Dictionaries are accessed using keys, not numerical indexes.
β Mistake 2: Assuming duplicate keys are preserved
data = {
"name": "Alex",
"name": "Sam"
} # {'name': 'Sam'}
The final value wins.
β Mistake 3: Confusing keys and values
checks whether "name" is a key.
π‘ Key Takeaways
β Dictionaries store key-value pairs
β Keys must be unique
β Keys must be hashable
β Values can be of different data types
β Use [] for direct access
β Use .get() when a missing key should be handled safely
β .keys(), .values(), and .items() are important methods
β Dictionaries support nested structures and comprehensions
β They are heavily used in APIs, JSON, AI applications, and data processing
π₯ Mastering dictionaries is essential because you'll use them constantly when working with Python, APIs, data science, machine learning, and AI systems.
Double Tap β€οΈ For More
squares = {x: x * x for x in range(1, 6)}
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
even_squares = {
x: x * x
for x in range(1, 6)
if x % 2 == 0
}
# {2: 4, 4: 16}πΉ 13. Dictionary Keys Must Be Hashable
Dictionary keys must be hashable.
Valid examples:
data = {
"name": "Alex",
10: "ten",
(1, 2): "tuple"
}β A list cannot be used as a key.
data = {
[1, 2]: "numbers"
} # TypeError
Because lists are mutable and therefore unhashable.
πΉ 14. Can Dictionary Values Be Mutable?
Yes! Values can be almost any Python object.
data = {
"numbers": [1, 2, 3],
"info": {"age": 21}
}
So:
Keys β must be hashable
Values β can be mutable or immutable
π€ Dictionaries in AI & Data Science
Dictionaries are everywhere in AI applications.
API responses
response = {
"status": "success",
"score": 0.94,
"model": "classifier"
}
Configuration
config = {
"learning_rate": 0.001,
"epochs": 10,
"batch_size": 32
}
Feature mapping
features = {
"age": 25,
"income": 60000,
"experience": 3
}
JSON data - JSON objects map naturally to Python dictionaries.
This makes dictionaries particularly important when working with REST APIs, machine learning pipelines, LLM APIs, and configuration files.
β οΈ Common Beginner Mistakes
β Mistake 1: Using an index
student[0]
- Dictionaries are accessed using keys, not numerical indexes.
β Mistake 2: Assuming duplicate keys are preserved
data = {
"name": "Alex",
"name": "Sam"
} # {'name': 'Sam'}
The final value wins.
β Mistake 3: Confusing keys and values
"name" in student
checks whether "name" is a key.
π‘ Key Takeaways
β Dictionaries store key-value pairs
β Keys must be unique
β Keys must be hashable
β Values can be of different data types
β Use [] for direct access
β Use .get() when a missing key should be handled safely
β .keys(), .values(), and .items() are important methods
β Dictionaries support nested structures and comprehensions
β They are heavily used in APIs, JSON, AI applications, and data processing
π₯ Mastering dictionaries is essential because you'll use them constantly when working with Python, APIs, data science, machine learning, and AI systems.
Double Tap β€οΈ For More
β€4π1
So far, weβve covered Lists, Tuples, Sets, and Dictionaries. Now letβs learn a powerful Python feature that helps you write cleaner and more efficient code.
π Phase 1: Programming Fundamentals
π Topic 19: List & Dictionary Comprehensions
Comprehensions provide a short and readable way to create lists and dictionaries using loops and conditions.
πΉ 1. List Comprehension
Normally, you might write:
Output:
With list comprehension:
Much shorter.
Basic Syntax:
Example:
Output:
πΉ 2. List Comprehension with Conditions
You can add an if condition:
Output:
General syntax:
πΉ 3. Converting Values
Comprehensions aren't only for numbers.
Output:
πΉ 4. Using if-else
When using if-else, the syntax changes:
Output:
Remember:
This is a common interview question.
πΉ 5. Nested List Comprehension
Traditional approach:
List comprehension:
Output:
πΉ 6. Dictionary Comprehension
Basic syntax:
Example:
Output:
πΉ 7. Dictionary Comprehension with Conditions
Output:
πΉ 8. Creating a Dictionary from Two Lists
Output:
πΉ 9. Transforming an Existing Dictionary
πΉ 10. Filtering a Dictionary
Output:
π Phase 1: Programming Fundamentals
π Topic 19: List & Dictionary Comprehensions
Comprehensions provide a short and readable way to create lists and dictionaries using loops and conditions.
πΉ 1. List Comprehension
Normally, you might write:
numbers = []
for i in range(1, 6):
numbers.append(i)
print(numbers)
Output:
[1, 2, 3, 4, 5]
With list comprehension:
numbers = [i for i in range(1, 6)]
Much shorter.
Basic Syntax:
[expression for item in iterable]
Example:
squares = [x * x for x in range(1, 6)]
Output:
[1, 4, 9, 16, 25]
πΉ 2. List Comprehension with Conditions
You can add an if condition:
even_numbers = [
x for x in range(1, 11)
if x % 2 == 0
]
Output:
[2, 4, 6, 8, 10]
General syntax:
[expression for item in iterable if condition]
πΉ 3. Converting Values
Comprehensions aren't only for numbers.
names = ["alex", "sam", "john"]
uppercase = [name.upper() for name in names]
Output:
['ALEX', 'SAM', 'JOHN']
πΉ 4. Using if-else
When using if-else, the syntax changes:
result = [
"Even" if x % 2 == 0 else "Odd"
for x in range(1, 6)
]
Output:
['Odd', 'Even', 'Odd', 'Even', 'Odd']
Remember:
# Only if
[expression for x in data if condition]
# if-else
[expression_if_true if condition else expression_if_false for x in data]
This is a common interview question.
πΉ 5. Nested List Comprehension
Traditional approach:
result = []
for x in [1, 2]:
for y in [10, 20]:
result.append((x, y))
List comprehension:
result = [
(x, y)
for x in [1, 2]
for y in [10, 20]
]
Output:
[(1, 10), (1, 20), (2, 10), (2, 20)]
πΉ 6. Dictionary Comprehension
Basic syntax:
{key: value for item in iterable}Example:
squares = {
x: x * x
for x in range(1, 6)
}Output:
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}πΉ 7. Dictionary Comprehension with Conditions
even_squares = {
x: x * x
for x in range(1, 11)
if x % 2 == 0
}Output:
{2: 4, 4: 16, 6: 36, 8: 64, 10: 100}πΉ 8. Creating a Dictionary from Two Lists
names = ["Alex", "Sam", "John"]
scores = [85, 90, 78]
result = {
name: score
for name, score in zip(names, scores)
}
Output:
{'Alex': 85, 'Sam': 90, 'John': 78}πΉ 9. Transforming an Existing Dictionary
prices = {
"Laptop": 800,
"Phone": 500,
"Tablet": 300
}
updated_prices = {
item: price * 1.10
for item, price in prices.items()
}πΉ 10. Filtering a Dictionary
expensive = {
item: price
for item, price in prices.items()
if price > 500
}Output:
{'Laptop': 800}β€1
πΉ 11. When Should You Use Comprehensions?
Use when:
β The logic is simple
β You are transforming data
β You are filtering values
β You want concise and readable code
Avoid them when logic becomes too complex. Readable code is more important than fewest lines.
π€ Why Comprehensions Matter in AI & Data Science
You'll use them for:
β’ Cleaning datasets
β’ Transforming columns
β’ Filtering records
β’ Creating feature mappings
β’ Processing API responses
β’ Preparing data for ML models
Example:
Output:
β οΈ Common Mistakes
β Confusing order with if-else
β Making comprehensions unnecessarily complex
β Forgetting dictionary needs key: value
π‘ Key Takeaways
β List comprehension creates lists concisely
β Dictionary comprehension creates key-value pairs
β Both can include conditions
β if-else has a different syntax
β
β‘οΈ Double Tap β€οΈ For More ποΈ
Use when:
β The logic is simple
β You are transforming data
β You are filtering values
β You want concise and readable code
Avoid them when logic becomes too complex. Readable code is more important than fewest lines.
π€ Why Comprehensions Matter in AI & Data Science
You'll use them for:
β’ Cleaning datasets
β’ Transforming columns
β’ Filtering records
β’ Creating feature mappings
β’ Processing API responses
β’ Preparing data for ML models
Example:
scores = [0.2, 0.8, 0.6, 0.3]
high_scores = [
score for score in scores
if score >= 0.5
]
Output:
[0.8, 0.6]
β οΈ Common Mistakes
β Confusing order with if-else
# Wrong
[x for x in range(5) if x % 2 == 0 else 0]
# Correct
[x if x % 2 == 0 else 0 for x in range(5)]
β Making comprehensions unnecessarily complex
β Forgetting dictionary needs key: value
{x for x in range(5)} # This is a set
{x: x * x for x in range(5)} # This is a dictπ‘ Key Takeaways
β List comprehension creates lists concisely
β Dictionary comprehension creates key-value pairs
β Both can include conditions
β if-else has a different syntax
β
zip() is useful for combining multiple sequences β‘οΈ Double Tap β€οΈ For More ποΈ
β€5π₯1