An underwater microphone recorded five simplified frequency readings overnight. Run the detector to see whether any reading falls inside the review range.

Real acoustic analysis uses frequency, duration, repetition, background noise, and labeled recordings. This small program gives us a useful first look at the shape of the problem.

A simplified detector

At 4:36 AM, an underwater microphone sixty kilometers offshore uploads five simplified frequency readings. One of them is much lower than the surrounding noise.

You do not need to understand every line yet. Run the detector and see whether it notices the unusual reading.

The reading at 42 falls below the review limit. Look at the final line in the output after you press Run.

What to watch

Run the overnight detector

The overnight recording

The reading at 42 triggered the detector. Replace 42 with 110, then run the program again.

The code stays the same, but the conclusion changes with the recording. That is the first important idea: a program can respond to its data instead of memorizing one answer.

Change the recording

The detector currently reviews frequencies below 60. Change whale_range to 30. The reading at 42 should no longer be flagged.

Run the code when you are ready. You will see whether both the setting and the result are correct.

Tune the listening range

The final part gives the program two possible paths. If matches contains a reading, Python reports a possible call. Otherwise, it clears the recording.

You are not expected to write this decision from memory yet. Later lessons will unpack the list, comparison, and condition one piece at a time.

You will return to this

Follow the matching branch

Follow the decision

A new recording contains a low reading at 38, but the matching branch prints an empty message.

Replace print("") with print("Possible whale call detected"), then run the detector.

Your turn

A second recording arrives

Your first program received observations, searched for a matching value, applied a threshold, made a decision, and reported the result.

A real whale call detector considers far more than one frequency threshold. The important part today is seeing how data can move through code and produce a decision.

A first look, not a final model

The next recording will contain different values. To work with changing information, the program needs a way to name and store it. That is where variables come in.

Run the complete pipeline

The shape of the problem

Run and modify a tiny detector that flags a possible whale call in underwater frequency readings.

Your first Python program

Learn Python from the beginning, with small examples drawn from data, machine learning, and everyday programming.

A variable gives a name to a value. Use clear names so another person can understand what the value represents.

Imagine seeing the number 0.92 by itself. You would have to guess what it means. A name such as confidence_score gives the number context. Good variable names are especially useful in AI code because the same program may contain inputs, predictions, labels, scores, and settings.

Use lowercase words separated by underscores, such as favorite_color or lesson_count.

Naming variables

Describe a training run

The whale detector found the number 42 in the last lesson. By itself, 42 has no meaning. A variable gives that value a useful name.

Run the code and confirm that frequency_hz carries the value 42 into the output.

Run the named reading

Give the reading a name

Python keeps track of what kind of value each variable contains. Text, whole numbers, decimals, and yes-or-no states behave differently.

Run the program and inspect the four type names in the output.

Inspect four value types

Meet four kinds of values

A variable can keep its name while its value changes. A second analysis raised the detector confidence from 0.42 to 0.92.

Change confidence from 0.42 to 0.92, then run the code.

Update detector confidence

Change the stored value

Short names make people guess. Rename x to frequency_hz so the code explains what 38 represents.

Rename the variable on both lines without changing its value.

Use a meaningful variable name

Replace a mystery name

Real programs keep several related values at once. Complete a small record describing an image-classifier training run.

Create training_rows = 1200, learning_rate = 0.01, and training_complete = False. Then print the three values, one per line.

Variables connect names to values. Clear names explain the data, types determine how values behave, and assignments let programs update their state.

Run the status report and verify that every value keeps its meaning from assignment to output.

Final check

Run the variable status

Build a readable status

Store information in variables and inspect the type of each value.

Variables and values

A string is a sequence of characters. Python gives you simple tools for joining text, changing its case, and selecting part of it.

An f string places values inside text with braces. Indexes start at zero, so the first character is at index 0. A slice selects a range of characters.

Dataset labels, file names, prompts, model names, and generated answers are all strings. You will often clean them with strip, compare them in lowercase, or combine them into a readable message. None of that is advanced, but messy text causes plenty of real bugs.

String methods return a new string. Save that result in a variable if you want to use it later.

Strings cannot be changed in place

Format a prediction

The monitoring station stores names, labels, and reports as strings. Quotation marks tell Python that a value is text.

Run the code and confirm that the species label travels from the variable to the output.

Run the species label

Treat text as data

station stores the text North Reef. species stores the text humpback whale. We want Python to combine those two stored values into one label.

Putting f before the opening quotation mark lets Python replace names inside curly braces with their stored values. In f"{station}: {species}", Python replaces {station} with North Reef and {species} with humpback whale.

Replace the empty label with label = f"{station}: {species}", then run the code. The output should read North Reef: humpback whale.

Combine the station and species

Combine two pieces of text

Incoming data is rarely tidy. This label has extra spaces and inconsistent capitalization. Clean it before the program compares it with other labels.

Use strip() to remove outside spaces and lower() to make the text lowercase.

Clean the label

Clean an incoming label

A recording ID contains several pieces of information. A slice selects a range of characters without changing the original string.

Slice the first five characters from WHALE-042-AM so the output is WHALE.

Extract the category

Select part of a string

Model output becomes useful when people can read it. Combine the model name, predicted label, and confidence into one sentence.

Build this exact report: Plant Classifier predicts Sunflower (94%).

Strings let programs store text, clean inconsistent input, select useful pieces, and assemble readable output.

Run the complete alert flow: clean the label, extract the recording category, and format the report.

Run the clean alert

Build a clean alert

Combine, format, slice, and transform text.

Working with strings

Python supports addition, subtraction, multiplication, division, powers, and remainders. Parentheses make the order of a calculation clear.

The festival team needs attendance totals, capacity percentages, average crowd ratings, and wristband pack counts. Each answer comes from ordinary arithmetic.

Use int, float, and str to convert compatible values from one type to another.

Converting values

Calculate festival capacity

Seventy guests bought tickets online and 30 bought them at the entrance. Python uses + to combine those two arrival counts.

Run the code. total_attendees should be 100.

Count all attendees

Count the arriving crowd

The festival sold 87 tickets for a venue that holds 100 people. The fill rate is tickets sold divided by total capacity.

Replace fill_rate = 0 with tickets_sold / venue_capacity. The output should be 0.87.

Calculate the fill rate

Measure how full the venue is

A fill rate of 0.87 means the festival has sold 87% of its capacity. Multiply a decimal by 100 to turn it into a percentage.

Replace fill_percent = 0 with fill_rate * 100. The output should be 87.0.

Calculate the capacity percentage

Convert a decimal to percent

The first three performers received crowd ratings of 92, 88, and 95. Add the ratings first, then divide by 3. Parentheses tell Python to perform the addition before the division.

Set average_score to (92 + 88 + 95) / 3. The rounded festival rating should be 91.7.

Calculate the average crowd rating

Control calculation order

Twenty-three staff wristbands must be packed into bundles of 5. The // operator counts complete bundles. The % operator returns the wristbands left over.

Calculate full_packs with 23 // 5 and leftover_wristbands with 23 % 5. The answers should be 4 full packs and 3 loose wristbands.

Pack the wristbands

Pack the entry wristbands

Festival numbers become useful when a program combines them. You counted arrivals, measured venue capacity, converted a percentage, averaged crowd ratings, and packed wristbands.

Run the check-in calculation. 180 checked-in guests out of 240 ticket holders should produce 0.75 and 75.0.

Run the festival check-in rate

Calculate the check-in rate

Calculate with integers and floats, then learn how operator order works.

Numbers and math

A comparison produces either True or False. Your program can use that result to decide what happens next.

Use two equals signs to compare values. A single equals sign assigns a value. You can combine comparisons with and, or, and not.

A meter beside the main stage reports the current sound level. Python compares that reading with safety limits and tells the crew whether to continue, lower the volume, or pause the show.

Python normally uses four spaces for each indentation level.

Indentation matters

Choose a stage response

A sound meter beside the main stage reads 82 decibels. A comparison asks whether that reading has reached the crew’s 80-decibel warning level and produces either True or False.

Run the code. Because 82 is at least 80, the output should be True.

Run the sound check

Check the main-stage volume

The sound meter still reads 82, but the crew changes the warning level to 90 for an outdoor sound check. A reading of 82 does not reach 90.

Change warning_level from 80 to 90. The output should change from True to False.

Raise the warning level

Change the warning level

The crew acts only when the stage is loud and the front-row area is occupied. The word and requires both safety conditions to be True.

Set action_needed to sound_level >= 80 and front_row_occupied. Both conditions are true, so the output should be True.

Combine the safety conditions

Protect the front row

An if statement runs its indented instruction when a condition is True. A loud reading tells the crew to lower the volume; else confirms the volume is safe.

Complete both messages. With sound_level = 91, the output should be Lower the volume. Use Volume is safe for else.

Complete the two responses

Choose the sound-crew response

Not every sound reading needs the same response. elif gives the crew a middle action between pausing the show and continuing normally.

Complete all three branches. For sound_level = 86, the output must be Lower the volume.

Choose the stage response

Choose one of three stage actions

The final safety rule combines an extreme sound reading with a crowded front-row area. Comparisons create booleans, and combines them, and if turns the result into an immediate stage action.

Run the completed rule. Because sound_level is 101 and crowd_near_stage is True, the output should be Pause the show.

Run the show-safety rule

Pause an unsafe show

Compare values, combine conditions, and choose which code should run.

Booleans and decisions

A list stores an ordered collection that can change. A tuple stores an ordered collection that is meant to stay fixed.

Negative indexes count from the end. A slice can select several items without changing the original list.

Festival bookings change throughout the day. A list keeps the artist lineup in performance order, while a tuple keeps a fixed headline start time paired as hour and minute.

Start with a list. Use a tuple when the fixed structure of the value is important.

Choose the simple option

Update the artist lineup

Three artists are confirmed for the main stage. A list keeps their names under one variable and preserves the order in which they will perform.

Run the code. Python should print Nova Echo, Velvet Circuit, and Luna Park in lineup order.

Run the lineup

Build the artist lineup

Every artist has an index. Python starts counting at 0, so index 0 selects the opening performer and index 1 selects the second act.

Change the print line to artist_lineup[0]. The output should be Nova Echo.

Print the opening artist

Find the opening artist

Midnight Taxi accepts a late invitation to close the festival. append adds the artist to the end without replacing anyone already booked.

Replace the comment with artist_lineup.append("Midnight Taxi"). The lineup should now end with Midnight Taxi.

Append the closing artist

Add a late booking

Luna Park cancels, and Sunset Arcade takes the third slot. Assigning to index 2 replaces that booking because Python counts positions from 0.

Add artist_lineup[2] = "Sunset Arcade". The updated lineup should end with Sunset Arcade.

Replace the third artist

Handle an artist cancellation

The lineup can change, but the headline slot is fixed at 21:30. A tuple keeps the hour and minute together as one two-part time.

Run the code. headline_time[0] should print the hour 21, and headline_time[1] should print the minute 30.

Read the fixed headline time

Keep the headline time together

The gates are opening, so the festival app needs the finalized artist order. The list grows with the late booking, indexes identify the opener and closer, and len counts the performers.

Run the completed summary. It should show Nova Echo opening, Midnight Taxi closing, and 4 artists total.

Run the final lineup summary

Publish the final lineup

Store ordered groups of values and select the items you need.

Lists and tuples

A dictionary connects each key to a value. A set stores unique values and makes membership checks easy.

A dictionary is a natural way to represent one player because every value has a label: name, health, coins, or current level. A set is useful for unlocked abilities because each ability should appear only once.

Build a player profile

The studio’s new adventure game needs to remember who the player is. A dictionary connects each label, called a key, to its value.

Run the code. The profile should print Mira, 100 health, and 12 coins.

Run the player profile

Create the player profile

The health bar does not need the whole profile. Square brackets with the key "health" retrieve that one value.

Change the print line to player["health"]. The output should be 100.

Read the health value

Read one player stat

Mira finishes a side quest and earns 8 coins. Assigning a new value to an existing key updates that part of the profile.

Award quest coins

Look up values by name and keep collections of unique items.