Variables

This task helps you understand how to assign multiple inputs to different variables and combine them in a formatted output. It also trains you to use variable names that reflect their purpose.

• Use input() to collect name and city from the user.
• Assign each input to a separate variable.
• Use print() with an f-string or string concatenation to display the final message.

1. Using one variable for both inputs: If you overwrite a variable, the previous value is lost. Use one variable for the name and another for the city.
2. Forgetting to include both variables in the output: Double-check that your print statement includes both the user’s name and their city.
3. Mixing up variable names: Make sure the names match exactly when using them - City and city are different.
4. Hardcoding values instead of using variables: The point is to work with what the user inputs, not predefined strings.
5. Poor formatting: Watch spacing and punctuation to keep your output clean and readable.

Think of this as filling out a digital contact form and then summarizing it in one sentence.

1. Ask the user for their name using input()
2. Ask the user for the city where they live
3. Store each answer in its own variable
4. Create a sentence combining the two values using print()
5. Make sure the sentence is grammatically correct and includes both values

• Add a third question about the user’s profession.
• Capitalize the city name using .title().
• Allow the user to re-enter values if any field is left blank.

This exercise shows how to store numeric data in variables and perform arithmetic operations on them. It also strengthens your understanding of type conversion and result formatting.

• Use input() and int() to collect and convert numbers.
• Assign each number to a separate variable.
• Add the numbers and store the result in another variable.
• Display the result using print().

1. Forgetting to convert input to numbers: If you try to add two strings, you’ll get concatenation, not numeric addition.
2. Reusing variable names: Be careful not to overwrite your input variables before calculating the sum.
3. Inconsistent formatting: Output like “Thetotalis17” is hard to read. Use spaces or string formatting.
4. Using vague variable names: Avoid names like a and b. Use first_number, second_number, etc.
5. Missing a print statement: Make sure the result actually shows up - don’t forget the output step!

Treat this task like a calculator: input two values, compute, and show the result. Think clearly through each phase.

1. Ask the user to enter the first number
2. Convert the input to an integer and store it in a variable
3. Repeat the process for the second number
4. Add both numbers and store the result in a new variable
5. Print the final result in a full sentence

• Calculate and display the average of the two numbers.
• Allow decimal inputs using float() instead of int().
• Print a breakdown: “8 + 9 = 17” instead of just the result.

This task focuses on using numeric variables in calculations and applying conditional logic to show different outcomes. You’ll also practice naming and updating variables based on user input.

• Use int() or float() to convert the user’s input to numbers.
• Calculate the difference with subtraction.
• Use if statements to check whether the result is positive or negative.
• Use separate messages for each case.

1. Using strings for arithmetic: Remember to convert input to numbers before calculating. Otherwise, subtraction will fail.
2. Incorrect subtraction order: Don’t mix up spending - money and money - spending. The meaning changes!
3. Not handling overspending: The program should display a warning if the user tries to spend more than they have.
4. Hardcoding output: Always calculate the difference dynamically, based on what the user enters.
5. Inconsistent formatting: Use spaces, punctuation, and clean output messages to keep it readable.

Think of this like a simple money tracker. The logic follows a clear flow from input to decision.

1. Ask the user how much money they have and store it in a variable
2. Ask how much they want to spend and store that too
3. Subtract spending from available money and store the result
4. Use if to check if the result is negative or positive
5. Print a message based on the result (“You have X left” or “You are short by Y”)

• Round the output to two decimal places using round().
• Show a warning if spending exceeds a certain limit (e.g., 100).
• Allow the user to enter multiple purchases and calculate the total spending.

This task shows how variables can be used to store input, apply a formula, and display a formatted result. It also reinforces working with decimal numbers and combining math with string output.

• Convert the input to float() to allow decimal temperatures.
• Use parentheses in the formula to ensure correct order of operations.
• Use an f-string to format both Celsius and Fahrenheit in one sentence.

1. Forgetting type conversion: Without float(), decimal temperatures will be treated as strings, leading to errors in calculations.
2. Incorrect formula usage: Make sure you multiply Celsius by 9/5 before adding 32 - don’t reverse the steps.
3. No formatting in output: Displaying raw numbers without ° symbols or rounding can be confusing to users.
4. Hardcoded Celsius value: Don't assign the value manually - take it from the user input.
5. Overwriting variable names: Keep variables like celsius and fahrenheit clearly named and separate.

This is a simple formula-based transformation. Focus on accurate calculations and user-friendly output.

1. Ask the user to enter a temperature in Celsius
2. Convert the input to a float
3. Use the formula fahrenheit = celsius × 9/5 + 32
4. Store the result in a separate variable
5. Display both the original and converted values in one formatted sentence

• Round the Fahrenheit result to 1 decimal place.
• Add support for converting Fahrenheit to Celsius as well.
• Let the user choose which direction to convert (C → F or F → C).

This task teaches how to store multiple related values in variables and combine them in a calculation. You’ll also practice formatting output and structuring code for clarity. It helps reinforce the habit of using variables for clean, maintainable code.

• Use float() to allow prices with decimals.
• Store each item price in a separate variable.
• Add the variables together to get the total.
• Use round() or formatting to display two decimal places.

1. Forgetting float conversion: Using int() will cut off decimal parts. Always use float() for monetary values.
2. Mixing calculation and print logic: It’s better to calculate the total in one variable and print it separately, not inline.
3. Hardcoding item prices: Always take input from the user instead of assigning fixed values.
4. Skipping formatting: Without rounding, the total might show many unnecessary decimals (e.g., 12.6666667).
5. Using unclear variable names: Avoid generic names like a, b, c. Use item1_price, etc.

Think of this as a digital receipt. You collect prices, calculate the total, and present the result clearly.

1. Ask the user to enter the price of item 1 and store it as a float
2. Repeat for item 2 and item 3
3. Add all three variables to compute the total
4. Round the result to 2 decimal places using round() or f-string formatting
5. Display the result with a dollar sign and message

• Ask how many items the user wants to add and repeat input dynamically.
• Apply a 10% discount if total exceeds $50.
• Add sales tax (e.g., 7%) to the total before displaying it.

This task trains you to combine multiple numeric inputs in a logical context. It also helps build good practices in naming variables, performing aggregation, and giving clear, concise output summaries.

• Ask the user separately about each type of workout.
• Use int() to convert the time to minutes.
• Add the times together in a separate variable.
• Make your output message motivational and well-formatted.

1. Skipping input conversion: If you forget int(), you can’t add the time values together - they’re strings by default.
2. Incorrect addition: Make sure you’re adding all three values - no more, no less.
3. Overwriting variables: If you accidentally use the same name twice, earlier values will be lost.
4. Weak variable naming: Use specific names like running_minutes or cycling_minutes to keep the code readable.
5. Unclear message: Always show the total and context (e.g., “minutes” and the workout theme).

Picture this as a daily fitness log. You collect each session’s duration and present a motivating total at the end.

1. Ask how many minutes were spent running, and store it in a variable
2. Repeat for cycling and strength training
3. Convert all inputs to integers using int()
4. Add the three values and store in total_minutes
5. Print a summary message with the final time

• Convert minutes to hours and minutes (e.g., “1 hour 15 minutes”).
• Add calorie estimation based on minutes and exercise type.
• Store the session in a log (e.g., dictionary or write to file).