Python input() Returns Strings — TypeError Fixes

# -----------------------------------------------------------
# Exploring Python's built-in functions for the first time
# -----------------------------------------------------------

# print() sends text to the screen — the most-used built-in of all
print("Hello, I am already built into Python!")

# len() counts how many items are in something (string, list, etc.)
course_name = "Python Fundamentals"
character_count = len(course_name)          # counts every character including the space
print("Course name has", character_count, "characters")

# type() tells you WHAT kind of data something is
student_age = 21
print("The data type of student_age is:", type(student_age))  # should say <class 'int'>

# abs() returns the absolute (positive) version of a number
temperature_change = -7
print("Absolute temperature change:", abs(temperature_change))  # -7 becomes 7

# Notice: no import statement anywhere. These just work.

# -----------------------------------------------------------
# GROUP 1: OUTPUT & INPUT — talking to the user
# -----------------------------------------------------------

# print() can take multiple values separated by commas
first_name = "Maria"
last_name = "Chen"
print("Full name:", first_name, last_name)   # print joins them with a space by default
print(first_name, last_name, sep="-")        # sep= changes the separator
print("Line one", end=" | ")                 # end= changes what goes at the end
print("Line two")                            # this continues on the same line

# input() pauses the program and waits for the user to type something
# Uncomment the next two lines to test it interactively:
# user_city = input("What city are you in? ")
# print("You are in:", user_city)

print()  # blank line for readability

# -----------------------------------------------------------
# GROUP 2: TYPE CONVERSION — changing data from one form to another
# -----------------------------------------------------------

# int() converts something INTO a whole number
rating_as_text = "42"                        # this is text, NOT a number yet
rating_as_number = int(rating_as_text)       # now it IS a number we can do math with
print("Rating doubled:", rating_as_number * 2)

# float() converts something into a decimal number
price_text = "9.99"
price = float(price_text)                    # now we can do math with it
print("Price with tax:", price * 1.2)

# str() converts something INTO text
user_score = 850
leaderboard_entry = "Score: " + str(user_score)  # can't join text + number without str()
print(leaderboard_entry)

# bool() converts something into True or False
print(bool(0))         # 0 is considered False
print(bool(42))        # any non-zero number is True
print(bool(""))        # empty string is False
print(bool("hello"))   # non-empty string is True

print()

# -----------------------------------------------------------
# GROUP 3: INSPECTION — understanding what you have
# -----------------------------------------------------------

shop_items = ["apple", "bread", "milk", "eggs"]

# len() — how many items?
print("Items in cart:", len(shop_items))     # 4

# type() — what kind of data is this?
print("Type of shop_items:", type(shop_items))   # <class 'list'>

# isinstance() — is this data a specific type? Returns True or False
print("Is shop_items a list?", isinstance(shop_items, list))    # True
print("Is shop_items a string?", isinstance(shop_items, str))   # False

print()

# -----------------------------------------------------------
# GROUP 4: MATH — number operations without importing anything
# -----------------------------------------------------------

exam_scores = [72, 88, 91, 65, 79]

print("Highest score:", max(exam_scores))    # 91
print("Lowest score:",  min(exam_scores))    # 65
print("Total points:",  sum(exam_scores))    # 395
print("Rounded pi:",    round(3.14159, 2))   # 3.14  — second arg = decimal places
print("Absolute:",      abs(-50))            # 50

# -----------------------------------------------------------
# range() — generating a sequence of numbers
# -----------------------------------------------------------

# range(start, stop, step) — stop is EXCLUSIVE (it doesn't include that number)
print("Counting 1 to 5:")
for number in range(1, 6):              # starts at 1, stops BEFORE 6
    print(number, end=" ")
print()                                 # new line after the loop

print("Even numbers from 2 to 10:")
for even in range(2, 11, 2):            # start=2, stop before 11, step=2
    print(even, end=" ")
print()

print()

# -----------------------------------------------------------
# sorted() — sorting without destroying your original list
# -----------------------------------------------------------

raw_temperatures = [34, 19, 27, 41, 22, 30]

sorted_temperatures = sorted(raw_temperatures)              # ascending by default
reverse_sorted = sorted(raw_temperatures, reverse=True)     # descending

print("Original list (unchanged):", raw_temperatures)       # still in original order!
print("Sorted ascending:         ", sorted_temperatures)
print("Sorted descending:        ", reverse_sorted)

print()

# sorted() also works on lists of strings — sorts alphabetically
team_members = ["Zara", "Ahmed", "Liu", "Beatriz"]
print("Alphabetical order:", sorted(team_members))

print()

# -----------------------------------------------------------
# enumerate() — getting position AND value at the same time
# -----------------------------------------------------------

podium_finishers = ["Kenji", "Amara", "Tobias"]

print("Race results:")
for position, name in enumerate(podium_finishers, start=1):  # start=1 means count from 1
    print(f"  Position {position}: {name}")

print()

# -----------------------------------------------------------
# zip() — pairing two lists together like a zipper
# -----------------------------------------------------------

student_names = ["Alice", "Bob", "Carol"]
final_grades  = [88,      74,    95]

print("Student grades:")
for name, grade in zip(student_names, final_grades):   # pairs index-by-index
    status = "PASS" if grade >= 75 else "FAIL"         # inline condition for label
    print(f"  {name}: {grade} — {status}")

# -----------------------------------------------------------
# help() — read Python's own documentation from inside Python
# -----------------------------------------------------------

# To avoid printing 30 lines here, we'll demonstrate the CONCEPT
# In your own terminal, type: help(sorted)
# You'll see the full signature and description

# A quick demo that DOES run cleanly:
print("--- What does abs() do? ---")
help(abs)   # prints the official description of abs()

print()

# -----------------------------------------------------------
# dir() — list every operation something can perform
# -----------------------------------------------------------

sample_text = "hello world"

# Filter out the 'dunder' methods (the ones with double underscores)
# to see just the readable method names
useful_methods = [method for method in dir(sample_text) if not method.startswith("_")]

print("Things you can do with a string:")
print(useful_methods)

print()

# -----------------------------------------------------------
# A practical use-case: discovering built-ins you didn't know
# -----------------------------------------------------------

numbers_list = [5, 2, 8, 1, 9, 3]

# You already know max() and min(). But did you know about sorted()?
# Let's verify what type sorted() gives back:
result = sorted(numbers_list)
print("sorted() returns type:", type(result))        # <class 'list'>
print("Original unchanged:   ", numbers_list)        # [5, 2, 8, 1, 9, 3]

# reversed() returns an ITERATOR, not a list — a common gotcha!
reversed_result = reversed(numbers_list)
print("reversed() returns type:", type(reversed_result))     # <class 'list_reverseiterator'>
print("To get a list, wrap it: ", list(reversed(numbers_list)))  # [3, 9, 1, 8, 2, 5]

# -----------------------------------------------------------
# map() — apply a function to every item
# -----------------------------------------------------------

prices_chf = [15, 22, 8, 30]
# Convert Swiss Francs to USD (approx 1.12 rate)
prices_usd = list(map(lambda p: p * 1.12, prices_chf))
print("Prices in USD:", prices_usd)

# map with a named function
def celsius_to_fahrenheit(c):
    return (c * 9/5) + 32

temps_c = [0, 20, 30, 100]
temps_f = list(map(celsius_to_fahrenheit, temps_c))
print("Temps in F:", temps_f)

print()

# -----------------------------------------------------------
# filter() — keep items that match a condition
# -----------------------------------------------------------

grades = [55, 72, 88, 43, 91, 67]
passing = list(filter(lambda grade: grade >= 60, grades))
print("Passing grades:", passing)

# filter with None to remove falsy values
mixed = [0, "hello", "", [], [1,2], None, 42]
clean = list(filter(None, mixed))
print("Truthy values only:", clean)

print()

# -----------------------------------------------------------
# all() and any() — quick truthiness checks
# -----------------------------------------------------------

user_permissions = ["read", "write", "execute"]
required = ["read", "write"]
print("Has all required?", all(p in user_permissions for p in required))  # True

scores = [45, 78, 92, 33]
print("Any failures? (< 40)", any(s < 40 for s in scores))              # True (33)

print()

# -----------------------------------------------------------
# map vs list comprehension — which is faster?
# -----------------------------------------------------------
import timeit

setup = "nums = list(range(1000000))"
map_time = timeit.timeit("list(map(lambda x: x*2, nums))", setup, number=10)
comp_time = timeit.timeit("[x*2 for x in nums]", setup, number=10)
print(f"map() total: {map_time:.3f}s")
print(f"list comp total: {comp_time:.3f}s")
print(f"map is {comp_time/map_time:.1f}x faster")

// io.thecodeforge — python tutorial

import time

sensor_readings = [23.4 + (i * 0.1) for i in range(100_000)]

# Slow: manual loop
def manual_max(data):
    max_val = data[0]
    for val in data[1:]:
        if val > max_val:
            max_val = val
    return max_val

start = time.perf_counter()
result = manual_max(sensor_readings)
manual_time = time.perf_counter() - start

# Fast: built-in
start = time.perf_counter()
result = max(sensor_readings)
builtin_time = time.perf_counter() - start

print(f"Manual loop: {manual_time:.6f}s")
print(f"Built-in max: {builtin_time:.6f}s")
print(f"Speedup: {manual_time / builtin_time:.1f}x")

// io.thecodeforge — python tutorial

total_records = 52467
page_size = 50

# Naive: two operations
total_pages_naive = total_records // page_size
last_page_size_naive = total_records % page_size
print(f"Naive -> {total_pages_naive} pages, last page: {last_page_size_naive}")

# Optimized: one call
pages, last_chunk = divmod(total_records, page_size)
print(f"divmod -> {pages} pages, last chunk: {last_chunk}")

# pow() with modulo - cryptographic scenario
base = 7
exp = 1000
modulus = 1000000007

# Bad: huge intermediate
slow_result = pow(base, exp) % modulus

# Good: modular exponentiation
fast_result = pow(base, exp, modulus)

print(f"pow(base, exp, mod) matches: {fast_result == slow_result}")

// io.thecodeforge — python tutorial

daily_sales = [1200, 3400, 2750, 4100, 1850]
total = sum(daily_sales)
print(total)  // 13300

// Starting from a base value
total_with_cash = sum(daily_sales, 500)
print(total_with_cash)  // 13800

// io.thecodeforge — python tutorial

value = 255
print(bin(value))    // 0b11111111
print(oct(value))    // 0o377
print(hex(value))    // 0xff

// int() with base
print(int("1010", 2))  // 10
print(int("ff", 16))   // 255

// io.thecodeforge — python tutorial

data = [10, 20, 30, 40]
print(len(data))            // 4

name = "Python"
print(len(name))            // 6

settings = {"debug": True, "port": 8080}
print(len(settings))        // 2

// Custom class support
class Inventory:
    def __len__(self):
        return 42

print(len(Inventory()))     // 42