For the sake of simplicity, imagine a program that opens a file, writes something to it, and then closes the file.

One way to implement this program in Python would be like this:

def main():
    my_file = open('books.txt', 'w')
    my_file.write('If Tomorrow Comes by Sidney Sheldon')
    my_file.close()


if __name__ == '__main__':
    main()

Given that you run this program with the right permissions on your computer, it'll create a file called books.txt and write If Tomorrow Comes by Sidney Sheldon in it.

The open() function is one of the built-in functions in Python. It can open a file from a given path and return a corresponding file object.

A file object or file-like object, as it's often called, is a useful way to encapsulate methods like read(), write(), or close().

The write() method can be used write/send bytes-like object to an open stream, like a file.

Whenever you open an external resource, you must close it when its no longer needed, and the close() method does just that.

This program is functional, but it has a big flaw. If the program fails to close the file, it will remain open until the program itself closes.

You see, every program that you run on your computer gets a finite amount of memory allocated to it. All the variables you create or external resource you open from a program stay within the memory allocated to it by your computer.

If a program like this one, keeps opening new files without closing the previous ones, the allocated memory will keep shrinking.

At one point the program will inevitably run out of memory and crash ungracefully. This problem is referred to as a memory leak.

One way to prevent this from happening in Python is using a try...except...finally statement.

def main():
    my_file = open('books.txt', 'w')

    try:
        my_file.write('If Tomorrow Comes by Sidney Sheldon')
    except Exception as e:
        print(f'writing to file failed: {e}')
    finally:
        my_file.close()


if __name__ == '__main__':
    main()

The code inside the finally block will run no matter what. So even if the program fails on the right action, it'll still be executed.

So, this solves the problem but imagine writing these lines of code every time you want to write something to a file.

It's not very reusable. You will have to repeat yourself a lot and chances of skipping a portion of the if...except...finally ladder is also a possibility.

That's where context managers come in.

What is a Context Manager in Python?

According to the Python glossary, a context manager is —

An object which controls the environment seen in a with statement by defining __enter__() and __exit__() methods.

That may not be noticeably clear to you. Let me explain the concept with an example.

The with statement in Python lets you run a block of code within a runtime context defined by a context manager object.

Once the block of code has finished executing, the context manager object will take care of tearing down any external resources that are no longer needed.

You can rewrite the program by using the with statement as follows:

def main():
    with open('books.txt', 'w') as my_file:
        my_file.write('If Tomorrow Comes by Sidney Sheldon')


if __name__ == '__main__':
    main()

Since the open() function is paired with a with statement in this example, the function will create a context manager.

The file object will be accessible within the context of the indented code block, which means the file object doesn't exist outside of that scope.

The as keyword is useful when you want to assign a target variable to a returned object. Here, the my_file variable is the target and will hold the file object.

You can do whatever you want within the indented block of code and don't have to worry about closing the file.

Because once the block of code has finished executing the context manager will close the file automatically.

So, you have rewritten the entire try...except...finally ladder within two lines of code using the with statement and a context manager.

But how does that happen? How does a context manager object handle the task of setting up and closing resources?

And where are those __enter__() and __exit__() methods you read about on the Python documentation glossary?

Well, I'm so glad you asked :-)

How To Create a Custom Context Manager in Python

The American theoretical physicist, Richard Feynman famously said —

What I cannot create, I do not understand.

So, to understand the functionalities of a context manager you must create one by yourself and there are two distinct ways of doing that.

The first one is a generator-based approach and the second one is a class-based approach. In this section, I'll teach you both.

But before that, let me you a complex example that does more than merely opening and closing files in Python.

Imagine another Python application that must communicate with an SQLite database for reading and writing data.

You can write that program as follows:

import sqlite3

create_table_sql_statement = 'CREATE TABLE IF NOT EXISTS books(title TEXT, author TEXT)'
insert_into_table_sql_statement = "INSERT INTO books VALUES ('If Tomorrow Comes', 'Sidney Sheldon'), ('The Lincoln Lawyer', 'Michael Connelly')"
select_from_table_sql_statement = 'SELECT * FROM books'


def main():
    database_path = ':memory:'

    connection = sqlite3.connect(database_path)
    cursor = connection.cursor()

    try:
        cursor.execute(create_table_sql_statement)
        connection.commit()

        cursor.execute(insert_into_table_sql_statement)
        connection.commit()

        cursor.execute(select_from_table_sql_statement)

        print(cursor.fetchall())
    except Exception as e:
        print(f'read or write action to the database failed: {e}')
    finally:
        connection.close()


if __name__ == '__main__':
    main()

# [('If Tomorrow Comes', 'Sidney Sheldon'), ('The Lincoln Lawyer', 'Michael Connelly')]

This Python program establishes a connection with an SQLite database. Then it creates a new table called books with two TEXT columns named title and author.

The program then stores information about three books on the table, retrieves them from the database, and prints out the retrieved data on the console.

As evident from the output of the print() statement, the program has successfully saved and retrieved the given data from the database.

There are three SQL queries in this program responsible for the database actions I just described.

create_table_sql_statement = 'CREATE TABLE IF NOT EXISTS books(title TEXT, author TEXT)'
insert_into_table_sql_statement = "INSERT INTO books VALUES ('If Tomorrow Comes', 'Sidney Sheldon'), ('The Lincoln Lawyer', 'Michael Connelly')"
select_from_table_sql_statement = 'SELECT * FROM books'

I've kept these three lines of code at the top of the file to keep the main() function to cleaner. The rest of the program sets up the database and executes the queries.

Python comes with excellent support for SQLite databases, thanks to the sqlite3 module encapsulating useful methods such as the sqlite3.connect() method.

This method takes the path to a database as a string, attempts to establish a connection and in case of success, returns a Connection object.

If you pass :memory: instead of a file path, the program will create a temporary database on your computer's memory.

Once you have a connection, you'll need a Cursor object. A cursor object is a layer of abstraction required for executing SQL queries.

The cursor() method encapsulated within the Connection object returns a new cursor to the connected database.

Inside a try block, you can attempt to execute whatever query you want using the execute() or executemany() methods.

    try:
        cursor.execute(create_table_sql_statement)
        connection.commit()

        cursor.execute(insert_into_table_sql_statement)
        connection.commit()

        cursor.execute(select_from_table_sql_statement)

        print(cursor.fetchall())

You need to call the connection.commit() method every time you write something to the database. Otherwise, the changes will be lost.

Data returned from a database remains within the cursor object and you can access them using the cursor.fetchone() or cursor.fetchall() methods.

In case of a failure, the except block will be triggered. The finally block will run unconditionally and close the database connection in the end.

This is fine and functional but like I've already said, it's not very reusable and is error prone.

Unfortunately, or in our case fortunately Python doesn't come with a built-in context manager for handling connections with SQLite databases.

So, let's try and see if we can produce one ourselves.

How to Create a Class Based Context Manager in Python

To write a class-based context manager in Python, you need to create an empty class with three specific methods:

class Database:
    def __init__(self):
        pass

    def __enter__(self):
        pass

    def __exit__(self, exc_type, exc_val, exc_tb):
        pass

The first one is obviously the class constructor that doesn't accept any parameter yet. It'll be responsible for accepting a database path:

import sqlite3

class Database:
    def __init__(self, path: str):
        self.path = path

    def __enter__(self):
        pass

    def __exit__(self, exc_type, exc_val, exc_tb):
        pass

The __enter__() method handles the task of setting up the resource. This is where you establish the connection and instantiate the cursor:

import sqlite3

class Database:
    def __init__(self, path: str):
        self.path = path

    def __enter__(self):
        self.connection = sqlite3.connect(self.path)
        self.cursor = self.connection.cursor()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        pass

However you can not return two objects at once so you have to return the instance of the class itself.

Finally, the __exit__() method handles the task of closing the external resource in question.

import sqlite3

class Database:
    def __init__(self, path: str):
        self.path = path

    def __enter__(self):
        self.connection = sqlite3.connect(self.path)
        self.cursor = self.connection.cursor()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is not None:
            print(f'an error occurred: {exc_val}')

        self.connection.close()

You can use this context manager in conjunction with the with statement in your code as follows:

import sqlite3

create_table_sql_statement = 'CREATE TABLE IF NOT EXISTS books(title TEXT, author TEXT)'
insert_into_table_sql_statement = "INSERT INTO books VALUES ('If Tomorrow Comes', 'Sidney Sheldon'), ('The Lincoln Lawyer', 'Michael Connelly')"
select_from_table_sql_statement = 'SELECT * FROM books'


class Database:
    def __init__(self, path: str):
        self.path = path

    def __enter__(self):
        self.connection = sqlite3.connect(self.path)
        self.cursor = self.connection.cursor()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is not None:
            print(f'an error occurred: {exc_val}')


def main():
    with Database(':memory:') as db:
        db.cursor.execute(create_table_sql_statement)
        db.connection.commit()

        db.cursor.execute(insert_into_table_sql_statement)
        db.connection.commit()

        db.cursor.execute(select_from_table_sql_statement)

        print(db.cursor.fetchall())


if __name__ == '__main__':
    main()

# [('If Tomorrow Comes', 'Sidney Sheldon'), ('The Lincoln Lawyer', 'Michael Connelly')]

Evident from the output of the print() function call, the program has successfully stored and retrieved the given data from the database.

Without the with statement, Database is just a plain old class. However, the moment you put with infront of it, the three methods hop into action.

The __init__() method is the initializer and works identically to any other plain Python class's initializer method. It takes the path to the database.

The __enter__() method sets up the connection to the database and returns the instance of the context manager class to the target variable, db in this case.

This target variable is now encapsulating both the connection and the cursor objects. You can access them as db.connection and db.cursor respectively.

Once the code inside the with block finishes running, the __exit__() method will execute and close the active connection to the database.

You can handle any exception that may occur during the execution inside the __exit__() method. If there is an exception, exc_type holds the type of the exception, exc_val holds the value of the exception, exc_tb holds the traceback.

If there is no exception, the three variables will have a value of None. I'll not get into the details of exception handling in this article since that can take on many forms depending on what you're dealing with.

To make this custom context manager accessible from anywhere in the program, you can put it into its own separate module or even package.

This is far better solution than the try...except...finally ladder you saw earlier. You don't have to repeat yourself and chances of a human error is lower.

How to Create a Generator Based Context Manager in Python

Evident from the title of this section, this approach uses a generator instead of a class to implement a context manager.

Syntactically, generators are almost the same as normal functions, except that you need to use yield instead of return in a generator.

Writing a generator-based context manager requires less code but it also loses some of its readability.

You can write the generator-based equivalent of the class-based Database context manager as follows:

import sqlite3
from contextlib import contextmanager

@contextmanager
def database(path: str):
    connection = sqlite3.connect(path)
    try:
        cursor = connection.cursor()
        yield {'connection': connection, 'cursor': cursor}
    except Exception as e:
        print(f'an error occurred: {e}') 
    finally:
        connection.close()

Instead of a class, you have a generator function here so there is no initializer. Instead, the function itself can accept the path to the database as a parameter.

Within a try block, you can establish a connection to the database, instantiate the cursor, and return both objects to the user.

You can write yield connection, cursor to return the two objects but in that case the generator will return them as a tuple.

I prefer to use strings over numbers as accessors and that's why I have put the two objects inside a dictionary with descriptive keys.

The except block will run in case of an exception. Feel free to implement any exception handling strategy that you see fit.

The finally block will run unconditionally and close the open connection at the end of the with block.

Since there are no __enter__() or __exit__() methods either, you need to decorate the generator with the @contextmanager decorator.

This decorator defines a factory function for with statement context managers, without needing to create a class or separate __enter__() and __exit__() methods.

Usage of this context manager is identical to its class-based conterpart except the capitalization of its name.

import sqlite3
from contextlib import contextmanager

create_table_sql_statement = 'CREATE TABLE IF NOT EXISTS books(title TEXT, author TEXT)'
insert_into_table_sql_statement = "INSERT INTO books VALUES ('If Tomorrow Comes', 'Sidney Sheldon'), ('The Lincoln Lawyer', 'Michael Connelly')"
select_from_table_sql_statement = 'SELECT * FROM books'


@contextmanager
def database(path: str):
    connection = sqlite3.connect(path)
    try:
        cursor = connection.cursor()
        yield {'connection': connection, 'cursor': cursor}
    except Exception as e:
        print(f'an error occurred: {e}') 
    finally:
        connection.close()


def main():
    database_path = ':memory:'

    with database(database_path) as db:
        db.get('cursor').execute(create_table_sql_statement)
        db.get('connection').commit()

        db.get('cursor').execute(insert_into_table_sql_statement)
        db.get('connection').commit()

        db.get('cursor').execute(select_from_table_sql_statement)

        print(db.get('cursor').fetchall())


if __name__ == '__main__':
    main()

# [('If Tomorrow Comes', 'Sidney Sheldon'), ('The Lincoln Lawyer', 'Michael Connelly')]

Since db is a dictionary instead of an object in this case, you will need to use square braces or the get() method to access the connection or cursor object.

Conclusion

Context managers in Python is one of those topics that a lot of programmers have used but do not understand clearly.

I hope this article has cleared up some of your confusions.

If you'd like to connect to me, I am always available on LinkedIn. Feel free to shoot a message and I'd be happy to respond. Also, if you think this was helpful, consider endorsing my relevant skills on the platform.

Until the next one, take care and keep exploring.

Thanks to its popularity, video and written resources about Python are plentiful. This handbook, however, tries to be a bit different by not being a definitive guide to the language.

Instead you'll learn about all the topics that I consider to be the language fundamentals with a lot of code examples.

I haven't discussed object-oriented programming in this handbook because I believe it to be a very broad subject deserving of its own separate handbook.

Near the end, I've also listed out some learning resources to further your knowledge of Python and programming in general.

Without any further ado, let's jump in!

Table of Contents

• Prerequisites
• How to Setup Python on Your Computer
• How to Install a Python IDE on Your Computer
• How to Create a New Project on PyCharm
• How to Write the Hello World Program in Python
• How to Initialize and Publish a Git Repository From PyCharm
• How to Work With Variables and Different Types of Data in Python
• How to Work With Simple Numbers in Python
• How to Take Inputs From Users in Python
• How to Work With Strings in Python
• What Are the Sequence Types in Python?
  • Lists in Python
  • Tuples in Python
  • Ranges in Python
  • How Indexing Works in Python
• What Are the Iterable Types and How to Use them for Loops in Python
• How to Use While Loops in Python
• How to Write Nested Loops in Python
• What Are Some Common Sequence Type Operations in Python?
  • How to Use the in Operator in Python
  • How to Use the + and * Operators with Sequence Types in Python
  • How to Use the len(), min(), and max() Functions in Python
• What Are Some String Type Operations in Python?
  • How to Capitalize Strings in Python
  • How to Convert Strings to Lower Case or Upper Case in Python
  • How to Count the Number of Occurrences of a Substring in a String in Python
  • How to Split and Join Strings in Python
• How to Write Conditional Statements in Python
• What are Relational and Logical Operators in Python?
• What Are Assignment Operators in Python?
• What Is the Set Type in Python?
• What Is the Mapping Type in Python?
  • What Are Dictionary View Objects in Python?
• How to Write Functions in Python
  • How to Write Anonymous or Lambda Functions in Python
  • How to Work with local, nonlocal and global Variables in Python
  • How to Pass a Variable Number of Arguments to a Function Using args and *kwargs in Python
• What Are Modules in Python?
• How to Use the Python Documentation Efficiently
• What's Next?
  • Object Oriented Programming
  • Algorithms and Data Structures
  • Django
  • Qt
  • PyGame
  • Data Science
• Conclusion

Prerequisites

You don't need to know any other programming language for this book, but knowing one may help you understand the basics of Python.

Other than that you'll need to be efficient enough with your choice of operating system to download and install new software, and gain administrative access if needed.

How to Setup Python on Your Computer

Installing Python on your computer is a very straightforward process. In fact, if you're on a Linux system, Python should already be installed.

Open up your terminal window and execute the following command:

python --version

If Python is installed on your system, you'll get an output like Python 3.10.4 or some other minor version.

Although most of the modern Linux distribution use Python 3 as default, some of the older distributions may still use Python 2 by default.

So if the aforementioned command refers to Python 2, try out the following command:

python3 --version

I'd also suggest that you check for updates on your Linux distribution and install any new updates for Python.

Although Python comes preinstalled with macOS as well, I'd suggest that you follow this article by Dillion Megida and install a more recent version.

Finally, for Windows, I'd suggest you follow an article by Md. Fahim Bin Amin and properly install the latest version of Python.

As long as you have a Python 3 version installed, you're good to go.

How to Install a Python IDE on Your Computer

Much of your experience as a developer will depend on what program you've chosen to write your code in. A good integrated development environment (IDE) or Code Editor can really boost your productivity.

These days Visual Studio Code has become the go to code editor for all languages and platforms. But for the sake of simplicity, we'll use PyCharm in this book.

If you'd like to use VS Code, have written a full-length article on how to configure Visual Studio Code for Python development. Feel free to check that out if you do not mind configuring your editor manually.

The professional edition of the IDE can cost you $89.00 per year but there is also a free and open-source community edition. Head over to the PyCharm download page.

Download PyCharm page

Use the black "Download" button to download the community edition. The file size should be a little larger than 350 megabytes.

On Windows you'll get an executable installer, on macOS you'll get an Apple disc image, and on Linux you'll get a TAR archive.

I won't demonstrate the installation process in this book since it's similar to installing any other software on your machine.

Once installed, you can start the IDE from your start menu/app launcher. On your first launch, you'll be given the chance to configure a few things. I'd suggest you keep the defaults.

Once the configuration wizard ends, you should see the following welcome window:

Welcome to PyCharm screen - with options to start a new project, open a project, or get one from your VCS

Picking one IDE or code editor instead of the other one will not affect your experience with following this handbook, so feel free to use whatever you feel comfortable with.

How to Create a New Project on PyCharm

If you have the welcome window open from the previous section, click on the "New Project" button.

Start a new project in PyCharm

In the next step, pick a location to store your project:

In the location input box, the HelloWorld part is the name of the project. Then make sure you have "New environment using Virtualenv" selected. Then, make sure that the correct version of Python is selected from the "Base interpreter" dropdown.

Virtualenv is a program that can create isolated Python environments from a given base interpreter. This is very helpful because later on when you'll work on multiple Python projects, their dependencies may conflict with each other.

Creating isolated environments for each project will solve that issue and it'll also keep your global Python installation free from any unnecessary package installation.

Since this may be your first Python project, I'd suggest you leave the "Create a main.py welcome script" option checked. Once you're happy with your choices, click the "Create" button.

The project creation process shouldn't take very long. Once it's done, the IDE should open the project automatically for you.

You can use the play button at the top right corner to run the code. The button is configured to run the "main.py" file by default.

That's why you can see "main" written by its side. You can write your custom configuration as well, but that's a topic for a later section.

You can see the output of your program at the bottom of the IDE. PyCharm comes with support for TODO comments, a built in terminal and more. You'll learn about a bunch of these features as you go forward.

How to Write the Hello World Program in Python

Continuing on from the last section, open up the "main.py" file and replace all the preexisting code with the following line of code:

print('Hello, World!')

# Hello, World!

The print() function prints out anything that you pass into the set of parenthesis. You don't have to name your Python file "main.py" specifically. It's just a way to let you know that this is the entry point to this program.

That's all you need to write the simplest executable program in Python. But there is even a better way to do it. Update the code as follows:

def main():
    print('Hello, World!')


if __name__ == '__main__':
    main()

# Hello, World!

As you keep working on bigger projects, you'll eventually have more than one Python file in your project and this way of writing a script can be useful.

To simulate a bigger project, create another Python file by right clicking on the "HelloWorld" project name and selecting "Python File" under the "New" sub menu.

Name your file something like "library" and press enter while "Python file" is highlighted in the list of file types.

A new file with the name "library.py" will show up on your project folder. Put the following line of code inside the file:

def greet():
    print('Hello, World!')

This is a very simple function that prints out "Hello, World!" on the console. You can import and use this function in your "main.py" file.

To do so, update the code for "main.py" file as follows:

from library import greet


def main():
    greet()


if __name__ == '__main__':
    main()

# Hello, World!

You're importing the greet() function from the "library.py" file and executing that inside the main() function.

Right now in your project, you have two types of Python file. You have the "main.py" file which is a script. In other words, you can run this file.

Then you have the "library.py" file which is a library. In other words, it houses a number of useful functions and variables that you can import inside other Python files.

Now imagine you have hundreds of files in your project and they more or less look the same. How would someone else find the entry point to the program?

The easiest way would be to perform a search for the line if __name__ == '__main__' on the entire project. This makes your code a lot more readable.

Now that I have you convinced that this is the way to go, let me explain what is actually going on here.

The __name__ is a special Python variable. In case of a script, the value of this variable will be __main__ and in case of a library, its value will be the name of that file.

So in the aforementioned program, the value of __name__ inside the "main.py" file will be __main__ and library inside the "library.py" file.

If you change the name of then "main.py" file to something else, the value will still be __main__ because it's a script.

Nothing is stopping the "library.py" file from being a script, though. If you run that file instead, it'll become a script.

In languages like C/C++/Go/Java, you'll have a specified main function. That function will be the entry point to the program.

Since Python doesn't have anything like that, the usage of the if __name__ == '__main__' expression enforces a sense of a specified entry point to your program.

It tells the programmer and the IDE that this script is for execution (not for importing inside other Python files).

How to Initialize and Publish a Git Repository From PyCharm

You may already be familiar with Git and know how to initialize a new repository. If you prefer using some other Git client, that's totally fine.

However I think knowing how to make commits right from your IDE can boost your productivity.

Keep in mind you'll need to have Git installed and configured on your system. If you don't have that, this article by Bolaji Ayodeji may come in handy.

Now, continuing on from the last section, if you look at the bottom of your IDE, you should see a "Version Control" tab.

Click on it and you should switch to the version control tab. Now click on the "Create Git repository..." link.

PyCharm will ask you where you want to initialize the new repository. Make sure you're picking the right folder.

As soon as you press the "OK" button, the "Version Control" tab will change to a "Git" tab.

At it's current state, there are no commits. Before you make your first commit, I'd suggest you add a ".gitignore" file so that no unwanted file gets to the repository.

To generate a new gitignore file, head over to gitignore.io website. You can generate gitignore files for a large number of technologies from this website.

You write the name of the technologies that you want to generate the file for. I usually go with "Python", "PyCharm" and hit the "Create" button.

The website will display the content of your desired ".gitignore" file. Select and copy everything from there and go back to PyCharm.

To simulate that, create a new file in your project by right clicking on the "HelloWorld" project name and selecting "File" under the "New" sub menu.

Name your file ".gitignore" and press enter. PyCharm will ask whether you want to add this file to Git or not. Click on Add and then paste the copied content.

At this moment, your repository doesn't have any commits. To create a new commit, click on the "Commit local changes" link or switch to the "Commit" tab.

Since this is your first commit, check all "Changes" and "Unversioned Files" from the commit tab.

Since this is your first commit, put a descriptive commit message such as "Initial commit" and press the "Commit" button to finalize.

You've successfully made a commit to your local repository. You can now see all the commits under the master branch in detail.

Now it's time to publish this repository on GitHub. To do so, create a new repository under your GitHub account.

Then copy the SSH link to this repository. If you do not have SSH configured for your project, you may use the HTTPS link but I'd highly recommend SSH.

Now go back to PyCharm and look at the top right corner. Besides where it says Git, you'll find a few signs.

The downwards blue arrow will pull code from your remote repository, the tick sign will create a new commit, the upwards green arrow will push code.

The clock icon will show your commit history and finally the looped back arrow will revert your changes. Click on the push arrow and a new window will pop up.

Click on the "Define remote" link and inside the URL input box, paste the link you've copied from GitHub. Press the OK button and wait until the process ends.

If everything goes fine, PyCharm will give you a "Push" button. It shouldn't take more than a few seconds to push the code to your remote repository.

If you're using HTTPS instead of SSH, you may have to provide your GitHub email and password on every push.

Once done, visit your remote repository and refresh the page to see if the changes have been pushed correctly or not.

Now you can commit and push your code to GitHub right from your IDE every time you make any significant change.

For example, delete the "library.py" file and update the code inside the "main.py" file to print out "Hello, World!" on the console.

def main():
    print("Hello, World!")


if __name__ == '__main__':
    main()

# Hello, World!

Once you've made the changes, switch to the commit tab and you'll see all the uncommitted changes.

Make sure you've checked all the changes you want to commit. Write a descriptive commit message.

Then instead of just committing, try the "Commit and Push..." button this time. A new window will show up.

If everything looks good to you, click on the Push button and wait for the process to finish.

Remember, if you're using HTTPS you may have to reenter your email and password on every push.

You can check your remote repository on GitHub to make sure that the push has been done correctly.

You can do a lot more in terms of version controlling within PyCharm such as handling pull requests, but I'll leave those out for a later time.

How to Work With Variables and Different Types of Data in Python

A variable is an entity that can take on different values of different types. It's a named location in your computer's memory.

To create a new variable in Python, you just need to type out the name of the variable, followed by an equal sign and the value.

def main():
    book = 'Dracula'
    author = 'Bram Stoker'
    release_year = 1897
    goodreads_rating = 4.01

    print(book)
    print(author)
    print(release_year)
    print(goodreads_rating)


if __name__ == '__main__':
    main()

# Dracula
# Bram Stoker
# 1897
# 4.01

When it comes to naming your variable, the PEP 8 - Style Guide for Python says:

Function names should be lowercase, with words separated by underscores as necessary to improve readability.

And

Variable names follow the same convention as function names.

The guide also says:

Never use the characters ‘l’ (lowercase letter el), ‘O’ (uppercase letter oh), or ‘I’ (uppercase letter eye) as single character variable names. In some fonts, these characters are indistinguishable from the numerals one and zero. When tempted to use ‘l’, use ‘L’ instead.

As long as you're keeping these guidelines in mind, declaring variables in Python is very straightforward.

Instead of declaring the variables in separate lines, you can declare them in one go as follows:

def main():
    book, author, release_year, goodreads_rating = 'Dracula', 'Bram Stoker', 1897, 4.01

    print(book)
    print(author)
    print(release_year)
    print(goodreads_rating)


if __name__ == '__main__':
    main()

# Dracula
# Bram Stoker
# 1897
# 4.01

All you have to do is write the individual variable names in a single line using commas as separators.

Then after the equal sign you have to write the corresponding values in the same order as their names again using commas as separators.

In fact, you can also print them all out in one go. The print() method can take multiple parameters separated by commas.

def main():
    book, author, release_year, goodreads_rating = 'Dracula', 'Bram Stoker', 1897, 4.01

    print(book, author, release_year, goodreads_rating)


if __name__ == '__main__':
    main()

# Dracula Bram Stoker 1897 4.01

These parameters are then printed on the terminal in a single line using spaces for separating each of them.

Speaking of the print() method, you can use the + sign to add variables with strings inside a print method:

def main():
    book, author, release_year, goodreads_rating = 'Dracula', 'Bram Stoker', 1897, 4.01

    print(book + ' is a novel by ' + author + ', published in ' + release_year + '. It has a rating of ' + goodreads_rating + ' on goodreads.')


if __name__ == '__main__':
    main()


# TypeError: can only concatenate str (not "int") to str

If you try to run this code you'll get a TypeError that says Python can concatenate or add together strings not integers.

In the code snippet above, book, author, release_year, and goodreads_rating are all variables of different types.

The book and author variables are strings. The release_year is an integer and finally the goodreads_rating variable is a floating point number.

Whenever Python encounters a + sign in front of a numeric type, it assumes that the programmer may be performing an arithmetic operation.

The easiest way to solve this problem is to convert the numeric types to strings. You can do that by calling the str() method on the numeric variables.

def main():
    book, author, release_year, goodreads_rating = 'Dracula', 'Bram Stoker', 1897, 4.01

    print(book + ' is a novel by ' + author + ', published in ' + str(release_year) + '. It has a rating of ' + str(goodreads_rating) + ' on goodreads.')


if __name__ == '__main__':
    main()

# Dracula is a novel by Bram Stoker, published in 1897. It has a rating of 4.01 on goodreads.

That's better – but you can make that line of code even more readable by using a f string.

def main():
    book, author, release_year, goodreads_rating = 'Dracula', 'Bram Stoker', 1897, 4.01

    print(f'{book} is a novel by {author}, published in {release_year}. It has a rating of {goodreads_rating} on goodreads.')


if __name__ == '__main__':
    main()

# Dracula is a novel by Bram Stoker, published in 1897. It has a rating of 4.01 on goodreads.

You can turn a regular string to a f string by putting a f in front of it and suddenly you can write variable names inside curly braces right within the string itself.

There is one last thing that's bugging me, and that's the length of the line of code itself. Fortunately you can split long strings into multiple shorter ones as follows:

def main():
    book, author, release_year, goodreads_rating = 'Dracula', 'Bram Stoker', 1897, 4.01

    print(f'{book} is a novel by {author}, published in {release_year}.'
          f' It has a rating of {goodreads_rating} on goodreads.')


if __name__ == '__main__':
    main()

# Dracula is a novel by Bram Stoker, published in 1897. It has a rating of 4.01 on goodreads.

Now that's how a good piece of Python code should look. I'd suggest you try to make your code readable from the very beginning – you'll thank me later for that.

Other than int and float, there is another numeric type called complex in Python. It was specifically designed for dealing with numbers like 500+2j.

There are also boolean data that can hold the value True or False and nothing else. You can actually ask Python questions and it'll answer in boolean.

Throughout this book you'll not see complex numbers in action and booleans will come into play much later. So for now, lets focus on simple numbers and strings.

How to Work With Simple Numbers in Python

Simple numbers in Python are of two types. Whole numbers are integers and numbers with floating points in them are floats.

In Python, you can represent integers using four different bases. These are decimal, hexadecimal, octal, and binary.

So you can represent the value of 404 in hexadecimal, octal, or binary by prefixing the corresponding value with 0x, 0o, or 0b respectively.

On the other hand you can represent floats with the precision of up to 15 significant digits in Python. Any digit after the 15th place may be inaccurate.

There are six different arithmetic operations that you can perform on any of the simple numeric types. The simplest of the bunch are addition and subtraction.

def main():
    num_1 = 15
    num_2 = 12

    print(f'sum of num_1 and num_2 is: {num_1 + num_2}')
    print(f'difference of num_1 and num_2 is: {num_1 - num_2}')

if __name__ == '__main__':
    main()

# sum of num_1 and num_2 is: 27
# difference of num_1 and num_2 is: 3

In case of a subtraction operation, the result will be negative if the second operand is larger than the first one.

def main():
    num_1 = 15
    num_2 = 12

    print(f'difference of num_2 and num_1 is: {num_2 - num_1}')

if __name__ == '__main__':
    main()

# difference of num_2 and num_1 is: -3

Similarly you can perform multiplication and division operations using their corresponding operators.

def main():
    num_1 = 15
    num_2 = 12

    print(f'product of num_1 and num_2 is: {num_1 * num_2}')
    print(f'quotient of num_1 and num_2 is: {num_1 / num_2}')
    print(f'floored quotient of num_1 and num_2 is: {num_1 // num_2}')


if __name__ == '__main__':
    main()

# product of num_1 and num_2 is: 180
# quotient of num_1 and num_2 is: 1.25
# floored quotient of num_1 and num_2 is: 1

Keep in mind that you can not divide a number by zero in Python. If you attempt that, you'll get a ZeroDivisionError error (more on that later).

Output from a division operation will always be a float value, unless you perform a floored division by using two division operators.

def main():
    num_1 = 15
    num_2 = 12

    print(f'floored quotient of num_1 and num_2 is: {num_1 // num_2}')


if __name__ == '__main__':
    main()

# floored quotient of num_1 and num_2 is: 1

In this case the result will be rounded off to the nearest integer low – so, for example, 0.25 will be lost. So only perform this operation when such loss of data is permissible.

The last operation to discuss is finding the remainder of a division operation.

def main():
    num_1 = 15
    num_2 = 12

    print(f'remainder of num_1 / num_2 is: {num_1 % num_2}')


if __name__ == '__main__':
    main()

# remainder of num_1 / num_2 is: 3

This operation is also called a modulo or modulus operation. So if someone mentions the modulo or modulus operator, they're referring to the percent sign.

You can turn an unsigned number into a negative one just by adding a - sign in front of it. You can also freely convert between integer to float and vice versa.

def main():
    float_variable = 1.25
    integer_variable = 55

    print(f'{float_variable} converted to an integer is: {int(float_variable)}')
    print(f'{integer_variable} converted to a float is: {float(integer_variable)}')


if __name__ == '__main__':
    main()

# 1.25 converted to an integer is: 1
# 55 converted to a float is: 55.0

Loss of data in case of a float to integer conversion is inevitable, so be careful. You can use the int() and float() methods on strings as well (more on that later).

Any arithmetic operation involving a float operand will always produce a float result, unless converted to integer explicitly.

def main():
    float_variable = 5.0
    integer_variable = 55

    print(f'the sum of {float_variable} and {integer_variable} is: {float_variable + integer_variable}')
    print(f'the sum of {float_variable} and {integer_variable} '
          f'converted to integer is: {int(float_variable + integer_variable)}')


if __name__ == '__main__':
    main()

# the sum of 5.0 and 55 is: 60.0
# the sum of 5.0 and 55 converted to integer is: 60

If you ever want to get the absolute value of a signed value you can do so using the abs() method.

def main():
    num_1 = -5.8

    print(f'the absolute value of {num_1} is: {abs(num_1)}')


if __name__ == '__main__':
    main()

# the absolute value of -5.8 is: 5.8

There is a similar method pow(x, y) that you can use to apply x as the power of y like this.

def main():
    x = 2
    y = 3

    print(f'{2} to the power of {3} is: {pow(2, 3)}')
    print(f'{2} to the power of {3} is: {2 ** 3}')


if __name__ == '__main__':
    main()

# 2 to the power of 3 is: 8
# 2 to the power of 3 is: 8

You can perform the same operation using two multiplication operators but I always prefer the pow() method.

Finally there is the divmod() method that you can use to combine the division and modulo operation.

def main():
    num_1 = 8
    num_2 = 2

    print(f'division and modulus of {num_1} and {num_2} is: {divmod(num_1, num_2)}')


if __name__ == '__main__':
    main()

# division and modulus of 8 and 2 is: (4, 0)

The method returns a tuple of numbers (more on that later). The first one is the result of the division and the second one is the result of the modulo operation.

These are the basic operations you can perform on simple numbers right from the get go. But you can do much more once you start to pull in the built-in modules.

How to Take Inputs From Users in Python

Learning how to take input from a user is an important milestone because it lets you create programs that a human being can interact with.

Unlike many other programming languages, taking user inputs in Python is very straightforward.

def main():
    name = input('What is your name? ')

    print(f'Nice to meet you {name}')


if __name__ == '__main__':
    main()

# What is your name? Farhan
# Nice to meet you Farhan

The built-in input() method does exactly what it sounds like. The method accepts a single parameter prompt which is of string type.

Whatever you write as the value of this parameter will be shown in the console – like in this case, "What is your name?" is the prompt.

Once the user writes something on the console and presses enter, the input method will return that as a string.

You can save that string to any variable like I've saved the name inside the name variable. Even if the user inputs a number, input() will return that as a string.

def main():
    name = input('What is your name? ')
    age = input(f'How old are you {name}? ')
    current_year = input(f'What year is this again? ')

    print(f'If my calculations are right, you were born in {current_year - age}')


if __name__ == '__main__':
    main()

# What is your name? Farhan
# How old are you Farhan? 27
# What year is this again? 2023
# TypeError: unsupported operand type(s) for -: 'str' and 'str'

Even though Python is taking all the user inputs correctly, it fails to calculate the user's birth year because arithmetic operations are not a good fit for strings.

To solve this problem, you just have to convert the user inputs to numeric types using the int() or float() functions as needed.

def main():
    name = input('What is your name? ')
    age = int(input(f'How old are you {name}? '))
    current_year = int(input(f'What year is this again? '))

    print(f'If my calculations are right, you were born in {current_year - age}')


if __name__ == '__main__':
    main()

# What is your name? Farhan
# How old are you Farhan? 27
# What year is this again? 2023
# If my calculations are right, you were born in 1996

There you go, works like a charm. You can perform this conversion at any point in the code. It's not mandatory to convert them right at the beginning.

def main():
    temperature_in_celsius = input('What is the temperature in celsius? ')

    temperature_in_fahrenheit = (float(temperature_in_celsius) * 1.8) + 32

    print(f'{temperature_in_celsius} degree celsius is equivalent to {temperature_in_fahrenheit} degree fahrenheit.')


if __name__ == '__main__':
    main()

# What is the temperature in celsius? 32
# 32 degree celsius is equivalent to 89.6 degree fahrenheit.

This program can convert temperature from Celsius to Fahrenheit. In this program, I didn't convert the input from string to a numeric type right away.

I performed the conversion during the calculation leaving the original input variable intact. Also notice the use of float() instead of the int() function.

How to Work With Strings in Python

You've already seen examples of strings in the previous sections – but there is a lot more that you need to learn about strings.

In Python, anything enclosed within a set of single, double, or triple quotes is a string. These are sequences of bytes representing Unicode characters.

def main():
    book = 'Dracula'
    author = "Bram Stoker"

    print('Title:', book)
    print('Author:', author)


if __name__ == '__main__':
    main()

# Title: Dracula
# Author: Bram Stoker

Declaring a string with single or double quotes makes no difference whatsoever. But based on the scenario, you may have to choose on over the other.

For example, if you have an apostrophe within your sentence, you may want to use double quotes.

def main():
    question = "What's your name?"

    print(question)


if __name__ == '__main__':
    main()

# What's your name?

The opposite can also occur. For example, when you have a direct quote within your string:

def main():
    sentence = 'Harriet Jacobs writes, "She sat down, quivering in every limb"'

    print(sentence)


if __name__ == '__main__':
    main()

# Harriet Jacobs writes, "She sat down, quivering in every limb"

You can also go for escape sequences if you want to, but the PEP 8 - Style Guide for Python Code recommends avoiding the usage of back slashes within strings.

Triple quotes are a different case altogether. You can put multi-line strings within triple quotes and Python will preserve the white spaces as well.

def main():
    synopsis = """Dracula comprises journal entries, letters, and telegrams written by the main characters.
It begins with Jonathan Harker, a young English lawyer, as he travels to Transylvania.
Harker plans to meet with Count Dracula, a client of his firm, in order to finalize a property transaction.
When he arrives in Transylvania, the locals react with terror after he discloses his destination: Castle Dracula.
Though this unsettles him slightly, he continues onward.
The ominous howling of wolves rings through the air as he arrives at the castle.
When Harker meets Dracula, he acknowledges that the man is pale, gaunt, and strange.
Harker becomes further concerned when, after Harker cuts himself while shaving, Dracula lunges at his throat.
Soon after, Harker is seduced by three female vampires, from whom he barely escapes.
He then learns Dracula’s secret—that he is a vampire and survives by drinking human blood.
Harker correctly assumes that he is to be the count’s next victim.
He attacks the count, but his efforts are unsuccessful.
Dracula leaves Harker trapped in the castle and then, along with 50 boxes of dirt, departs for England."""

    print('Synopsis:', synopsis)


if __name__ == '__main__':
    main()

# Synopsis: Dracula comprises journal entries, letters, and telegrams written by the main characters.
# It begins with Jonathan Harker, a young English lawyer, as he travels to Transylvania.
# Harker plans to meet with Count Dracula, a client of his firm, in order to finalize a property transaction.
# When he arrives in Transylvania, the locals react with terror after he discloses his destination: Castle Dracula.
# Though this unsettles him slightly, he continues onward.
# The ominous howling of wolves rings through the air as he arrives at the castle.
# When Harker meets Dracula, he acknowledges that the man is pale, gaunt, and strange.
# Harker becomes further concerned when, after Harker cuts himself while shaving, Dracula lunges at his throat.
# Soon after, Harker is seduced by three female vampires, from whom he barely escapes.
# He then learns Dracula’s secret—that he is a vampire and survives by drinking human blood.
# Harker correctly assumes that he is to be the count’s next victim.
# He attacks the count, but his efforts are unsuccessful.
# Dracula leaves Harker trapped in the castle and then, along with 50 boxes of dirt, departs for England.

So if you ever want to print out a multi line string while preserving the white spaces, go for triple quotes.

You can declare a triple quoted string using three single quotes but the PEP 8 - Style Guide for Python Code recommends the usage of three double quotes.

There is a lot more to learn about strings, but I'd like to introduce you to some other sequence types in Python.

What Are the Sequence Types in Python?

In Python, there are three sequence types. They are lists, tuples, and ranges. I'll start with the lists because it's probably the most utilized sequence type in Python.

Lists in Python

A list in Python is exactly what it sounds like: a collection of data stored sequentially on the computer's memory.

You can create a new list in Python by writing out its name followed by an equal sign, followed by the values to store enclosed in square brackets:

def main():
    horror_books = ['Dracula', 'Carmilla', 'The Imago Sequence']

    print(horror_books)


if __name__ == '__main__':
    main()

# ['Dracula', 'Carmilla', 'The Imago Sequence']

In this example, horror_books is a list of strings. But you can create lists of integers, floats, or even of mixed types.

def main():
    a_random_list = ['Dracula', 1, 5.7, 'Carmilla']

    print(a_random_list)


if __name__ == '__main__':
    main()

# ['Dracula', 1, 5.7, 'Carmilla']

Though this is perfectly valid, you may find yourself creating lists of the same types more often.

Lists in Python are mutable. This means you can modify a list after its creation. For example, you can use the pop() method to get rid of the last value in a list.

def main():
    horror_books = ['Dracula', 'Carmilla', 'The Imago Sequence']

    print(horror_books.pop())
    print(horror_books)


if __name__ == '__main__':
    main()

# The Imago Sequence
# ['Dracula', 'Carmilla']

As you can see, the pop() method returns the last value from the list and gets rid of it. Like pop() there is the append() method for inserting new item to the list.

def main():
    horror_books = ['Dracula', 'Carmilla', 'The Imago Sequence']

    print(horror_books)

    horror_books.append('The Exorcist')

    print(horror_books)


if __name__ == '__main__':
    main()

# ['Dracula', 'Carmilla', 'The Imago Sequence']
# ['Dracula', 'Carmilla', 'The Imago Sequence', 'The Exorcist']

As you can see from the method name, it adds the new item at the end of the list. Given their mutable nature, lists can also be sorted.

Feel free to check out the following article written by my colleague Dionysia Lemonaki here on freeCodeCamp about how to sort lists in Python:

Tuples in Python

Lists are not the only sequence type in Python. The closest sibling of lists in Python are tuples.

You can create a new tuple in Python by writing out its name followed by an equal sign, then enclosing inside a pair of parenthesis the values you want to store.

def main():
    horror_books = ('Dracula', 'Carmilla', 'The Imago Sequence')

    print(horror_books)


if __name__ == '__main__':
    main()

# ('Dracula', 'Carmilla', 'The Imago Sequence')

Just like lists, you can also mix and match different types of data within a single tuple as you see fit.

def main():
    a_random_list = ('Dracula', 1, 5.7, 'Carmilla')

    print(a_random_list)


if __name__ == '__main__':
    main()

# ('Dracula', 1, 5.7, 'Carmilla')

The most glaring dissimilarity between a list and a tuple is the fact that a tuple is immutable. So there's no popping and appending for us this time.

Ranges in Python

The final sequence type that you're going to learn about in this section is a range. A range in Python is just a range of numbers.

You can create a range by calling the range() method and it'll return a range of numbers. You can call the method in a few different ways.

The most common is by passing a single number as a parameter. In this case, the method will treat that number as the end of the range and 0 as the start.

def main():
    a_range = range(10)

    print(a_range)

    list_a_range = list(a_range)

    print(list_a_range)


if __name__ == '__main__':
    main()

# range(0, 10)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

Printing out a range as is won't give you much information. You'll have to convert the range to a list or a tuple by either calling the list() or tuple() method.

Once converted, you can then print out the entire range to the console. Notice how 10 or the number passed to the range() method is not included in the range.

The second way of calling the method is by supplying both the starting and ending numbers for the range.

def main():
    a_range = range(5, 15)

    print(a_range)

    list_a_range = list(a_range)

    print(list_a_range)

    tuple_a_range = tuple(a_range)

    print(tuple_a_range)


if __name__ == '__main__':
    main()

# range(5, 15)
# [5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
# (5, 6, 7, 8, 9, 10, 11, 12, 13, 14)

Once again, the number you pass as the ending for the range will not be included in the resultant range.

The third and final way to call the method is by also defining a step. For example, imagine you want a range comprising of all the odd numbers within 1 to 10.

def main():
    a_range = range(1, 10, 2)

    print(a_range)

    list_a_range = list(a_range)

    print(list_a_range)

    tuple_a_range = tuple(a_range)

    print(tuple_a_range)


if __name__ == '__main__':
    main()

# range(1, 10, 2)
# [1, 3, 5, 7, 9]
# (1, 3, 5, 7, 9)

Since the value of step is 2 in this case, the range will begin with 1 but then skip every second number.

It may take some time to wrap your head around this concept but practicing with different step values will help.

Or you can read the following article written by Bala Priya C:

How Indexing Works in Python

One of the most important concepts regarding sequence types that you need to understand is indexing.

You see, each element in a sequence has a number attached to it that expresses its position in the list called an index. These indices are 0 based.

This diagram represents our list of horror books. The index of the first book is 0 – this means that the first element is at the 0th place.

The second one is at the 1st place and the third one is at the 2nd place. This zero-based indexing is may seem confusing at first but you'll get the hang of it.

The most basic usage of a index is to access its corresponding value from the sequence.

def main():
    horror_books = ['Dracula', 'Carmilla', 'The Imago Sequence']

    print(horror_books[0])
    print(horror_books[1])
    print(horror_books[2])


if __name__ == '__main__':
    main()

# Dracula
# Carmilla
# The Imago Sequence

You can also use negative numbers as indices but in that case the counting will start from the end.

def main():
    books = ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow',
             'And Then There Were None', 'The ABC Murders', 'The Valley of Fear']

    print(books[0])

    print(books[1])
    print(books[-1])

    print(books[2])
    print(books[-2])


if __name__ == '__main__':
    main()

# Dracula

# Frankenstein
# The Valley of Fear

# The Omen
# The ABC Murders

The 0th element in a list will always be the first one. Now if you access the element on the 1st position you get "Frankenstein".

But if you try to access the element on the -1st position, you get "The Valley of Fear" because that's the second item in reverse.

The element on the 2nd position is "The Omen" but the element at the -2nd position is "The ABC Murders" because that's the third item in reverse.

If you're finding it hard to wrap your head around, imagine the list like a clock.

Zero-based indexing represented as a circular diagram like a clock

Here the outer number is the negative index and the inner number is the positive index. If you try to match the outputs against this imaginary clock, it should be easier to understand.

What Are the Iterable Types and How to Use them for Loops in Python

So far you've learned about creating collections of data and accessing them one by one. That's cool but there is something cooler.

Imagine you have a list or some other type of that contains a bunch of numbers.

Now you want to multiply each number in that list by two, insert the multiplied numbers in a new list, and print out the list on the terminal.

This is an excellent use case for the for statement in Python. Let's begin by first iterating through each number in a given list.

def main():
    random_numbers = [6, 1, 3, 8, 0, 9, 12, 3, 4, 0, 54, 8, 100, 55, 60, 70, 85]

    for number in random_numbers:
        print(number)

if __name__ == '__main__':
    main()

# 6
# 1
# 3
# 8
# 0
# 9
# 12
# 3
# 4
# 0
# 54
# 8
# 100
# 55
# 60
# 70
# 85

You start by writing out the word for followed by a variable name. I've used number but you can use anything that makes sense to you.

Although you write it as for number, Python reads it as for each number and wonders where are these numbers staying?

That's when you say in followed by the name of the sequence, random_numbers in this case.

Now Python understands that you want to do something with each number in the random_numbers sequence, but what?

That's what you have to write out after the colon and be very careful about the indentation. Anything indented one level after the for loop declaration is considered the loop body.

Inside the for loop you can write whatever you want to do with the current value of the number variable.

Since there are 17 numbers in the sequence, the loop will run 17 times and each time it'll have a new value.

It'll start at index 0 which has the value of 6 and go through index 1, 2, 3, 4, 5, and so on.

On each iteration, it'll save the value of the index it's currently working on inside the number variable and print it out. Hence you get the long list of numbers.

Instead of printing out the original value, you can multiply it by 2 and print out the resultant value instead.

def main():
    random_numbers = [6, 1, 3, 8, 0, 9, 12, 3, 4, 0, 54, 8, 100, 55, 60, 70, 85]

    for number in random_numbers:
        print(number * 2)

if __name__ == '__main__':
    main()

# 12
# 2
# 6
# 16
# 0
# 18
# 24
# 6
# 8
# 0
# 108
# 16
# 200
# 110
# 120
# 140
# 170

Now you're getting the multiplied values. The final task is to insert these multiplied values in a new list and print out the new list itself.

def main():
    random_numbers = [6, 1, 3, 8, 0, 9, 12, 3, 4, 0, 54, 8, 100, 55, 60, 70, 85]
    multiplied_random_numbers = []

    for number in random_numbers:
        multiplied_random_numbers.append(number * 2)

    print(multiplied_random_numbers)

if __name__ == '__main__':
    main()

# [12, 2, 6, 16, 0, 18, 24, 6, 8, 0, 108, 16, 200, 110, 120, 140, 170]

For that you'll need an empty list. Then, after multiplying the number, you can simply call the append() method on the new list and pass the multiplied value.

Finally, make sure that you're putting the print statement outside of the loop body otherwise you'll end up printing out the list 17 times.

The for loop works with all the sequence types and any iterable type in the Python language. What is an iterable type, I hear you ask.

Well, any object that has the __iter__() method is considered an iterable in Python.

You can call the dir() function on any object to list out all its methods and properties. Take the random_numbers list as an example.

def main():
    random_numbers = [6, 1, 3, 8, 0, 9, 12, 3, 4, 0, 54, 8, 100, 55, 60, 70, 85]

    print(dir(random_numbers))

if __name__ == '__main__':
    main()

# ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

You can see some familiar methods such as append, count, and index but most importantly it has the __iter__ method.

As you keep working in Python you'll eventually remember the types supported by the for loop but you can always use the dir() method on a object to find out.

How to Use While Loops in Python

There is another type of loop in Python known as the while loop. Unlike for, a while loop can execute a statement as long as a given condition evaluates to true.

def main():
    number = 1
    while number < 11:
        print(number)
        number += 1

if __name__ == '__main__':
    main()

# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# 10

Here you have a variable number with the value 11 and a while loop that prints out the value of number, then increases it by 1.

A while loop starts by writing out while followed by the condition. Then you write the loop body starting from the next line after the colon.

for loops are useful when you're trying to access every element inside an iterable. while loops are useful when you want to repeat the same set of instructions an arbitrary number of times.

The line number += 1 is another way to write number = number + 1 and it's very commonly used by programmers across different programming languages.

How to Write Nested Loops in Python

You can also nest one loop inside another. For example, look at the following code that prints out multiplication tables:

def main():
    for x in range(1, 6):
        print()
        for y in range(1, 11):
            print(f"{x} x {y} = {x * y}")


if __name__ == '__main__':
    main()

#
# 1 x 1 = 1
# 1 x 2 = 2
# 1 x 3 = 3
# 1 x 4 = 4
# 1 x 5 = 5
# 1 x 6 = 6
# 1 x 7 = 7
# 1 x 8 = 8
# 1 x 9 = 9
# 1 x 10 = 10
#
# 2 x 1 = 2
# 2 x 2 = 4
# 2 x 3 = 6
# 2 x 4 = 8
# 2 x 5 = 10
# 2 x 6 = 12
# 2 x 7 = 14
# 2 x 8 = 16
# 2 x 9 = 18
# 2 x 10 = 20
#
# 3 x 1 = 3
# 3 x 2 = 6
# 3 x 3 = 9
# 3 x 4 = 12
# 3 x 5 = 15
# 3 x 6 = 18
# 3 x 7 = 21
# 3 x 8 = 24
# 3 x 9 = 27
# 3 x 10 = 30
#
# 4 x 1 = 4
# 4 x 2 = 8
# 4 x 3 = 12
# 4 x 4 = 16
# 4 x 5 = 20
# 4 x 6 = 24
# 4 x 7 = 28
# 4 x 8 = 32
# 4 x 9 = 36
# 4 x 10 = 40
#
# 5 x 1 = 5
# 5 x 2 = 10
# 5 x 3 = 15
# 5 x 4 = 20
# 5 x 5 = 25
# 5 x 6 = 30
# 5 x 7 = 35
# 5 x 8 = 40
# 5 x 9 = 45
# 5 x 10 = 50

To be honest, this is a very simple bit of code that makes use of a lot of the things you've already learned in this handbook.

To create a multiplication table we need two operands: one remains constant for the entire table and the other increases by 1 until it reaches 10.

Here, x represents the left operand or the constant one and y represents the right operand or the variable one.

The first loop iterates through a range of 1 to 5 and the second loop iterates through a range of 1 to 10.

Since the ending number of a range is exclusive, you need to put a number that is 1 higher than the desired ending number.

First the Python interpreter encounters the outer loop and starts executing it. While inside that loop, the value of x is 1.

The interpreter then encounters the inner loop and starts executing that. While inside the inner loop, the value of x remains 1 but the value of y increases in each iteration.

The inner loop is the body of the outer loop in this case, so the first iteration of the outer loop lasts until the inner loop finishes.

After finishing 10 iterations of the inner loop, the interpreter comes back to the outer loop and starts executing it once again.

This time the value of x becomes 2 since that's what comes next in the range.

Just like that, the outer loop executes 5 times and the inner loop executes 10 times for each of those iterations.

Like a lot of other concepts, wrapping your head around nested loops can be difficult, but practice will make things easier.

I'd suggest you go ahead and implement this program using while loops to test your understanding.

You can also take the two numbers from the user and print the multiplication table within that range.

For example, if the user puts 5 and 10 as inputs, then you'll print out the multiplication tables of all the numbers from 5 to 10.

You can nest loops to even deeper levels, but going deeper than two loops may cause performance issues so be careful with that.

What Are Some Common Sequence Type Operations in Python?

Assuming you remember the text sequence type (strings), you're now familiar with the four most popular Python sequence types.

So I think it's time for you to learn some common operations that you can perform on them. Let's begin, shall we?

How to Use the in Operator in Python

The in operator is the most common way of checking for any object's existence. For example, assume that you have a string and you want to check if it contains the word "red" or not.

def main():
    a_string = 'Little Red Riding-Hood comes to me one Christmas Eve to give me information of the cruelty and ' \
               'treachery of that dissembling Wolf who ate her grandmother. '

    print('Red' in a_string)


if __name__ == '__main__':
    main()

# True

It's literally like asking Python, if the word Red is in the a_string variable. And Python will give you either True or False as an answer.

The in operator is not exclusive to strings. You can actually use it on any other collection type such as lists, tuples, and ranges.

def main():
    books = ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow']
    movies = ('A Christmas Carol', 'The Sea Beast', 'Enchanted', 'Pinocchio', 'The Addams Family')
    numbers = range(10)

    print('A Christmas Carol' in books)
    print('Enchanted' in movies)
    print(5 in numbers)


if __name__ == '__main__':
    main()

# False
# True
# True

A Christmas Carol doesn't exist in the books list so it's a False statement. The other two statements are right, so they're True.

You may also want to find out about the absence of an object. For that, you can use the not operator in conjunction with the in operator.

def main():
    books = ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow']
    movies = ('A Christmas Carol', 'The Sea Beast', 'Enchanted', 'Pinocchio', 'The Addams Family')
    numbers = range(10)

    print('A Christmas Carol' not in books)
    print('Enchanted' not in movies)
    print(15 not in numbers)


if __name__ == '__main__':
    main()

# True
# False
# True

A Christmas Carol doesn't exist in the books list, so the first statement evaluates to true. The second one evaluates to false because Enchanted is present in the movies list.

The last one is self explanatory at this point. The in and not in operators come in very handy when working with conditional statements.

How to Use the + and * Operators with Sequence Types in Python

You've already learned about + and * as arithmetic operators – but in the case of sequence types, they play a very different role.

The + operator lets you merge two sequences together.

def main():
    books = ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow']
    more_books = ['And Then There Were None', 'The ABC Murders', 'The Valley of Fear', 'The Hound of the Baskervilles', 'The Chestnut Man']


    print(books + more_books)


if __name__ == '__main__':
    main()

# ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow', 'And Then There Were None', 'The ABC Murders', 'The Valley of Fear', 'The Hound of the Baskervilles', 'The Chestnut Man']

As you can see, the operator has appended the content of the books list to the content of the more_books list.

The * operator, on the other hand, makes multiple copies of a given sequence.

def main():
    books = ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow']


    print(books * 2)


if __name__ == '__main__':
    main()

# ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow', 'Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow']

So multiplying the books list by 2 gives us all the 5 books in the list twice. These operators work the same for tuples, strings, ranges or any other sequence types.

How to Use the len(), min(), and max() Functions in Python

The len() function can return the length of a given sequence. And the min() and max() functions can return the minimum and maximum value in a given sequence, respectively.

def main():
    random_numbers = [6, 1, 3, 8, 0]


    print(len(random_numbers))
    print(min(random_numbers))
    print(max(random_numbers))


if __name__ == '__main__':
    main()

# 5
# 0
# 8

Since there are 5 elements in the list, 5 is the output from the len() function call.

The smallest value in the list is 0 and the largest value is 8 which are the outputs from the min() and max() function calls, respectively.

Depending on the type of programs you end up writing in the future, these three functions can prove to be some of the most useful ones.

What Are Some String Type Operations in Python?

In the previous section, you've learned about some common operations that you can perform on any sequence type including strings.

However, the text sequence type aka strings have some special operations available to them.

In this chapter I'll introduce you to some of the most common string methods. Keep in mind that this is not a definitive list.

Although each of the methods I'm going to teach you performs a different task, they have one thing in common. None of them modifies a given string variable in place, but rather returns a new, modified copy.

If you want to learn about all the available string methods, feel free to consult the official Python documentation.

Also remember it's not a matter of just going through each method and memorizing their usage.

It's about knowing what works best in a given scenario and coming up with clever solutions. And that requires practice.

How to Capitalize Strings in Python

The first method you're going to learn is called capitalize() and it does what it sounds like.

def main():
    country_name = 'bangladesh'

    print(country_name.capitalize())


if __name__ == '__main__':
    main()

# Bangladesh

As you can see from the code snippet above, the capitalize() method turns the first letter of the word to a capital letter.

This is simple, but let's try this on a string with multiple words in it – a sentence perhaps.

def main():
    book_name = 'the house of silk'

    print(book_name.capitalize())


if __name__ == '__main__':
    main()

# The house of silk

Although the method did its job, there is slight problem. Depending on what you're trying to achieve, you may expect the first letter of each word to be capitalized.

That's where the title() method comes in. This method returns a title cased version of a given string.

def main():
    book_name = 'the house of silk'

    print(book_name.title())


if __name__ == '__main__':
    main()

# The House Of Silk

But there is still an issue. Take the following string with apostrophes for example.

def main():
    book_name = "alice's adventures in wonderland"

    print(book_name.title())


if __name__ == '__main__':
    main()

# Alice'S Adventures In Wonderland

As you can see, the title() method treats the s following the apostrophe as a separate word and capitalizes it.

Regarding this issue, the official documentation states:

The algorithm uses a simple language-independent definition of a word as groups of consecutive letters. The definition works in many contexts but it means that apostrophes in contractions and possessives form word boundaries.

The capwords() helper function can solve this issue. This function breaks the string into multiple words based on the spaces between them, capitalizes the words, joins them back into a string and returns that to the user.

from string import capwords


def main():
    book_name = "alice's adventures in wonderland"

    print(capwords(book_name))


if __name__ == '__main__':
    main()

# Alice's Adventures In Wonderland

Pay attention to the import statement at the top. The capwords() function is not a method within the string type but a function that resides inside the string module.

You'll learn about modules and imports in more details later on. For now, just roll with it. Although the function uses spaces to split words, you can overwrite it.

from string import capwords


def main():
    address = 'house 42, road 02, wonderland'

    print(capwords(address, ', '))


if __name__ == '__main__':
    main()

# House 42, Road 02, Wonderland

As you can see, in this case the string has multiple parts divided by a comma followed by a space.

The capwords() function can take a custom delimiter as its second parameter. You can pass any string as the delimiter.

Finally, there is the istitle() method that can check whether a given string is in title case or not.

def main():
    book_name = 'hearts in atlantis'

    print(f'Is "{book_name}" in title case? {book_name.istitle()}')
    print(f'Is "{book_name.title()}" in title case? {book_name.title().istitle()}')


if __name__ == '__main__':
    main()

# Is "hearts in atlantis" in title case? False
# Is "Hearts In Atlantis" in title case? True

However, keep in mind that the istitle() method doesn't work with the capwords() helper function.

How to Convert Strings to Lower Case or Upper Case in Python

Apart from capitalization, you may want to convert an entire string to upper case or lower case. You can do that by using the upper() and lower() methods in Python.

def main():
    book_name = 'moriarty'

    print(book_name.upper())

    another_book_name = 'DRACULA'

    print(another_book_name.lower())


if __name__ == '__main__':
    main()

# MORIARTY
# dracula

There are also the isupper() and islower() methods to check whether a given string is already in either of the letter cases or not.

def main():
    book_name = 'moriarty'

    print(book_name)
    print(f'Is {book_name} in upper case? {book_name.isupper()}')
    print(f'Is {book_name} in lower case? {book_name.islower()}')

    another_book_name = 'DRACULA'

    print(another_book_name)
    print(f'Is {another_book_name} in upper case? {another_book_name.islower()}')
    print(f'Is {another_book_name} in lower case? {another_book_name.isupper()}')


if __name__ == '__main__':
    main()

# moriarty
# Is moriarty in upper case? False
# Is moriarty in lower case? True
# DRACULA
# Is DRACULA in upper case? True
# Is DRACULA in lower case? False

There is one last method called casefold() which is kind of a more aggressive version of the lower() method.

According to the official documentation:

Casefolding is similar to lowercasing but more aggressive because it is intended to remove all case distinctions in a string. For example, the German lowercase letter 'ß' is equivalent to "ss". Since it is already lowercase, lower() would do nothing to 'ß'; casefold() converts it to "ss".

The usage of this method is identical to the lower() method.

def main():
    book_name = 'DRACULA'

    print(book_name.casefold())


if __name__ == '__main__':
    main()

# dracula

These three methods are fine and dandy, but what if you don't want to use any of these particular methods and just want to switch the case of a given string?

The swapcase() method can do just that.

def main():
    book_name = 'HEARTS IN ATLANTIS'

    print(book_name.swapcase())


if __name__ == '__main__':
    main()

# hearts in atlantis

As you can see, the method has converted the book name into lower case from upper case.

How to Count the Number of Occurrences of a Substring in a String in Python

If you want to find out the number of occurrences of a substring within a string, you can use the count() method in Python.

def main():
    paragraph = '''At three in the morning the chief Sussex detective, obeying the urgent call from Sergeant Wilson of 
    Birlstone, arrived from headquarters in a light dog-cart behind a breathless trotter. By the five-forty train in 
    the morning he had sent his message to Scotland Yard, and he was at the Birlstone station at twelve o'clock to 
    welcome us. White Mason was a quiet, comfortable-looking person in a loose tweed suit, with a clean-shaved, 
    ruddy face, a stoutish body, and powerful bandy legs adorned with gaiters, looking like a small farmer, 
    a retired gamekeeper, or anything upon earth except a very favourable specimen of the provincial criminal 
    officer.'''

    substring = 'morning'

    print(f'The substring "{substring}" shows up {paragraph.count(substring)} times in the paragraph.')


if __name__ == '__main__':
    main()

# The substring "morning" shows up 2 times in the paragraph.

If you call the count() method without passing anything to it, the method will return the number of empty spaces in the given string.

How to Split and Join Strings in Python

You can actually break a string into a list of words or join a list of words in a string in Python.

def main():
    string = 'Holmes was certainly not a difficult man to live with'

    word_list = string.split()

    print(word_list)


if __name__ == '__main__':
    main()

# ['Holmes', 'was', 'certainly', 'not', 'a', 'difficult', 'man', 'to', 'live', 'with']

If you call the split() method without any parameters, it'll split the given string into words using the spaces as separators.

You can override that by passing a custom separator and also fix the number of splits you want.

def main():
    string = 'Holmes,was,certainly,not,a,difficult,man,to,live,with'

    word_list = string.split(',', 5)

    print(word_list)


if __name__ == '__main__':
    main()

# ['Holmes', 'was', 'certainly', 'not', 'a', 'difficult,man,to,live,with']

This time I've replaced the spaces in the source string with commas. I've also overridden the default separator with a comma and fixed the number of splits to five.

As you can see in the output, there are five splits and the rest of the string is kept unchanged as the sixth element in the list.

The split() method is good for using with data that has been intentionally delimited. Using it with natural text with punctuation may produce unexpected results.

The opposite of the split() method is join() and it works on any iterator type in Python.

def main():
    word_list = ['Holmes', 'was', 'certainly', 'not', 'a', 'difficult', 'man', 'to', 'live', 'with']
    string = ''

    string = string.join(word_list)

    print(string)

    word_list = ['Holmes ', 'was ', 'certainly ', 'not ', 'a ', 'difficult ', 'man ', 'to ', 'live ', 'with']
    string = ''

    string = string.join(word_list)

    print(string)


if __name__ == '__main__':
    main()

# Holmeswascertainlynotadifficultmantolivewith
# Holmes was certainly not a difficult man to live with

There you have it. Notice how the join() method didn't care about adding spaces as separator after each word in the first call.

So I appended a space with each word in the list and in the second call the line has become much more readable.

How to Write Conditional Statements in Python

This is where it gets interesting. In Python or in any other programming language you can make decisions based on conditions.

I hope you remember the boolean data type from a previous section – the one that can only hold True or False values.

Well, you can use a boolean with an if statement (a conditional statement) in Python to perform an action conditionally.

def main():
    number = int(input('what number would you like to check?\n- '))

    if number % 2 == 0:
        print(f"{number} is even.")
    else:
        print(f"{number} is odd.")


if __name__ == '__main__':
    main()

# what number would you like to check?
# - 10
# 10 is even.

You start by writing out if followed by a condition and a colon. By condition, what I mean is a statement that evaluates to a boolean value (true or false).

You've been using the == operator since the beginning and already know that it checks whether the value on the left side of it is equal to the one in the right or not.

So, if you divide a given number by 2 and the remainder is 0, that's an even number – otherwise, it'll be odd.

You can use the if...else statement to choose between two different options. But, if you have multiple options to choose from, you can use the if...elif...else statement.

def main():
    year = int(input('which year would you like to check?\n- '))

    if year % 400 == 0 and year % 100 == 0:
        print(f"{year} is leap year.")
    elif year % 4 == 0 and year % 100 != 0:
        print(f"{year} is leap year.")
    else:
        print(f"{year} is not leap year.")


if __name__ == '__main__':
    main()

# which year would you like to check?
# - 2004
# 2004 is leap year.

The elif statement usually goes after an if statement and before an else statement.

Think of it like "else if", so if the if statement fails, then the elif will take over. You write it exactly like a regular if statement.

Another new thing in this example is the and operator. It's one of the logical operators in Python. It does what it does in real life.

If the expressions on both sides of the and statement evaluates to true, then the whole expression evaluates to true. Simple.

Don't worry if you do not understand the and operator in detail at the moment. You'll learn about it and its siblings in the very next section.

Another thing you need to understand is that these if statements are just regular statements so you can do pretty much anything inside them.

def main():
    number = int(input('what number would you like to check?\n- '))

    is_not_prime = False

    if number == 1:
        print(f"{number} is not a prime number.")
    elif number > 1:
        for n in range(2, number):
            if (number % n) == 0:
                is_not_prime = True
                break

        if is_not_prime:
            print(f"{number} is not a prime number.")
        else:
            print(f"{number} is a prime number.")


if __name__ == '__main__':
    main()

# what number would you like to check?
# - 10
# 10 is not a prime number.

This example is a bit more complex than what you've seen so far. So let me break it down for you. The program checks whether a given number is a prime number or not.

First, you take a number from the user. For a number to be prime, it has to be divisible only by 1 and itself. Since 1 is only divisible by 1, it's not a prime number.

Now, if the given number is larger than 1, then you'd have to divide the number with all the numbers from 2 to that particular number.

If the number is divisible by any of these numbers, then you'll turn the is_not_prime variable to True, and break the loop.

The break statement simply breaks out of a loop immediately. There is also the continue statement that can skip the current iteration instead of breaking out.

Finally, if the is_not_prime variable is True then the number is not prime, otherwise it's a prime number.

So as you can see, not only you can put loops inside a conditional statement but also put conditional statements inside a loop.

The final example that I'd like to show you is the for...else statement. As you can see in the example above, you have a for statement followed by a if...else statement.

def main():
    number = int(input('what number would you like to check?\n- '))

    if number == 1:
        print(f"{number} is not a prime number.")
    elif number > 1:
        for n in range(2, number):
            if (number % n) == 0:
                print(f"{number} is not a prime number.")
                break
        else:
            print(f"{number} is a prime number.")


if __name__ == '__main__':
    main()

# what number would you like to check?
# - 5
# 5 is a prime number.

If you put an else statement on the same level as a for statement, then Python will execute whatever you put inside that else block as soon as the loop has finished.

What are Relational and Logical Operators in Python?

In the examples above, you've seen the usage of == as well as the and operators. In this section, you'll learn about them in detail.

The relational operators come in handy when you want to check the relationship between two operands. There are six of these operators:

You've been using the equal to operator since the very beginning. The other ones you'll learn about as you keep going.

Apart from these, there are three logical operators in Python. They are the and, or, and not operators.

Take an RPG game, for example, where the hero has to have a level 45 or up shield and a level 48 or up sword in order to go to the next level.

def main():
    shield = int(input('what is your shield level? '))
    sword = int(input('what is your sword level? '))

    if shield >= 45 and sword >= 48:
        print('you shall pass!')
    else:
        print('you shall not pass!')


if __name__ == '__main__':
    main()

# what is your shield level? 42
# what is your sword level? 52
# you shall not pass!

Unless you meet both conditions, the statement will evaluate to False. You can have more conditions in a statement like this:

def main():
    shield = int(input('what is your shield level? '))
    sword = int(input('what is your sword level? '))
    armor = int(input('what is your armor level? '))

    if shield >= 45 and sword >= 48 and armor >= 25:
        print('you shall pass!')
    else:
        print('you shall not pass!')


if __name__ == '__main__':
    main()

# what is your shield level? 45
# what is your sword level? 50
# what is your armor level? 10
# you shall not pass!

The or operator, on the other hand, is a bit more forgiving. If any of the given conditions evaluates true, than the entire statement will evaluate to true.

For example in another horror game, you can only get into The Castle Dracula if you are more than 500,000 years old or legally dead.

def main():
    age = 10_000
    is_legally_dead = True

    if is_legally_dead or age > 500_000:
        print('you shall pass!')
    else:
        print('you shall not pass!')


if __name__ == '__main__':
    main()

# you shall pass!

You can mix the and and or operators together. I won't list out all the possible combinations of these operators, but as you keep working with Python, you'll get to use a lot of them.

The last logical operator that I'd like to discuss is the not operator. This operator takes only one operand and returns the opposite value.

def main():
    print('not True =', not True)
    print('not False =', not False)


if __name__ == '__main__':
    main()

# not True = False
# not False = True

For example, if you change the rules of the horror game we talked about in the previous example and make is so that only people who are over 500,000 years old and not Van Helsing can enter the castle.

def main():
    age = 800_000
    is_van_helsing = True

    if age > 500_000 and not is_van_helsing:
        print('you shall pass!')
    else:
        print('you shall not pass!')


if __name__ == '__main__':
    main()

# you shall not pass!

Since we've been talking about conditional statements and some of the operators associated with them, I'd like to introduce you to another statement first introduced in Python 3.10, the match...case statement.

Since my colleague Kolade Chris has written such a nice article on the topic, I'll not repeat that here. Feel free to check it out at your leisure.

What Are Assignment Operators in Python?

You've already encountered the simple assignment operator which is the = sign you used to assign a value to a variable.

Now there are a few variations to this operator that you can use to perform arithmetic and bitwise operations while also assigning a value.

Bitwise operations are a little out of the scope of this book, so I'll stick to the arithmetic operations.

There are seven different assignment operators in Python. Since you've already learned about the simple one, I'll discuss the other six in the following table.

These operators are not exclusive to Python, and in most programming resources, you'll find these in a much earlier chapter.

But I wanted to wait until you've learned about taking input from the user, working with ranges, and looping through them before introducting them here.

Assume that you want to write a program that calculates the sum of all the numbers within a given range.

def main():
    start = int(input('which number do you want to start from?\n- '))
    end = int(input('which number do you want to stop at?\n- '))

    total = 0

    for number in range(start, end + 1):
        total += number

    print(f"the sum of the numbers between {start} and {end} is: {total}")


if __name__ == '__main__':
    main()

# which number do you want to start from?
# - 1
# which number do you want to stop at?
# - 10
# the sum of the numbers between 1 and 10 is: 55

I hope you remember that the ending number of a range() function call is exclusive. So I had to add a +1 with the ending number.

Otherwise it's a very simple range based for loop that adds each number to the total variable and prints it out once the loop has finished.

What Is the Set Type in Python?

So far you've learned about a number of iterable types such as lists, tuples, and also strings. There is another one known as a set. Let's look at an example:

def main():
    numbers = {1, 2, 3, 4, 5}

    for number in numbers:
        print(number)


if __name__ == '__main__':
    main()

# 1
# 2
# 3
# 4
# 5

You can create a new set by putting the values between a set of curly braces. Keep in mind however, you can not create an empty set using the curly braces.

You'll have to use the set() function for that.

def main():
    numbers = {}

    print(type(numbers))

    numbers = set()

    print(type(numbers))


if __name__ == '__main__':
    main()

# <class 'dict'>
# <class 'set'>

As you can see, usage of empty curly braces creates a dictionary whereas the set() function creates an empty set.

Sets may seem similar to lists, but they are actually quite different. For starters, you can not put duplicate values in a set.

def main():
    numbers_list = [1, 2, 3, 4, 5, 3, 2, 4]

    print(numbers_list)

    numbers_set = set(numbers_list)

    print(numbers_set)


if __name__ == '__main__':
    main()

# [1, 2, 3, 4, 5, 3, 2, 4]
# {1, 2, 3, 4, 5}

The list of numbers can hold duplicate values without any problem. But as soon as you create a set from that list, all the duplicate values will be gone.

Sets are mutable, so you can add new values to a set using the add() method.

def main():
    numbers = {1, 2, 3, 4, 5}

    numbers.add(500)

    print(numbers)


if __name__ == '__main__':
    main()

# {1, 2, 3, 4, 5, 500}

Likewise you can use the discard() method to remove an item from a set or use the clear() method to remove all values altogether.

def main():
    numbers = {1, 2, 3, 4, 5}

    numbers.discard(3)

    print(numbers)

    numbers.clear()

    print(numbers)


if __name__ == '__main__':
    main()

# {1, 2, 4, 5}
# set()

Notice how an empty set shows up as set() instead of {} because the latter indicates an empty dictionary.

Apart from the fact that a set never contains duplicate values, there is another speciality of this type.

You can perform set operations such as union, intersection, complement, and difference using sets in Python.

My colleague Estefania Cassingena Navone has written an excellent guide on sets, frozen set and all the operations that you can perform on them.

Finally, if you'd like to get a definitive look at the set type, the official documentation will more than suffice.

What Is the Mapping Type in Python?

You've already learned about the sequence types and set types in Python. Those are really useful for containing a bunch of data.

But situations where you want to store data in key value pairs are not uncommon. Take, for example, an online bookshop where you have to store the prices of the books.

def main():
    programming_books = {
        'C Programming Language': 35,
        'Introduction to Algorithms': 100,
        'Clean Code: A Handbook of Agile Software Craftsmanship': 50
    }

    print(programming_books)


if __name__ == '__main__':
    main()

# {'C Programming Language': 35, 'Introduction to Algorithms': 100, 'Clean Code: A Handbook of Agile Software Craftsmanship': 50}

The variable programming_books here is a mapping type usually known as a dictionary. Declaring a dictionary is similar to declaring a list or tuple but you use a set of curly braces instead of square braces or parenthesis.

Enclosed within the braces are a bunch of key value pairs. The strings on the left side are the keys and the numbers are the values. You can access any of the keys using the get() method.

def main():
    programming_books = {
        'C Programming Language': 35,
        'Introduction to Algorithms': 100,
        'Clean Code: A Handbook of Agile Software Craftsmanship': 50
    }

    cpl = 'C Programming Language'
    algo = 'Introduction to Algorithms'

    print(f"The price of {cpl} is ${programming_books.get(cpl)}")
    print(f"The price of {algo} is ${programming_books[algo]}")


if __name__ == '__main__':
    main()

# The price of C Programming Language is $35
# The price of Introduction to Algorithms is $100

Alternatively, you can also use square braces like you did with lists to access a dictionary item.

Dictionaries are mutable which means you can add new items to them, remove or change existing items.

def main():
    programming_books = {
        'C Programming Language': 35,
        'Introduction to Algorithms': 100,
        'Clean Code: A Handbook of Agile Software Craftsmanship': 50
    }

    key = 'C Programming Language'

    programming_books[key] = 45

    programming_books['The Pragmatic Programmer'] = 32

    print(programming_books)


if __name__ == '__main__':
    main()

# {'C Programming Language': 45, 'Introduction to Algorithms': 100, 'Clean Code: A Handbook of Agile Software Craftsmanship': 50, 'The Pragmatic Programmer': 32}

You can change an existing item by accessing the item using the square braces and assign a new value to it. The price of C Programming Language has gone up by $10.

If you put a nonexistent key in between the square braces, then that'll show up as a new item. The price of The Pragmatic Programmer was not in the dictionary before but now it has been added.

For removing an item from a dictionary, you can use the popitem() or the pop() method.

def main():
    programming_books = {
        'C Programming Language': 35,
        'Introduction to Algorithms': 100,
        'Clean Code: A Handbook of Agile Software Craftsmanship': 50
    }

    print(programming_books.popitem())

    key = 'C Programming Language'

    print(programming_books.pop(key))

    print(programming_books)


if __name__ == '__main__':
    main()

# ('Clean Code: A Handbook of Agile Software Craftsmanship', 50)
# 35
# {'Introduction to Algorithms': 100}

The popitem() method removes the last item in the dictionary and returns that as a tuple.

The pop() method, on the other hand, returns the value for a given key and removes the pair.

The final print() function call shows that indeed two items were removed from the dictionary due to the pop calls.

Finally, there is the clear() method that wipes out all the pairs in a given dictionary in one go.

def main():
    programming_books = {
        'C Programming Language': 35,
        'Introduction to Algorithms': 100,
        'Clean Code: A Handbook of Agile Software Craftsmanship': 50
    }

    programming_books.clear()

    print(programming_books)


if __name__ == '__main__':
    main()

# {}

What Are Dictionary View Objects in Python?

So far in this section, you've seen dictionaries printed out as long comma separated lines between pairs of curly braces – but that's not very readable.

This is where the view objects come in handy. You can call some specific methods on dictionaries and get view objects in return.

The first method that I'm going to discuss is the keys() methods. It returns the keys of a given dictionary and you can loop over them.

def main():
    programming_books = {
        'C Programming Language': 35,
        'Introduction to Algorithms': 100,
        'Clean Code: A Handbook of Agile Software Craftsmanship': 50
    }

    for key in programming_books.keys():
        print(key)


if __name__ == '__main__':
    main()

# C Programming Language
# Introduction to Algorithms
# Clean Code: A Handbook of Agile Software Craftsmanship

Just like the keys() method, there is the values() method that returns the values in a dictionary instead.

def main():
    programming_books = {
        'C Programming Language': 35,
        'Introduction to Algorithms': 100,
        'Clean Code: A Handbook of Agile Software Craftsmanship': 50
    }

    for value in programming_books.values():
        print(value)


if __name__ == '__main__':
    main()

# 35
# 100
# 50

Finally, if you want both the keys and the values as tuples, you can use the items method.

def main():
    programming_books = {
        'C Programming Language': 35,
        'Introduction to Algorithms': 100,
        'Clean Code: A Handbook of Agile Software Craftsmanship': 50
    }

    for item in programming_books.items():
        print(item)


if __name__ == '__main__':
    main()

# ('C Programming Language', 35)
# ('Introduction to Algorithms', 100)
# ('Clean Code: A Handbook of Agile Software Craftsmanship', 50)

How to Write Functions in Python

A function in Python (and programming in general) is a self-contained collection of instructions that perform a single task.

def print_hello():
    print('Hello, World!')


def main():
    print_hello()


if __name__ == '__main__':
    main()

# Hello, World!

You define a function by writing out def followed by the name of the funtion and a colon. You can then write the function body from the next indented line.

In this example, the print_hello() prints out Hello, World! on the terminal. It doesn't accept any argument.

def print_hello(message):
    print(message)


def main():
    print_hello('Hello, Universe!')


if __name__ == '__main__':
    main()

# Hello, Universe!

Now instead of printing out Hello, World! all the time, you can pass a custom message for the function to print out.

You can make a function accept multiple arguments and even set a default value for it.

def print_hello(message, is_lower=False):
    if is_lower:
        print(message.lower())
    else:
        print(message.upper())


def main():
    print_hello('Hello, Universe!')
    print_hello('Hello, Universe!', True)


if __name__ == '__main__':
    main()

# HELLO, UNIVERSE!
# hello, universe!

Setting a default value to a function parameter makes it optional. So if you do not pass a value during the function call, your program will use the default value.

Instead of printing out the message outright, you can make the function return the message.

def hello(message, is_lower=False):
    if is_lower:
        return message.lower()
    else:
        return message.upper()


def main():
    print(hello('Hello, Universe!'))
    print(hello('Hello, Universe!', True))


if __name__ == '__main__':
    main()

# HELLO, UNIVERSE!
# hello, universe!

Since the function doesn't print out the message anymore, changing its name from print_hello() to just hello() makes more sense.

When you call the function with or without a custom message, the function returns a string that you can then print out within the main() function.

You can also save the message in variables instead of passing them to the print() function directly.

def hello(message, is_lower=False):
    if is_lower:
        return message.lower()
    else:
        return message.upper()


def main():
    uppercase_message = hello('Hello, Universe!')
    print(uppercase_message)

    lowercase_message = hello('Hello, Universe!', True)
    print(lowercase_message)


if __name__ == '__main__':
    main()

# HELLO, UNIVERSE!
# hello, universe!

It's not that you can only pass singular values to a function. You can pass lists, tuples, dictionaries or any other object to a function.

def total(numbers):
    s = 0
    for number in numbers:
        s += number
    return s


def main():
    print(total([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))


if __name__ == '__main__':
    main()

# 55

In this function, you can pass a list of numbers to and get their sum. I had to name the function total() instead of sum() because there is a built-in function with that name.

There is one last concept regarding functions that I'd like to discuss in this section, and that is recursion.

Recursion in Python or programming in general is the technique of making a function call itself to perform a task iteratively.

For example, imagine a function that accepts an integer and calculates the sum of all natural numbers up to that given integer. You can write this program using loops.

def natural_sum(last_number):
    if last_number < 1:
        return last_number

    total = 0
    for number in range(1, last_number + 1):
        total += number

    return total


def main():
    last_number = int(input('up to which number would you like to calculate the sum?\n- '))

    print(natural_sum(last_number))


if __name__ == '__main__':
    main()

# up to which number would you like to calculate the sum?
# - 10
# 55

There is nothing new there, just regular usage of a range-based for loop. Now, you can also write the same program without any loop.

def recursive_natural_sum(last_number):
    if last_number < 1:
        return last_number

    return last_number + recursive_natural_sum(last_number - 1)


def main():
    last_number = int(input('up to which number would you like to calculate the sum?\n- '))

    print(recursive_natural_sum(last_number))


if __name__ == '__main__':
    main()

# up to which number would you like to calculate the sum?
# - 10
# 55

At a glance, this piece of code may look very complicated to you. But in reality it's very simple. Let's break it down step by step.

When you call the recursive_natural_sum() function with the value of 10 for the first time, you start a chain reaction of sorts.

Since the value is not less than 1, the if statement evaluates to False and the second return statement gets called.

Inside that return statement, you're calling the recursive_natural_sum() function by passing the value of last_number - 1 which is 9 at this point.

You're also adding the returned value from this call to the current value of the last_number variable.

But you'll not get a return value because your inner function call will call itself again with last_number - 1 which will be 8 at that point.

This calling goes on and on until the value of last_digit becomes zero. Once it becomes zero, the if statement evaluates to True and the function calls start to return a value.

The value returned from each function call is last_digit + (last_digit - 1) by the end of the recursion chain it adds up to 55.

My colleague Beau Carnes has written a more in-depth article discussing how recursion works. You may take a look at it if you want to learn more.

I'm not sating that recursive functions are easier than loops – but at times, using a recursive function instead of nested loops can be more efficient.

How to Write Anonymous or Lambda Functions in Python

Anonymous or lambda functions are functions without any name. This is not something exclusive to Python and most of the modern programming languages have some sort of lambda implementation.

Instead of beginning the function declaration with def, you instead start with writing out lambda followed by a colon and the function body.

print_hello = lambda: print('Hello, World!')


def main():
    print_hello()


if __name__ == '__main__':
    main()

# Hello, World!

Since lambdas do not have a name, you have to put it in a variable in order to access it but that's not recommended. If you need a named function, use def instead.

Lambda functions are useful when you want to pass a function as an argument to another function call. Take the filter() function for example.

def check_even(number):
    if number % 2 == 0:
        return True
    else:
        return False


def main():
    numbers = [1, 2, 5, 4, 7, 88, 12, 15, 55, 77, 95]

    even_numbers = filter(check_even, numbers)

    print(list(even_numbers))


if __name__ == '__main__':
    main()

# [2, 4, 88, 12]

The filter() function takes a function and an iterable type as its two arguments. The function should describe the logic for filtering and the iterable type will contain the values you want to filter from.

In this code, you have a list of numbers and you want to filter out the odd numbers from that list.

The check_even() function takes a number as argument. It then returns True if the number is divisible by two and False if not.

The filter() function iterates through the list of numbers and passes each number to the check_even() function.

It keeps the number if the check_even() function returns True or discards the number if the check_even() function returns False.

Now this check_even() function doesn't have any purpose other than checking if a given number is divisible by two or not. So you can write it as a lambda.

def main():
    numbers = [1, 2, 5, 4, 7, 88, 12, 15, 55, 77, 95]

    even_numbers = filter(lambda number: True if number % 2 == 0 else False, numbers)

    print(list(even_numbers))


if __name__ == '__main__':
    main()

# [2, 4, 88, 12]

This lambda takes an argument named number then returns True if that's divisible by two and False otherwise.

You can add multiple arguments separating each by a comma. Finally a lambda doesn'e need a return statement but you can assume a return.

So True if number % 2 == 0 else False is equivalent to return True if number % 2 == 0 else False. The if...else statement inside the lambda is in short hand form.

How to Work with local, nonlocal and global Variables in Python

Scope of a variable in Python or programming in general refers to region where that variable is accessible.

def outside():
    message = 'Hello, World!'


def main():
    print(message)


if __name__ == '__main__':
    main()

# NameError: name 'msg' is not defined

In this example, the message variable is defined inside the outside() function and there is no existence of it anywhere else.

As a result, when you try to access that variable from the main() function, you get a NameError since the variable is scoped to the outside() function.

Variables like this are called local variables and they only exist within the block they've been declared.

Global variables, on the other hand, are usually declared outside of any particular block of code.

message = 'Hello, World!'


def main():
    print(message)


if __name__ == '__main__':
    main()

# Hello, World!

As you can see, now the message variable has no indentation and is declared at the top of the function. You could've declared the variable after the main() function.

def main():
    print(message)


message = 'Hello, World!'

if __name__ == '__main__':
    main()

# Hello, World!

This works because you don't try to access the variable until you call the main() function inside the if statement.

Although global variables are accessible pretty much everywhere, it can be a bit tricky to work with if you have a local variable with a similar name.

message = 'Hello, {name}!'


def main():
    message = message.format(name='Farhan')
    print(message)


if __name__ == '__main__':
    main()

# UnboundLocalError: local variable 'message' referenced before assignment

In this code, you have a placeholder for a name inside the message variable. You can use the format() method to put a name there.

But if you try to run this code, you'll get a local variable 'message' referenced before assignment message. In simpler words, you're trying to access a local variable named message before even assigning anything to it.

So clearly, Python is looking for a local variable with the given name instead of accessing the global one. Since it's asking, try giving it a local variable.

message = 'Hello, {name}!'


def main():
    message = str()

    message = message.format(name='Farhan')
    print(message)


if __name__ == '__main__':
    main()

This time the error will be gone but you will not get any output in your console. This is because the local message variable is empty and there is no placeholder to put a name in.

This is where the global keyword comes in. Instead of creating a local variable, you can let Python know that you're trying to access the global message variable.

message = 'Hello, {name}!'


def main():
    global message

    message = message.format(name='Farhan')
    print(message)


if __name__ == '__main__':
    main()

# Hello, Farhan!

Now, instead of trying to look for a variable named message within the local scope, Python will directly reach out to the global scope.

Finally, there is the nonlocal keyword usually used in nested functions. It solves a similar problem as the global keyword but in a local scope.

def greet(name):
    message = 'Hello, {name}!'

    def include_name():
        message = message.format(name=name)

    include_name()
    return message


def main():
    print(greet('Farhan'))


if __name__ == '__main__':
    main()

# UnboundLocalError: local variable 'message' referenced before assignment

In this example, you're dealing with three functions. There is the main() function, there is the greet() function, and inside that is the include_name() function.

The greet() function takes a name as an argument but doesn't include that in the message right away.

Instead it calls the include_name() function defined within its local scope. That's where the problem begins.

You see, the message variable is outside the scope of the include_message() function and that's why you're getting the referenced before assignment error message.

def greet(name):
    message = 'Hello, {name}!'

    def include_name():
        global message

        message = message.format(name=name)

    include_name()
    return message


def main():
    print(greet('Farhan'))


if __name__ == '__main__':
    main()

# NameError: name 'message' is not defined

You can't use the global keyword either since the message variable is not defined in the global scope and that's what the error message dictates.

You can use the nonlocal keyword to use variables that are not in the global scope but in the scope of the outer function.

def greet(name):
    message = 'Hello, {name}!'

    def include_name():
        nonlocal message
        message = message.format(name=name)

    include_name()
    return message


def main():
    print(greet('Farhan'))


if __name__ == '__main__':
    main()

# Hello, Farhan!

Now the include_name() function will look for the message variable within the scope of the greet() function instead of its local scope.

How to Pass a Variable Number of Arguments to a Function Using args and *kwargs in Python

Imagine a function that takes a bunch of numbers as arguments and returns their sum. In a function like this, it'd be nice to have the provision of passing a variable number of arguments.

Surely you can pass the numbers as a tuple or as a list but you may want to pass them as regular arguments separated by commas. You can do that by using *args or non key arguments in Python.

def total(*args):
    print(type(args))

    t = 0
    for arg in args:
        t += arg

    return t


def main():
    print(total(1, 2, 3, 4, 5))


if __name__ == '__main__':
    main()

# <class 'tuple'>
# 15

Here, you can pass an arbitrary number of variables to the total() function as argument and you'll have access to them as a tuple inside that function.

It's not mandatory to name the argument as *args, you can call it something more descriptive like _*_numbers or anything else. As long as you put the asterisk in front, you're good to go.

Like *args there is also **kwargs or keyword arguments that will allow you to access the function arguments as a dictionary.

def items(**kwargs):
    print(type(kwargs))

    for key, value in kwargs.items():
        print(f"{key} : {value}")


def main():
    items(
        Apple=10,
        Orange=8,
        Grape=35
    )


if __name__ == '__main__':
    main()

# <class 'dict'>
# Apple : 10
# Orange : 8
# Grape : 35

In this case, you can pass arbitrary number of key-value pairs and access them as a dictionary inside the items() function.

Just like the the *args keyword, you don't have to absolutely name it **kwargs. Instead you can name it anything you want.

As long as you put the double asterisks at the front, you'll be fine. The items() method within dictionaries lets you iterate through them.

You can also change the names of the key and value variables. A more readable version of the function can be as follows:

def items(**fruits):
    print(type(fruits))

    for fruit, price in fruits.items():
        print(f"{fruit} : {price}")


def main():
    items(
        Apple=10,
        Orange=8,
        Grape=35
    )


if __name__ == '__main__':
    main()

# <class 'dict'>
# Apple : 10
# Orange : 8
# Grape : 35

Keep in mind that the type of the keys in this case has to be a string and the values can be anything you want.

What Are Modules in Python?

As you project grows, breaking off your code into multiple files becomes a necessity. A module in Python is just a file containing Python code that you can import inside other Python files.

For example, assume that you have a Python project with two files. The first one may be "mathstuff.py" and the other one may be "main.py".

The "mathstuff.py" file can contain stuff related to mathematics, for example a function that sums up all the natural numbers in a range.

# mathstuff.py

def natural_sum(last_number):
    if last_number < 1:
        return last_number

    total = 0
    for number in range(1, last_number + 1):
        total += number

    return total

Now you can import this function any other file such as the "main.py" file.

import mathstuff


def main():
    last_number = int(input('up to which number would you like to calculate the sum?\n- '))

    print(mathstuff.natural_sum(last_number))


if __name__ == '__main__':
    main()

# up to which number would you like to calculate the sum?
# - 10
# 55

The import statement, as the name suggests, imports bits of code from another file or module.

It's not uncommon to house more than one function, variable, or other object in a Python module and often times you may want to use only few of them.

You can use the from...import statement in these situations.

from mathstuff import natural_sum


def main():
    last_number = int(input('up to which number would you like to calculate the sum?\n- '))

    print(natural_sum(last_number))


if __name__ == '__main__':
    main()

# up to which number would you like to calculate the sum?
# - 10
# 55

It also saves you from having to write the module name everytime you want to access a function or object living inside that module.

Finally, you can use the as keyword to change the name of an imported module to make that more easily accessible.

import mathstuff as math


def main():
    last_number = int(input('up to which number would you like to calculate the sum?\n- '))

    print(math.natural_sum(last_number))


if __name__ == '__main__':
    main()

# up to which number would you like to calculate the sum?
# - 10
# 55

Also works with the from...import statement.

from mathstuff import natural_sum as nsum


def main():
    last_number = int(input('up to which number would you like to calculate the sum?\n- '))

    print(nsum(last_number))


if __name__ == '__main__':
    main()

# up to which number would you like to calculate the sum?
# - 10
# 55

Importing modules is something that you'll have to do all the time. Apart from modules, there is also the idea of packages.

In these examples, both files are in the same folder. Packages are a nifty little way of keeping related Python modules together in different folders.

For example, in a web framework, you may have a package called framework that houses all the code that comes with this web framework.

Now this framework package can in turn have multiple subpackages – for example there may be a package named http for handling HTTP requests and responses.

├───framework
│   └───http

At the moment, these are just regular folders. To turn them into Python, all you need is to create "init.py" files inside them.

├───framework
│   │   __init__.py
│   │
│   └───http
│           __init__.py

Now these files have turned into packages. These "init.py" files will tell the Python import system that these folders are indeed packages.

Finally, to put some code inside the http package, create a file named response.py with the following content:

# framework/http/response.py

from json import dumps


def as_json(message):
    return dumps({
        'message': message
    })

First, you're importing the dumps function from the json package. These are part of the Python standard library.

The dumps function can turn a Python object like a dictionary into a JSON string, which means the as_json() function returns a given value in JSON format.

{"message": "Hello, World"}

Now you can import this function in the "main.py" file.

from framework.http.response import as_json


def main():
    print(as_json('Hello, World!'))


if __name__ == '__main__':
    main()

# {"message": "Hello, World"}

Instead of putting the as_json() function inside another Python file, you can simply put it inside the "framework/http/init.py" file.

Then you can update the "main.py" file to use the updated package path.

from framework.http import as_json


def main():
    print(as_json('Hello, World!'))


if __name__ == '__main__':
    main()

# {"message": "Hello, World"}

If you ever try out a framework like Django, you'll see that the framework contains a huge amount of packages, so understanding how the import system works will help you out immensely.

How to Use the Python Documentation Efficiently

Since you're now out of infancy as a Python programmer, I'd like to show you how you can browse through the official Python documentation.

You may think, well browsing documentation is not hard and you'd be absolutely right. But it can be daunting at first.

So what I'm going to do is give you a little primer on how I have used the documentation throughout my career.

The first step is to visit https://docs.python.org/ and you'll automatically land on the documentation for the latest version of Python.

Python Documentation (https://docs.python.org/)

At the time of writing, the latest version of Python is 3.11.4 however I still have version 3.10.11 installed on my computers.

Right from the get go, you can see lots of different links other pages and to be honest, you're not going to need all of them right away.

The best way to find out which link to what page is to to have a look at whichever looks interesting to you.

I'll talk about three links from this page that have helped me immensely. The first one is the "Tutorial" page.

The Python Tutorial (https://docs.python.org/3/tutorial/index.html)

Back when I was making my shift from C to Python, this is the tutorial I went through. The tutorial starts with an introduction to the Python interpreter.

Then it teaches you topics including but not limited to data types, control flow statements, data structures, modules, error handling, the standard library, and even object oriented programming.

The other page that's extremely useful is the "Glossary" page. It contains a list of all the important terminology that you may come across while working with Python.

Glossary (https://docs.python.org/3/glossary.html)

So at any point if you feel like that you do not know the meaning of a word, take a look at the glossary.

Finally the "Library Reference" page is a detailed description of everything included in the standard Python library.

Library Reference (https://docs.python.org/3/library/index.html)

Say, for example, I'd like to learn about the context manager type (which is beyond the scope of this book). I can just look under the "Built-in Types" section.

Or if you want to know about something else such as the JSON package, you can search the library reference for JSON – and sure enough you'll find something on it.

JSON is under the Internet Data Handling section ()

Following the link will land you on the page describing how the JSON package works.

JSON encoder and decoder (https://docs.python.org/3/library/json.html)

The page not only contains text but also contains practical and very useful code examples.

The official documentation is going to be your most reliable and in-depth source of learning, so the sooner you get used to it the better.

What's Next?

As I've said, this text is not a definitive guide to Python – which means there is still a lot to learn. In this section I'll list out a number of different resources.

Object Oriented Programming

The first thing that you may want to learn right after finishing this handbook is object oriented programming with Python.

This comprehensive video course is hosted on the freeCodeCamp YouTube channel. It's a little over 2 hours long and covers the essential concepts nicely.

Object Oriented Programming is not just about learning about concepts like classes, objects, and inheritance.

Writing good object oriented code takes a lot of practice and it all begins with the basics. Take your time with this one and make sure to understand everything.

Algorithms and Data Structures

The second item on the list that you should absolutely learn if you're serious about being an efficient programmer is data structures and algorithms.

Fortunately, the freeCodeCamp YouTube channel hosts a very comprehensive video produced by some of the finest teachers out there on the topic.

The video is a little over 5 hours long and will teach everything you need to know about data structures and algorithms as beginner.

This course is not going to turn you into a better programmer instantly, but it'll teach you a better and more efficient way of thinking about problems.

Django

If you'd like to get into web development using Python, Django is among the most popular choices out there.

The freeCodeCamp YouTube channel hosts this massive 18 hour long course taught by Dr. Chuck, one of the best teachers in the world.

The course not only teaches Django from the ground up but also a long list of concepts around the web itself.

Having a good understanding of object oriented programming is important before you jump into the world of Django, so make sure you have that.

Qt

Python may not be the most popular languages for building graphical user interfaces, but it's surprisingly capable on that end, too.

Qt is a very popular cross-platform UI framework and PySide6 is the official Python bindings for Qt 6.

In this 5 hour long course, you'l learn all the fundamentals of creating user interfaces using Qt and create cross-platform, robust software in no time.

PyGame

Just like cross-platform graphical user interfaces, Python is not the most popular choice when it comes to game programing.

However, the PyGame library is a very powerful and easy to use library for writing 2D games in Python.

In this almost 7 hour long course on game programming with Python, you'll learn about writing a game that mimicks the very popular Stardew Valley.

Undoubtedly, this is a very challenging video to go through but so is making games. So if you're into gamedev and Python, this may be the course you need.

Data Science

Data science is arguably the most popular field where Python plays a huge role. Becoming a data scientist can take years but you gotta start somewhere.

This 12 hour long course on the freeCodeCamp YouTube channel teaches you a lot about how to use your Python knowledge in data science.

Although the course doesn't go very deep into the realm of data science, it teaches you about a number of very important libraries used regularly in data science.

Near the end of the course, you'll also create a project by applying everything you learn throughout the course.

Conclusion

I would like to thank you from the bottom of my heart for the time you've spent reading this article.

Although I've listed only a small number of courses here, the freeCodeCamp YouTube channel is just filled with excellent Python learning resources.

Keep in mind that this handbook is a living document and I'll update it with from time to time. So bookmarking it maybe a great idea.

I also have a personal blog where I write about random tech stuff, so if you're interested in something like that, checkout https://farhan.dev.

If you have any questions or are confused about anything – or just want to get in touch – I'm available on Twitter and LinkedIn.

In this article, I'll walk you through the entire process of configuring Visual Studio Code for Python development. It's not a universal setup, but this is something that I use personally and have found it to be really comfortable.

The first step is to install Visual Studio Code on your computer. I'm on Debian 12 at the moment and I have the editor ready to go. Platform specific installation instructions are available in the documentation.

Assuming you are past the installation step, now I'll introduce you to a set of essential extensions that will elevate your Python development experience to the next level.

Python Extension

The first extension that you need to install is the Python Extension from Microsoft.

https://marketplace.visualstudio.com/items?itemName=ms-python.python

This is actually an extension pack that contains two extensions. The first extension is the Python extension. It lays the foundation for Python development in Visual Studio Code.

The other one is Pylance, which is a very performant language server for Python.

https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance

This extension provides rich intellisense support and is powered by Pyright, the static type checker from Microsoft. The next thing you need to think about is linting.

Ruff Linter

A linter is a program that analyses your code statically and provides valuable insights on possible errors.

The Pylance extension does an excellent job of finding out fatal errors within your code, but there is more to code than just that.

When working on a big project, it's pretty common to leave unwanted mess within your codebase. Things like unused imports and variables, bad code practices, and so on.

A good linter can point out code smells like this and make your code cleaner. Now, the go-to choice when it comes to Python linters is Pylint.

Pylint has been around for ages and works quite well, but I think there is a better alternative.

Ruff is an extremely fast Python linter written in Rust that imposes stricter linting rules than Pylint. The tool also has an official extension.

https://marketplace.visualstudio.com/items?itemName=charliermarsh.ruff

It's a plug n' play extension and doesn't require any additional configuration whatsoever. So once you have it installed, you're good to go.

Isort

Like a linter, isort is another utility that's sole purpose is sorting import statements.

https://marketplace.visualstudio.com/items?itemName=ms-python.isort

The utility sorts all the imports alphabetically, while also dividing them into sections.

The extension is very straightforward. Once you have the extension, it'll render squiggly lines under any import statement that seems out of place.

You can then use the quick action menu to sort them. Or, you can also use the command palette to quickly access the isort command.

Mypy Type Checker

Before I start talking about this extension, let me explain what mypy actually is.

According to the info on their homepage:

Mypy is an optional static type checker for Python that aims to combine the benefits of dynamic (or "duck") typing and static typing. Mypy combines the expressive power and convenience of Python with a powerful type system and compile-time type checking.

In simpler words, mypy forces you to add essential type annotations to your Python programs, making them easier to comprehend.

https://mypy-lang.org/

Recently, Microsoft has published an extension that adds type checking functionality using mypy to their beloved editor.

https://marketplace.visualstudio.com/items?itemName=ms-python.mypy-type-checker

Once you have installed the extension, it'll perform necessary checks on your code and report any missing type annotations as compile-time errors.

While having type annotations is not mandatory, it's highly recommended.

IntelliCode

IntelliCode provides AI assisted code completion in Visual Studio Code. It may sound similar to GitHub Copilot, but in reality it's a lot smaller than that.

https://marketplace.visualstudio.com/items?itemName=VisualStudioExptTeam.vscodeintellicode

Where GitHub Copilot or Tabnine provides full-blown code blocks, IntelliCode autocompletes lines of code pretty flawlessly.

In most cases, this extension can help you type less of the same code by suggesting the right thing while also keeping out of your way.

Error Lens

While not related to Python specifically, Error Lens is a great extension that embeds errors right by the side of the line of code.

I often work on my 14 inch Thinkpad and like to turn off the terminal pane. Error Lens eradicates the need to look at the terminal now and then to see my errors and warnings.

As useful as it may be, sometimes your editor can look cluttered due to all the warning and error outputs, so decide accordingly.

Indent Rainbow

Unlike other programming languages, an incorrect level of indentation can literally break your program in Python.

Visual Studio Code already does a good job of visualizing indentation levels within your code, but if you want to add some color to it, the indent-rainbow package is what you need.

https://marketplace.visualstudio.com/items?itemName=oderwat.indent-rainbow

It adds different colors to the different levels of indentation. Personally, I don't use this one on a regular basis, but you may find it useful.

Conclusion

Like I said, these extensions and my personal configuration are not a silver bullet. But this setup is something that I've been using for quite a while and I hope it's useful to you as well.

I often install specialized extensions depending on the projects I work on. For example, I use the Django or Jinja project when I work on a Django or Flask project.

Or I install the Jupyter extension while working on a Jupyter Notebook. So feel free to install whatever you need, just don't overdo it.

Regardless of how people feel about Java, I can tell you from experience is that it is an excellent programming language. After its first appearance back in 1995, it's still widely-used – and chances are it's not going anywhere anytime soon.

You can use Java to build servers, create desktop applications, games, mobile applications and more. There are also other JVM (we'll discuss what that means very soon) languages such as Kotlin, Groovy, Scala, and Clojure that you can use for different purposes.

Java is also cross-platform which means code you write and compile on one platform can run on any other platform that has Java installed on it. We'll discuss this topic in much more detail later on.

For now, I can tell you that although Java has its fair share of flaws, it also a has a lot to offer.

Table of Contents

• Prerequisites
• How to Write Hello World in Java
  • What’s Going On in the Code?
  • What is JVM?
  • What is JRE and JDK?
• How To Setup Java on Your Computer?
• How To Install a Java IDE on Your Computer?
• How To Create a New Project on IntelliJ IDEA
• How to Work with Variables in Java
  • What Are the Rules for Declaring Variables?
  • What Are final Variables?
• What are the Primitive Data Types in Java?
  • What is Type Conversion or Casting?
  • What are Wrapper Classes in Java
• How to Use Operators in Java
  • What Are the Arithmetic Operators?
  • What Are the Assignment Operators?
  • What Are the Relational Operators?
  • What Are the Logical Operators?
  • What Are the Unary Operators?
• How to Work with Strings in Java
  • How to Format a String
  • How to Get the Length of a String or Check if It's Empty or Not
  • How to Split and Join Strings
  • How to Convert a String to Upper or Lowercase
  • How to Compare Two Strings
  • How to Replace Characters or Substring in a String
  • How to Check If a String Contains a Substring or Not
• What Are the Different Ways of Inputting and Outputting Data?
• How to Use Conditional Statements in Java
• What is a switch-case statement?
• What is Variable Scope in Java?
• What Are Default Values of Variables in Java?
• How to Work with Arrays in Java
  • How to Sort an Array
  • How to Perform Binary Search on an Array
  • How to Fill an Array
  • How to Make Copies of an Array
  • How to Compare Two Arrays
• How to Use Loops in Java
  • For Loop
  • For-Each Loop
  • While Loop
  • Do-While Loop
• How to Work with Array Lists in Java
  • How to Add or Remove Multiple Elements
  • How to Remove Elements Based on a Condition
  • How to Clone and Compare Array Lists
  • How To Check if an Element Is Present or the Array List Is Empty
  • How to Sort an Array List
  • How To Keep Common Elements From Two Array Lists
  • How To Perform an Action on All Elements of an Array List
• How To Work With Hash Maps in Java
  • How To Put or Replace Multiple Elements in a Hash Map
  • How To Check if a Hash Map Contains an Item or if It’s Empty
  • How To Perform an Action on All Elements of a Hash Map
• Classes and Objects in Java
  • What is a Method?
  • What is Method Overloading?
• What are Constructors in Java?
• What Are Access Modifiers in Java?
• What Are the Getter and Setter Methods in Java?
• What is Inheritance in Java?
• How to Override a Method in Java
• Conclusion

Prerequisites

The only re-requisite for this course is familiarity with any other programming language such as Python, JavaScript, and so on.

Although I'll explain crucial programming concepts in the context of Java, I'll not explain things like what a variable is in the context of programming in general.

How to Write Hello World in Java

Ideally the first step should've been setting up Java on your computer, but I don't want to bore you with downloading and installing a bunch of software right at the beginning. For this example, you'll use https://replit.com/ as your platform.

First, head over to https://replit.com/ and create a new account if you don't already have one. You can use your existing Google/GitHub/Facebook account to login. Once logged in, you'll land on your home. From there, use the Create button under My Repls to create a new repl.

In the Create a Repl modal, choose Java as Template, set a descriptive Title such as HelloWorld and hit the Create Repl button.

A code editor will show up with an integrated terminal as follows:

On the left side is the list of files in this project, in the middle is the code editor, and on the right side is the terminal.

The template comes with some code by default. You can run the code by hitting the Run button. Go ahead and do that, run the program.

If everything goes fine, you'll see the words "Hello world!" printed on the right side. Congratulations, you've successfully run your first Java program.

What’s Going On in the Code?

The hello world program is probably the most basic executable Java program that you can possibly write – and understanding this program is crucial.

class Main {
  public static void main(String[] args) {
    System.out.println("Hello world!");
  }
}

Let's start with the first line:

class Main {
  //...
}

This line creates a Main class. A class groups together a bunch of related code within a single unit.

This is a public class, which means this class is accessible anywhere in the codebase. One Java source file (files with the .java extension) can contain only one top level public class in it.

This top level public class has to be named exactly the same as the source code filename. That's why the file named Main.java contains the main class in this project.

To understand why, click on the three dots in the list of files and click on the Show hidden files option.

This will unveil some new files within the project. Among them is the Main.class file. This is called a bytecode. When you hit the Run button, the Java compiler compiled your code from the Main.java file into this bytecode.

Now, modify the existing Hello World code as follows:

class Main {
  public static void main(String[] args) {
    System.out.println("Hello world!");
  }
}

class NotMain {
  public static void main(String[] args) {
    System.out.println("Not hello world!");
  }
}

As you can see, a new class called NotMain has been added. Go ahead and hit the Run button once more while keeping your eyes on the Files menu.

A new bytecode named NotMain.class has showed up. This means that for every class you have within your entire codebase, the compiler will create a separate bytecode.

This creates confusion about which class is the entry-point to this program. To solve this issue, Java uses the class that matches the source code file name as the entry-point to this program.

Enough about the class, now let's look at the function inside it:

class Main {
  public static void main(String[] args) {
    System.out.println("Hello world!");
  }
}

The public static void main (String[] args) function is special in Java. If you have experience with languages like C, C++ or Go, you should already know that every program in those languages has a main function. The execution of the program begins from this main function.

In Java, you have to write this function as exactly public static void main (String[] args) otherwise it won't work. In fact, if you change it even a little bit Java will start to scream.

The return type has changed from void to int and the function now returns 0 at the end. As you can see in the console, it says:

Error: Main method must return a value of type void in class Main, please 
define the main method as:
   public static void main(String[] args)

Listen to that suggestion and revert your program back to how it was before.

class Main {
  public static void main(String[] args) {
    System.out.println("Hello world!");
  }
}

The main method is a public method and the static means, you can call it without instantiating its class.

The void means that the function doesn't return any value and the String[] args means that the function takes an array of strings as an argument. This array holds command line arguments passed to the program during execution.

The System.out.println prints out strings on the terminal. In the example above, "Hello world!" has been passed to the function, so you get Hello world! printed on the terminal.

In Java, every statement ends with a semicolon. Unlike JavaScript or Python, semicolons in Java are mandatory. Leaving one out will cause the compilation to fail.

That's pretty much it for this program. If you didn't understand every aspect of this section word by word, don't worry. Things will become much clearer as you go forward.

For now, remember that the top level public class in a Java source file has to match the file name, and the main function of any Java program has to be defined as public static void main(String[] args).

What is JVM?

I've uttered the word "bytecode" a few times already in the previous section. I've also said that Java is "cross-platform" which means code written and compiled in one platform can run on any platform that has Java installed on it.

You see, your processor doesn't understand English. In fact the only thing it understands are zeros and ones, aka binary.

When you write and compile a C++ program it results in a binary file. Your processor understands it and based on the program's targeted platform, this file can be different.

Take an AMD64 and an ARMv8-A processor for example. These processors have different instruction sets. So in order to run your program on these two different platforms, you'll have to compile them separately.

But a Java program can be written once and run anywhere. I hope you remember the bytecodes we talked about in the previous section. When you compile Java code it doesn't result in binary but rather in bytecode.

This bytecode is not entirely binary but it's also not human readable. In fact, your processor can't read it either.

So instead of throwing this bytecode at the CPU, we instead run it through the Java Virtual Machine or JVM for short. JVM then reads and interprets the bytecode to the CPU.

If you would like to understand the architecture of JVM at a deeper level, I would suggest Siben Nayak's in-depth article on the topic.

What is JRE and JDK?

JRE stands for Java Runtime Environment and JDK stands for Java Development Kit.

The JRE or Java Runtime Environment packages together an implementation of the JVM along with a set of libraries required for running Java programs.

The JDK, on the other hand, packages the JRE along with all the necessary libraries for developing Java programs.

So if you want to run Java programs on your computer you install the JRE. If you want to develop Java programs yourself, you install the JDK. There are multiple implementation of the JDK.

There is the Java SE (Standard Edition) Development Kit from Oracle, then there is the OpenJDK, an official reference implementation of Java SE (Standard Edition) Development Kit.

As you can tell from the name of OpenJDK, it's open-source. So there are multiple builds of it. If you're on a Linux machine and use your distro's package manager to install JDK, it's highly likely that you'll install an OpenJDK build such as Adoptium, Microsoft Build of OpenJDK and so on.

I hope that you understand that JRE is a superset of JVM and JDK is a superset of JRE. Don't worry about different implementations or builds at the moment, you'll get your hands on them when the time comes.

How to Setup Java on Your Computer

First, head over to https://www.oracle.com/java/technologies/downloads/ and download the latest version of the Java SE Development Kit according to the platform you're on:

Once the download has finished, start the installer and go through the installation process by hitting the Next buttons. Finish it by hitting the Close button on the last page.

The installation process may vary on macOS and Linux but you should be able to figure it out by yourself.

Once the installation has finished, execute the following command on your terminal:

java --version

# java 18.0.2 2022-07-19
# Java(TM) SE Runtime Environment (build 18.0.2+9-61)
# Java HotSpot(TM) 64-Bit Server VM (build 18.0.2+9-61, mixed mode, sharing)

If it works, you've successfully install Java SE Development Kit on your computer. If you want to use OpenJDK instead, feel free to download Microsoft Build of OpenJDK or Adoptium and go through the installation process.

For the simple example programs that we're going to write in this article, it won't matter which JDK you're using. But in real life, make sure that your JDK version plays nicely with the type of project you're working on.

How to Install a Java IDE on Your Computer

When it comes to Java, IntelliJ IDEA is undeniably the best IDE out there. Even Google uses it as a base for their Android Studio.

The ultimate version of the IDE can cost an individual up-to $149.00 per year. But if you're student, you can get educational licenses for all JetBrains products for free.

There is also the completely free and open-source community edition. This is the one we'll be using throughout the entire book.

Head over to the IntelliJ IDEA download page, and download the community edition for your platform.

Once the download finishes, use the installer to install IntelliJ IDEA like any other software.

How to Create a New Project on IntelliJ IDEA

Use the shortcut from your start menu to start IntelliJ IDEA. The following window will show up:

Use the New Project button and a New Project window will show up:

Put a descriptive name for your project. Leave the rest of the options as they are and press the Create button.

The project creation shouldn't take longer than a moment and once it's done, the following window will show up:

That's the project tool window on the left side. All your source code will live inside that src folder.

Right click on the src folder and go to New > Java Class.

In the next step, put a name, such as Main for your class and make sure Class is highlighted as the type.

A new class will be created with a few lines of code.

Update the code as follows:

public class Main {
    public static void main (String[] args) {
        System.out.println("Hello World!");
    }
}

To run this code, use the green play button on the right side of the top bar.

The code will run and the output will be shown in the integrated terminal at the bottom of the window.

Congratulations, you've successfully recreated the previously discussed HelloWorld program in IntelliJ IDEA.

How to Work with Variables in Java

To work with different kinds of data in Java, you can create variables of different types. For example, if you want to store your age in a new variable, you can do so like this:

public class Main {

    public static void main(String[] args) {
        // <type> <name>
        int age;

    }

}

You start by writing out the type of data or variable. Since age is a whole number, its type will be integer or int for short, followed by the name of the variable age and a semicolon.

At the moment, you've declared the variable but you haven't initialized it. In other words, the variable doesn't have any value. You can initialize the variable as follows:

public class Main {

    public static void main(String[] args) {
        // <type> <name>
        int age;

        // <name> = <value>
        age = 27;

        // prints the age on the terminal
        System.out.println("I am " + age + " years old.");

    }

}

When assigning a value, you start by writing the name of the variable you want to initialize, followed by an equal sign (it's called the assignment operator) then the value you want to assign to the variable. And don't forget the semicolon at the end.

The System.out.println(); function call will print the line I am 27 years old. to the console. In case you're wondering, using a plus sign is one of the many ways to dynamically print out variables in the middle of a sentence.

One thing that you have to keep in mind is you can not use an uninitialized variable in Java. So if you comment out the line age = 27 by putting two forward slashes in front of it and try to compile the code, the compiler will throw the following error message at you:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    The local variable age may not have been initialized

    at variables.Main.main(Main.java:13)

The line The local variable age may not have been initialized indicates that the variable has not been initialized.

Instead of declaring and initializing the variable in different lines, you can do that in one go as follows:

public class Main {

    public static void main(String[] args) {
        // <type> <name> = <value>
        int age = 27;

        // prints the age on the terminal
        System.out.println("I am " + age + " years old.");

    }

}

The code should be back to normal again. Also, you can change the value of a variable as many times as you want in your code.

public class Main {

    public static void main(String[] args) {
        int age = 27;

        // updates the value to be 28 instead of 27
        age = 28;

        System.out.println("I am " + age + " years old.");

    }

}

In this code, the value of age will change from 27 to 28 because you're overwriting it just before printing.

Keep in mind, while you can assign values to a variables as many times as you want, you can not declare the same variable twice.

public class Main {

    public static void main(String[] args) {
        // <type> <name> = <value>
        int age = 27;

        int age = 28;

        // prints the age on the terminal
        System.out.println("I am " + age + " years old.");

    }

}

If you try to compile this code, the compiler will throw the following error message at you:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Duplicate local variable age

    at variables.Main.main(Main.java:9)

The line Duplicate local variable age indicates that the variable has already been declared.

Apart from variables, you may find the term "literal" on the internet. Literals are variables with hardcoded values.

For example, here, age = 27 and it's not dynamically calculated. You've written the value directly in the source code. So age is an integer literal.

What Are the Rules for Declaring Variables?

There are some rules when it comes to naming your variables in Java. You can name it anything as long as it doesn't start with a number and it can't contain any spaces in the name.

Although, you can start a variable name with an underscore (_) or a dollar sign ($), not being mindful of their usage can make your code hard to read. Variable names are also case sensitive. So age and AGE are two different variables.

Another important thing to remember is you can not use any of the keywords reserved by Java. There are around 50 of them at present. You can learn about these keywords from the official documentation but don't worry about memorizing them.

As you keep practicing, the important ones will slip into your neurons automatically. And if you still manage to mess up a variable declaration, the compiler will be there to remind you that something's wrong.

Apart from the rules, there are some conventions that you should follow:

• Start your variable name with small letter and not any special character (like an underscore or dollar sign).
• If the variable name has multiple words, use camel case: firstName, lastName
• Don't use single letter names: f, l

As long as you follow these rules and conventions, you're good to go. If you'd like to learn more about naming conventions in general, checkout my article on the topic.

What Are final Variables?

A final variable in Java can be initialized only once. So if you declare a variable as final, you can not reassign it.

public class Main {

    public static void main(String[] args) {
        // final <type> <name> = <value>
        final int age = 27;

        age = 28;

        System.out.println("I am " + age + " years old.");

    }

}

Since the age variable has been declared as final, the code will throw the following error message at you:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    The final local variable age cannot be assigned. It must be blank and not using a compound assignment

    at variables.Main.main(Main.java:9)

However, if you leave the variable uninitialized while declaring, the code will work:

public class Main {

    public static void main(String[] args) {
        // final <type> <name>
        final int age;

        age = 28;

        // prints the age on the terminal
        System.out.println("I am " + age + " years old.");

    }

}

So, declaring a variable as final will limit your ability to reassign its value. If you leave it uninitialized, you'll be able to initialize it as usual.

What are the Primitive Data Types in Java?

At a high level, there are two types of data in Java. There are the "primitives types" and the "non-primitive" or "reference types".

Primitive types store values. For example, int is a primitive type and it stores an integer value.

A reference type, on the other hand, stores the reference to a memory location where a dynamic object is being stored.

There are eight primitive data types in Java.

Yeah yeah I know the table looks scary but don't stress yourself. You don't have to memorize them.

You will not need to think about these ranges very frequently, and even if you do, there are ways to print them out within your Java code.

However, if you do not understand what a bit is, I would recommend this short article to learn about binary.

You've already learned about declaring an integer in the previous section. You can declare a byte, short, and long in the same way.

Declaring a double also works the same way, except you can assign a number with a decimal point instead of an integer:

public class Main {

    public static void main(String[] args) {
        double gpa = 4.8;

        System.out.println("My GPA is " + gpa + ".");

    }
}

If you assign an int to the double, such as 4 instead of 4.8, the output will be 4.0 instead of 4, because double will always have a decimal point.

Since double and float are similar, you may think that replacing the double keyword with float will convert this variable to a floating point number – but that's not correct. You'll have to append a f or F after the value:

public class Main {

    public static void main(String[] args) {
        float gpa = 4.8f;

        System.out.println("My GPA is " + gpa + ".");

    }
}

This happens because, by default, every number with a decimal point is treated as a double in Java. If you do not append the f, the compiler will think you're trying to assign a double value to a float variable.

boolean data can hold either true or false values.

public class Main {

    public static void main(String[] args) {
        boolean isWeekend = false;

        System.out.println(isWeekend); // false

    }
}

As you can imagine, false can be treated as a no and true can be treated as a yes.

Booleans will become much more useful once you've learned about conditional statements. So for now, just remember what they are and what they can hold.

The char type can hold any Unicode character within a certain range.

public class Main {

    public static void main(String[] args) {
        char percentSign = '%';

        System.out.println(percentSign); // %

    }
}

In this example, you've saved the percent sign within a char variable and printed it out on the terminal.

You can also use Unicode escape sequences to print out certain symbols.

public class Main {

    public static void main(String[] args) {
        char copyrightSymbol = '\u00A9';

        System.out.println(copyrightSymbol); // ©

    }
}

The Unicode escape sequence for the copyright symbol, for example, is \u00A9 and you can find more Unicode escape sequences on this website.

Among these 8 types of data, you'll be working with int, double, boolean, and char majority of the time.

What is Type Conversion or Casting?

Type conversion in Java can be either "implicit" or "explicit". When the compiler converts a smaller type of data to a larger one automatically, it's known as an implicit or narrowing type conversion.

public class Main {

    public static void main(String[] args) {
        int number1 = 8;
        double number2 = number1;

        System.out.println(number2); // 8.0
    }

}

Since a double is larger than an integer, the compiler could easily perform the conversion. If you try to do the reverse however, you'll face the following error from the compiler:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Type mismatch: cannot convert from double to int

    at operators.Main.main(Main.java:7)

When performing an implicit conversion, the flow of conversion should be as follows:

You can of course go from a short to a double, for example, skipping the others in between.

You can also go from smaller data types to larger ones. That's called an explicit or widening type conversion.

package datatypes;

public class Main {

    public static void main(String[] args) {
        double number1 = 8.5;
        int number2 = (int) number1;

        System.out.println(number2); // 8
    }

}

Previously you've seen that if you try to convert a larger data type to a smaller one, the compiler complains. But when you add the (int) cast operator explicitly, you show the compiler who's boss.

In doing so, you lose a part of your data. If you change the initial double number from 8.5 to just 8.0, you'll not lose any information. So whenever you're performing an explicit conversion, be careful.

You can also convert a char to an int as follows:

public class Main {

    public static void main(String[] args) {
        char character = 'F';
        int number = character;

        System.out.println(number); // 70
    }

}

70 is the ASCII code for the character F – that's why the output was like this. If you'd like to learn more about ASCII codes, my colleague Kris Koishigawa has written an excellent article on the topic.

The flow of conversion in this case will be the opposite of what you've seen already.

I'd suggest you to experiment by converting various values from one type to another and see what happens. This will deepen your understanding and make you confident.

What are Wrapper Classes in Java?

Wrapper classes can wrap around primitive datatypes and turn them into reference types. Wrapper classes are available for all eight primitive data types.

You can use these wrapper classes as follows:

public class Main {
    public static void main (String[] args) {
        Integer age = 27;
        Double gpa = 4.8;

        System.out.println(age); // 27
        System.out.println(gpa); // 4.8
    }
}

All you have to do is replace the primitive data type with the equivalent wrapper class. These reference types also have methods for extracting the primitive type from them.

For example, age.intValue() will return the age as a primitive integer and the gpa.doubleValue() will return the GPA in a primitive double type.

There are such methods for all eight datatypes. Although you'll use the primitive types most of the time, these wrapper classes will be handy in some scenarios we'll discuss in a later section.

How to Use Operators in Java

Operators in programming are certain symbols that tell the compiler to perform certain operations such as arithmetic, relational, or logical operations.

Although there are six types of operators in Java, I won't talk about bitwise operators here. Discussing bitwise operators in a beginner guide can make it intimidating.

What Are the Arithmetic Operators?

Arithmetic operators are the ones that you can use to perform arithmetic operations. There are five of them:

Addition, subtraction, multiplication, and division operations are pretty self-explanatory. Have a look at the following code example to understand:

public class Main {

    public static void main(String[] args) {
        int number1 = 10;
        int number2 = 5;

        System.out.println(number1 + number2); // 15
        System.out.println(number1 - number2); // 5
        System.out.println(number1 * number2); // 50
        System.out.println(number1 / number2); // 2
        System.out.println(number1 % number2); // 0

    }

}

Outputs from the first four operations need no explanation. In the last operation, you've performed a modulo/modulus operation using the % symbol. The result is 0 because if you divide 10 by 2, there'll be nothing left (no remainder).

Addition and multiplication operations are quite simple. But, when performing a subtraction, if the first operand is larger than the second operand, the result will be a negative number, just like in real life.

The type of data you're working with makes a difference in the result of division and modulo operations.

public class Main {

    public static void main(String[] args) {
        int number1 = 8;
        int number2 = 5;

        System.out.println(number1 / number2); // 1
    }

}

Although the result of this operation should've been 1.6 it didn't happen because in Java, if you divide an integer by another integer, the result will be an integer. But if you change both or one of them to a float/double, everything will be back to normal.

public class Main {

    public static void main(String[] args) {
        double number1 = 8;
        double number2 = 5;

        System.out.println(number1 / number2); // 1.6
    }

}

This principle applies to the modulo operations as well. If both or one of the operands are a float/double, the result will be a float/double.

What Are the Assignment Operators?

You've already worked with the assignment operator in a previous section.

public class Main {

    public static void main(String[] args) {
        // <type> <name> = <value>
        int age = 27;

        // prints the age on the terminal
        System.out.println(age);

    }

}

When you use the = symbol to assign a value to a variable, it works as an assignment operator. But, this is not the only form of this operator.

Combining the regular assignment operator with the arithmetic operators, you can achieve different results.

The following code example should make things clearer:

package operators;

public class Main {

    public static void main(String[] args) {
        double number1 = 10;
        double number2 = 5;

        number1 += number2;

        System.out.println(number1); // 15
    }

}

The other operators work the same. They operate and then assign the resultant value to the left operand.

I could demonstrate the other ones using code but I think if you try them out yourself, you'll get a better understanding. After all, experimentation and practice are the only ways to solidify your knowledge.

What Are the Relational Operators?

Relational operators are used to check the relation between operands. Such as whether an operand is equal to another operand or not.

These relational operators return either true or false depending on the operation you've performed.

There are six relational operators in Java.

The following code example demonstrates the usage of these operators:

public class Main {

    public static void main(String[] args) {
        double number1 = 10;
        double number2 = 5;

        System.out.println(number1 == number2); // false
        System.out.println(number1 != number2); // true
        System.out.println(number1 > number2); // true
        System.out.println(number1 < number2); // false
        System.out.println(number1 >= number2); // true
        System.out.println(number1 <= number2); // false
    }

}

Practical usage of these operators will become much apparent to you once you've learned about conditional statements in a later section.

You can also use these operators with characters.

public class Main {

    public static void main(String[] args) {
        char smallLetter = 'a';
        char capitalLetter = 'A';

        System.out.println(smallLetter > capitalLetter); // ???
    }

}

What do you think the output of this code will be? Find out for yourself. Remember the ASCII values of the characters? They play a role in the output of this program.

What Are the Logical Operators?

Imagine a scenario where a program you've made can only be used by people who are 18 and up but not over 40 years old. So the logic should be as follows:

can run the program if ->
    age >= 18 and age <= 40

Or in another scenario, a user has to be a student of your school or member of the library to borrow books. In this case the logic should be as follows:

can borrow books if ->
    isSchoolStudent or isLibraryMember

These logical decisions can be made using logical operators. There are three such operators in Java.

Let's see these operators in code. First, the logical and operator:

public class Main {

    public static void main(String[] args) {
        int age = 20;

        System.out.println(age >= 18 && age <= 40); // true
    }

}

In this case, there are two conditions on either side of the && operator. If and only if both conditions evaluate to true, the and operation evaluates to true.

If the first condition evaluates to false, the computer will not evaluate the rest of the conditions and return false. Because if the first one evaluates to false, then there is no way for the entire operation to evaluate to true.

The logical or operator works similarly, but in this case, if any of the conditions are true then the entire operation will evaluate to true:

public class Main {

    public static void main(String[] args) {
        boolean isSchoolStudent = true;
        boolean isLibraryMember = false;

        System.out.println(isSchoolStudent || isLibraryMember); // true
    }

}

If the first condition of a logical or operation evaluates to true, the computer will not evaluate the rest of the conditions and return true. Because if the first condition evaluates to true the operation will evaluate to true regardless of what the other conditions evaluate to.

Finally the not operator evaluates to the opposite of whatever its condition evaluates to. Take a look at the following code example:

public class Main {

    public static void main(String[] args) {
        boolean isLibraryMember = true;

        System.out.println(isLibraryMember); // true
        System.out.println(!isLibraryMember); // false
    }

}

As you can see, the not operator returns the opposite of the given boolean value. The not operator is a unary operator, meaning it operates on a single operand.

public class Main {

    public static void main(String[] args) {
        boolean isLibraryMember = true;
        boolean isSchoolStudent = false;

        System.out.println(!isSchoolStudent || isLibraryMember); // true
    }

}

In this example, the not operator turns isSchoolStudent into true, so the operation evaluates to true. However, if you modify the code as follows:

public class Main {

    public static void main(String[] args) {
        boolean isLibraryMember = true;
        boolean isSchoolStudent = false;

        System.out.println(!(isSchoolStudent || isLibraryMember)); // false
    }

}

First, the logical or operation will take place and evaluate to true. The not operator will turn it into false.

Although you've used two operands with each operator, you can use as many as you want. You can also mix and match multiple operators together.

public class Main {

    public static void main(String[] args) {
        boolean isSchoolStudent = true;
        boolean isLibraryMember = false;
        int age = 10;

        System.out.println(isSchoolStudent || isLibraryMember && age > 18); // ???
    }

}

What do you think the output of this code will be? I'd recommend you find out by yourself. :)

What Are the Unary Operators?

There are some operators that are used with one operand at a time and these are called the unary operators. Although there are five of them, I'll only discuss two.

The following code example will demonstrate them nicely:

public class Main {

    public static void main(String[] args) {
        int score = 95;
        int turns = 11;

        score++;
        turns--;

        System.out.println(score); // 96
        System.out.println(turns); // 10
    }

}

You can also use the operators as prefixes:

public class Main {

    public static void main(String[] args) {
        int score = 95;
        int turns = 11;

        ++score;
        --turns;

        System.out.println(score); // 96
        System.out.println(turns); // 10
    }

}

So far this is simple. But there are some slight differences between the postfix and prefix syntaxes that you need to understand. Look at the following code:

package operators;

public class Main {

    public static void main(String[] args) {
        int score = 95;


        System.out.println(++score); // 96
        System.out.println(score); // 96
    }

}

This is expected behavior. The prefix decrement operator will work the same. But look what happens if you switch to the postfix version:

package operators;

public class Main {

    public static void main(String[] args) {
        int score = 95;


        System.out.println(score++); // 95
        System.out.println(score); // 96
    }

}

Confusing, isn't it? What do you think is the actual value of the variable right now? It's 96. Let me explain.

When using the postfix syntax within a print function, the print function encounters the variable first and then increments it. That's why the second line prints out the newly updated value.

In case of the prefix syntax, the function encounters the increment operator first and performs the operation. Then it goes on to printing the updated value.

This little difference may catch you off guard if you're not careful. Or you try to avoid incrementing or decrementing within function calls.

How to Work with Strings in Java

The String type in Java is one of the most commonly used reference types. It's a collection of characters that you can use to form lines of text in your program.

There are two ways of creating new strings in Java. The first one is the literal way:

public class Main {
    public static void main(String[] args) {
        String name = "Farhan";

        System.out.println("My name is " + name + ".");
    }

}

As you can see, declaring and using a String this way is not very different from declaring the primitive types in Java.

The second way to create a new String is by using the new operator.

public class Main {
    public static void main(String[] args) {
        // <type> <name> = new <type>(<value>)
        String name = new String("Farhan");

        System.out.println("My name is " + name + ".");
    }

}

This program will work exactly like the previous one but there's a slight difference between the two.

The JVM maintains a portion of your computer's memory for storing strings. This portion is called the string pool.

Whenever you create a new String in the literal way, the JVM first checks if that String already exists in the pool. If it does, JVM will reuse it. If it doesn't, then the JVM will create it.

On the other hand, when you use the new operator, the JVM will always create a new String object no matter what. The following program demonstrates this concept clearly:

public class Main {

    public static void main(String[] args) {
        String literalString1 = "abc";
        String literalString2 = "abc";

        String objectString1 = new String("abc");
        String objectString2 = new String("abc");

        System.out.println(literalString1 == literalString2);
        System.out.println(objectString1 == objectString2);

    }

}

As you may already know, the == operator is used for checking equality. The output of this program will be:

true
false

Since abc was already in the string pool, the literalString2 variable reuses that. In case of the object strings however, both of them are different entities.

How to Format a String

You've already seen the usage of the + operator to sew strings together or format them in a specific way.

That approach works until you have a lot of additions to a string. It's easy to mess up the placements of the quotation marks.

A better way to format a string is the String.format() method.

public class Main {
    public static void main(String[] args) {
        String name = "Farhan";
        int age = 27;

        String formattedString = String.format("My name is %s and I'm %d years old.", name, age);

        System.out.println(formattedString);
    }

}

The method takes a string with format specifiers as its first argument and arguments to replace those specifiers as the later arguments.

In the code above, the %s, and %d characters are format specifiers. They're responsible for telling the compiler that this part of the string will be replaced with something.

Then the compiler will replace the %s with the name and the %d with the age. The order of the specifiers needs to match the order of the arguments and the arguments need to match the type of the specifier.

The %s and %d are not random. They are specific for string data and decimal integers. A chart of the commonly used specifiers are as follows:

There is also %o for octal integers, %x or %X for hexadecimal numbers, and %e or %E for scientific notations. But since, we won't discuss them in this book, I've left them out.

Just like the %s and %d specifiers you saw, you can use any of these specifiers for their corresponding data type. And just in case you're wondering, that %f specifier works for both floats and doubles.

How to Get the Length of a String or Check if It's Empty or Not

Checking the length of a string or making sure its not empty before performing some operation is a common task.

Every string object comes with a length() method that returns the length of that string. It's like the length property for arrays.

public class Main {
    public static void main(String[] args) {
        String name = "Farhan";

        System.out.println(String.format("Length of this string is: %d.", name.length())); // 6
    }

}

The method returns the length as an integer. So you can freely use it in conjunction with the integer format specifier.

To check if a string is empty or not, you can use the isEmpty() method. Like the length() method, it also comes with every string object.

public class Main {
    public static void main(String[] args) {
        String name = "Farhan";

        if (name.isEmpty()) {
            System.out.println("There is no name mentioned here");
        } else {
            System.out.println(String.format("Okay, I'll take care of %s.", name));
        }
    }

}

The method returns a boolean value so you can use it directly in if statements. The program checks if the name is empty or not and prints out different responses based off of that.

How to Split and Join Strings

The split() method can split a string based on a regular expression.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String name = "Farhan Hasin Chowdhury";

        System.out.println(Arrays.toString(name.split(" ")));
    }

}

The method returns an array of strings. Each string in that array will be a substring from the original string. Here for example, you're breaking the string Farhan Hasin Chowdhury at each space. So the output will be [Farhan, Hasin, Chowdhury].

Just a reminder that arrays are collections of multiple data of the same type.

Since the method takes a regex as argument, you can use regular expressions to perform more complex split operations.

You can also join this array back into a string like this:

public class Main {
    public static void main(String[] args) {
        String name = "Farhan Hasin Chowdhury";

        String substrings[] = name.split(" ");

        String joinedName = String.join(" ", substrings);

        System.out.println(joinedName); // Farhan Hasin Chowdhury
    }

}

The join() method can also help you in joining multiple strings together outside of an array.

public class Main {
    public static void main(String[] args) {
        System.out.println(String.join(" ", "Farhan", "Hasin", "Chowdhury")); // Farhan Hasin Chowdhury
    }

}

How to Convert a String to Upper or Lowercase

Converting a string to upper or lower case is very straightforward in Java. There are the aptly named toUpperCase() and toLowerCase() methods to perform the tasks:

public class Main {
    public static void main(String[] args) {
        String name = "Farhan Hasin Chowdhury";

        System.out.println(name.toUpperCase()); // FARHAN HASIN CHOWDHURY

        System.out.println(name.toLowerCase()); // farhan hasin chowdhury
    }

}

How to Compare Two Strings

Since strings are reference types, you can not compare them using the = operator.

The equals() method checks whether two strings are equal or not and the equalsIgnoreCase() method ignores their casing when comparing.

public class Main {
    public static void main(String[] args) {
        String name = "Farhan Hasin Chowdhury";
        String nameUpperCase = name.toUpperCase();

        System.out.println(name.equals(nameUpperCase)); // false

        System.out.println(name.equalsIgnoreCase(nameUpperCase)); // true
    }

}

How to Replace Characters or Substrings in a String

The replace() method can replace characters or entire substrings from a given string.

package strings;

public class Main {
    public static void main(String[] args) {
        String loremIpsumStd = "Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.";

        System.out.println(String.format("Standard lorem ipsum text: %s", loremIpsumStd));

        String loremIpsumHalfTranslated = loremIpsumStd.replace("Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium", "But I must explain to you how all this mistaken idea of denouncing pleasure and praising pain was born and I will give you a complete account of the system");

        System.out.println(String.format("Translated lorem ipsum text: %s", loremIpsumHalfTranslated));
    }

}

Here, the loremIpsumStd string contains a portion of the original lorem ipsum text. Then you're replacing the first line of that string and saving the new string in the loremIpsumHalfTranslated variable.

How to Check If a String Contains a Substring or Not

The contains() method can check whether a given string contains a certain substring or not.

public class Main {
    public static void main(String[] args) {
        String lyric = "Roses are red, violets are blue";

        if (lyric.contains("blue")) {
            System.out.println("The lyric has the word blue in it.");
        } else {
            System.out.println("The lyric doesn't have the word blue in it.");
        }
    }

}

The method returns a boolean value, so you can use the function in any conditional statement.

There were some of the most common string methods. If you'd like to learn about the other ones, feel free to consult the official documentation.

What Are the Different Ways of Inputting and Outputting Data?

So far you've learned about the System.out.println() method to print out information on the terminal. You've also learned about the String.format() method in a previous section.

In this section, you'll learn about some siblings of the System.out.println() method. You'll also learn about taking input from the user.

Taking input from user is extremely easy in languages like Python. However in Java, it takes a few more lines of code.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("What's your name? ");
        String name = scanner.nextLine();

        System.out.printf("So %s. How old are you? ", name);
        int age = scanner.nextInt();

        System.out.printf("Cool! %d is a good age to start programming.", age);

        scanner.close();

    }

}

The java.util.Scanner class is necessary for taking user inputs. You can bring the class to your program using the import keyword.

Then, you'll need to create a new instance of the Scanner class using the new keyword. While creating the new instance, you'll have to let it know your desired input stream.

You may want to take input from the user or from a file. Whatever it is, you'll have to let the compiler know about it. The System.in stream is the standard input and output stream.

The scanner object has methods like nextLine() for taking string input, nextInt() for taking integer input, nextDouble() for taking double input and so on.

In the code above, the scanner.nextLine() method will ask for a string from the user and return the given input with a newline character appended.

Then the scanner.nextInt() method will ask for an integer and return the given number from the user.

You may be seeing the System.out.printf() method for the first time here. Well, apart from the System.out.println() method, there is also the System.out.print() method that prints out a given string without appending a newline character to it.

The System.out.printf() is kind of a combination of the System.out.print() and String.format() methods. You can use the previously discussed format specifiers in this method as well.

Once you're done with taking input, you'll need to close the scanner object. You can do that by simply calling the scanner.close() method.

Simple right? Let me complicate it a bit.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("What's your name? ");
        String name = scanner.nextLine();

        System.out.printf("So %s. How old are you? ", name);
        int age = scanner.nextInt();

        System.out.printf("Cool! %d is a good age to start programming. \nWhat language would you prefer? ", age);
        String language = scanner.nextLine();

        System.out.printf("Ah! %s is a solid programming language.", language);

        scanner.close();

    }

}

I've added a new scanner.nextLine() statement after the scanner.nextInt() method call. Will it work?

No, it won't. The program will simply skip the last input prompt and print out the last line. This behavior is not exclusive to just scanner.nextInt(). If you use scanner.nextLine() after any of the other nextWhatever() methods, you'll face this issue.

In short, this happens because when you press enter on the scanner.nextInt() method, it consumes the integer and leaves the newline character in the input buffer.

So when scanner.nextLine() is invoked, it consumes that newline character as the end of the input. The easiest solution to this problem is writing an additional scanner.nextLine() call after the other scanner method calls.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("What's your name? ");
        String name = scanner.nextLine();

        System.out.printf("So %s. How old are you? ", name);
        int age = scanner.nextInt();

        // consumes the dangling newline character
        scanner.nextLine();

        System.out.printf("Cool! %d is a good age to start programming. \nWhat language would you prefer? ", age);
        String language = scanner.nextLine();

        System.out.printf("Ah! %s is a solid programming language.", language);

        scanner.close();

    }

}

There is another way of solving this problem. But I won't get into that here. If you're interested, checkout my article on this topic.

How to Use Conditional Statements in Java

You use conditional statements for making decision based on conditions.

It's done using the if statement as follows:

public class Main {

    public static void main(String[] args) {
        int age = 20;

        // if (condition) {...}
        if (age >= 18 && age <= 40) {
            System.out.println("you can use the program");
        }

    }

}

The statement starts with an if and then there is the condition inside a pair of parenthesis. If the condition evaluates to true, the code within the curly braces will be executed.

Code enclosed between a set of curly braces is known as a code block.

If you change the value of age to 50 the print statement will not be executed and there'll be no output on the console. For these kind of situations where the condition evaluates to false, you can add an else block:

public class Main {

    public static void main(String[] args) {
        int age = 20;

        if (age >= 18 && age <= 40) {
            System.out.println("you can use the program");
        } else {
            System.out.println("you can not use the program");
        }

    }

}

Now if the condition evaluates to false, the code within the else block will execute and you'll see you can not use the program printed on your terminal.

You can also have multiple conditions within an if-else if-else ladder:

public class Main {

    public static void main(String[] args) {
        int age = 50;
        boolean isSchoolStudent = true;
        boolean isLibraryMember = false;

        // if (condition) {...}
        if (age >= 18 && age <= 40) {
            System.out.println("you can use the program");
        } else if (isSchoolStudent || isLibraryMember) {
            System.out.println("you can use the program for a short time");
        } else {
            System.out.println("you can not use the program");
        }

    }

}

Now, if the first condition evaluates to false then the second condition will be tested. If the second one evaluates to true then the code within curly braces will be executed. If the conditions in both if statements evaluate to false, then the else block will be executed.

You can also nest if statements within other if statements as follows:

package operators;

public class Main {

    public static void main(String[] args) {
        int age = 20;

        if (age >= 18 && age <= 40) {
            boolean isSchoolStudent = true;
            boolean isLibraryMember = false;

            if (isSchoolStudent || isLibraryMember) {
                System.out.println("you can use the program");
            }
        } else {
            System.out.println("you can not use the program");
        }

    }

}

In this case, only if the first if statement evaluates to true will the inner if statement be tested.

What is a switch-case statement?

Apart from the if-else blocks, there are also switch cases where you can define multiple cases based on a single switch.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("What is the first operand? ");
        int a =scanner.nextInt();

        // consumes the dangling newline character
        scanner.nextLine();

        System.out.print("What is the second operand? ");
        int b = scanner.nextInt();

        // consumes the dangling newline character
        scanner.nextLine();

        System.out.print("What operation would you like to perform? ");
        String operation = scanner.nextLine();

        switch (operation) {
            case "sum":
                System.out.printf("%d + %d = %d", a, b, a+b);
                break;
            case "sub":
                System.out.printf("%d - %d = %d", a, b, a-b);
                break;
            case "mul":
                System.out.printf("%d * %d = %d", a, b, a*b);
                break;
            case "div":
                if (b == 0) {
                    System.out.print("Can't divide by zero!");
                } else {
                    System.out.printf("%d / %d = %d", a, b, a / b);
                }
                break;
            default:
                System.out.printf("Invalid Operation!");
        }

        scanner.close();

    }

}

This is a very simple calculator program. The program prompts the user for two numbers and then asks what operation they would like to perform.

Every switch-case statement will have one switch and multiple cases. When you say case "sum", the program checks whether the value of the switch or the operation variable in this is sum or not.

If it matches, the case body will execute. If none of the cases match, the default case will be executed.

And about that break statement. It does what it sounds like: stops the program from going into the next case.

If you remove the break statements, all the cases will be executed one after the other until the default case has been reached.

What is Variable Scope in Java?

Scope is the lifetime and accessibility of a variable. Depending on where you declare a variable you may or may not be able to access it from other places.

Take the following code snippet as an example:

public class Main {

    public static void main(String[] args) {
        int age = 20;

        if (age >= 18 && age <= 40) {
            // age variable is accessible here
            // booleans are not accessible here

            boolean isSchoolStudent = true;
            boolean isLibraryMember = false;

            if (isSchoolStudent || isLibraryMember) {
                // booleans are accessible here
                // age variable is accessible here

                System.out.println("you can use the program");
            }
        } else {
            // age variable is accessible here
            // booleans are not accessible here

            System.out.println("you can not use the program");
        }

    }

}

Here, the age variable is declared within the class code block. That means you can access this variable within the entire class without any issue. Since the variable is accessible in the entire class instance, it's an instance variable.

However, the isSchoolStudent and isLibraryMember variables have been declared within the first if statement code block. So it'll not be accessible outside of that code block.

But, it'll be accessible within any nested code block inside the first if block. These are called local variables.

There are also class variables declared using the static keyword but you'll learn about them in the object-oriented programming sections.

So for now, the rule of thumb is, a variable will be accessible within the code block it was declared at and any other code block nested inside the parent block.

What Are Default Values of Variables in Java?

You've learned that in Java, you need to initialize a variable after declaring it. Otherwise, you'll not be able to use that. Well that's not true in all cases.

If you declare a variable in the class level, that variable will be assigned a default value by the compiler.

public class Main {

    // gets 0 as the value by default
    static int age;

    public static void main(String[] args) {
        System.out.println(age); // 0
    }
}

Since the main method is static, it can only access static variables in the class level. I'll discuss static in greater detail in the object-oriented programming section.

But if you move the variable declaration inside the main method, it becomes local to that method and doesn't get any default value.

public class Main {
    public static void main(String[] args) {
        // remains uninitialized
        int age;

        System.out.println(age); // fails to compile
    }
}

This code will throw the The local variable age may not have been initialized error on compilation.

Variables get their default values based on their type. In most cases, it'll be 0 or null. I'm giving a list of all the primitive types and their default values:

Any reference type will be assigned the value null by default. We'll discuss reference types, classes, and objects in the object-oriented programming sections.

How to Work with Arrays in Java

You've already learned about declaring single variables and using them in your program. This is where arrays come in.

Arrays are data structures containing multiple value sof the same data type in sequential memory locations. Arrays can be of any primitive or non-primitive data type.

You can create an array in Java as follows:

public class Main {

    public static void main(String[] args) {
        // <type> <name>[] = new <type>[<length>]
        char vowels[] = new char[5];

    }
}

You start by typing out the type of data you want to hold in the array, char in this case. Then you write out the name of the array, vowels followed by a pair of square braces here. This pair of braces tells Java that you're declaring an array of characters and not a regular character variable.

Then you put an equal sign followed by the new operator used for creating new objects in Java. Since arrays are reference types in Java, new is required to create new instances.

You finish off the declaration by writing out the type again, followed by another pair of square braces enclosing the length of the array. Here, 5 means the array will hold five elements and not more than that.

When working with a single variable, you can refer to the variable simply by its name. But in case of an array, each element will have an index and arrays are zero-based. This means the first element in an array will have 0 as its index and not 1.

To access an element in an array, you start by writing out the name of the array – in this case vowels followed by a pair of square braces enclosing your desired index. So if you want to access the first element in the array, you can do so as follows:

public class Main {

    public static void main(String[] args) {
        char vowels[] = new char[5];

        vowels[0] = 'a';
    }
}

At this point, vowels[0] is similar to a regular character variable. You can print it out, assign new value to it, perform calculations in case of number types, and so on.

Since the array is empty at this moment, I'm assigning the character a to the first index. You can assign the rest of the vowels to the rest of the indices as follows:

public class Main {

    public static void main(String[] args) {
        char vowels[] = new char[5];

        vowels[0] = 'a';
        vowels[1] = 'e';
        vowels[2] = 'i';
        vowels[3] = 'o';
        vowels[4] = 'u';

    }
}

Since the indices start at 0 they'll end at the length of the array - 1, which in this case is 4. If you try to assign another element to the array like vowels[4] = 'x'; the compiler will throw the following error:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
    at arrays.Main.main(Main.java:18)

Arrays can not be printed like regular variables. You'll have to use a loop or you'll have to convert the array into a string. Since, I haven't discussed loops yet, I'll use the second method.

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        char vowels[] = new char[5];

        vowels[0] = 'a';
        vowels[1] = 'e';
        vowels[2] = 'i';
        vowels[3] = 'o';
        vowels[4] = 'u';

        System.out.println("These are the vowels: " + Arrays.toString(vowels));

    }
}

You'll need to first import the java.util.Arrays; and use the Arrays.toString() method to convert the array to a string. This class has a bunch of other interesting methods, but before discussing them, I'd like to show you how you can declare and initialize an array in one go.

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        char vowels[] = {'a', 'e', 'i', 'o', 'u'};

        System.out.println("These are the vowels: " + Arrays.toString(vowels));

    }
}

The left side of the declaration syntax remains unchanged. However, after the assignment operator, instead of using new you write out the individual array elements separated by comma and enclosed within a pair of curly braces.

In this case the compiler will count the number of elements in the array and use that as the length of the array.

If you do not know the length of an array, you can take a look at the length property.

In this case, vowels.length will be 5 since there are five elements in the array. The length property is an integer and is present in every array in Java.

Arrays can also be multidimensional. So far you've worked with arrays that look like this:

Single dimensional arrays like this are perfect when you want to store a series of values. But imagine someone's daily medicine routine in the form of a table:

The first row represents the seven days in a week and the columns represent how many times the patient should take their medicine out of three times a day. 0 means no and 1 means yes.

You can map this routine using a multidimensional array in your program:

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {        
        int medicineRoutine[][] = {
                {1, 2, 3, 4, 5, 6, 7},
                {0, 1, 1, 0, 1, 1, 0},
                {1, 0, 1, 0, 1, 0, 0},
                {0, 0, 1, 1, 0, 1, 0},
        };

        System.out.println(Arrays.deepToString(medicineRoutine)); // [[1, 2, 3, 4, 5, 6, 7], [0, 1, 1, 0, 1, 1, 0], [1, 0, 1, 0, 1, 0, 0], [0, 0, 1, 1, 0, 1, 0]]

    }
}

Multidimensional arrays can not be printed out using the regular Arrays.toString() method, you have to dig deeper.

Although the output doesn't look anything like the table, you can make it look like a table using some clever programming:

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {        
        int medicineRoutine[][] = {
                {1, 2, 3, 4, 5, 6, 7},
                {0, 1, 1, 0, 1, 1, 0},
                {1, 0, 1, 0, 1, 0, 0},
                {0, 0, 1, 1, 0, 1, 0},
        };

        System.out.println(Arrays.deepToString(medicineRoutine).replace("], ", "]\n"));
    }
}

// [[1, 2, 3, 4, 5, 6, 7]
// [0, 1, 1, 0, 1, 1, 0]
// [1, 0, 1, 0, 1, 0, 0]
// [0, 0, 1, 1, 0, 1, 0]]

You've already learned about the replace() method for strings. You're just replacing the ending square brace in each line with a square brace and a newline character.

The first row represents the 7 weekdays and the rest of the rows are medicine routines for each day. Each line in this table represents an array.

To access a single value from a multidimensional array, you'll need two indices. The first index determines the row and the second one determines the column.

So medicineRoutine[2][3] will select the element in index 3 of the third array. That element will be 0. Working with multidimensional array can seem a bit tricky but practicing will make it much easier.

Since you can create arrays of any type in Java, why don't you try creating some other types of arrays by yourself, huh?

How to Sort an Array

One of the most common tasks that you will perform on arrays is sorting them. The java.utils.Arrays comes with the Arrays.sort() method to do just that:

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {        
        char vowels[] = {'e', 'u', 'o', 'i', 'a'};

        Arrays.sort(vowels);

        System.out.println("The sorted array: " + Arrays.toString(vowels)); // [a, e, i, o , u]

    }
}

The Arrays.sort() method takes the unsorted array as its argument and sorts it in place. So instead of getting a new sorted array in return, your original array itself will be sorted in ascending order.

By default, the method treats the first index of the array as its starting index and the length of the array as its ending index.

You can specify these two indices manually. For example, if you want to sort only u, o, i in ascending order and leave e, a as is, you can do so as follows:

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {        
        char vowels[] = {'e', 'u', 'o', 'i', 'a'};

        int startIndex = 1;
        int endIndex = 4;

        Arrays.sort(vowels, startIndex, endIndex);

        System.out.println("The sorted array: " + Arrays.toString(vowels)); // [e, i, o, u , a]

    }
}

This time, the method takes the array as the first parameter, the starting index as the second parameter, and the ending index as the third parameter. The rest of the behaviors stay the same as before.

How to Perform Binary Search on an Array

Searching for values within a sorted value is another common task. The Arrays.binarySearch() method lets you search for items in a sorted array using the binary search algorithm.

public class Main {

    public static void main(String[] args) {
        char vowels[] = {'a', 'e', 'i', 'o', 'u'};

        char key = 'i';

        int foundItemIndex = Arrays.binarySearch(vowels, key);

        System.out.println("The vowel 'i' is at index: " + foundItemIndex); // 2

    }
}

The Arrays.binarySearch() method takes an array as its first parameter and the the search key (aka the item you're looking for) as its second parameter. It'll return the index of the found item as an integer.

You can store that index in an int and use that to access the element from the array as vowels[foundItemIndex].

Note that the array has to be sorted in ascending order. If you're unsure of the array's ordering, use the Arrays.sort() method to sort it first.

By default, the method treats the first index of the array as its starting index and the length of the array as its ending index. But you can also specify those indices manually.

For example, if you want the search to take place from index 2 to index 4, you can do so as follows:

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        char vowels[] = {'a', 'e', 'i', 'o', 'u'};

        char key = 'i';
        int startIndex = 2;
        int endIndex = 4;

        int foundItemIndex = Arrays.binarySearch(vowels, startIndex, endIndex, key);

        System.out.println("The vowel 'i' is at index: " + foundItemIndex); // 2

    }
}

This time the method takes the array you want to search on as the first parameter, the starting index as the second parameter, the ending index as the third parameter, and the search key as the fourth parameter.

Now the search will take place within i, o, and u. So if you look for a, it'll not be found. In cases where the given item is not found, you'll get a negative index. The resultant negative index will vary based on a number of factors but I won't get into those here. If you're interested in learning more, check out my article on the topic.

How to Fill an Array

You've already learned about initializing an array with values but you may sometimes want to fill an entire array with the same value. The Arrays.fill() method can do that for you:

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {        
        char vowels[] = {'e', 'u', 'o', 'i', 'a'};

        Arrays.fill(vowels, 'x');

        System.out.println("The filled array: " + Arrays.toString(vowels)); // [x, x, x, x, x]

    }
}

Like the Arrays.sort() method, Arrays.fill() also performs its operation in place. It takes your array as the first parameter, the value you want to fill the array with as the second parameter, and updates the original array in place.

This method also treats the first index as the starting index and the length of the array as the ending index. You can specify these indices manually as follows:

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {        
        char vowels[] = {'e', 'u', 'o', 'i', 'a'};

        int startIndex = 1;
        int endIndex = 4;

        Arrays.fill(vowels, startIndex, endIndex, 'x');

        System.out.println("The filled array: " + Arrays.toString(vowels)); // [e, x, x, x, a]

    }
}

This time the method takes your array as the first argument, the starting index as the second argument, the ending index as the third argument, and the filler as the fourth argument.

How to Make Copies of an Array

Since arrays in Java are of reference types, copying them using the assignment operator can cause some unexpected behavior.

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        int oddNumbers[] = {1, 3, 5};
        int copyOfOddNumbers[] = oddNumbers;

        Arrays.fill(oddNumbers, 0);

        System.out.println("The copied array: " + Arrays.toString(copyOfOddNumbers)); // [0, 0, 0]

    }
}

Although you've made changes to the source array, the copy reflects them as well. This happens because when you use the assignment operator to copy an array, the copy references the original array in the memory.

To properly copy an array, you can use the Arrays.copyOf() method as follows:

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        int oddNumbers[] = {1, 3, 5};
        int copyOfOddNumbers[] = Arrays.copyOf(oddNumbers, oddNumbers.length);

        Arrays.fill(oddNumbers, 0);

        System.out.println("The copied array: " + Arrays.toString(copyOfOddNumbers)); // [1, 3, 5]

    }
}

The method takes the source array as its first argument and the desired length of the new array as the second argument. If you want the length to be the same, simply pass the length of the original array using the length property.

If you put a smaller length, any value after that will be cut off and if you put a larger length, the new indices will be filled with the default value of the array data type.

There is another method Arrays.copyOfRange() that can copy a portion of an array to a new one:

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        int oddNumbers[] = {1, 3, 5, 7, 9, 11, 13, 15};

        int startIndex = 2;
        int endIndex = 7;

        int copyOfOddNumbers[] = Arrays.copyOfRange(oddNumbers, startIndex, endIndex);

        System.out.println("The copied array: " + Arrays.toString(copyOfOddNumbers)); // [5, 7, 9, 11, 13]

    }
}

This method takes the source array as its first argument, then the start index and finally the end index.

Keep in mind, the ending index is not inclusive. That's why 15 is absent from the new array. But if you want to include the last index of the array, use the length of the original array as the ending index.

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        int oddNumbers[] = {1, 3, 5, 7, 9, 11, 13, 15};

        int startIndex = 2;
        int endIndex = oddNumbers.length;

        int copyOfOddNumbers[] = Arrays.copyOfRange(oddNumbers, startIndex, endIndex);

        System.out.println("The copied array: " + Arrays.toString(copyOfOddNumbers)); // [5, 7, 9, 11, 13, 15]

    }
}

Now the new array will also include 15 in it. You can also put a higher number than the length of the source array. In that case the newly added indices will contain the default value of the array data type.

How to Compare Two Arrays

If you try two check if two arrays are the same or not in Java using the equal relational operator, you'll get some unexpected results.

public class Main {

    public static void main(String[] args) {        
        int oddNumbers1[] = {1, 3, 5, 7, 9, 11, 13, 15};
        int oddNumbers2[] = {1, 3, 5, 7, 9, 11, 13, 15};

        System.out.println(oddNumbers1 == oddNumbers2); // false
    }
}

Even though the two arrays are identical, the output of the program is false. Since arrays are reference types, the relational operator will check whether they are the same instance or not.

To compare two arrays in Java, you can use the Arrays.equals() method:

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {        
        int oddNumbers1[] = {1, 3, 5, 7, 9, 11, 13, 15};
        int oddNumbers2[] = {1, 3, 5, 7, 9, 11, 13, 15};

        System.out.println(Arrays.equals(oddNumbers1, oddNumbers2)); // true
    }
}

However, if you change even a single element in either of these arrays, the output will be false since the arrays will not remain identical anymore.

You can also compare multidimensional arrays, but for that you'll have to use the Arrays.deepEquals() method instead of the regular one.

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {        
        int medicineRoutine[][] = {
                {1, 2, 3, 4, 5, 6, 7},
                {0, 1, 1, 0, 1, 1, 0},
                {1, 0, 1, 0, 1, 0, 0},
                {0, 0, 1, 1, 0, 1, 0},
        };

        int medicineRoutine2[][] = {
                {1, 2, 3, 4, 5, 6, 7},
                {0, 1, 1, 0, 1, 1, 0},
                {1, 0, 1, 0, 1, 0, 0},
                {0, 0, 1, 1, 0, 1, 0},
        };

        System.out.println(Arrays.deepEquals(medicineRoutine, medicineRoutine2)); // true
    }
}

This method calls itself each time it encounters a new array inside the parent array.

These were some of the most common methods inside the java.util.Arrays class. You can consult the official documentation if you'd like to learn more.

How to Use Loops in Java

If you ever need to repeat a task for a set number of times, you can use a loop. Loops can be of three types: they are for loops, for...each loops, and while loops.

For Loop

For loops are probably the most common types of loops that you'll see on the internet.

Every for loop consists of three parts. The initialization, condition, and update expression. The looping happens in multiple steps.

If you want to print the numbers from 0 to 10 using a for loop, you can do so as follows:

public class Main {

    public static void main(String[] args) {
        for (int number = 0; number <= 10; number++) {
            System.out.println(number);
        }
    }
}

// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 10

The flowchart for this loop looks like this:

1. In the beginning of the loop, you initialize a new integer named number with the initial value of 0.
2. Then you check whether the number is less than or equal to 10 or not.
3. If its less than or equal to 10, you execute the statement inside the loop block and print out the number on the terminal.
4. Then you update the number variable by incrementing its value by 1.
5. The loop goes back to checking whether the value of number is still less than or equal or not.

As long as the value of number remains less than or equal to 10, the loop goes on. The moment the value of the number variable becomes 11, the loop ends.

You can use a for loop to loop over an array as follows:

public class Main {

    public static void main(String[] args) {
        int fibonacciNumbers[] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55};

        for(int index = 0; index < fibonacciNumbers.length; index++) {
            System.out.println(fibonacciNumbers[index]);
        }
    }
}

The flowchart for this loop will be as follows:

Since the last index of the array is one less than its length, you run the loop as long as the index is less than the array length. The moment the index becomes equal to the length of the array, you exit the loop.

One of the fun things that you can do with loops is printing out multiplication tables. For example, the multiplication table for 5 will be as follows:

public class Main {

    public static void main(String[] args) {
        int number = 5;

        for (int multiplier = 1; multiplier <= 10; multiplier++) {
            System.out.println(String.format("%d x %d = %d", number, multiplier, number * multiplier));
        }
    }
}

// 5 x 1 = 5
// 5 x 2 = 10
// 5 x 3 = 15
// 5 x 4 = 20
// 5 x 5 = 25
// 5 x 6 = 30
// 5 x 7 = 35
// 5 x 8 = 40
// 5 x 9 = 45
// 5 x 10 = 50

Loops can also be nested. Which means you can put one loop inside another. You can print out the multiplication table of all the numbers from 1 to 10 using nested loops:

public class Main {

    public static void main(String[] args) {
        for (int number = 1; number <= 10; number++) {
            System.out.println(String.format("\nmultiplication table of %d", number));
            for (int multiplier = 1; multiplier <= 10; multiplier++) {
                System.out.println(String.format("%d x %d = %d", number, multiplier, number * multiplier));
            }
        }
    }
}

I wouldn't dare printing out the output here. Instead, try out the code by yourself. Draw out each iteration of the loop on a piece of paper so that you understand what's happening on each step.

For-Each Loop

If you want to iterate over a collection like an array and perform some operation on each element of that collection, you can use a for...each loop.

public class Main {

    public static void main(String[] args) {
        int fibonacciNumbers[] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55};

        for(int number : fibonacciNumbers) {
            System.out.println(number);
        }
    }
}

In the case of a for-each loop, the type of the item needs to match the type of the collection you're working with. Here, the array is of type integer so the item in the loop is of type integer.

This does the same task as the previously shown for loop. But in this one, you don't have to keep track of the index or use the square braces to access the elements. It looks cleaner and is less error prone.

While Loop

If you want to execute a bunch of code until a certain condition is met, you can use a while loop.

There are no initialization or update steps in a while loop. Whatever happens, happens within the loop body. If you rewrite the program for printing out the multiplication table of 5 using a while loop, it'll be as follows:

public class Main {

    public static void main(String[] args) {
        int number = 5;
        int multiplier = 1;

        while (multiplier <= 10) {
            System.out.println(String.format("%d x %d = %d", number, multiplier, number*multiplier));

            multiplier++;
        }
    }
}

// 5 x 1 = 5
// 5 x 2 = 10
// 5 x 3 = 15
// 5 x 4 = 20
// 5 x 5 = 25
// 5 x 6 = 30
// 5 x 7 = 35
// 5 x 8 = 40
// 5 x 9 = 45
// 5 x 10 = 50

Although, while loops are not as common as for loops in the real world, learning about them is worth it.

Do-While Loop

The final type of loop you'll learn about is the do-while loop. It kind of reverses the order of the regular while loop – so instead of checking the condition before executing the loop body, you execute the loop body first and then check the condition.

The multiplication table code implemented using a do-while loop will be as follows:

public class Main {

    public static void main(String[] args) {
        int number = 5;
        int multiplier = 1;

        do {
            System.out.println(String.format("%d x %d = %d", number, multiplier, number*multiplier));

            multiplier++;
        } while (multiplier <= 10);
    }
}

// 5 x 1 = 5
// 5 x 2 = 10
// 5 x 3 = 15
// 5 x 4 = 20
// 5 x 5 = 25
// 5 x 6 = 30
// 5 x 7 = 35
// 5 x 8 = 40
// 5 x 9 = 45
// 5 x 10 = 50

Do-while loops are very useful when you need to perform some operation until the user gives a specific input. Such as, show a menu until user presses the "x" key.

How to Work with Array Lists in Java

Arrays in Java are not resizable. Once you've set a length for an array, you can not change it any way. The ArrayList class in Java mitigates this limitation.

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        oddNumbers.add(7);
        oddNumbers.add(9);

        System.out.println(oddNumbers.toString()); // [1, 3, 5, 7, 9]
    }
}

To create array lists, you'll need to import the java.util.ArrayList class at the top of your source file.

Then you start by writing ArrayList and then inside a pair of less than-greater than signs, you'll write the data type for the elements. Then you'll add the name of the array list itself followed by the assignment operator and new ArrayList<>().

You can not create array lists of primitive types, so you'll have to use the corresponding wrapper class.

Although these elements have zero-based indices like arrays, you can not use the square brace notation to access them. Instead, you'll have to use the get() method:

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        oddNumbers.add(7);
        oddNumbers.add(9);

        System.out.println(oddNumbers.get(2)); // 5
    }
}

The get() method will get the value in the given index. Just like get() you can use the set() method to update the value of an element.

import java.time.LocalDate;
import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        oddNumbers.add(7);
        oddNumbers.add(9);

        oddNumbers.set(2, 55);

        System.out.println(oddNumbers.get(2)); // 55
    }
}

The first parameter to the set() method is the index and the second one is the updated value.

There is no length property like in an array but you can use the size() method on any array list to find out its length.

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        oddNumbers.add(7);
        oddNumbers.add(9);

        System.out.println(oddNumbers.size()); // 5
    }
}

You can remove elements from an array list using the remove method:

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        oddNumbers.add(7);
        oddNumbers.add(9);

        oddNumbers.remove(Integer.valueOf(7));
        oddNumbers.remove(Integer.valueOf(9));

        System.out.println(oddNumbers.toString()); // [1, 3, 5]
    }
}

The remove() method can remove an element by value or by index. If you pass a primitive integer value to the method, it'll remove the element in the given index.

But if you pass an object like in this code, the method will find and delete that given element. The valueOf() method is present in all wrapper classes and it can convert a primitive value to a reference type.

How to Add or Remove Multiple Elements

You've already seen examples of the add() and remove() methods. There are two other methods addAll() and removeAll() for working with multiple elements.

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);

        ArrayList<Integer> moreOddNumbers = new ArrayList<>();

        moreOddNumbers.add(7);
        moreOddNumbers.add(9);
        moreOddNumbers.add(11);

        oddNumbers.addAll(moreOddNumbers); // [1, 3, 5, 7, 9, 11]

        System.out.println(oddNumbers.toString());

        oddNumbers.removeAll(moreOddNumbers);

        System.out.println(oddNumbers.toString()); // [1, 3, 5]
    }
}

Both methods accept collections as their parameter. In the code above, you're creating two separate array lists and joining them using the addAll() method.

Then you remove the elements from the second array list using the removeAll() method and the array list goes back to its original state.

You can also drop all elements from an array list using the clear() method:

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);

        oddNumbers.clear();

        System.out.println(oddNumbers.toString()); // []
    }
}

The method doesn't require any parameter at all and also doesn't return any value. It just empties your array list in a single call.

How to Remove Elements Based on a Condition

The removeIf() method can remove elements from an array list if they meet a certain condition:

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();

        for (int i = 0; i <= 10; i++) {
            numbers.add(i);
        }

        System.out.println(numbers.toString()); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        numbers.removeIf(number -> number % 2 == 1);

        System.out.println(numbers.toString()); // [0, 2, 4, 6, 8, 10]
    }
}

The method takes a lambda expression as a parameter. Lambda expressions are like unnamed methods. They can receive parameters and work with them.

Here, the removeIf() method will loop over the array list and pass each element to the lambda expression as the value of the number variable.

Then the lambda expression will check whether the given number is divisible by 2 or not and return true or false based on that.

If the lambda expression returns true, the removeIf() method will keep the value. Otherwise the value will be deleted.

How to Clone and Compare Array Lists

To make a duplicate of an array list, you can use the clone() method.

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();

        for (int i = 0; i <= 10; i++) {
            numbers.add(i);
        }

        ArrayList<Integer> numbersCloned = (ArrayList<Integer>)numbers.clone();

        System.out.println(numbersCloned.equals(numbers)); // true
    }
}

The clone() method returns an object, so you'll have to cast it to a proper array list manually. You can compare two array lists using the equals() method just like in arrays.

How to Check if an Element Is Present or the Array List Is Empty

You can use the contains() method to check if an array list contains a given element or not:

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        oddNumbers.add(7);
        oddNumbers.add(9);

        System.out.println(oddNumbers.isEmpty()); // false
        System.out.println(oddNumbers.contains(5)); // true
    }
}

If you want to check if an array list is empty or not, just call the isEmpty() method on it and you'll get a boolean in return.

How to Sort an Array List

You can sort an array list in different orders using the sort() method:

import java.util.ArrayList;
import java.util.Comparator;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        oddNumbers.add(5);
        oddNumbers.add(7);
        oddNumbers.add(1);
        oddNumbers.add(9);
        oddNumbers.add(3);

        System.out.println(oddNumbers.toString()); [5, 7, 1, 9, 3]

        oddNumbers.sort(Comparator.naturalOrder());

        System.out.println(oddNumbers.toString()); [1, 3, 5, 7, 9]
    }
}

The sort() method takes a comparator as its parameter. A comparator imposes the order of sorting on the array list.

You can sort the array list in reverse order just by changing the passed comparator:

import java.util.ArrayList;
import java.util.Comparator;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        oddNumbers.add(5);
        oddNumbers.add(7);
        oddNumbers.add(1);
        oddNumbers.add(9);
        oddNumbers.add(3);

        System.out.println(oddNumbers.toString()); // [5, 7, 1, 9, 3]

        oddNumbers.sort(Comparator.reverseOrder());

        System.out.println(oddNumbers.toString()); // [9, 7, 5, 3, 1]
    }
}

Comparators have other usages as well but those are out of the scope of this book.

How to Keep Common Elements From Two Array Lists

Think of a scenario where you have two array lists. Now you'll have to find out which elements are present in both array lists and remove the rest from the first array list.

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);

        ArrayList<Integer> moreOddNumbers = new ArrayList<Integer>();

        moreOddNumbers.add(5);
        moreOddNumbers.add(7);
        moreOddNumbers.add(9);

        oddNumbers.retainAll(moreOddNumbers);

        System.out.println(oddNumbers.toString()); // [5]
    }
}

The retainAll() method can get rid of the uncommon elements from the first array list for you. You'll need to call the method on the array list you want to operate on and pass the second array list as a parameter.

How to Perform an Action on All Elements of an Array List

You've already learned about looping in previous sections. Well, array lists have a forEach() method of their own that takes a lambda expression as parameter and can perform an action on all the elements of the array list.

import java.util.ArrayList;

public class Main {
    public static void main (String[] args) {
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        oddNumbers.add(7);
        oddNumbers.add(9);

        oddNumbers.forEach(number -> {
            number = number * 2;
            System.out.printf("%d ", number); // 2 6 10 14 18
        });

        System.out.println(oddNumbers.toString()); // [1, 3, 5, 7, 9]
    }
}

Last time, the lambda expression you saw was a single line – but they can be bigger. Here, the forEach() method will loop over the array list and pass each element to the lambda expression as the value of the number variable.

The lambda expression will then multiply the supplied value by 2 and print it out on the terminal. However, the original array list will be unchanged.

How to Work With Hash Maps in Java

Hash maps in Java can store elements in key-value pairs. This collection type is comparable to dictionaries in Python and objects in JavaScript.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        System.out.printf(prices.toString()); // {orange=1.8, banana=1.0, apple=2.0, berry=2.5, guava=1.5}
    }
}

To create hash maps, you'll first have to import the java.util.HashMap class at the top of your source file.

Then you start by writing HashMap and then inside a pair of less than-greater than signs, you'll write the data type for the key and the value.

Here, the keys will be strings and values will be doubles. After that the assignment operator, followed by new HashMap<>().

You can use the put() method to put a record in the hash map. The method takes the key as the first parameter and its corresponding value as the second parameter.

There is also the putIfAbsent() method that adds the given element only if it already doesn't exist in the hash map.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        prices.putIfAbsent("guava", 2.9);

        System.out.println(prices.toString()); // {orange=1.8, banana=1.0, apple=2.0, berry=2.5, guava=1.5}
    }
}

You can use the get() method to bring out a value from the hash map. The method takes the key as its parameter.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        System.out.println(prices.get("banana")); // 1.000000
    }
}

There is another variation of the this method. The getOrDefault() method works like get() but if the given key is not found, it'll return a specified default value.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        System.out.println(prices.getOrDefault("jackfruit", 0.0)); // 0.0
    }
}

The default value has to match the type of the values in the hash map. You can update a value in a hash map using the replace() method:

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        prices.replace("berry", 2.8);

        System.out.printf(prices.toString()); // {orange=1.8, banana=1.0, apple=2.0, berry=2.8, guava=1.5}
    }
}

For removing elements from a hash map, you can use the aptly named remove() method:

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        prices.remove("guava");

        System.out.printf(prices.toString()); // {orange=1.8, banana=1.0, apple=2.0, berry=2.5}
    }
}

If you ever need to know how many entries are there in a hash map, you can do so by using the size() method:

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        System.out.println(prices.size()); // 5
    }
}

Finally if you want to clear a hash map in Java, you can do so by using the clear() method.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        prices.clear();

        System.out.println(prices.toString()); // {}
    }
}

Just like in the array lists, the method doesn't take any argument or return any value.

How to Put in or Replace Multiple Elements in a Hash Map

If you want to put multiple elements into a hash map in a single go, you can do so by using the putAll() method:

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        HashMap<String, Double> morePrices = new HashMap<>();

        prices.put("jackfruit", 2.9);
        prices.put("pineapple", 1.1);
        prices.put("tomato", 0.8);

        prices.putAll(morePrices);

        System.out.println(prices.toString()); // {orange=1.8, banana=1.0, apple=2.0, berry=2.5, pineapple=1.1, tomato=0.8, guava=1.5, jackfruit=2.9}
    }
}

The method takes another hash map as its parameter and adds its elements to the one the method has been called upon.

You can also use the replaceAll() method to update multiple values in a hash map.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        prices.replaceAll((fruit, price) -> price * 2);

        System.out.println(prices.toString()); // {orange=3.6, banana=2.0, apple=4.0, berry=5.0, guava=3.0}
    }
}

The replace all method iterates over the hashmap and passes each key value pair to the lambda expression.

The first parameter to the lambda expression is the key and the second one is the value. Inside the lambda expression, you perform your actions.

How to Check if a Hash Map Contains an Item or if It’s Empty

You can use the methods containsKey() and containsValue() for checking if a hash map contains a value or not.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        System.out.println(prices.containsKey("banana")); // true
        System.out.println(prices.containsValue(2.5)); // true
    }
}

Difference between the two methods is that the containsKey() method checks if the given key exists or not and the containsValue() method checks if the given value exists or not.

And if you want to check if a hash map is empty or not, you can do so by using the isEmpty() method:

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        System.out.println(prices.isEmpty()); // false
    }
}

Since the method returns a boolean value, you can use it within if-else statements.

How to Perform an Action on All Elements of a Hash Map

Like the array lists, hash maps also have their own forEach() method that you can use to loop over the hash map and repeat a certain action over each entry.

import java.util.HashMap;

public class Main {
    public static void main (String[] args) {
        HashMap<String, Double> prices = new HashMap<>();

        prices.put("apple", 2.0);
        prices.put("orange", 1.8);
        prices.put("guava", 1.5);
        prices.put("berry", 2.5);
        prices.put("banana", 1.0);

        System.out.println("prices after discounts");

        prices.forEach((fruit, price) -> {
            System.out.println(fruit + " - " + (price - 0.5));
        });
    }
}

// prices after discounts
// orange - 1.3
// banana - 0.5
// apple - 1.5
// berry - 2.0
// guava - 1.0

The method loops over each entry and passes the key and value to the lambda expression. Inside the lambda expression body, you can do whatever you want.

Classes and Objects in Java

Here's a helpful definition of object-oriented programming:

OOP (Object-oriented programming) is a programming paradigm based on the concept of "objects", which can contain data and code: data in the form of fields (often known as attributes or properties), and code, in the form of procedures (often known as methods).

Imagine a library management system where members of the library can log in, take a look at the books they have already borrowed, request new ones, and so on.

In this system the users and the books can all be objects. These objects will have their own properties such as name and birthday (in case of a user) and title and author in case of the books.

Classes in object oriented programming are blueprints for the aforementioned objects. We've already discussed the possible properties of the user and book objects.

To create a new User class, right click on the src folder once again. Then go to New > Java Class, name it User, and hit enter.

Keeping the previously discussed properties in mind, your code for the User class should be as follows:

import java.time.LocalDate;

public class User {
    String name;
    LocalDate birthDay;
}

The LocalDate is a reference data type that represents a date. Now go back to the Main.java file and create a new instance of this class:

import java.time.LocalDate;

public class Main {
    public static void main (String[] args) {
        User user = new User();

        user.name = "Farhan";
        user.birthDay = LocalDate.parse("1996-07-15");

        System.out.printf("%s was born on %s.", user.name, user.birthDay.toString()); // Farhan was born on 15th July 1996.
    }
}