Ask Programiz - Human Support for Coding Beginners

Hi there!

Time complexity is a way to understand how an algorithm's runtime increases as the input size grows. It helps us compare the efficiency of different algorithms, especially in terms of speed.

You’ve probably seen that some methods are faster than others—time complexity lets us describe and analyze those differences using big O notation (like O(n), O(log n), etc.).

By learning time complexity, you'll be able to write more efficient code, which becomes crucial as the problems you tackle get larger. Hope that helps! Feel free to ask if you have more questions.

Hi Abhishek!

For starters, we believe that anyone can code; all you need is study and practice.

Transitioning from electrical engineering to the computer science sector can be a good move. Your electrical engineering background is actually a huge advantage; you already know how to break down complex problems.

As for whether coding is the right fit for you, consider this:

It looks like you've just started the Python Basics course. Continue through it, take the time to practice writing code, and see how you feel about it. If you enjoy solving problems and building projects, that's a good sign that coding could be a fulfilling path for you.

Let me know if you have any more questions or need guidance along the way. I'm here to help!

Oh, and one last thing - if you're willing to put in the time, if you're willing to study and practice, there's absolutely no reason why someone from your background can't excel in coding.

So, in Python, you don't need to use curly braces {} when printing a variable like this:

name = input("Enter your name: ")
print("Your name is", name)
    

That works because print() can take multiple things, separated by commas. It just puts spaces between them automatically, so you don't have to do anything fancy.

Now, curly braces do show up when you're using something like an f-string. That looks like this:

print(f"Your name is {name}")
    

In that case, the {name} is inside the string, and Python replaces it with the actual value of the name variable — but only because the string starts with an f.

So yeah, curly braces are just for special formatting stuff like f-strings. If you're just printing normally with commas, you don’t need them at all.

Whitespaces are just empty spaces in your text.

For example:

text = "  Hello  "

This has extra spaces before and after Hello.

Those extra spaces are called whitespaces.

We usually remove them to make the text look clean.

In programming, input simply means getting information from the user.

As you progress through the course, you'll learn how to take input in Python and use it in your programs.

Let me know if anything is unclear or if you'd like to explore this further.

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.

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.

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.