Ask Programiz - Human Support for Coding Beginners

In Python, semicolons are optional and are generally not used. You can add one at the end of a line, but it isn’t required.

Feel free to try the code below in the editor on the right (or switch to the Code tab if you’re on mobile):

print("Hello, World!");

You'll see this code works just fine.

And I see you’ve started your Python journey. Nice... If you have more questions along the way, just let me know.

Hi! Good observation but the summary is actually correct, and the confusion usually comes from how the word immutable is used.

In Python, a set itself is mutable. This means you can add or remove items from a set after it’s created, which is why the table correctly marks Set → Mutable: Yes.

immutable are the elements inside a set. Every item stored in a set must be immutable (for example: numbers, strings, or tuples). This is why you cannot put lists or other sets inside a set.

So to summarize:

• Set (container): Mutable ✅

• Elements inside a set: Must be immutable ✅

If a lesson mentioned that “sets are immutable,” it was likely referring to the elements of a set, not the set itself.

Hope this clears your confusion. Feel free to ask again. I will take a look at the previous lesson too to make sure we are clarifying it properly. Thanks for asking.

Hi Az! That’s a great question, and I really like your mindset of trying to understand why things behave the way they do. This approach is very important when learning programming, keep it up.

To answer your question, in Java, the data types of the operands used in an operation determine how the calculation is performed.

In this code:

class Main {
    public static void main(String[] args) {

        int number = 12;
        int result = number / 8;
        System.out.println(result);
    }
}

Both number and 8 are of type int. Because of this, Java performs integer division.

Integer division removes the decimal part, so 12 / 8 is evaluated as 1, which is why the output is 1.

Even if you store the result in a double, the calculation still happens using integers:

int number = 12;
double result = number / 8;
System.out.println(result); // prints 1.0

Here, the division produces 1 first, and then Java converts it to 1.0 when assigning it to the double.

To get a decimal result like 1.5, at least one operand must be a double before the division and data type of variable used as result should be double too:

class Main {
    public static void main(String[] args) {

        int number = 12;
        double result = number / 8.0;
        System.out.println(result); // 1.5
    }
}

Here, 8.0 is a double, so Java uses floating-point division and preserves the decimal value.

Hope that helps. Feel free to reply here or in any other topics if you have doubts.

Hello! enumerate() is just a simple Python helper that lets you loop through a list and get two things at once:

1. the index (position) of an element

2. the value (the actual item) of the element

Example:

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

for index, fruit in enumerate(fruits):
    print(index, fruit)

Output:

0 apple
1 banana
2 cherry

So instead of manually keeping a counter yourself, Python does it for you.

And I see that you've asked this question based on the code below:

def two_sum(num_list, target_value):
    
    dictionary = {}

    for index, value in enumerate(num_list): 
        # add items of num_list to dictionary
        # value as key and index as value
        dictionary[value] = index
    
    for i in range(len(num_list)):
        complement = target_value - num_list[i]
        
        # check if item's complement is present in dictionary
        if complement in dictionary and dictionary[complement] != i:
            
            # return element index and complement's index
            return [i, dictionary[complement]]
    
num_list = [2, 7, 11, 15]
target_value = 9

result = two_sum(num_list, target_value)
print(result)   

In the two_sum() function, enumerate(num_list) is used because you need both the number and where it sits in the list (its index) to store and return the answer.

Hope that helps. Feel free to ping if you need more help or have any more questions.

If the table already exists but the columns are different, CREATE TABLE IF NOT EXISTS won’t try to “fix” or update anything. It simply checks: does a table named Customers already exist? If yes, it stops right there.

So what this really means is:

• No error is thrown

• No changes are made

• The existing table stays exactly as it is, even if your new CREATE TABLE statement has different columns

If you actually want to change the table’s structure (add/remove columns, change data types, etc.), you’d use something like ALTER TABLE, or you’d drop and recreate the table if that’s appropriate for your setup.

Hope that helps. Feel free to reach out if you have any more questions.

If you try to write two print() statements on the same line, Python needs a clear separator between them. Without one, Python won’t know where the first print() ends and the next one begins, so you’ll get a syntax error.

For example, this won’t work:

print("Hello") print("World")

But this works perfectly, because the semicolon ; separates the two commands:

print("Hello"); print("World")

You’ll see:

Hello
World

Hope that helps. Feel free to ping if you need more help or have any more questions.

Hello there, good question.

Yep, it still works the same. input() always takes what the user types and gives it back as a string. Adding something like input("Enter temperature in Celsius: ") only shows a message on the screen. It doesn’t change how the value is stored.

So:

• x = input() → x is a string

• x = input("...") → x is still a string

That’s why we usually do float(input()) here, so you can actually do the Celsius-to-Fahrenheit math.

Feel free to reach out if you have any more queries.

Hello there!

Indentation is a common pain point in Python because it’s not just style, it’s part of the syntax. A few rules will save you a lot of errors:

• For blocks that end with : (like if, for, while, def), the very next line must be indented.

• Everything inside that block must line up at the same indentation level.

• Nested blocks go one level deeper (usually 4 spaces).

• Don’t mix tabs and spaces. Pick one (4 spaces is the standard) and stick to it.

Example:

for i in range(1, n + 1):      # level 0
    if i % 2 == 0:             # level 1
        continue               # level 2 (inside the if)
    print(i)                   # level 1 (outside the if)

If you keep getting errors, it’s usually one line that’s slightly misaligned or tabs are sneaking in. Feel free to reach out if you have any more queries.

Hello there, good question.

Yes, Python does have some pretty standard naming conventions, and following them makes your code way easier to read (especially when you come back to it later).

• Use clear, specific names

  • Good: favorite_food, total_price, student_count

  • Not so good: x, temp, data (unless it truly is temporary or generic)

• Use snake_case for variables

  • Python style is lowercase words separated by underscores (known as snake_case):

  • favorite_food instead of favoriteFood

• Don’t use Python keywords

  • You can’t name variables things like class, def, if, for, etc.

  • If you really need something close, people often do: class_ (with an underscore at the end)

• Be consistent with casing

  • Python treats score, Score, and SCORE as different names.

  • Most variables stay lowercase: score, high_score, max_score

• Special naming patterns you’ll see a lot

  • Constants (values you don’t plan to change): MAX_SPEED, PI, TAX_RATE

  • “Private” / internal use (a hint to other programmers): _hidden_value

  • Avoid names that look like built-ins: don’t name a variable list, str, or sum (you’ll overwrite the built-in function by accident)

If you stick to descriptive names + snake_case, your code will instantly look more professional and be easier to understand.

Feel free to reach out if you have any questions.

Hello Woi Shingo! The </code> tag includes the <code>name</code> attribute to identify the data that the text area collects when the form is submitted. This is a common aspect of form elements, which are grouped together within a form tag.</p><p>When a form is submitted, the values of the form inputs are sent to the server. The <code>name</code> attribute gives a unique identity to each input, helping the server distinguish between the different pieces of data.</p><p>For example, in your current HTML code:</p><pre><code class="language-html"><form action="/html-form-submit" method="post"> <label>Write a movie plot.</label><br> <textarea name="plot" rows="3" cols="40">

Here, name="plot" tells the server that whatever text the user enters into the text area should be associated with the plot identifier once the form is submitted.

Consider this scenario:

Imagine needing to capture both a movie title and its plot in a form. You might adjust your code to look like this:

    Movie Title:

    

    Write a movie plot:

    

Here, you'd have two inputs each with a different name:

1. name="title": captures the movie title.

2. name="plot": captures the movie plot.

When this form is submitted, the server will know exactly which text is the title and which is the plot.

Hope this helps make sense of the name attribute! Let me know if you have more questions, or if there's anything else you'd like to understand better. 😊