name = "Alice"
age = 25
print(f"Hello, my name is {name} and I am {age} years old.")

Hello, my name is Alice and I am 25 years old.

print("Hello"   # missing closing parenthesis

SyntaxError: '(' was never closed

print(nmae)   # typo — 'nmae' instead of 'name'

NameError: name 'nmae' is not defined

age = "25"
total = age + 5   # can't add a string and a number

TypeError: can only concatenate str (not "int") to str

name = "Claude"
age = 3
temperature = 0.7
is_active = True

score = 0       # create variable with value 0
score = score + 10    # update it to 10
score += 5      # shortcut for score = score + 5
print(score)    # prints 15

# This is a single-line comment

# Calculate the total cost
price = 10
quantity = 5
total = price * quantity   # multiply price by quantity

"""
This is a multi-line comment.
You can write as many lines as you want.
Useful for longer explanations.
"""

print(type(42))         # <class 'int'>
print(type(3.14))       # <class 'float'>
print(type("hello"))    # <class 'str'>
print(type(True))       # <class 'bool'>

tokens = 1024
year = 2025
negative = -50

temperature = 0.7
price = 19.99
pi = 3.14159

a = 10
b = 3

print(a + b)    # 13  — addition
print(a - b)    # 7   — subtraction
print(a * b)    # 30  — multiplication
print(a / b)    # 3.333...  — division (always returns float)
print(a // b)   # 3   — floor division (drops the decimal)
print(a % b)    # 1   — remainder (modulo)
print(a ** b)   # 1000  — exponent (10 to the power of 3)

x = "42"          # this is a string
y = int(x)        # converts to integer: 42
z = float(x)      # converts to float: 42.0

num = 3.9
print(int(num))   # 3 — drops the decimal, does NOT round

first_name = "Alice"
last_name = 'Smith'
sentence = "Python is great for AI!"

word = "Python"
print(word[0])    # P  — first character
print(word[1])    # y
print(word[-1])   # n  — last character (negative index counts from the end)

text = "Hello, World!"
print(text[0:5])     # Hello
print(text[7:])      # World!  (from index 7 to the end)
print(text[:5])      # Hello   (from the start to index 5)

sentence = "  hello world  "

print(sentence.upper())         # "  HELLO WORLD  "
print(sentence.lower())         # "  hello world  "
print(sentence.strip())         # "hello world"  — removes spaces from both ends
print(sentence.strip().title()) # "Hello World"  — capitalizes first letter of each word

text = "Python is great"
print(text.replace("great", "amazing"))   # "Python is amazing"
print(text.split(" "))                    # ['Python', 'is', 'great']
print(text.startswith("Python"))          # True
print(text.endswith("code"))              # False
print(len(text))                          # 15  — number of characters

name = "Claude"
version = 3
cost = 0.015

print(f"Model: {name}")
print(f"Version: {version}")
print(f"Cost per token: ${cost:.4f}")   # formats to 4 decimal places
print(f"2 + 2 = {2 + 2}")              # you can do math inside {}

Model: Claude
Version: 3
Cost per token: $0.0150
2 + 2 = 4

is_trained = True
is_deployed = False

print(type(True))    # <class 'bool'>

x = 10
y = 5

print(x == y)    # False — equal to
print(x != y)    # True  — not equal to
print(x > y)     # True  — greater than
print(x < y)     # False — less than
print(x >= 10)   # True  — greater than or equal to
print(x <= 9)    # False — less than or equal to

age = 25
has_account = True

# and — both conditions must be True
print(age > 18 and has_account)   # True

# or — at least one condition must be True
print(age > 30 or has_account)    # True

# not — reverses the Boolean
print(not has_account)            # False

count = 10
count += 5    # same as count = count + 5  → 15
count -= 3    # same as count = count - 3  → 12
count *= 2    # same as count = count * 2  → 24
count /= 4    # same as count = count / 4  → 6.0

score = 85

if score >= 90:
    print("Grade: A")
elif score >= 80:
    print("Grade: B")
elif score >= 70:
    print("Grade: C")
else:
    print("Grade: F")

Grade: B

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print(fruit)

apple
banana
cherry

for i in range(5):
    print(i)
# prints 0, 1, 2, 3, 4

for i in range(1, 6):
    print(i)
# prints 1, 2, 3, 4, 5

for i in range(0, 10, 2):
    print(i)
# prints 0, 2, 4, 6, 8 (step of 2)

count = 0

while count < 5:
    print(f"Count is: {count}")
    count += 1    # important! must change the condition, or the loop never stops

# break — exit the loop immediately
for i in range(10):
    if i == 5:
        break     # stops the loop when i reaches 5
    print(i)      # prints 0, 1, 2, 3, 4

# continue — skip the rest of this iteration and go to the next
for i in range(10):
    if i % 2 == 0:
        continue  # skip even numbers
    print(i)      # prints 1, 3, 5, 7, 9

models = ["GPT-4", "Claude", "Gemini", "Llama"]

# Access items by index (starts at 0)
print(models[0])     # GPT-4
print(models[-1])    # Llama (last item)

# Slice the list
print(models[1:3])   # ['Claude', 'Gemini']

# Add items
models.append("Mistral")         # adds to the end
models.insert(1, "Claude-3")     # inserts at position 1

# Remove items
models.remove("Gemini")          # removes by value
del models[0]                    # removes by index

# Check membership
print("Claude" in models)        # True or False

# Useful list operations
print(len(models))               # number of items
models.sort()                    # sorts alphabetically (in place)
models.reverse()                 # reverses the order
print(sorted(models))            # returns a sorted copy without changing original

model = {
    "name": "Claude",
    "provider": "Anthropic",
    "max_tokens": 200000,
    "temperature": 0.7,
    "supports_vision": True
}

# Access values by key
print(model["name"])             # Claude
print(model.get("provider"))     # Anthropic (safer — won't crash if key missing)

# Add or update a key
model["version"] = 3
model["temperature"] = 0.5

# Remove a key
del model["supports_vision"]

# Loop through a dictionary
for key, value in model.items():
    print(f"{key}: {value}")

# Check if a key exists
print("name" in model)           # True

coordinates = (40.7128, -74.0060)
rgb_color = (255, 128, 0)

# Access items the same way as lists
print(coordinates[0])    # 40.7128

# Unpack a tuple into variables
latitude, longitude = coordinates
print(latitude)          # 40.7128

# Tuples can be used as dictionary keys (lists cannot)
locations = {(0, 0): "origin", (1, 2): "point A"}

languages = {"Python", "JavaScript", "Python", "Go", "Python"}
print(languages)    # {'Python', 'JavaScript', 'Go'} — duplicates removed

# Add and remove items
languages.add("Rust")
languages.remove("Go")

# Check membership (very fast)
print("Python" in languages)    # True

# Set operations
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a | b)    # {1, 2, 3, 4, 5, 6}  — union (all items from both)
print(a & b)    # {3, 4}              — intersection (items in both)
print(a - b)    # {1, 2}              — difference (in a but not b)

# Define the function
def greet():
    print("Hello! Welcome to the Python for AI course.")

# Call (run) the function
greet()     # Hello! Welcome to the Python for AI course.
greet()     # You can call it as many times as you want

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

greet_user("Alice")         # 'Alice' is an argument
greet_user("Bob")

def calculate_cost(tokens, price_per_token):
    total = tokens * price_per_token
    print(f"Cost: ${total:.4f}")

calculate_cost(1000, 0.00002)   # Cost: $0.0200

def generate(prompt, model="claude-3", temperature=0.7):
    print(f"Model: {model}")
    print(f"Temperature: {temperature}")
    print(f"Prompt: {prompt}")

generate("Tell me a joke")                          # uses defaults
generate("Write code", model="gpt-4")              # overrides model
generate("Summarize", model="llama", temperature=0.1)  # overrides both

def create_model(name, provider, max_tokens):
    print(f"{name} by {provider}, max {max_tokens} tokens")

# Using keyword arguments (order does not matter)
create_model(provider="Anthropic", max_tokens=200000, name="Claude")

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

result = add(3, 5)    # result = 8
print(result)

# You can use the return value directly
print(add(10, 20))    # 30

def multiply(a, b):
    result = a * b
    return result

# You can return multiple values as a tuple
def min_max(numbers):
    return min(numbers), max(numbers)

low, high = min_max([3, 1, 8, 2, 9])
print(low, high)    # 1 9

def my_function():
    local_var = "I only exist inside this function"
    print(local_var)

my_function()       # works fine
print(local_var)    # ERROR: NameError — local_var doesn't exist here

model_name = "Claude"   # global variable

def show_model():
    print(model_name)   # can read the global variable

show_model()    # prints "Claude"

call_count = 0

def make_call():
    global call_count
    call_count += 1

make_call()
make_call()
print(call_count)   # 2

import math

print(math.sqrt(25))      # 5.0
print(math.pi)            # 3.14159...
print(math.ceil(3.2))     # 4
print(math.floor(3.8))    # 3

from math import sqrt, pi

print(sqrt(49))    # 7.0  — no need to write math.sqrt
print(pi)          # 3.14159...

import numpy as np         # very common convention
import pandas as pd        # very common convention

# Now use np and pd instead of the full name

import random

print(random.randint(1, 10))        # random integer between 1 and 10
print(random.choice(["a", "b", "c"]))   # random item from a list
print(random.random())              # random float between 0.0 and 1.0

my_list = [1, 2, 3, 4, 5]
random.shuffle(my_list)             # shuffles the list in place
print(my_list)

from datetime import datetime, date

now = datetime.now()
print(now)                          # 2025-01-01 14:30:00.123456
print(now.year)                     # 2025
print(now.strftime("%B %d, %Y"))    # January 01, 2025

today = date.today()
print(today)                        # 2025-01-01

# Always use 'with' — it automatically closes the file when done
with open("notes.txt", "r") as file:
    content = file.read()    # read the whole file as one string
    print(content)

# Read line by line
with open("notes.txt", "r") as file:
    for line in file:
        print(line.strip())  # .strip() removes the newline character at the end

with open("output.txt", "w") as file:
    file.write("Hello, file!\n")
    file.write("This is a second line.\n")

import json

# Python dictionary
config = {
    "model": "claude-3",
    "temperature": 0.7,
    "max_tokens": 2048
}

# Save to a JSON file
with open("config.json", "w") as file:
    json.dump(config, file, indent=2)

# Read from a JSON file
with open("config.json", "r") as file:
    loaded_config = json.load(file)

print(loaded_config["model"])    # claude-3

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Error: Cannot divide by zero!")

def safe_convert(value):
    try:
        return int(value)
    except ValueError:
        print(f"'{value}' cannot be converted to an integer")
        return None
    except TypeError:
        print("Input must be a string or number")
        return None

print(safe_convert("42"))      # 42
print(safe_convert("hello"))   # error message, returns None
print(safe_convert(None))      # error message, returns None

try:
    file = open("data.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("File not found!")
finally:
    print("This always runs.")

class AIModel:
    # __init__ is called automatically when you create an object
    # 'self' refers to the specific object being created
    def __init__(self, name, provider, max_tokens):
        self.name = name              # instance attribute
        self.provider = provider
        self.max_tokens = max_tokens
        self.call_count = 0          # starts at 0 for every new object

    def generate(self, prompt):
        self.call_count += 1
        print(f"{self.name}: Generating response for '{prompt}'")

    def get_info(self):
        return f"{self.name} by {self.provider} | Calls made: {self.call_count}"

# Create two separate objects from the same class
claude = AIModel("Claude", "Anthropic", 200000)
gpt = AIModel("GPT-4", "OpenAI", 128000)

# Each object is independent
claude.generate("Tell me about Python")
claude.generate("Explain neural networks")
gpt.generate("Write a haiku")

print(claude.get_info())   # Claude by Anthropic | Calls made: 2
print(gpt.get_info())      # GPT-4 by OpenAI | Calls made: 1

class AIModel:
    # Class attribute — shared by ALL instances
    total_models_created = 0

    def __init__(self, name):
        self.name = name                         # instance attribute
        AIModel.total_models_created += 1        # update class attribute

model1 = AIModel("Claude")
model2 = AIModel("GPT-4")

print(AIModel.total_models_created)    # 2
print(model1.name)                     # Claude
print(model2.name)                     # GPT-4

class BaseModel:
    def __init__(self, name):
        self.name = name

    def respond(self, prompt):
        return f"Response to: {prompt}"


class ChatModel(BaseModel):
    def respond(self, prompt):
        base = super().respond(prompt)   # call the parent's method
        return f"[Chat] {base}"


class CodeModel(BaseModel):
    def respond(self, prompt):
        base = super().respond(prompt)
        return f"```\n{base}\n```"


chat = ChatModel("Claude-Chat")
code = CodeModel("Claude-Code")

print(chat.respond("Hello!"))
# [Chat] Response to: Hello!

print(code.respond("Write a loop"))
# ```
# Response to: Write a loop
# ```