Learn Python basics and discover how it compares to C# - two powerful languages, different flavors! (Grades K-12)
Session Date: Saturday, April 18, 2026 at 11:00 AM EST
| 🧒 Grades 3-5 | 🧑 Grades 6-8 | 🎓 Grades 9-12 | |
|---|---|---|---|
| 🐍 Python Syntax | Write simple print statements and variables | Create functions and use loops | Build classes and understand object-oriented concepts |
| 🔄 Comparison | Notice differences in how code looks | Translate basic C# to Python | Understand language paradigms and trade-offs |
| 📦 Data Types | Use strings, numbers, and lists | Work with dictionaries and tuples | Implement type hints and understand duck typing |
| 🏁 By End | Write a simple Python program that prints and uses variables | Create a program with functions and loops | Build a complete class-based program with Python |
🎬 Setup: Show students the same program in C# and Python side-by-side
THE SAME "HELLO WORLD" IN TWO LANGUAGES 🌍
═══════════════════════════════════════════════════════
C# (What we've been learning):
┌─────────────────────────────────────────────────────┐
│ using System; │
│ │
│ class Program │
│ { │
│ static void Main() │
│ { │
│ Console.WriteLine("Hello, World!"); │
│ } │
│ } │
└─────────────────────────────────────────────────────┘
Lines of code: 9 📝
Python (What we're learning today):
┌─────────────────────────────────────────────────────┐
│ print("Hello, World!") │
└─────────────────────────────────────────────────────┘
Lines of code: 1 📝
🤔 Discussion: "Python is like texting, C# is like writing a formal letter!"
💬 Questions to Ask:
- What do you notice is different? 👀
- Which one looks easier to read? 📖
- Why might someone choose one over the other? 🤷
🎬 Setup: Students stand in groups, some are "C# code" and some are "Python code"
HOW WE SHOW CODE BLOCKS 📦
═══════════════════════════════════════════════════════
C# Team (Use your arms as curly braces!):
┌─────────────────────────────────────────────────────┐
│ │
│ if (happy) 👐 { ← Arms curve OUT │
│ { │
│ jump(); 🦘 Jump! │
│ spin(); 🔄 Spin! │
│ } 👐 } ← Arms curve OUT │
│ │
└─────────────────────────────────────────────────────┘
Python Team (Use steps forward for indentation!):
┌─────────────────────────────────────────────────────┐
│ │
│ if happy: 🧍 Stand at start │
│ jump() 👟 Step forward, then jump! │
│ spin() 👟 Stay stepped, then spin! │
│ 🧍 Step back = block ended │
│ │
└─────────────────────────────────────────────────────┘
💡 Key Insight:
"In Python, HOW FAR you step forward (indentation) is what shows your code blocks - no curly braces needed!"
WHY IS IT CALLED PYTHON? 🐍
═══════════════════════════════════════════════════════
❌ NOT because of the snake!
✅ Named after "Monty Python's Flying Circus"! 🎪
(A silly British comedy show from the 1970s)
The creator, Guido van Rossum, wanted:
┌─────────────────────────────────────────────────────┐
│ 🎯 A FUN name (not boring!) │
│ 📖 An EASY language to read │
│ 😊 Programming that feels PLAYFUL │
└─────────────────────────────────────────────────────┘
Python's Philosophy (The Zen of Python):
┌─────────────────────────────────────────────────────┐
│ 🌟 "Beautiful is better than ugly" │
│ 📝 "Simple is better than complex" │
│ 👀 "Readability counts" │
└─────────────────────────────────────────────────────┘
THE BIG PICTURE 🖼️
═══════════════════════════════════════════════════════
┌───────────────────────┬───────────────────────────────┐
│ C# 💜 │ Python 🐍 │
├───────────────────────┼───────────────────────────────┤
│ Created: 2000 │ Created: 1991 │
│ By: Microsoft │ By: Guido van Rossum │
│ Uses: Games, Apps, │ Uses: AI, Data Science, │
│ Web APIs │ Automation, Web │
├───────────────────────┼───────────────────────────────┤
│ Type: Compiled │ Type: Interpreted │
│ Typing: Static │ Typing: Dynamic │
│ Blocks: { curly } │ Blocks: indentation │
│ End lines: semicolon; │ End lines: nothing needed │
└───────────────────────┴───────────────────────────────┘
WHAT DOES THIS MEAN? 🤔
═══════════════════════════════════════════════════════
Compiled (C#):
┌─────────────────────────────────────────────────────┐
│ 📝 Your Code → 🔨 Compiler → 💿 Program.exe │
│ │
│ Like baking a cake 🎂 │
│ You mix ingredients, bake it ONCE, │
│ then you can eat it whenever! │
└─────────────────────────────────────────────────────┘
Interpreted (Python):
┌─────────────────────────────────────────────────────┐
│ 📝 Your Code → 🐍 Python reads line by line │
│ │
│ Like a live translator 🗣️ │
│ Translates each sentence as you speak it! │
└─────────────────────────────────────────────────────┘
Session19/
├── 📄 README.md ← 📖 You're reading this!
├── 📄 hello_python.py ← 🐍 Starter Python code
├── 📄 csharp_to_python.md ← 🔄 Quick reference guide
└── 📄 .gitignore ← 🙈 Python files to ignore
- ✅ Python 3 installed (python.org or via your package manager)
- ✅ VS Code with Python extension
- ✅ Basic understanding of programming from C# sessions
- ✅ Excitement to learn something new! 🎉
# Open your terminal and type:
python3 --version
# You should see something like:
# Python 3.11.0 ✅ INSTALLING PYTHON 🐍
═══════════════════════════════════════════════════════
Windows:
┌─────────────────────────────────────────────────────┐
│ 1. Go to python.org/downloads │
│ 2. Click the big yellow "Download Python" button │
│ 3. Run the installer │
│ ⚠️ CHECK "Add Python to PATH" at the bottom! │
│ 4. Click "Install Now" │
└─────────────────────────────────────────────────────┘
Mac:
┌─────────────────────────────────────────────────────┐
│ Option 1: Download from python.org │
│ Option 2: Use Homebrew: │
│ brew install python3 │
└─────────────────────────────────────────────────────┘
Linux:
┌─────────────────────────────────────────────────────┐
│ Usually pre-installed! If not: │
│ sudo apt install python3 │
└─────────────────────────────────────────────────────┘
IN VS CODE:
┌─────────────────────────────────────────────────────┐
│ 1. Click Extensions icon (or Ctrl+Shift+X) │
│ 2. Search "Python" │
│ 3. Install "Python" by Microsoft │
│ 4. You're ready! 🎉 │
└─────────────────────────────────────────────────────┘
# 🎉 My First Python Program!
# This is a comment - Python ignores it (just like // in C#)
print("Hello, World!")
print("I'm learning Python! 🐍")
print("This is SO much easier than C#!")python3 hello_python.py📊 C# Comparison:
C#: Python:
───────────────────────── ─────────────────────────
Console.WriteLine("Hi!"); print("Hi!")
✓ No "Console." prefix
✓ No semicolon needed
✓ Uses regular parentheses
# 📦 Variables in Python - No type declarations needed!
# In C#, you'd write: string name = "Alex";
# In Python, just:
name = "Alex"
age = 13
height = 5.2
is_student = True
print(f"Name: {name}")
print(f"Age: {age}")
print(f"Height: {height} feet")
print(f"Is a student: {is_student}") VARIABLE COMPARISON 📦
═══════════════════════════════════════════════════════
C# (Must declare types): Python (Types are automatic):
┌─────────────────────────────┐ ┌─────────────────────────────┐
│ string name = "Alex"; │ │ name = "Alex" │
│ int age = 13; │ │ age = 13 │
│ double height = 5.2; │ │ height = 5.2 │
│ bool isStudent = true; │ │ is_student = True │
└─────────────────────────────┘ └─────────────────────────────┘
↑
Notice: True with capital T!
# 🏷️ Type Hints - Tell Python what types you EXPECT
# Python won't enforce these, but they help readability!
name: str = "Alex"
age: int = 13
height: float = 5.2
is_student: bool = True
grades: list[int] = [95, 87, 92, 88]
def greet(person_name: str) -> str:
"""Return a greeting message."""
return f"Hello, {person_name}!"
# Even with wrong types, Python runs (but linters will warn you!)
age = "thirteen" # Works, but type hints say this should be int# 🎤 Getting input from the user
# In C#: Console.ReadLine()
# In Python: input()
name = input("What's your name? ")
print(f"Hello, {name}! Welcome to Python! 🐍")
# ⚠️ Input ALWAYS returns a string!
age_string = input("How old are you? ")
age = int(age_string) # Convert string to integer
print(f"Next year you'll be {age + 1}!") INPUT COMPARISON 🎤
═══════════════════════════════════════════════════════
C#:
┌─────────────────────────────────────────────────────┐
│ Console.Write("Enter name: "); │
│ string name = Console.ReadLine(); │
│ │
│ Console.Write("Enter age: "); │
│ int age = int.Parse(Console.ReadLine()); │
└─────────────────────────────────────────────────────┘
Python:
┌─────────────────────────────────────────────────────┐
│ name = input("Enter name: ") │
│ age = int(input("Enter age: ")) │
└─────────────────────────────────────────────────────┘
🎉 Python combines the prompt AND reading in one step!
# 🔀 Making Decisions in Python
age = int(input("Enter your age: "))
# Notice: No parentheses around condition, ends with colon!
if age < 13:
print("You're a kid! 🧒")
print("Enjoy your childhood!")
elif age < 20: # "elif" instead of "else if"
print("You're a teenager! 🧑")
elif age < 65:
print("You're an adult! 👨")
else:
print("You're a senior! 👴")
print("Age check complete!") IF STATEMENT COMPARISON 🔀
═══════════════════════════════════════════════════════
C#: Python:
┌─────────────────────────────┐ ┌─────────────────────────────┐
│ if (age < 13) │ │ if age < 13: │
│ { │ │ print("Kid!") │
│ Console.WriteLine("Kid"); │ elif age < 20: │
│ } │ │ print("Teen!") │
│ else if (age < 20) │ │ else: │
│ { │ │ print("Adult!") │
│ Console.WriteLine("Teen"); │ │
│ } │ │ │
│ else │ │ │
│ { │ │ │
│ Console.WriteLine("Adult"); │ │
│ } │ │ │
└─────────────────────────────┘ └─────────────────────────────┘
KEY DIFFERENCES:
✓ No parentheses around condition
✓ Colon : instead of curly brace {
✓ "elif" instead of "else if"
✓ Indentation defines the block!
# 🔄 For Loops in Python
# Loop through a range of numbers
print("Counting to 5:")
for i in range(1, 6): # 1, 2, 3, 4, 5 (doesn't include 6!)
print(f" {i}")
# Loop through a list
fruits = ["apple", "banana", "cherry"]
print("\nFruits:")
for fruit in fruits:
print(f" 🍎 {fruit}")
# C# foreach equivalent - it's the default in Python! FOR LOOP COMPARISON 🔄
═══════════════════════════════════════════════════════
C# (counting): Python (counting):
┌─────────────────────────────┐ ┌─────────────────────────────┐
│ for (int i = 0; i < 5; i++) │ │ for i in range(5): │
│ { │ │ print(i) │
│ Console.WriteLine(i); │ │ │
│ } │ │ │
└─────────────────────────────┘ └─────────────────────────────┘
C# (foreach): Python (for each):
┌─────────────────────────────┐ ┌─────────────────────────────┐
│ foreach (var f in fruits) │ │ for f in fruits: │
│ { │ │ print(f) │
│ Console.WriteLine(f); │ │ │
│ } │ │ │
└─────────────────────────────┘ └─────────────────────────────┘
# 🔁 While Loops
count = 0
while count < 5:
print(f"Count is: {count}")
count += 1 # Same as count = count + 1
print("Done counting!")
# 🎮 Simple Guessing Game
import random
secret = random.randint(1, 10)
guess = 0
while guess != secret:
guess = int(input("Guess a number (1-10): "))
if guess < secret:
print("Too low! ⬆️")
elif guess > secret:
print("Too high! ⬇️")
print("🎉 You got it!")# 📋 Lists in Python
# Creating a list
numbers = [1, 2, 3, 4, 5]
names = ["Alice", "Bob", "Charlie"]
mixed = [1, "hello", 3.14, True] # Python allows mixed types!
# Accessing elements (same as C#!)
print(names[0]) # "Alice"
print(names[-1]) # "Charlie" (last item - Python special!)
# Adding items
names.append("Diana") # Like C# .Add()
print(names) # ["Alice", "Bob", "Charlie", "Diana"]
# Removing items
names.remove("Bob") # Remove by value
print(names) # ["Alice", "Charlie", "Diana"]
# List slicing (Python superpower! 🦸)
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[2:5]) # [2, 3, 4] - from index 2 to 4
print(numbers[:3]) # [0, 1, 2] - first 3 items
print(numbers[7:]) # [7, 8, 9] - from index 7 to end
print(numbers[::2]) # [0, 2, 4, 6, 8] - every 2nd item! LIST COMPARISON 📋
═══════════════════════════════════════════════════════
C#: Python:
┌─────────────────────────────┐ ┌─────────────────────────────┐
│ var nums = new List<int> │ │ nums = [1, 2, 3] │
│ { 1, 2, 3 }; │ │ │
│ │ │ │
│ nums.Add(4); │ │ nums.append(4) │
│ nums.Remove(2); │ │ nums.remove(2) │
│ nums.Count │ │ len(nums) │
│ nums[0] │ │ nums[0] │
└─────────────────────────────┘ └─────────────────────────────┘
🌟 PYTHON BONUS - Negative Indexing:
┌─────────────────────────────────────────────────────┐
│ names = ["A", "B", "C", "D"] │
│ [0] [1] [2] [3] ← Forward index │
│ [-4] [-3] [-2] [-1] ← Backward index! │
│ │
│ names[-1] = "D" (last item!) │
│ names[-2] = "C" (second to last!) │
└─────────────────────────────────────────────────────┘
# 🔧 Functions in Python
# Basic function
def say_hello():
print("Hello! 👋")
say_hello()
# Function with parameters
def greet(name):
print(f"Hello, {name}! 🎉")
greet("Alex")
# Function with return value
def add(a, b):
return a + b
result = add(5, 3)
print(f"5 + 3 = {result}")
# Function with default parameter
def greet_with_title(name, title="Friend"):
print(f"Hello, {title} {name}!")
greet_with_title("Alex") # "Hello, Friend Alex!"
greet_with_title("Alex", "Dr.") # "Hello, Dr. Alex!"
# 🎓 Grades 9-12: Type hints in functions
def calculate_area(length: float, width: float) -> float:
"""Calculate the area of a rectangle."""
return length * width FUNCTION COMPARISON 🔧
═══════════════════════════════════════════════════════
C#: Python:
┌─────────────────────────────┐ ┌─────────────────────────────┐
│ void SayHello() │ │ def say_hello(): │
│ { │ │ print("Hello!") │
│ Console.WriteLine("Hi");│ │ │
│ } │ │ │
│ │ │ │
│ int Add(int a, int b) │ │ def add(a, b): │
│ { │ │ return a + b │
│ return a + b; │ │ │
│ } │ │ │
└─────────────────────────────┘ └─────────────────────────────┘
KEY DIFFERENCES:
✓ "def" keyword instead of return type
✓ No type declarations for parameters
✓ Colon : instead of curly braces
✓ snake_case naming (say_hello, not SayHello)
# 📖 Dictionaries - Key-Value Pairs
# Creating a dictionary
student = {
"name": "Alex",
"age": 14,
"grade": 8,
"is_enrolled": True
}
# Accessing values
print(student["name"]) # "Alex"
print(student.get("age")) # 14
# Adding/updating values
student["email"] = "alex@school.com" # Add new
student["age"] = 15 # Update existing
# Looping through dictionary
print("\nStudent Info:")
for key, value in student.items():
print(f" {key}: {value}")
# Check if key exists
if "name" in student:
print(f"Found: {student['name']}") DICTIONARY COMPARISON 📖
═══════════════════════════════════════════════════════
C#: Python:
┌─────────────────────────────┐ ┌─────────────────────────────┐
│ var dict = new Dictionary │ │ dict = { │
│ <string, int> │ │ "apple": 5, │
│ { │ │ "banana": 3 │
│ {"apple", 5}, │ │ } │
│ {"banana", 3} │ │ │
│ }; │ │ │
│ │ │ │
│ dict["cherry"] = 7; │ │ dict["cherry"] = 7 │
│ dict.ContainsKey("apple") │ │ "apple" in dict │
└─────────────────────────────┘ └─────────────────────────────┘
# 🏗️ Classes in Python
class Dog:
"""A simple Dog class."""
# Constructor (like C# constructor)
def __init__(self, name, age):
self.name = name # Instance variable
self.age = age
self.tricks = [] # Empty list
# Method
def bark(self):
print(f"{self.name} says: Woof! 🐕")
# Method with parameter
def add_trick(self, trick):
self.tricks.append(trick)
print(f"{self.name} learned {trick}!")
# Method with return
def get_info(self):
return f"{self.name} is {self.age} years old"
# Using the class
buddy = Dog("Buddy", 3)
buddy.bark()
buddy.add_trick("roll over")
buddy.add_trick("fetch")
print(buddy.get_info())
print(f"Tricks: {buddy.tricks}") CLASS COMPARISON 🏗️
═══════════════════════════════════════════════════════
C#: Python:
┌─────────────────────────────┐ ┌─────────────────────────────┐
│ class Dog │ │ class Dog: │
│ { │ │ def __init__(self, name)│
│ public string Name; │ │ self.name = name │
│ │ │ │
│ public Dog(string name) │ │ def bark(self): │
│ { │ │ print("Woof!") │
│ Name = name; │ │ │
│ } │ │ │
│ │ │ │
│ public void Bark() │ │ │
│ { │ │ │
│ Console.WriteLine();│ │ │
│ } │ │ │
│ } │ │ │
└─────────────────────────────┘ └─────────────────────────────┘
KEY DIFFERENCES:
✓ __init__ instead of constructor name
✓ self instead of this
✓ self is always the first parameter
✓ No access modifiers (public/private) by default
Create a program that:
- Asks for the user's name
- Asks for their favorite color
- Prints a personalized message
# YOUR TURN! Fill in the blanks:
name = input("What is your name? ")
color = input("What is your favorite color? ")
# Print a message using both variables
print(f"Hello ____! Your favorite color is ____!")Create a guessing game:
- Generate a random number 1-20
- Let the user guess
- Give hints (higher/lower)
- Count the guesses
import random
# YOUR TURN! Complete this game:
secret = random.randint(1, 20)
guesses = 0
print("I'm thinking of a number between 1 and 20!")
# Add a while loop here that:
# - Gets a guess from the user
# - Tells them if it's too high or too low
# - Stops when they guess correctly
# - Counts how many guesses they tookCreate a Book class that:
- Has title, author, and pages
- Has a method to display info
- Has a method to check if it's long (> 300 pages)
- Create a list of books and display them all
# YOUR TURN! Create the Book class:
class Book:
def __init__(self, title, author, pages):
# Initialize the attributes
pass
def display(self):
# Print book info nicely
pass
def is_long(self):
# Return True if over 300 pages
pass
# Create some books and test your class!Create a program that converts Fahrenheit to Celsius and vice versa.
- Formula: C = (F - 32) × 5/9
Create a program that:
- Lets users add items to a list
- Lets users remove items
- Shows the current list
- Counts total items
Create a program with:
- A Student class with name and grades list
- Methods to add grades and calculate average
- Store multiple students in a dictionary
- Display all students and their averages
🔄 Circle Share - Answer one:
- "Python is easier than C# because..."
- "I like C# better because..."
- "The biggest difference I noticed was..."
- "Indentation instead of curly braces makes me feel..."
- "I want to use Python for..."
| Term | 📝 Kid-Friendly Definition | 💻 Example |
|---|---|---|
| 🐍 Python | A programming language that's easy to read | print("Hello!") |
| 📝 Interpreted | Code runs line by line, no compiling needed | Just run python file.py |
| 🔀 Dynamic Typing | Variables can change types anytime | x = 5; x = "hello" |
| 📏 Indentation | Spaces at the start of lines that matter! | 4 spaces = inside a block |
| 🔧 def | Keyword to define a function | def say_hi(): |
| 📋 List | An ordered collection of items | [1, 2, 3, "four"] |
| 📖 Dictionary | Key-value pairs (like a real dictionary!) | {"name": "Alex"} |
| 🏗️ class | A blueprint for creating objects | class Dog: |
| 🔨 init | The constructor method in Python | def __init__(self): |
| 👤 self | Refers to the current object (like this in C#) |
self.name = name |
👨👩👧 Talk to a family member:
"Today I learned Python! It's another programming language like C#, but it looks very different. Python uses indentation to organize code instead of curly braces, and it's used for things like AI and data science!"
🌍 Real-world Python uses:
- 🤖 Artificial Intelligence (ChatGPT, image recognition)
- 📊 Data Science (analyzing data, making charts)
- 🎮 Game scripting (Minecraft mods!)
- 🌐 Websites (Instagram, Spotify backend)
- 🔬 Science & Research (NASA, CERN)
🤔 Questions to explore:
- What language would you choose for a video game?
- Why do you think Python is popular for AI?
- Can you think of a project where you'd use Python?
Before you leave, make sure you can:
- ✍️ Write and run a basic Python program
- 📦 Create and use variables
- 🔀 Use if/elif/else statements
- 🔄 Write for and while loops
- 📋 Create and manipulate lists
- 🔧 Define and call functions
- 🔄 Explain 3 differences between Python and C#
In Session 20, we'll build a Web API with Python using Flask! 🌶️
YOUR JOURNEY SO FAR 🗺️
┌─────────────────────────────────────────────────────────┐
│ │
│ 📚 Sessions 1-10: C# Fundamentals & OOP │
│ 🌐 Sessions 11-15: Building Web APIs │
│ 🎨 Sessions 16-18: Frontend & JavaScript │
│ 🐍 Session 19: Python Basics ◀── YOU ARE HERE! │
│ 🌶️ Session 20: Flask Web APIs │
│ 🎭 Session 21: Final Showcase! │
│ │
└─────────────────────────────────────────────────────────┘
You're becoming a multi-language programmer! 🎉🐍💜