Syntax

This task helps you understand the syntax for calling functions like input() and print(), how to work with strings, and how indentation affects the readability and correctness of code. You’ll also get comfortable with combining literal text and user-provided data in output.

• Use input() to get the user’s name.
• Store it in a variable.
• Use print() to display a personalized message.
• Don’t forget the quotation marks and colons.

1. Forgetting parentheses in print or input: In Python 3, both print() and input() require parentheses. Skipping them leads to syntax errors.
2. Not storing user input in a variable. Without saving the input, you won’t be able to use it in the greeting message.
3. Incorrect string formatting. Beginners often forget how to properly include a variable inside a string or accidentally use wrong concatenation methods.
4. Indentation errors. Accidentally indenting a line that doesn’t need it can result in unexpected errors or behavior.
5. Case sensitivity. Python is case-sensitive. Using Print instead of print will throw a NameError.

Before you write the code, think about how a conversation with a user works. You ask for information, store it, and then use it in a reply. That’s exactly what your program should do.

1. Ask the user to enter their name using input()
2. Store the result in a variable (e.g., name)
3. Use print() to output a greeting message
4. Combine the static greeting text with the dynamic user name
5. Make sure the code is syntactically correct and well-formatted

• Add a second input asking for the user's age and include it in the message.
• Format the greeting to appear in all uppercase or all lowercase letters.
• Add validation: if the user leaves the name blank, prompt again.

This task focuses on using arithmetic operators, type conversion from string to integer, if-else conditions, and how to write readable control flow using proper Python syntax. It also introduces beginners to the concept of remainder-based logic.

• Use input() to get the number as a string, then convert it to an integer using int().
• Use the modulo operator % to check if a number is divisible by 2.
• Remember: if number % 2 == 0 means the number is even.

1. Forgetting to convert input to an integer. input() always returns a string. Trying to use % on it will throw a TypeError.
2. Using = instead of == in conditionals. A single = assigns a value, while == checks equality.
3. Incorrect modulo logic. Some learners check number % 2 == 1 for odd, but forget the case for zero or negative numbers.
4. Bad indentation in the if block. Inconsistent indentation will lead to syntax errors or unintended logic.
5. Hardcoding numbers instead of using input. The whole point is to respond dynamically to what the user provides.

When solving this, break it down into clear steps. Don’t jump straight into coding - think like a programmer.

1. Prompt the user to enter a number
2. Convert the input to an integer
3. Use the modulo % operator to check if the number is divisible by 2
4. If number % 2 == 0, print “Number is even”
5. Else, print “Number is odd”
6. Make sure every line is properly indented and clear

• Add error handling: what if the user enters something that’s not a number?
• Handle negative numbers and zero explicitly.
• Add a loop that repeats the question until the user types “exit”.

This task teaches how to accept multiple inputs from a user, perform arithmetic calculations, and use if/elif logic to branch behavior. It also reinforces string-to-integer conversion, formatting output, and controlling program flow based on user input.

• Use input() to get numbers and the operation symbol from the user.
• Convert input strings to integers using int().
• Use if and elif to determine the chosen operation.
• Always show the result using print().

1. Forgetting to convert input to integer. If you try to add or subtract strings, Python will raise a TypeError. Always use int() or float() before calculations.
2. Using = instead of == in conditions. = assigns a value, while == checks equality. Using the wrong one will result in a syntax error or incorrect logic.
3. Not validating the operation. If the user enters something unexpected like *, your program might behave incorrectly or crash.
4. Improper indentation. Python requires consistent indentation. An extra space or missing tab can cause errors or change the program flow.
5. Missing a fallback message. If none of the if/elif branches match, the program should still respond with something like “Invalid operation”.

Let’s break the task into clear steps. Focus on handling input and control flow in a structured way.

1. Ask the user to enter the first number using input()
2. Ask for the second number in the same way
3. Ask the user to choose an operation: + or -
4. Convert both inputs to integers using int()
5. Use if and elif to perform the correct operation
6. Display the result using print()
7. Optionally, use else to handle unexpected operation input

• Support multiplication and division operations too.
• Handle division by zero with an error message.
• Use float() instead of int() to allow decimal numbers.

This task reinforces the use of loops, arithmetic, and variable initialization. It helps you understand the flow of iteration and how to accumulate values using a for loop. It also improves your ability to write clean, sequential logic with consistent indentation.

• Start with a sum variable initialized to 0.
• Use a for loop to iterate from 1 to N (inclusive).
• In each loop iteration, add the current number to sum.
• Print the final value after the loop ends.

1. Using the wrong range. Remember that range(N) goes from 0 to N-1. To include N, use range(1, N+1).
2. Not converting input to integer. input() returns a string, and using it in range() without int() will cause an error.
3. Printing inside the loop. This will print intermediate values instead of just the final result.
4. Reusing reserved keywords like sum as variable names. Avoid naming variables after built-in functions to prevent unexpected behavior.
5. Incorrect indentation of the loop body. All statements that should run in the loop must be properly indented.

This task can be broken down into a predictable pattern. Think of what you want to repeat, and how to keep track of the total as numbers increase.

1. Ask the user to input a positive number N
2. Convert the input to an integer using int()
3. Initialize a variable like total = 0
4. Use a for loop to iterate from 1 to N (inclusive)
5. On each iteration, add the current number to total
6. After the loop ends, print the final value of total

• Reject negative numbers or zero with a proper error message.
• Allow the user to choose whether to sum even numbers only, odd numbers only, or all numbers.
• Add support for repeating the task multiple times until the user types “exit”.

This task teaches how to compare strings properly, use conditional logic with multiple variables, and control access with basic validation rules. You'll also learn how to apply case-insensitive comparison and structure your code cleanly.

• Use input() to collect both username and password.
• Convert the username to lowercase using .lower() before comparing.
• Compare the password without changing its case.
• Use an if statement with and to check both conditions.

1. Case-sensitive username check. If you compare username == "admin" without lowercasing, users typing “Admin” will be rejected. Use username.lower().
2. Checking only one of the two fields. You must verify both username and password. Skipping one condition can lead to faulty access logic.
3. Storing passwords in plain text (even for demos). While fine here, it’s a bad habit in real applications. Later, learn about hashing.
4. Improper indentation in condition blocks. Keep your logic blocks properly nested and cleanly indented.
5. No fallback response. Make sure there’s an else that clearly tells the user access was denied.

You want to check if a user is allowed to log in. First, collect the necessary data, then validate each condition carefully.

1. Ask the user to enter a username and a password using input()
2. Convert the username to lowercase using .lower()
3. Use if to check if the username equals admin and the password equals 12345
4. If both are correct, print “Login successful!”
5. If not, print “Invalid credentials”
6. Make sure your logic is clear and indentation is consistent

• Allow the user up to 3 attempts before blocking further input.
• Store valid credentials in a dictionary and check them dynamically.
• Simulate a login system where the user can register first, then log in.

This task helps you collect multiple inputs, store them in variables, and present the data in a clean formatted output. It emphasizes consistent structure, user interaction, and basic string formatting.

• Use input() three times to ask each question.
• Store each answer in a clearly named variable.
• Use a single print() statement to summarize all the information.
• You can use f-strings for cleaner formatting.

1. Asking unclear questions. The user may not understand what to type. Make sure each prompt is clear and specific.
2. Printing each result separately. This makes the program less clean. Combine all the information into one final sentence.
3. Not converting age to integer (if used for calculation). If you plan to do math with age, convert it using int(). Otherwise, keep it as a string.
4. Misspelled variable names. Make sure the names are consistent throughout the program.
5. No spacing or formatting in output. Use spacing and punctuation to make the final sentence easy to read.

Think of this as a mini form. Ask clearly, store answers, then display a short profile summary.

1. Ask the user to enter their name and store it
2. Ask for favorite color and store it
3. Ask for age and store it
4. Use a formatted string to combine all answers into one sentence
5. Display the final summary with print()

• Validate that age is a number before accepting it.
• Store the answers in a dictionary and format output from the dictionary.
• Export the results to a text file using the open() function.