Python Basics

In the last chapter, we learnt how to set up Python on our computer, and run scripts written in it in given IDEs — IDLE and PyCharm.

In this chapter, we'll explore the general syntax of Python and some of the most used aspects of it such as printing stuff, receiving user input, working with variables and so on. The aim is to get a hands-on experience of Python, and in this way also get experience of working with our respective IDE.

Let's begin the show!

Almost always, the first thing a learner of a programming language is taught is how to 'print' stuff in the language. That is, how to generate output using the programming language.

Printing in Python is superbly easy as compared to languages like Java that require a big boilerplate to be first set up in order to print the shortest of messages.

In Python, we just call the print() function with whatever we want to output.

Now there might be many questions in your mind right now such as 'why are there () after print', or 'what is a function', or 'what is meant by calling a function'. For now, let's first see a couple of examples of using print() and then move over to explain it thoroughly.

Below we make one of the most conventional programming outputs i.e. 'Hello World!' in Python:

print('Hello World!')

Time to understand a couple of things...

This completes the explanation of your first Python code! Did you understand everything?

Frankly speaking, in this beginning stage of learning Python, it's not important for everything to make perfect sense. What's important is that you keep track of all the new concepts learnt, try your level best to understand their outskirts.

If you don't understand any concept fully, don't worry. As you progress through this course, everything would come naturally to you.

Anyways, let's print something else:

print('Hello World!')
print('This is my first Python code!')
print('Python is easy.')

Here, we call print() three times to output three different lines of text.

Note that the spacing of the print() statements in the code won't affect the spacing in the output.

For example, consider the code below:

print('Hello World!')

print('This is my first Python code!')


print('Python is easy.')

This time, there is a blank line between the first and second print() statements and two blank lines between the second and third print() statements. Regardless, these don't show up in the final output.

Why?

This is because, very obviously, the Python code is not part of the output — it gets parsed and executed; that's it. The print() statement, which is part of the code, is what governs the output. Whatever it provided to it is what's shown in the output. After how many lines does print() come, that doesn't matter!

Moving on, as we've been seeing right now, passing one argument to print() outputs that argument onto the shell. But we can give the function more than one argument.

But how?

The print() function can be passed multiple arguments, separated by commas (,). When multiple argument are given, they are output with a space between them.

Consider the following code:

print('Hello', 'World', '!')
print('Language:', 'Python')

In the first print() statement, we provide three args to the function. All of these get output in the shell with a space between them.

Similarly, in the second print() call, we provide two args to the function and they too get output with a space between them.

As we'll see later on, this can be extremely handy when we want to print stuff other than plain text, such as numbers, Booleans, lists, etc.

Let's now do some math. Recall addition, subtraction, multiplication and division from school days? What about basic algebra?

Below we'll perform these simple operations on given numbers using Python.

To represent any number, just type the number as is. For example, to denote the number 10 we would write exactly 10 in the shell.

The + plus symbol is used to add together two numbers. Consider the following shell snippet:

Similarly, the - minus symbol is used to find the difference between two numbers. It subtracts the second number from the first number and returns the result:

Numbers with a decimal point, known as floating-point numbers or simply floats, are also available in Python (and almost all other programming languages):

In the snippet below we work with a couple of floats and integers:

Moving on, to multiply two numbers together we use the * asterisk symbol (NOT the x character, which is usually used in mathematics!):

Division is done using the / forward slash symbol:

Akin to most programming languages, Python provides a way to calculate the remainder when a given integer is divided by another integer.

That is using the % percent symbol, also referred to as the modulus operator.

5 % 4 returns 1, because when 5 is divided by 4, the remainder left is 1.

print(5 + 10)
print(2 * 4 + 2)
print(150 % 2)
print(10 / 2.5)

Recall from mathematics that when we have an expression with multiple operators in it, there is a set of rules as to which do we perform first. Would we perform division first, or addition first?

This set of rules exists in Python as well. We call this operator precedence.

Shown below are the operators we saw above, arranged by their level of precedence, from highest precedence (computed first) to lowest precedence (computed last):

What this means is that division/multiplication/modulus operations are performed before any subtraction/addition operations.

Consider the following code:

One way to override this precedence, which is also commonly employed in mathematics, is to use parentheses i.e (), to group expressions that are desired to be computed first.

Below we have the shell script as before, but this time with our choice of order of computation:

If you've ever done algebra, you would be familiar with the term variables. They are simply placeholders for given values, and can vary (as the name 'variable' implies).

In programming as well, we have these things to perform exactly the same function — hold values.

In Python, we create a variable simply by typing in its name that we have in our mind followed by an equals = sign followed by the value we wish to put in the variable.

A lot of steps? Let's create one variable...

Suppose we want to create a variable x with the value 30. To do so in Python, we'd do the following:

x = 30

First comes the name x, followed by an equals sign (=), followed by the value 30.

This short script creates a variable named x and assigns to it the value 30. Now like any other value, we can use this variable in expressions, operations and so on.

Consider the code below:

A variable can store anything.

Recall the piece of text we sent to print() in the section above. In programming, a piece of text, with quotes surrounding it, is known as a string. Like numbers, a string is a type of data in Python and can therefore also be put inside a variable.

Below we create a variable msg, put the string 'Hello World!' in it and finally print this variable:

msg = 'Hello World!'
print(msg)

Note that print(msg) won't print 'msg' in the shell, but rather the value of the variable msg.

Working with a variable is exactly the same as working with the value itself. It's that simple, but at the same time, a principle idea.

We'll discover a lot on variables in the coming chapters. For now, you shall be comfortable with the idea of variables and how are they created.

x = 10
y = 30
print(x, '+', y, '=', x + y)

Getting input is a crucial part of today's modern computing. It's a means of getting data from the user of a machine and then processing that data for a corresponding consequence.

Most programming languages have some sort of method to collect a user's input. Python is no way behind.

To get input from the user, we can use the input() function.

Let's see how to work with it.

input()

As soon as input() is called, focus moves to the shell and a cursor is displayed asking you to type in something. Let's go forward and type the word Hello:

input()

After typing Hello, when we press the Enter key, the input() function completes, and the value input is displayed as an output:

input()

The whole input() expression gets replaced by whatever value is input by the user — in this case 'Hello'.

You can call it with an optional argument, which is output to the user explaining what input is desired.

Below we ask the user for his/her name:

input("What is your name? ")

The moment the input() function is called, execution stops until the user inputs some data and then presses Enter. The execution of the input() function will complete and return with the value input by the user.

When a function returns a value, you can think of its calling expression being replaced by the return value.

For example, as we've stated, input() returns the value input by the user, so if let's say we enter "Ben", then the call to input() would be replaced by the value "Ben"

This means that the function could be called as part of a variable's assignment expression, as follows:

name = input("Enter your name: ")
print('Hello', name)

First Python creates a variable name and then executes the input() function. Next 'Alex' is entered in the shell. The whole expression input("Enter your name: ") gets replaced by the string 'Alex' which ultimately gets assigned to name.

Finally, print('Hello', name) is executed, which outputs 'Hello Alex'.

At this stage, even such a simple piece of code would look like some complicated business, but that's perfectly natural.

It takes time to understand things '' as soon as you do understand these basic building blocks of Python, such scripts might end up in your recycle bin since you would consider them too simple to be even a simple piece of code!

In the section above, we've seen strings a couple of times; specifically in the print() function and in the input() function.

Let's learn more about strings...

A string is how we represent a literal piece of text in a piece of code.

There are a handful of ways to denote a string in Python. For now, we'll cover the two most simple and most common ways:

1. Using a pair of single quotes ('')
2. Using a pair of double quotes ("")

In the code below, we create two strings using both these notations and save them in the variables a and b, respectively, followed by printing them:

a = 'Hello World!'
b = "This is Python."

print(a)
print(b)

As can be seen here, the quotes used in either of the strings are just a means of denoting a given piece of text — they themselves aren't included in the string and, hence, not even in the output of the string.

Simple.

Moving on, one very important thing to keep in mind is that a string denoted using single quotes can NOT have single quotes in itself. The same goes for double quotes.

When a character that's used to denote a string appears, as it is, inside the string, the Python engine misunderstands this character as the end of the string.

Likewise, anything that follows from this point onwards is considered as Python code, NOT as the string's data. Since what follows is usually invalid Python code, this ultimately leads to an error.

This is demonstrated below:

s = 'Let's write some code!'

Here, the string we meant to write was "Let's write some code!", but that is not what the engine sees.

What the engine sees is just the string 'Let'. This is because the string starts at the first ' character and then ends at the next one. The next ' turns out to occur in the string itself, hence it gets terminated before it was meant to.

What follows after this point is Python code (in the case above, it's s write some code!'), and because it's clearly invalid code, an error is thrown:

If we carefully look at the error message here, it says that the code has an invalid syntax. Most importantly, it even traces the exact point where the syntax is illegal using the ^ character pointing upwards at the illegal code segment.

So to boil it down, using the same character as the one used to denote a string is invalid in Python, and in almost all programming languages.

One simple way to mitigate such a problem is to use the other type of quote to denote the string.

For instance, going with the piece of text "Let's write some code", we could denote a string holding this text as follows:

s = "Let's write some code"
print(s)

The text contains a single quote ('), therefore we use a pair of double quotes ("") to denote the string.

If it was the other way round, i.e. the text contained a double quote (") in it, we'd use a pair of single quotes ('') to denote the string, as shown below:

s = 'He said, "I love you!"'
print(s)

Simple, isn't this?

From this point onwards, whenever denoting a string, we'll use single quotes ('').

This is because they are more readable than double quotes ("") and a bit easier to type i.e. we don't have to hold on to the Shift key and then enter ' to type a ", but rather just press ' to type '.

Moving on, two strings can be joined together into one single string using the + symbol.

As we saw above, when used on numbers, + adds the numbers together. However, when used on strings, it joins the strings together.

In programming terminology, the joining of two strings is referred to as concatenation.

In the code below, we concatenate the two strings 'Hello' and ' World!' together to obtain the complete string 'Hello World'.

'Hello' + ' World!'

Keep in mind that concatenation doesn't introduce spaces on its own between the joined strings — we have to do this ourselves. This can be seen as follows:

'Hello' + 'World!'

We concatenate 'Hello' with 'World!' (without a space at its beginning) and hence get 'HelloWorld' as the resulting string.

To include a space between both the words here, we can put a space at the end of the first string or at the start of the second string, as shown below:

'Hello ' + 'World!'

'Hello' + ' World!'

Let's apply some of the concepts that we've learnt so far in creating an elementary, yet interesting program.

name = input("What's your name?")
print('Hello ' + name + '!')