Since you already know how range() works, let’s look at an example to understand how the step argument works.

Consider this code:

print(list(range(1, 6)))

Output

[1, 2, 3, 4, 5]

Here, the list goes up by 1 each time by default.

Now let’s add 2 as the step:

print(list(range(1, 6, 2)))

Output

[1, 3, 5]

In this case, the list still starts at 1, but it jumps by 2 instead of 1.

So, the step argument simply controls how much the value increases by in each step.

Let me know if you need more clarification on this.

When you do range(1, 7), it gives you numbers starting from 1 up to but not including 7. So it stops at 6.

It’s not about indexing exactly — that’s just how range() works in Python. The second number is treated as the "stop point", and it’s excluded from the result.

Let me know if you need more explanation on this. I'm happy to help.

When performing arithmetic operations in Python, the result will be a floating-point number if you use the / operator for division. For example, 5 / 2 will give you 2.5.

If you're using operations like addition (+), subtraction (-), or multiplication (*), the result will be in floating-point only if any of the values involved are floating-point numbers. For example, 5 + 2.2 will give you 7.2.

If you use the // operator for integer division, like 5 // 2, the result will be an integer (in this case, 2).

This distinction helps you get the result you expect, depending on the type of operation and the numbers involved.

HTML tags are like labels that tell the browser what each part of a webpage is.

For example, if you want to show a heading, you use a heading tag like this:

Apples

The

tag tells the browser that the text Apple is a heading and it should be big and bold.

Tags usually come in pairs: an opening tag like

and a closing tag like

Tags not visible on the page—just instructions for how to show things. Only the content is visible.

As you continue with the course, you'll learn plenty of tags, each with their own purpose.

The key thing to note is that lists, tuples, and dictionaries are simply different ways to store data. Which one you choose depends on what you need your program to do.

That said, here are the major differences between them:

List: An ordered collection that can be changed (mutable).

my_list = [1, 2, 3]

my_list[0] = 10    # You can change items

print(my_list)    # Output: [10, 2, 3]

Tuple: Also ordered, but cannot be changed (immutable).

my_tuple = (1, 2, 3)

# my_tuple[0] = 10    # This would cause an error

print(my_tuple)    # Output: (1, 2, 3)

Dictionary: Stores data as key-value pairs, and you access values using keys.

my_dict = {"name": "Ali", "age": 25}

print(my_dict["name"])    # Output: Ali

my_dict["age"] = 26    # You can update values

So, lists and tuples store values by position — but only lists can be changed. Dictionaries store data using keys, which makes them great when you want to label and quickly access your data.

Let me know if you need more clarification on this.

The purpose of printing output — like using cout in C++ — is to display something on the screen so you can see what your program is doing.

It helps you understand if your code is working as expected, especially when you're learning. Think of it as a way for your program to "talk" to you.

To master the breaking conditions in recursion, you need to understand these two things first:

1. figuring out when the function should stop (usually with an if check),

2. and making sure it actually stops — usually with a return.

After this, you need to ask yourself "what's the smallest or simplest case where I don’t need more recursion?". This will serve as your base case. Then make sure the function hits that eventually.

It gets easier the more you practice. Try simple stuff like factorial or summing numbers — they help you build that instinct.

camelCase is a way of writing names where each new word starts with a capital letter, and there are no spaces or underscores. Example: myVariableName, firstName, lastName, and totalCount.

However, in Python, we usually prefer using snake_case (like my_variable_name) for variable names, where each word is separated with an underscore (_). Still, it's helpful to know what camelCase is, since you might come across it in other languages or examples.

You’ll learn more about variable naming toward the end of this chapter, which should make things clearer.

Let me know if anything’s unclear.

Simply put, main() is the starting point of every C program. When you run your code, execution always begins from main()

As you progress with your coding journey, you'll get a clearer understanding of what main() is and how it works.

Let me know if you have any more questions. I'm happy to help.

First of all, if you're new here, welcome!

Let me give you a quick introduction to our website, Programiz PRO.

Programiz PRO is a platform designed to teach programming to complete beginners. We offer courses in several programming languages, including Python, JavaScript, and C.

Our approach focuses on hands-on learning. Each course walks you through key concepts step by step, followed by practice exercises and quizzes to reinforce what you've learned. We also use helpful illustrations to make things easier to understand, and the platform includes several tools to support you throughout your learning journey.

One of those tools is this feature, where you can directly reach out to Programiz experts if you have questions while going through the course.

Feel free to reach out if anything is unclear or if you’d like help with something. I'm happy to help.