What's the output of the code snippet?

🔥 is vs == in Python

Many developers confuse these two operators. 
But they check completely different things.

📌 == (Equality Operator)

== checks whether values are equal.

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)

```text
Output:
True

👉 Values are the same  
👉 Even though they are different objects


📌 is (Identity Operator)

is checks whether two variables point to the same object in memory.

python
a = [1, 2, 3]
b = [1, 2, 3]

print(a is b)

text
Output:
False

👉 They are stored at different memory locations  
👉 So identity is different


📌 When is returns True

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

print(x is y)

text
Output:
True`


👉 Both reference the SAME object

🎯 Quick Difference

• == → Compares values 
• is → Compares memory identity 
• Use == for value comparison 
• Use is mainly for None checks

🚀 Shallow Copy vs Deep Copy in Python

When copying objects in Python, behavior changes for nested data structures.


📌 Shallow Copy

A shallow copy creates a new outer object 
but inner objects remain shared references 🔗 

import copy

original = [[1, 2], [3, 4]]
shallow = copy.copy(original)

shallow[0].append(99)

print(original)
print(shallow)

Output:
[[1, 2, 99], [3, 4]]
[[1, 2, 99], [3, 4]]

👉 Nested objects are shared.


📌 Deep Copy

A deep copy creates a completely independent copy 
including all nested objects 🧠 

import copy

original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)

deep[0].append(99)

print(original)
print(deep)

Output:
[[1, 2], [3, 4]]
[[1, 2, 99], [3, 4]]

👉 No shared references.


🎯 Quick Difference

• Shallow → Copies outer layer only 
• Deep → Copies entire structure 
• Use deep copy for nested data

🧠 LEGB Rule in Python (Scope Resolution)

When Python looks for a variable, 
it follows a fixed order called LEGB.

L → Local 
E → Enclosing 
G → Global 
B → Built-in 

Python searches in this order.


1️⃣ Local Scope (L) 📍 
Variables defined inside a function.

x = 10

def func():
    x = 5
    print(x)

func()

Output:
5
➤ Python finds x inside the function first.


2️⃣ Enclosing Scope (E) 🔄 
Variables in outer function (nested functions).

def outer():
    x = 20
    def inner():
        print(x)
    inner()

outer()

Output:
20
➤ Python finds x in the enclosing function.


3️⃣ Global Scope (G) 🌍 
Variables defined outside all functions.

x = 30

def func():
    print(x)

func()

Output:
30
➤ Python uses global x.


4️⃣ Built-in Scope (B) ⚙️ 
Predefined names like len, print, etc.

print(len([1, 2, 3]))

Output:
3

💡 Search Order

Local → Enclosing → Global → Built-in 

Python stops searching once it finds the name.

🚀 List vs Tuple in Python

Both store collections of data. 
But they differ in mutability and internal behavior.

1️⃣ List (Mutable) 📦

Can be modified after creation.

nums = [1, 2, 3]
nums.append(4)
print(nums)

Output:
[1, 2, 3, 4]
➤ How: Stored as a dynamic array 
➤ Wins: Flexible, easy to modify 
➤ Risk: Slightly higher memory usage 

2️⃣ Tuple (Immutable) 🔒

Cannot be modified after creation.

nums = (1, 2, 3)
nums.append(4)

Output:
AttributeError: 'tuple' object has no attribute 'append'
➤ How: Fixed-size structure 
➤ Wins: Faster iteration, lower memory usage 
➤ Risk: No modification allowed 

💡 Key Difference

• List → Mutable & flexible 
• Tuple → Immutable & lightweight 

Use List when data changes. 
Use Tuple when data should stay constant.

NumPy Cheatsheet (Basic to Advanced)

🐍 Let’s Fix How You’re Learning Python

If you feel slow in Python, it usually is not because Python is hard. It is because of the learning approach.

Let me be direct.

⚠️ Avoid these habits

- Jumping between many tutorials
- Copying code without thinking
- Ignoring error messages
- Watching more than building

👉 Instead, build this discipline

- Follow one main learning path
- After every concept, write your own small code
- When an error appears, read it slowly
- Build small projects every week

📌 Python becomes easier the moment you start treating it like a tool, not a subject.

Keywords in Python

🧠 Learn to Trace Code by Hand

Before running code, pause and predict the output. This builds real understanding.

Consider this:

x = 0

for i in range(3):
    x += i

print(x) 

Walk through slowly.

1. Start: x = 0

2. i = 0 → x = 0

3. i = 1 → x = 1

4. i = 2 → x = 3

Final output:

3

This habit strengthens your debugging ability more than passive reading ever will.

Try this daily with small snippets.

Python Basics Cheat Sheet (Beginner Friendly)

🐍 Python Functions (def) ⚙️

Functions help organize code into reusable blocks, making programs cleaner and more efficient. Essential for writing modular and scalable code.

👉 They are very important for avoiding repetitive code and building complex applications.

🔹 1. What is a Function?

A function is a block of code that only runs when it is called. You can pass data, known as parameters, into a function.

Example:

def greet():
    print("Hello from a function!")

🔹 2. Defining & Calling a Function

We use the def keyword to define a function, then call it by its name.

Syntax:

def function_name(parameters):
    # code to execute
function_name(arguments) # call the function

Example:

def say_hello():
    print("Hello, Python learner!")

say_hello() # calling the function

Output: Hello, Python learner!

🔹 3. Functions with Parameters & Arguments

Parameters are variables listed inside the parentheses in the function definition. Arguments are the actual values sent when calling the function.

Example:

def welcome_user(name): # 'name' is a parameter
    print(f"Welcome, {name}!")

welcome_user("Alice") # "Alice" is an argument
welcome_user("Bob")

Output:
Welcome, Alice!
Welcome, Bob!

🔹 4. Return Values

Functions can return data as a result using the return keyword.

Example:

def add_numbers(a, b):
    return a + b

result = add_numbers(5, 7)
print(result)

Output: 12

🔹 5. Common Function Uses

• Calculations: Performing mathematical operations.
• Data Processing: Transforming inputs.
• User Interaction: Handling prompts and responses.
• Code Reusability: Doing the same task many times.

🎯 Today's Goal

✔️ Understand what functions are
✔️ Define and call functions
✔️ Use parameters and arguments
✔️ Return values from functions

👉 Functions are fundamental building blocks in almost every Python project.

Learn Python

This is Scrimba's official Python course featuring their unique interactive scrim format. It offers 58 interactive video lessons where you can pause the screencast and edit the instructor's code directly in your browser with no local setup required. Its great for hands-on learners who want to code actively during the lesson rather than passively watching. No prerequisites are required.

📚 58 interactive lessons covering Python fundamentals: variables, data types, strings, lists, dictionaries, loops, functions, and file handling—all with built-in coding challenges

⏰ Duration: 5.6 hours

🏃‍♂️ Self Paced with immediate start

🏆 Certificate: Free completion certificate included

Created by 👨‍🏫: Olof Paulson & Scrimba Team

🔗 Course Link


#Python #InteractiveLearning #FreeCertificate

Join Python Learning for more