Day 1 of Python in 7 Days

Ravindranath PorandlaRavindranath Porandla
33 min read

Table of contents

🐍 Python: The Friendly Dragon of the Coding World! 🐉

Hey there, awesome readers! 👋 Have you ever wanted to build something amazing with just a few simple instructions? Like telling a robot what to do, or making a game, or even teaching a computer to understand pictures? Well, guess what? There's a super cool tool for that, and it's called Python! 🥳

Imagine Python as a friendly, wise dragon 🐉 that understands your words easily. Instead of speaking a super complicated secret language, you can tell this dragon what to do in a way that almost feels like talking in English! How cool is that? 😎

In this super exciting adventure, we're going to explore everything about Python, from its secret past to its amazing superpowers! So, buckle up, buttercups! 🚀

What Makes Our Dragon, Python, So Special? 🤔

Python isn't just any old programming language; it's got some unique traits that make it stand out. Let's unwrap them like presents! 🎁

1. General-Purpose Language: The All-Rounder Dragon! 🦸‍♂️

Imagine you have a magical tool that can fix a broken toy, draw a beautiful picture, and bake yummy cookies! 🛠️🎨🍪 That's what "General-Purpose Language" means for Python!

What does it mean? 🧐 It means Python isn't built for just ONE specific job. You can use it to build almost anything you can imagine!

Why is this cool? 😎 Because you don't need to learn a different language for every single project. Python is like your multi-tool for the digital world!

Where do we see it? 🌍

  • Making websites: Like Instagram or Spotify! 🌐

  • Building games: Think about those fun games on your phone! 🎮

  • Analyzing data: Helping scientists understand big numbers! 📊

  • Creating AI (Artificial Intelligence): Teaching computers to think! 🤖

Analogy: 🧒 Think of Python as a master chef 🧑‍🍳. This chef isn't just good at baking cakes 🎂; they can make pizzas 🍕, stir-fries 🍜, and even ice cream 🍦! They have all the tools and recipes to cook up anything!

2. Interpreted: Your Dragon Understands You Right Away! 🗣️

Imagine you're telling your pet dragon to fetch a stick. If it understands you instantly and brings the stick, that's like an "interpreted" language! If it needs to send your message to a magical translator first, that's different.

What does it mean? 🧐 When you write Python code, there's a special program called an interpreter that reads your code line by line and executes it immediately. It doesn't need to turn your whole story into a secret code (compile) first.

Why is this cool? 😎

  • Faster feedback! If you make a mistake, the interpreter tells you right away. It's like having a super-fast proofreader! ⚡

  • Easy to test! You can try out small pieces of code without building the whole thing.

How does it work? 🤔 You type your instructions, and the Python interpreter reads them and makes the computer do what you said, right then and there!

Analogy: 🧒 Imagine you're building with LEGOs. 🧱

  • A compiled language is like writing down all the instructions for building a giant LEGO castle 🏰, then giving the whole instruction book to someone to build it later.

  • An interpreted language (like Python!) is like you telling your friend, "Okay, put this red brick here! Now put this blue brick on top!" And your friend does it immediately. If you say "Put a green brick," and there are no green bricks, your friend says "Oops!" right away.

3. Object-Oriented: Every Toy is Special! 🧸

Imagine your toy box. You have cars, dolls, building blocks – each one is a "thing" or an "object" with its own special features (color, size) and things it can do (roll, talk, stack).

What does it mean? 🧐 "Object-Oriented" is a fancy way of saying Python loves to organize things into "objects." These objects are like little bundles of data (facts) and functions (actions they can do).

Why is this cool? 😎

  • Organized code: It makes your code neat and tidy, like putting all your toys back in their right boxes. 📦

  • Reusable parts: You can create one "car" object and then make many copies of it without starting from scratch. 🚗🚗🚗

  • Easy to understand: It mirrors how we think about the real world.

Example: 📝 If you have an object called Dog, it might have:

  • Data: name (like "Buddy"), breed (like "Golden Retriever"), color (like "golden")

  • Actions: bark(), run(), wag_tail()

Analogy: 🧒 Think of a bakery 🍞. Each type of bread, like a croissant 🥐 or a baguette 🥖, is an "object."

  • A croissant "object" has properties like "flaky," "buttery," "crescent shape."

  • It has actions like "can be eaten," "can be heated." You can make many croissants, but they all share the same blueprint!

4. High-Level: Speaking Your Language! 🗣️

Imagine you want to tell a friend to pick up a ball. You say, "Please pick up the ball!" That's high-level. You don't say, "Contract your bicep, extend your forearm, grasp the spherical object..." That would be low-level!

What does it mean? 🧐 "High-level" means Python is very close to human language and far away from the computer's secret language (which is just 0s and 1s!).

Why is this cool? 😎

  • Easy to read and write: It's almost like writing English sentences, making it much simpler to learn and use.

  • Focus on what to do: You don't have to worry about tiny, complicated details of how the computer actually works. Python handles those for you!

Analogy: 🧒 Imagine you're ordering food at a restaurant 🍽️.

  • A high-level language is like saying to the waiter, "I'd like a cheeseburger, please!" 🍔 The waiter (Python) understands and handles all the complex steps in the kitchen to make it.

  • A low-level language would be like you going into the kitchen yourself and telling the chef exactly how many grams of meat to use, how hot the grill should be, and precisely how to flip the patty! 🤯 Much harder, right?

You can also do Procedural! (The Recipe Book Approach) 📖

Even though Python loves objects, it's also flexible! You can write code in a "procedural" way.

What does it mean? 🧐 "Procedural" means you write your code like a step-by-step recipe. Do this, then do that, then do the next thing, in order.

Why is this cool? 😎 It's a straightforward way to write programs, especially for simpler tasks. Many beginners start this way!

Analogy: 🧒 It's like following a recipe book 🧑‍🍳.

  1. First, mix flour and eggs.

  2. Next, add sugar.

  3. Then, bake in the oven. Each step is a clear instruction!

Python: An Old Soul with New Tricks! 🕰️ (A Little History Lesson)

Many people think Python is a brand-new language because it's so popular now, especially with cool things like AI. But guess what? Python is actually older than you might think! 👴

  • Python's Birth Year: Python was created by a brilliant person named Guido van Rossum and first released in 1991! 🎂 That's over 30 years ago!

  • Java's Birth Year: Java, another famous language, came out a bit later, in 1995.

So, why do people think Java came first? 🤔 Well, Java became super popular very quickly in the late 90s for building things on the internet, like websites and apps. Python was around, but it took a bit longer to gain massive popularity.

Why Python is the Superstar Today! ✨ (ML, AI, DS & More!)

In recent years, Python has become the cool kid on the block, growing faster than a Bamboo! 🌱 Why? Because of exciting new fields like:

  • Machine Learning (ML): Teaching computers to learn from data without being explicitly programmed. Imagine teaching your computer to recognize cat pictures! 🐱

  • Artificial Intelligence (AI): Making computers think and act like humans. Think of smart assistants like Siri or Google Assistant! 🤖

  • Data Science (DS): Finding cool patterns and insights from huge amounts of information. Like being a detective with numbers! 🕵️‍♀️

  • Cybersecurity (CS): Protecting computers and networks from digital attacks and threats. Imagine being a superhero safeguarding a city from digital villains! 🦸‍♀️🔒

Python has awesome tools (called "libraries") that make working with ML, AI, DS and CS super easy. It's like having special magic wands 🪄 for these complex tasks!

Who Uses Our Dragon, Python? 🏢 (Big Companies & Cool Stuff!)

You'd be surprised by how many famous companies use Python every single day to power their amazing services!

  • Google: Yep, the giant search engine uses Python for many of its services! 🔍

  • Netflix: How do they recommend movies you'll love? Python helps! 🍿

  • Spotify: Python helps power their music recommendations! 🎶

  • Instagram: A huge part of the popular photo-sharing app is built with Python! 📸

  • Uber: Python helps power their ride-sharing platform! 🚗

  • Dropbox: The file-sharing service uses Python extensively! ☁️

  • Reddit: Ah, yes, Reddit! The huge online community where people discuss everything under the sun, uses Python! 👽 It's a prime example of Python handling massive amounts of user traffic and data.

And many, many more! Python is everywhere, often working behind the scenes like a diligent worker bee 🐝!

The Story Behind the Name! 🎬 (Monty Python!)

You might be wondering, why is it called "Python"? Is it because of the snake? 🐍 Nope!

The creator, Guido van Rossum, was a big fan of a famous British comedy group from the 1970s called "Monty Python's Flying Circus." 🤡😂 He wanted a name that was unique, slightly quirky, and short. And so, our friendly programming dragon was named after a hilarious comedy show!

The Tale of Two Pythons: 2.x vs. 3.x ✌️🥉

Sometimes, in the world of technology, things get updated and improved! Python went through a big change, leading to two main versions: Python 2.x and Python 3.x.

Why two versions? 🤔 Python 2.x was the older version, and over time, the creators saw ways to make Python even better! They decided to make some big changes that weren't "backward compatible" (meaning code written for Python 2 might not work directly on Python 3). They wanted to clean up some old ways of doing things and make the language more consistent and powerful for the future.

Which one should you use? 💡 Always use Python 3.x! 🚀 Python 2.x is like an old car that's no longer being made or supported. Python 3.x is the shiny, new, and actively maintained version. Most modern libraries and tools only work with Python 3.x.

Think of it like this: Imagine your favorite video game getting a huge update. 🎮 The old version (Python 2) is still there, but the new, improved version (Python 3) has better graphics, more levels, and fewer bugs! You'd definitely want to play the new one, right?

Getting Python Ready! 🚀 (Installation & First Steps)

Before we can tell our dragon what to do, we need to invite it to our computer! 💻

1. Python Interpreter: Your Dragon's Brain! 🧠

When you install Python, you're essentially installing the Python interpreter. Remember, this is the special program that reads your Python code and makes the computer understand it.

How to check if it's there? Open your computer's Terminal (on Mac/Linux) or Command Prompt (on Windows). It's like a secret command window!

Type this and press Enter:

python --version

or, more commonly for Python 3:

python3 --version

What you'll see: You'll see something like Python 3.10.12 or similar. This tells you which version of Python 3 is installed! If you see a Python 2 version, don't worry, you can still install Python 3 alongside it.

2. Where to Write Your Python Spells? (IDEs!) ✍️

You can write Python code in a simple text editor, but it's much easier and more fun to use a special tool called an IDE (Integrated Development Environment). Think of it as a super-powered notepad specifically designed for coding! 📝✨

  • PyCharm (Recommended for serious coding!): 🌟

    • Why it's awesome: PyCharm is like a super smart assistant that helps you write code faster, find mistakes, and organize your projects. It's especially good for bigger projects. It has features like "autocompletion" (finishes your words for you!) and "debugging" (helps find sneaky bugs!).

    • Analogy: It's like having a magic quill 🖊️ that corrects your spelling, suggests words, and points out errors in your story as you write!

  • Other great options:

    • VS Code (Visual Studio Code): Very popular, lightweight, and can be used for many languages, including Python! Think of it as a versatile Swiss Army knife 🔪.

    • Anaconda: This is actually a distribution that includes Python and many scientific computing tools, along with an IDE called Spyder. It's great if you're getting into Data Science. It's like a whole toolkit 🧰!

    • Jupyter Notebooks: Perfect for exploring data and sharing your code with others in a beautiful, interactive way. Imagine an interactive science notebook 🧪!

Tip: For beginners, starting with a simpler text editor or an online Python interpreter can be good too, but as you grow, an IDE like PyCharm will be your best friend!

Your Dragon's First Words: Basic Math & Printing! 🗣️🔢

Let's make our Python dragon do some basic tricks! We'll start with numbers and making it say things.

Open your Python interpreter (by typing python or python3 in your terminal) or your IDE.

1. Dragon Math! ➕➖✖️➗

Our Python dragon is a math whiz!

  • Addition (Adding):

      print(5 + 3) # The dragon says 8!

  • Multiplication (Multiplying):

      print(4 * 2) # The dragon says 8!

  • Power (To the power of): (The ** means "to the power of")

      print(2 ** 3) # The dragon says 8! (2 * 2 * 2)

  • Modulo (Remainder): (The % gives you the leftover after division)

      print(10 % 3) # The dragon says 1! (10 divided by 3 is 3 with 1 leftover)

    Division (Dividing normally):

      print(10 / 3) # The dragon says 3.3333333333333335 (a number with a decimal)

  • Floor Division (Dividing and only keeping the whole number):

      print(10 // 3) # The dragon says 3! (It ignores the decimal part)

2. Playing with print(): Making Your Dragon Talk! 💬

The print() function is how you make your Python dragon say things!

  • Printing simple text:

      print("Hello, little coder!")

  • Print with quotes: Python needs to know what's text and what's code. You put text inside quotes! "" or ''.

      print('Python is fun!')
  print("Coding is cool!")

    Why quotes? Imagine you tell your dragon, "Say banana." The dragon knows banana is a word. But if you tell it print banana, it might think banana is a secret command it doesn't know! Quotes tell it, "This is just text, dragon, just say it!"

  • Quotes inside quotes (tricky!): What if you want to print: He said, "Wow!" You can use different types of quotes!

      print('He said, "Wow!"') # Single quotes outside, double inside
  print("She replied, 'Amazing!'") # Double quotes outside, single inside

    What if you want to use the same quote type inside? You use a special character called a backslash (\) to "escape" it.

      print("It's a beautiful day!") # 's is fine
  print('He said, "It\'s raining!"') # See the \'

    The \ tells Python, "Hey, this is just a quote character that's part of the text, not the end of my text!"

  • \n examples (New Line): The \n is like pressing the Enter key on your keyboard! It creates a new line.

      print("Hello\nWorld")
  # Output:
  # Hello
  # World

  • Repeating text: You can multiply text!

      print(10 * "RAPO ") # The dragon says "RAPO RAPO RAPO RAPO RAPO RAPO RAPO RAPO RAPO RAPO "

  • Raw strings (Ignore special characters): Sometimes, you don't want \ to mean anything special, like when you're dealing with file paths. You can make a "raw string" by putting an r before the first quote.

      print("C:\new\text.txt") # \n and \t might try to do special things here
  print(r"C:\new\text.txt") # The dragon just prints it exactly as it is!

    Analogy: It's like telling your dragon, "Just say exactly what I write, don't try to find any secret meanings!" 🤐

Variables: Giving Names to Your Dragon's Treasures! 💰

Imagine you have a treasure chest 💰 and you want to give it a name like "GoldCoins." That way, whenever you say "GoldCoins," everyone knows you're talking about the gold in that specific chest!

In programming, we use variables to store information and give it a name.

my_age = 10
my_name = "Leo"
is_sunny = True # This stores True or False

Here:

  • my_age is a variable storing the number 10.

  • my_name is a variable storing the text "Leo".

  • is_sunny is a variable storing a "boolean" value True.

Statically Typed vs. Dynamically Typed: Dragon's Flexibility! 🤸‍♀️

This is a slightly technical but important concept!

  • Statically Typed Languages (Like Java): Imagine you have a special box, and before you put anything in it, you must label it "Numbers Only!" 🔢 If you try to put a toy car 🚗 in it, the box screams, "Error! I only accept numbers!" In these languages, you tell the computer in advance what kind of data (number, text, etc.) a variable will hold.

  • Dynamically Typed Languages (Like Python!): Imagine you have a flexible box. You can put numbers in it, then take them out and put toys in, then take those out and put books in! 📚 The box doesn't care; it just holds whatever you give it. In Python, you don't have to declare the type of data a variable will hold beforehand. Python figures it out as you go!

Why is Python's dynamic typing cool? 😎

  • Faster to write code: Less to type, less to worry about in advance.

  • More flexible: Variables can change what kind of data they hold during the program's run (though it's often good practice to keep them consistent for readability).

Analogy: 🧒

  • Statically Typed: Imagine a specific toy box labeled "Toy Cars ONLY!" 🚗 You can only put toy cars in it.

  • Dynamically Typed (Python): Imagine a magical toy box 🪄 that can hold toy cars one minute, then dolls 👧, then LEGOs 🧱 the next! It adapts to whatever you put inside.

Data Types: The Different Kinds of Treasures! 💎

Python loves to categorize information. These categories are called data types.

  • Numbers:

    • int (integers): Whole numbers like 5, 100, -3. (No decimals)

    • float (floating-point numbers): Numbers with decimals like 3.14, 0.5, -2.7.

  • Text:

    • str (strings): Any text, like "Hello", "Python", "123". Always inside quotes!

  • True/False:

    • bool (booleans): Only two possible values: True or False. Used for yes/no questions.

  • Collections (More on these below!):

    • list: An ordered collection, like a shopping list. Can be changed.

    • tuple: An ordered collection, like a list, but cannot be changed once created.

    • set: An unordered collection of unique items.

    • dict (dictionary): A collection of "key-value" pairs, like a real dictionary where words (keys) have definitions (values).

Python's Treasure Chests: Collections of Data! 📦

Imagine you have many treasures, and you want to keep them organized. Python gives you different types of treasure chests for this!

1. Lists: Your Flexible Shopping Cart! 🛒

  • What is it? An ordered collection of items. You can add, remove, or change items(Mutable - explained below).

  • Think of it like your grocery shopping list – you can add new items, cross out things you've bought, or change your mind!

  • Syntax: [item1, item2, item3]

  • Example:

      my_groceries = ["Milk", "Eggs", "Bread"]
  print(my_groceries) # Output: ['Milk', 'Eggs', 'Bread']

  my_groceries.append("Cheese") # Add something!
  print(my_groceries) # Output: ['Milk', 'Eggs', 'Bread', 'Cheese']

  my_groceries[0] = "Almond Milk" # Change the first item!
  print(my_groceries) # Output: ['Almond Milk', 'Eggs', 'Bread', 'Cheese']

2. Tuples: Your Unchangeable Lunchbox! 🥪

  • What is it? An ordered collection of items, just like a list, BUT once you put items in a tuple, you cannot change them, add new ones, or remove old ones! It's "immutable."

  • Think of it like a packed lunchbox – once your mom packs it, you can't change what's inside until you eat it!

  • Syntax: (item1, item2, item3)

  • Example:

      my_coordinates = (10, 20) # Represents an X, Y point
  print(my_coordinates) # Output: (10, 20)

  # my_coordinates[0] = 5 # This would cause an ERROR! You can't change it!

  • When to use? When you have data that should never change, like coordinates, colors (RGB values), or fixed settings.

3. Sets: Your Bag of Unique Toys! 🎲

  • What is it? An unordered collection of unique items. This means no duplicates! If you put two of the same toy in the bag, the set only counts it once. Also, there's no fixed order.

  • Syntax: {item1, item2, item3}

  • Example:

      my_favorite_colors = {"red", "blue", "green", "red"} # "red" is duplicated
  print(my_favorite_colors) # Output: {'green', 'red', 'blue'} (Order might be different, and only one 'red')

  my_favorite_colors.add("yellow") # Add a new color
  print(my_favorite_colors) # Output: {'yellow', 'green', 'red', 'blue'}

  • When to use? When you need to quickly check if something exists, or when you want to remove duplicate items from a list.

4. Dictionaries: Your Magical Word Finder! 📖

  • What is it? A collection of "key-value" pairs. Think of a real dictionary: a "word" (the key) has a "definition" (the value). You look up the word to find its definition. Each key must be unique!

  • Syntax: {key1: value1, key2: value2}

  • Example:

      my_dog = {"name": "Buddy", "breed": "Golden Retriever", "age": 5}
  print(my_dog["name"]) # Output: Buddy (We looked up the "name" key)

  my_dog["age"] = 6 # We can change the dog's age!
  print(my_dog) # Output: {'name': 'Buddy', 'breed': 'Golden Retriever', 'age': 6}

  my_dog["favorite_toy"] = "ball" # Add a new key-value pair!
  print(my_dog)

  • When to use? When you need to store related pieces of information together and access them by a meaningful name (the "key").

Slicing Operator: Cutting Out Pieces of Treasure! ✂️

Imagine you have a long candy bar 🍫 and you only want to eat a piece from the middle. Slicing helps you do that!

The slicing operator ([] with colons) lets you get a portion (a "slice") of a sequence like a string, list, or tuple.

Here positions is called indices. Indexing starts from 0. (0, 1, 2, 3, 4, ………..)

Syntax: [start:end:step]

  • start: Where to begin (inclusive). If you don't put a number, it starts from the beginning.

  • end: Where to stop (exclusive – it stops before this number). If you don't put a number, it goes to the end.

  • step: How many steps to take (e.g., every 2nd item). Default is 1.

Example with a string (text):

my_word = "PYTHON"
print(my_word[0])    # Output: P (The first letter, computers start counting from 0!)
print(my_word[1:4])  # Output: YTH (Starts at position 1, goes UP TO but NOT including position 4)
print(my_word[:3])   # Output: PYT (From the beginning up to position 3)
print(my_word[2:])   # Output: THON (From position 2 to the end)
print(my_word[::2])  # Output: PTO (Every second letter)
print(my_word[::-1]) # Output: NOHTYP (A cool trick to reverse!)

Example with a list:

my_numbers = [10, 20, 30, 40, 50, 60]
print(my_numbers[1:5]) # Output: [20, 30, 40, 50]

Analogy for : 🧒 Imagine you have a train 🚂 with cars numbered 0, 1, 2, 3...

  • train[0] is the engine (the first car).

  • train[1:4] means "give me the cars starting from car #1 up to, but not including, car #4."

Accessing Elements: Grabbing a Single Treasure! 🖐️

Just like slicing gets a piece, accessing elements gets a single item from a collection using its "index" (its position). Remember, Python (and most programming languages) start counting from 0!

  • Lists:

      fruits = ["apple", "banana", "cherry"]
  print(fruits[0]) # Output: apple
  print(fruits[2]) # Output: cherry

  • Tuples:

      colors = ("red", "green", "blue")
  print(colors[1]) # Output: green

  • Strings: (Strings are like lists of characters!)

      word = "hello"
  print(word[0]) # Output: h
  print(word[4]) # Output: o

  • Dictionaries: You access by the key, not a number!

      person = {"name": "Alice", "age": 30}
  print(person["name"]) # Output: Alice

Mutability vs. Immutability: Can Your Treasure Chest Change? 🔄

This is a super important concept in Python!

  • Mutable (Can Change): Think of a clay pot 🏺. You can reshape it, add more clay, or take some away.

    • In Python: Lists, Dictionaries, and Sets are mutable. You can change their contents after they've been created.

    • Why it matters: If you give a mutable object to another part of your program, and that part changes it, the original object changes too!

  • Immutable (Cannot Change): Think of a rock 🗿. Once it's formed, you can't easily change its shape.

    • In Python: Numbers, Strings, and Tuples are immutable. Once you create them, you can't change their contents. If you try to "change" an immutable object, Python actually creates a new one.

    • Why it matters: If you give an immutable object to another part of your program, and that part tries to "change" it, it's actually just getting a copy of the original. The original remains untouched.

More About Python's Collections: Deep Dive! 🏊‍♀️

Let's look at some cool things you can do with our treasure chests!

List Operations and Methods 🛠️

Lists are super versatile!

  • len(): Get the number of items in a list.

      my_list = ["a", "b", "c"]
  print(len(my_list)) # Output: 3

  • append(): Add an item to the end.

      my_list.append("d")
  print(my_list) # Output: ['a', 'b', 'c', 'd']

  • insert(): Add an item at a specific position.

      my_list.insert(1, "x") # Insert "x" at index 1
  print(my_list) # Output: ['a', 'x', 'b', 'c', 'd']

  • remove(): Remove the first matching item.

      my_list.remove("x")
  print(my_list) # Output: ['a', 'b', 'c', 'd']

  • pop(): Remove and return an item (by index, or last item if no index).

      last_item = my_list.pop() # Removes 'd'
  print(my_list) # Output: ['a', 'b', 'c']
  print(last_item) # Output: d

  • sort(): Sort the list in place.

      numbers = [5, 2, 8, 1]
  numbers.sort()
  print(numbers) # Output: [1, 2, 5, 8]

  • reverse(): Reverse the order of items.

      numbers.reverse()
  print(numbers) # Output: [8, 5, 2, 1]

  • count(): Count how many times an item appears.

      my_list = [1, 2, 2, 3, 2]
  print(my_list.count(2)) # Output: 3

More About Variables: Dragon's Memory Lane! 🧠

id(): Your Dragon's Secret Address Book! 🏠

Every piece of data in your computer's memory has a unique address, like a house number! The id() function tells you this unique address.

x = 10
y = 10
print(id(x))
print(id(y))

What you'll see: You'll notice that id(x) and id(y) might print the same number! Why? For small, commonly used immutable objects (like small integers and short strings), Python is super smart! If you create two variables that hold the exact same value, Python often saves memory by making both variables point to the same value in memory. It's like having two labels pointing to the exact same treasure chest. 🏷️➡️💰

a = [1, 2, 3]
b = [1, 2, 3]
print(id(a))
print(id(b))

What you'll see here: id(a) and id(b) will print different numbers. Why? Because lists are mutable! Even if they have the same content, Python creates two separate list objects in memory. It's like having two identical looking boxes, but they are still two separate boxes.

Garbage Collector: The Clean-Up Crew! 🧹

Imagine your computer's memory as a giant playroom. When you create variables and data, you're putting toys in the playroom. If you stop using a toy (a variable), it just sits there taking up space.

The garbage collector is like a friendly clean-up crew that automatically finds and removes toys (data) that are no longer being used by your program. This helps keep your computer's memory tidy and efficient! 🗑️✨

Why is it important? You don't have to manually worry about cleaning up memory, which makes writing Python code much easier!

type(): What Kind of Treasure Is It? 🤔

The type() function tells you what kind of data type a variable holds.

my_number = 10
my_text = "hello"
my_list = [1, 2, 3]

print(type(my_number)) # Output: <class 'int'>
print(type(my_text))   # Output: <class 'str'>
print(type(my_list))   # Output: <class 'list'>

Naming Conventions: How to Name Your Treasures! 🏷️

Just like humans have rules for naming things (like "first name, last name"), programmers have ways to name variables, functions, and other parts of their code to make it easy to read and understand.

Why are naming conventions important? 🤔

  • Readability: Other people (and your future self!) can easily understand what your code does.

  • Consistency: Makes your code look neat and professional.

  • Collaboration: When many people work on a project, consistent naming helps everyone.

Common Python Naming Cases:

  • snake_case (for variables and functions): All lowercase, words separated by underscores. This is the most common style in Python!

    • Example: my_variable, calculate_total_price

    • Analogy: Like a snake slithering through words! 🐍

  • CONSTANT_CASE (for constants): All uppercase, words separated by underscores. Used for values that shouldn't change.

    • Example: MAX_HEALTH, PI_VALUE

    • Analogy: Like shouting important words! 📣

  • PascalCase or CamelCase (for classes): Words start with an uppercase letter, no spaces. Python typically uses PascalCase for class names.

    • Example: MyClass, CustomerService (PascalCase)

    • Analogy: Like humps on a camel or the peak of a mountain! 🐫

Tips for Naming:

  • Be descriptive: age is better than a. total_score is better than ts.

  • Avoid single letters (mostly): Unless it's a loop variable like i or j.

  • Don't use Python keywords: Words Python already uses (like print, if, else).

Operators in Python: Dragon's Action Words! ⚔️

Operators are special symbols or keywords that tell Python to perform an operation. Think of them as action verbs for our dragon!

1. Arithmetic Operators: Dragon's Calculator! ➕➖✖️➗

We already saw these!

  • + (Addition)

  • - (Subtraction)

  • * (Multiplication)

  • / (Division)

  • % (Modulo - remainder)

  • ** (Exponentiation - power)

  • // (Floor Division - whole number division)

2. Unary Operators: Changing a Number's Mood! 😠

  • - (Negation): Makes a number negative.

      x = 10
  print(-x) # Output: -10

  • + (Unary Plus): Doesn't do much, just shows a positive number.

    Python

      x = -5
  print(+x) # Output: -5 (Still -5)

3. Relational (Comparison) Operators: Asking "Is it True?" 🤔

These operators compare two values and always give back True or False.

  • == (Equal to): Is it exactly the same?

      print(5 == 5)   # Output: True
  print(5 == 10)  # Output: False

  • != (Not equal to): Is it different?

    Python

      print(5 != 10)  # Output: True
  print(5 != 5)   # Output: False

  • > (Greater than)

  • < (Less than)

  • >= (Greater than or equal to)

  • <= (Less than or equal to)

Example:

age = 12
print(age >= 18) # Output: False (Is 12 greater than or equal to 18? No!)

Analogy: It's like asking your dragon, "Is this apple 🍎 bigger than that orange 🍊?" The dragon will say "Yes!" or "No!"

4. Logical Operators: Combining "True" and "False" Ideas! 🧩

These combine True and False conditions.

  • and: Both conditions must be True. (Like "I need a pen and a paper.")

      print(True and True)   # Output: True
  print(True and False)  # Output: False

  • or: At least one condition must be True. (Like "I want an apple or a banana.")

      print(True or False)   # Output: True
  print(False or False)  # Output: False

  • not: Reverses the condition. (Like "It's not raining.")

      print(not True)   # Output: False
  print(not False)  # Output: True

Analogy: Imagine you want to watch a movie. 🍿

  • and: "I can watch if I finish my homework AND my chores." (Both must be done)

  • or: "I can watch if I finish my homework OR I finish my chores." (Just one needs to be done)

  • not: "I will NOT watch if it's too late." (The opposite of too late)

5. Bitwise Operators: Dragon's Secret Binary Code! 🤫

These work on the individual "bits" (0s and 1s) that make up numbers inside the computer. This is a bit more advanced(used mostly to optimise you good, explore them when you start DSA), but good to know they exist!

  • & (Bitwise AND)

  • | (Bitwise OR)

  • ^ (Bitwise XOR)

  • ~ (Bitwise NOT)

  • << (Left Shift)

  • >> (Right Shift)

Number System Conversion: Dragon's Language Translator! 🔢➡️🔠

Computers speak in 0s and 1s (binary). We usually use base-10 numbers (decimal). Python can help convert between different number systems!

  • bin(): Decimal to Binary (Base 2)

      print(bin(10)) # Output: 0b1010 (0b means binary)

  • oct(): Decimal to Octal (Base 8)

      print(oct(10)) # Output: 0o12 (0o means octal)

  • hex(): Decimal to Hexadecimal (Base 16)

      print(hex(255)) # Output: 0xff (0x means hexadecimal)

  • int(): Convert from other bases back to Decimal

      print(int('1010', 2)) # Output: 10 (binary '1010' is 10 in decimal)
  print(int('ff', 16)) # Output: 255 (hex 'ff' is 255 in decimal)

Math Functions: Dragon's Magic Math Wand! 🪄

Python has a built-in math module (a collection of useful functions) that gives you more advanced math powers! You need to import it first, like bringing a new magic wand into your coding room.

import math # Ta-da! Now we have math powers!

  • math.sqrt() (Square Root):

      print(math.sqrt(25)) # Output: 5.0

  • math.pow() (Power - similar to ** but often for float results):

      print(math.pow(2, 3)) # Output: 8.0 (2 to the power of 3)

  • math.floor() (Round Down): Always rounds a number down to the nearest whole number.

      print(math.floor(3.9)) # Output: 3
  print(math.floor(3.1)) # Output: 3

  • math.ceil() (Round Up): Always rounds a number up to the nearest whole number.

      print(math.ceil(3.1)) # Output: 4
  print(math.ceil(3.9)) # Output: 4

  • math.pi (Pi Value):

      print(math.pi) # Output: 3.141592653589793

  • Other useful methods/functions in math:

    • math.sin(), math.cos(), math.tan() (for trigonometry)

    • math.log() (for logarithms)

    • math.fabs() (absolute value)

User Input: Talking to Your Dragon! 🗣️💬

How do we make our program ask us for information? With the input() function!

1. Taking different data types as input:

The input() function always reads whatever you type as a string (text). If you want numbers, you have to tell Python to convert it!

name = input("What's your name? ")
print("Hello, " + name + "!")

age_str = input("How old are you? ")
age_int = int(age_str) # Convert the text age to a whole number!
print("You are", age_int, "years old.")

height_str = input("What's your height in meters? ")
height_float = float(height_str) # Convert to a number with decimals!
print("You are", height_float, "meters tall.")

2. eval(): The Smarty-Pants Function! 🤓 (Use with caution!)

The eval() function is like a super smart assistant that can take a string of text and try to run it as if it were Python code.

expression = input("Enter a math problem (like 2+3*4): ")
result = eval(expression)
print("The answer is:", result) # If you type "2+3*4", it outputs 14

Why use with caution? 🚨 If someone types in something malicious, eval() could potentially run dangerous code. It's like giving your dragon the power to read your mind and do anything you think of, even if it's bad! Only use eval() when you trust the source of the input.

3. [0] to accept only character (for string input)

You can directly access the first character of a string input using [0].

first_letter = input("Type your favorite letter: ")[0]
print("Your favorite letter is:", first_letter)

Analogy: It's like asking your dragon, "What's the very first sound you make when you roar?" 🦁

4. Accepting value while you execute the program (sys.argv)

Sometimes, you want to give information to your Python program before it even starts running, right when you type the command in the terminal! This is done using sys.argv.

First, you need to import sys (like bringing in a special "system" tool).

Example my_program.py file:

import sys

print("Hello from my program!")

if len(sys.argv) > 1:
    print("You gave me these extra words:")
    for arg in sys.argv[1:]: # The first item sys.argv[0] is the program name itself
        print(arg)
else:
    print("You didn't give me any extra words.")

How to run it from your terminal:

python my_program.py apple banana cherry

What you'll see:

Hello from my program!
You gave me these extra words:
apple
banana
cherry

Conditionals and Loops: Dragon's Decision-Making & Repetitions! 🧠🔁

This is where coding gets really powerful! We can make our dragon make choices and repeat actions.

1. if, else, elif (If, Else If, Else Ladder): Dragon's Choices! 🤔

This is how your dragon makes decisions.

  • if: "IF something is true, THEN do this."

      weather = "sunny"
  if weather == "sunny":
      print("Let's go to the park! ☀️")

  • else: "IF the first thing isn't true, THEN do this instead."

      age = 10
  if age >= 18:
      print("You can vote!")
  else:
      print("You are too young to vote.")

  • elif (Else If Ladder): "IF the first thing isn't true, CHECK this other thing. IF that's true, THEN do this..." (You can have many elifs)

      score = 85
  if score >= 90:
      print("You got an A! 🎉")
  elif score >= 80: # If not 90+, is it 80+?
      print("You got a B! 👍")
  elif score >= 70: # If not 80+, is it 70+?
      print("You got a C! 😊")
  else: # If none of the above are true
      print("You need to study more! 📚")

2. while loop: Keep Doing it Until! ⏳

A while loop tells your dragon to keep doing something as long as a condition is true.

count = 0
while count < 5:
    print("Count is:", count)
    count = count + 1 # Important! Otherwise, it will never stop!
print("Done counting!")

What happens: Count is: 0 Count is: 1 Count is: 2 Count is: 3 Count is: 4 Done counting!

Caution: If the condition never becomes false, the loop will run forever! This is called an "infinite loop" and can crash your program! 🚨

Analogy: "Keep watering the plant 🌱 WHILE it's still thirsty!"

3. do-while loop (or its simulation in Python): Do it At Least Once! ✅

Some languages have a do-while loop, which guarantees that the code inside the loop runs at least once, then checks the condition. Python doesn't have a direct do-while loop, but you can simulate it:

# Simulating a do-while loop in Python
while True:
    secret_number = 7
    guess = int(input("Guess the secret number (1-10): "))
    if guess == secret_number:
        print("You got it! 🎉")
        break # Exit the loop!
    else:
        print("Nope, try again!")

In this example, the guessing game runs at least once, and then keeps running while True (which is always true) but has a break to exit when the condition is met.

Analogy: "Go outside 🚶‍♀️, THEN check if it's raining. If it's not raining, keep walking!"

4. for loop: For Each Thing in a Collection! 🧺

A for loop is great for going through each item in a list, string, or range of numbers.

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

What happens: I love apple I love banana I love cherry

for number in range(3): # Remember range(3) gives 0, 1, 2
    print(number)

What happens: 0 1 2

Analogy: "For EACH cookie 🍪 in the jar, take a bite!"

The range() Function: Counting Dragon Steps! 👣

The range() function is super useful when you want to repeat something a certain number of times or generate a sequence of numbers.

What it does: It creates a sequence of numbers, but it doesn't store them all in memory at once (it generates them as needed, which is efficient!).

Syntax:

  • range(stop): Numbers from 0 up to (but not including) stop.

  • range(start, stop): Numbers from start up to (but not including) stop.

  • range(start, stop, step): Numbers from start up to (but not including) stop, stepping by step.

Examples:

# From 0 to 4 (5 numbers total)
for i in range(5):
    print(i)
# Output: 0, 1, 2, 3, 4

# From 2 to 6
for i in range(2, 7): # Goes up to 6, not 7
    print(i)
# Output: 2, 3, 4, 5, 6

# From 0 to 10, skipping by 2
for i in range(0, 11, 2):
    print(i)
# Output: 0, 2, 4, 6, 8, 10

Analogy: It's like telling your dragon to take a certain number of steps, or to start at a specific step and jump a few steps at a time! 🚶‍♀️🚶‍♂️

5. for-each loop: Python's for loop is a for-each loop!

In some languages, "for-each" is a special type of loop. In Python, the for loop already works like a "for-each" loop when you iterate over collections (like lists, strings, etc.), making it super intuitive!

So, the for fruit in fruits: example above is already Python's version of a "for-each" loop!

6. break, continue, pass: Dragon's Loop Controls! 🚦

These are special words that help you control how loops run.

  • break: "STOP the loop right now!" 🛑

      for i in range(10):
      if i == 5:
          break # Stop when i is 5!
      print(i)
  # Output: 0, 1, 2, 3, 4

    Analogy: Imagine running a race, and someone shouts "BREAK!" You stop running immediately.

  • continue: "Skip the rest of this turn, and go to the next turn in the loop!" ⏩

      for i in range(5):
      if i == 2:
          continue # Skip printing 2!
      print(i)
  # Output: 0, 1, 3, 4

    Analogy: Imagine running a race, and someone says "CONTINUE!" for one specific obstacle. You skip that obstacle and keep running the rest of the race.

  • pass: "Do nothing! Just a placeholder." 🤷‍♀️ This is useful when Python expects a line of code, but you don't want anything to happen yet. It's like putting a "Coming Soon!" sign.

      if True:
      pass # I'll add code here later!
  print("Code will go here.")

  def my_function():
      pass # This function doesn't do anything yet

    Analogy: It's like having a blank page in your story. You know you'll write something there later, but for now, it's just a placeholder. 📝

7. for and else together: A Special Loop Ending! 🌟

This is a unique Python feature! An else block with a for loop (or while loop) runs only if the loop finishes without hitting a break statement.

for i in range(5):
    print(i)
else:
    print("Loop finished naturally!")

# Output:
# 0
# 1
# 2
# 3
# 4
# Loop finished naturally!

for i in range(5):
    print(i)
    if i == 2:
        break # Loop breaks here!
else:
    print("This will NOT print because the loop broke!")

# Output:
# 0
# 1
# 2

Analogy: Imagine you're searching for a hidden treasure. 💎

  • If you find the treasure (break), you stop searching, and the "else" message (like "Couldn't find it!") is not said.

  • If you search everywhere and don't find the treasure, then the "else" message ("Couldn't find it!") is said.

Phew! That was an epic journey into the world of Python, our friendly coding dragon! 🐉 You've learned about its amazing superpowers, how it works, and how to make it do cool tricks. Keep practicing, keep exploring, and soon you'll be building your own magical worlds with Python! ✨ happy coding! 🚀💻🥳

0
Subscribe to my newsletter

Read articles from Ravindranath Porandla directly inside your inbox. Subscribe to the newsletter, and don't miss out.

PythonbackendBackend DevelopmentWeb DevelopmentFull Stack DevelopmentDjangoFlask Framework

Written by

Ravindranath Porandla
Ravindranath Porandla