Join the “Zero to Data Analyst” Bootcamp. Limited seats.

A 20-week program covering 7 courses, 12 assignments, 4 real-world projects, and 12 months of career support.

Updated 5 months ago

This tutorial series is a beginner-friendly introduction to programming and data analysis using the Python programming language. These tutorials take a practical and coding-focused approach. The best way to learn the material is to execute the code and experiment with it yourself. Check out the full series here:

- First Steps with Python and Jupyter
- A Quick Tour of Variables and Data Types
- Branching using Conditional Statements and Loops
- Writing Reusable Code Using Functions
- Reading from and Writing to Files
- Numerical Computing with Python and Numpy
- Analyzing Tabular Data using Pandas
- Data Visualization using Matplotlib & Seaborn
- Exploratory Data Analysis - A Case Study

This tutorial covers the following topics:

- Performing arithmetic operations using Python
- Solving multi-step problems using variables
- Evaluating conditions using Python
- Combining conditions with logical operators
- Adding text styles using Markdown

This tutorial is an executable Jupyter notebook hosted on Jovian (don't worry if these terms seem unfamiliar; we'll learn more about them soon). You can *run* this tutorial and experiment with the code examples in a couple of ways: *using free online resources* (recommended) or *on your computer*.

The easiest way to start executing the code is to click the **Run** button at the top of this page and select **Run on Binder**. You can also select "Run on Colab" or "Run on Kaggle", but you'll need to create an account on Google Colab or Kaggle to use these platforms.

To run the code on your computer locally, you'll need to set up Python, download the notebook and install the required libraries. We recommend using the Conda distribution of Python. Click the **Run** button at the top of this page, select the **Run Locally** option, and follow the instructions.

Jupyter Notebooks: This tutorial is a Jupyter notebook - a document made ofcells. Each cell can contain code written in Python or explanations in plain English. You can execute code cells and view the results, e.g., numbers, messages, graphs, tables, files, etc. instantly within the notebook. Jupyter is a powerful platform for experimentation and analysis. Don't be afraid to mess around with the code & break things - you'll learn a lot by encountering and fixing errors. You can use the "Kernel > Restart & Clear Output" menu option to clear all outputs and start again from the top.

Let's begin by using Python as a calculator. You can write and execute Python using a code cell within Jupyter.

Working with cells: To create a new cell within Jupyter, you can select "Insert > Insert Cell Below" from the menu bar or just press the "+" button on the toolbar. You can also use the keyboard shortcut`Esc+B`

to create a new cell. Once a cell is created, click on it to select it. You can then change the cell type to code or markdown (text) using the "Cell > Cell Type" menu option. You can also use the keyboard shortcuts`Esc+Y`

and`Esc+M`

. Double-click a cell to edit the content within the cell. To apply your changes and run a cell, use the "Cell > Run Cells" menu option or click the "Run" button on the toolbar or just use the keyboard shortcut`Shift+Enter`

. You can see a full list of keyboard shortcuts using the "Help > Keyboard Shortcuts" menu option.

Run the code cells below to perform calculations and view their result. Try changing the numbers and run the modified cells again to see updated results. Can you guess what the `//`

, `%`

, and `**`

operators are used for?

In [1]:

`2 + 3 + 9`

Out[1]:

`14`

In [2]:

`99 - 73`

Out[2]:

`26`

In [3]:

`23.54 * -1432`

Out[3]:

`-33709.28`

In [4]:

`100 / 7`

Out[4]:

`14.285714285714286`

In [5]:

`100 // 7`

Out[5]:

`14`

In [6]:

`100 % 7`

Out[6]:

`2`

In [7]:

`5 ** 3`

Out[7]:

`125`

As you might expect, operators like `/`

and `*`

take precedence over other operators like `+`

and `-`

as per mathematical conventions. You can use parentheses, i.e. `(`

and `)`

, to specify the order in which operations are performed.

In [8]:

`((2 + 5) * (17 - 3)) / (4 ** 3)`

Out[8]:

`1.53125`

Python supports the following arithmetic operators:

Operator | Purpose | Example | Result |
---|---|---|---|

`+` |
Addition | `2 + 3` |
`5` |

`-` |
Subtraction | `3 - 2` |
`1` |

`*` |
Multiplication | `8 * 12` |
`96` |

`/` |
Division | `100 / 7` |
`14.28..` |

`//` |
Floor Division | `100 // 7` |
`14` |

`%` |
Modulus/Remainder | `100 % 7` |
`2` |

`**` |
Exponent | `5 ** 3` |
`125` |

Try solving some simple problems from this page: https://www.math-only-math.com/worksheet-on-word-problems-on-four-operations.html .

You can use the empty cells below and add more cells if required.

In [ ]:

` `

In [ ]:

` `

In [ ]:

` `

In [ ]:

` `

Let's try solving the following word problem using Python:

A grocery store sells a bag of ice for $1.25 and makes a 20% profit. If it sells 500 bags of ice, how much total profit does it make?

We can list out the information provided and gradually convert the word problem into a mathematical expression that can be evaluated using Python.

*Cost of ice bag ($)* = 1.25

*Profit margin* = 20% = .2

*Profit per bag ($)* = profit margin * cost of ice bag = .2 * 1.25

*No. of bags* = 500

*Total profit* = no. of bags * profit per bag = 500 * (.2 * 1.25)

In [9]:

`500 * (.2 * 1.25)`

Out[9]:

`125.0`

Thus, the grocery store makes a total profit of $125. While this is a reasonable way to solve a problem, it's not entirely clear by looking at the code cell what the numbers represent. We can give names to each of the numbers by creating Python *variables*.

Variables: While working with a programming language such as Python, information is stored invariables. You can think of variables as containers for storing data. The data stored within a variable is called itsvalue.

In [10]:

`cost_of_ice_bag = 1.25`

In [11]:

`profit_margin = .2`

In [12]:

`number_of_bags = 500`

The variables `cost_of_ice_bag`

, `profit_margin`

, and `number_of_bags`

now contain the information provided in the word problem. We can check the value of a variable by typing its name into a cell. We can combine variables using arithmetic operations to create other variables.

Code completion: While typing the name of an existing variable in a code cell within Jupyter, just type the first few characters and press the`Tab`

key to autocomplete the variable's name. Try typing`pro`

in a code cell below and press`Tab`

to autocomplete to`profit_margin`

.

In [13]:

`profit_margin`

Out[13]:

`0.2`

In [14]:

`profit_per_bag = cost_of_ice_bag * profit_margin`

In [15]:

`profit_per_bag`

Out[15]:

`0.25`

In [16]:

`total_profit = number_of_bags * profit_per_bag`

In [17]:

`total_profit`

Out[17]:

`125.0`

If you try to view the value of a variable that has not been *defined*, i.e., given a value using the assignment statement `variable_name = value`

, Python shows an error.

In [18]:

`net_profit`

```
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-18-5eb2b296f798> in <module>
----> 1 net_profit
NameError: name 'net_profit' is not defined
```

Storing and manipulating data using appropriately named variables is a great way to explain what your code does.

Let's display the result of the word problem using a friendly message. We can do this using the `print`

*function*.

Functions: A function is a reusable set of instructions. It takes one or more inputs, performs certain operations, and often returns an output. Python provides many in-built functions like

In [19]:

`print("The grocery store makes a total profit of $", total_profit)`

```
The grocery store makes a total profit of $ 125.0
```

: The`"this is some text"`

), numbers, variables, mathematical expressions, etc. We'll learn more about variables & functions in the next tutorial.

Creating a code cell for each variable or mathematical operation can get tedious. Fortunately, Jupyter allows you to write multiple lines of code within a single code cell. The result of the last line of code within the cell is displayed as the output.

Let's rewrite the solution to our word problem within a single cell.

In [20]:

```
# Store input data in variables
cost_of_ice_bag = 1.25
profit_margin = .2
number_of_bags = 500
# Perform the required calculations
profit_per_bag = cost_of_ice_bag * profit_margin
total_profit = number_of_bags * profit_per_bag
# Display the result
print("The grocery store makes a total profit of $", total_profit)
```

```
The grocery store makes a total profit of $ 125.0
```

Note that we're using the `#`

character to add *comments* within our code.

Comments: Comments and blank lines are ignored during execution, but they are useful for providing information to humans (including yourself) about what the code does. Comments can be inline (at the end of some code), on a separate line, or even span multiple lines.

Inline and single-line comments start with `#`

, whereas multi-line comments begin and end with three quotes, i.e. `"""`

. Here are some examples of code comments:

In [21]:

`my_favorite_number = 1 # an inline comment`

In [22]:

```
# This comment gets its own line
my_least_favorite_number = 3
```

In [23]:

```
"""This is a multi-line comment.
Write as little or as much as you'd like.
Comments are really helpful for people reading
your code, but try to keep them short & to-the-point.
Also, if you use good variable names, then your code is
often self explanatory, and you may not even need comments!
"""
a_neutral_number = 5
```

Apart from arithmetic operations, Python also provides several operations for comparing numbers & variables.

Operator | Description |
---|---|

`==` |
Check if operands are equal |

`!=` |
Check if operands are not equal |

`>` |
Check if left operand is greater than right operand |

`<` |
Check if left operand is less than right operand |

`>=` |
Check if left operand is greater than or equal to right operand |

`<=` |
Check if left operand is less than or equal to right operand |

The result of a comparison operation is either `True`

or `False`

(note the uppercase `T`

and `F`

). These are special keywords in Python. Let's try out some experiments with comparison operators.

In [24]:

```
my_favorite_number = 1
my_least_favorite_number = 5
a_neutral_number = 3
```

In [25]:

```
# Equality check - True
my_favorite_number == 1
```

Out[25]:

`True`

In [26]:

```
# Equality check - False
my_favorite_number == my_least_favorite_number
```

Out[26]:

`False`

In [27]:

```
# Not equal check - True
my_favorite_number != a_neutral_number
```

Out[27]:

`True`

In [28]:

```
# Not equal check - False
a_neutral_number != 3
```

Out[28]:

`False`

In [29]:

```
# Greater than check - True
my_least_favorite_number > a_neutral_number
```

Out[29]:

`True`

In [30]:

```
# Greater than check - False
my_favorite_number > my_least_favorite_number
```

Out[30]:

`False`

In [31]:

```
# Less than check - True
my_favorite_number < 10
```

Out[31]:

`True`

In [32]:

```
# Less than check - False
my_least_favorite_number < my_favorite_number
```

Out[32]:

`False`

In [33]:

```
# Greater than or equal check - True
my_favorite_number >= 1
```

Out[33]:

`True`

In [34]:

```
# Greater than or equal check - False
my_favorite_number >= 3
```

Out[34]:

`False`

In [35]:

```
# Less than or equal check - True
3 + 6 <= 9
```

Out[35]:

`True`

In [36]:

```
# Less than or equal check - False
my_favorite_number + a_neutral_number <= 3
```

Out[36]:

`False`

Just like arithmetic operations, the result of a comparison operation can also be stored in a variable.

In [37]:

```
cost_of_ice_bag = 1.25
is_ice_bag_expensive = cost_of_ice_bag >= 10
print("Is the ice bag expensive?", is_ice_bag_expensive)
```

```
Is the ice bag expensive? False
```

The logical operators `and`

, `or`

and `not`

operate upon conditions and `True`

& `False`

values (also known as *booleans*). `and`

and `or`

operate on two conditions, whereas `not`

operates on a single condition.

The `and`

operator returns `True`

when both the conditions evaluate to `True`

. Otherwise, it returns `False`

.

`a` |
`b` |
`a and b` |
---|---|---|

`True` |
`True` |
`True` |

`True` |
`False` |
`False` |

`False` |
`True` |
`False` |

`False` |
`False` |
`False` |

In [38]:

`my_favorite_number`

Out[38]:

`1`

In [39]:

`my_favorite_number > 0 and my_favorite_number <= 3`

Out[39]:

`True`

In [40]:

`my_favorite_number < 0 and my_favorite_number <= 3`

Out[40]:

`False`

In [41]:

`my_favorite_number > 0 and my_favorite_number >= 3`

Out[41]:

`False`

In [42]:

`True and False`

Out[42]:

`False`

In [43]:

`True and True`

Out[43]:

`True`

The `or`

operator returns `True`

if at least one of the conditions evaluates to `True`

. It returns `False`

only if both conditions are `False`

.

`a` |
`b` |
`a or b` |
---|---|---|

`True` |
`True` |
`True` |

`True` |
`False` |
`True` |

`False` |
`True` |
`True` |

`False` |
`False` |
`False` |

In [44]:

`a_neutral_number = 3`

In [45]:

`a_neutral_number == 3 or my_favorite_number < 0`

Out[45]:

`True`

In [46]:

`a_neutral_number != 3 or my_favorite_number < 0`

Out[46]:

`False`

In [47]:

`my_favorite_number < 0 or True`

Out[47]:

`True`

In [48]:

`False or False`

Out[48]:

`False`

The `not`

operator returns `False`

if a condition is `True`

and `True`

if the condition is `False`

.

In [49]:

`not a_neutral_number == 3`

Out[49]:

`False`

In [50]:

`not my_favorite_number < 0`

Out[50]:

`True`

In [51]:

`not False`

Out[51]:

`True`

In [52]:

`not True`

Out[52]:

`False`

Logical operators can be combined to form complex conditions. Use round brackets or parentheses `(`

and `)`

to indicate the order in which logical operators should be applied.

In [53]:

`(2 > 3 and 4 <= 5) or not (my_favorite_number < 0 and True)`

Out[53]:

`True`

In [54]:

`not (True and 0 < 1) or (False and True)`

Out[54]:

`False`

If parentheses are not used, logical operators are applied from left to right.

In [55]:

`not True and 0 < 1 or False and True`

Out[55]:

`False`

Experiment with arithmetic, conditional and logical operators in Python using the interactive nature of Jupyter notebooks. We will learn more about variables and functions in future tutorials.

Adding explanations using text cells (like this one) is a great way to make your notebook informative for other readers. It is also useful if you need to refer back to it in the future. You can double click on a text cell within Jupyter to edit it. In the edit mode, you'll notice that the text looks slightly different (for instance, the heading has a `##`

prefix. This text is written using Markdown, a simple way to add styles to your text. Execute this cell to see the output without the special characters. You can switch back and forth between the source and the output to apply a specific style.

For instance, you can use one or more `#`

characters at the start of a line to create headers of different sizes:

To create a bulleted or numbered list, simply start a line with `*`

or `1.`

.

A bulleted list:

- Item 1
- Item 2
- Item 3

A numbered list:

- Apple
- Banana
- Pineapple

You can make some text bold using `**`

, e.g., **some bold text**, or make it italic using `*`

, e.g., *some italic text.* You can also create links, e.g., a link. Images are easily embedded too:

Another really nice feature of Markdown is the ability to include blocks of code. Note that code blocks inside Markdown cells cannot be executed.

```
# Perform the required calculations
profit_per_bag = cost_of_ice_bag * profit_margin
total_profit = number_of_bags * profit_per_bag
# Display the result
print("The grocery store makes a total profit of $", total_profit)
```

You can learn the full syntax of Markdown here: https://learnxinyminutes.com/docs/markdown/

Whether you're running this Jupyter notebook online or on your computer, it's essential to save your work from time to time. You can continue working on a saved notebook later or share it with friends and colleagues to let them execute your code. Jovian offers an easy way of saving and sharing your Jupyter notebooks online.

First, you need to install the Jovian python library if it isn't already installed.

In [56]:

`!pip install jovian --upgrade --quiet`

Next, the library needs to be imported.

In [57]:

`import jovian`

Finally, you can run `jovian.commit`

to capture and upload a snapshot of the notebook.

In [ ]:

`jovian.commit(project='first-steps-with-python')`

```
[jovian] Attempting to save notebook..
```

The first time you run `jovian.commit`

, you'll be asked to provide an *API Key* to securely upload the notebook to your Jovian account. You can get the API key from your Jovian profile page after logging in / signing up.

`jovian.commit`

uploads the notebook to your Jovian account, captures the Python environment, and creates a shareable link for your notebook, as shown above. You can use this link to share your work and let anyone (including you) run your notebooks and reproduce your work. Jovian also includes a powerful commenting interface, so you can discuss & comment on specific parts of your notebook:

You can do a lot more with the `jovian`

Python library. Visit the documentation site to learn more: https://jovian.ai/docs/index.html

Following are some resources where you can learn about more arithmetic, conditional and logical operations in Python:

- Python Tutorial at W3Schools: https://www.w3schools.com/python/
- Practical Python Programming: https://dabeaz-course.github.io/practical-python/Notes/Contents.html
- Python official documentation: https://docs.python.org/3/tutorial/index.html

Now that you have taken your first steps with Python, you are ready to move on to the next tutorial: "A Quick Tour of Variables and Data Types in Python".

Try answering the following questions to test your understanding of the topics covered in this notebook:

- What is a Jupyter notebook?
- How do you add a new code cell below an existing cell?
- How do you add a new Markdown cell below an existing cell?
- How do you convert a code cell to a Markdown cell or vice versa?
- How do you execute a code cell within Jupyter?
- What the different arithmetic operations supported in Python?
- How do you perform arithmetic operations using Python?
- What is the difference between the
`/`

and the`//`

operators? - What is the difference between the
`*`

and the`**`

operators? - What is the order of precedence for arithmetic operators in Python?
- How do you specify the order in which arithmetic operations are performed in an expression involving multiple operators?
- How do you solve a multi-step arithmetic word problem using Python?
- What are variables? Why are they useful?
- How do you create a variable in Python?
- What is the assignment operator in Python?
- What are the rules for naming a variable in Python?
- How do you view the value of a variable?
- How do you store the result of an arithmetic expression in a variable?
- What happens if you try to access a variable that has not been defined?
- How do you display messages in Python?
- What types of inputs can the print function accept?
- What are code comments? How are they useful?
- What are the different ways of creating comments in Python code?
- What are the different comparison operations supported in Python?
- What is the result of a comparison operation?
- What is the difference between
`=`

and`==`

in Python? - What are the logical operators supported in Python?
- What is the difference between the
`and`

and`or`

operators? - Can you use comparison and logical operators in the same expression?
- What is the purpose of using parentheses in arithmetic or logical expressions?
- What is Markdown? Why is it useful?
- How do you create headings of different sizes using Markdown?
- How do you create bulleted and numbered lists using Markdown?
- How do you create bold or italic text using Markdown?
- How do you include links & images within Markdown cells?
- How do you include code blocks within Markdown cells?
- Is it possible to execute the code blocks within Markdown cells?
- How do you upload and share your Jupyter notebook online using Jovian?
- What is the purpose of the API key requested by jovian.commit ? Where can you find the API key?
- Where can you learn about arithmetic, conditional and logical operations in Python?