This tutorial is the first in a series of beginner-friendly tutorials on programming using the Python language. These tutorials take a practical coding-based approach, and the best way to learn the material is to execute the code and experiment with the examples. Check out the full series here: AIJAZ
The following topics are covered in this tutorial:
This tutorial is an executable Jupyter notebook hosted on Jovian.ml, a platform for sharing data science projects online (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 own computer.
The easiest way to start executing this notebook is to click the "Run" button at the top of this page, and select "Run on Binder". This will run the notebook on mybinder.org, a free online service for running Jupyter notebooks. 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 this notebook on your computer locally, you'll need to set up Python and download the notebook. We recommend using the Conda distribution of Python. Here's what you need to do to get started:
Install Conda by following these instructions. Make sure to add Conda binaries to your system
PATH to be able to run the
conda command line tool from your Mac/Linux terminal or Windows command prompt.
Create and activate a Conda virtual environment called
zerotopandas which you can use for this tutorial series, by running the follwing commands on your terminal / command prompt:
conda create -n intro-to-python -y python=3.8 conda activate intro-to-python
You'll need to create the environment only once, but you'll have to activate it every time want to run the notebook. When the environment is activated, you should be able to see a prefix
(intro-to-python) within your terminal or command prompt.
pip install jovian jupyter numpy pandas matplotlib seaborn --upgrade
jovian clone aakashns/first-steps-with-python
The notebook is downloaded to the directory
first-steps-with-python. You can also use the "Download Zip" option on the page instead of using the
jovian clone command.
cd first-steps-with-python jupyter notebook
first-steps-with-python.ipynbto open it and run the code. If you want to type out the code yourself, you can also create a new notebook using the "New" button.
Jupyter Notebooks: This tutorial is a Jupyter notebook - a document made of "cells", which can contain explanations in text or code written in Python. Code cells can be executed and their outputs e.g. numbers, messages, graphs, tables, files etc. can be viewed within the notebook, which makes it a really powerful platform for experimentation and analysis. Don't afraid to experiment with the code & break things - you'll learn a lot by encoutering and fixing errors. You can use the "Kernel > Restart & Clear Output" menu option to clear all outputs and start again from the top of the notebook.
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+Bto 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 "Cell > Cell Type" menu option. You can also use the keyboard shortcuts
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 changed cells again to see updated results. Can you guess what the
** operators are used for?
first = 8*2 + TRUE
--------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-7-0fe303a3b687> in <module> ----> 1 first = 8*2 + TRUE NameError: name 'TRUE' is not defined
--------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-9-0bcb49f3077c> in <module> ----> 1 type(TRUE) NameError: name 'TRUE' is not defined
2 + 3 + 9
99 - 73
23.54 * -1432
100 / 7
100 // 7
100 % 7
5 ** 3
As you might expect, certain operators like
* take precendence over other operators like
- as per mathematical conventions. You can use parantheses i.e.
) to specify the order in which operations are performed.
((2 + 5) * (17 - 3)) / (4 ** 3)
Python supports the following arithmetic operators:
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.
total_population=198568 num_of_men=45312 num_of_women=35678 num_of_children= total_population - num_of_men - num_of_women print("Children in population", num_of_children)
Children in population 117578
Let's try solving the following word problem using Python:
A grocery store sells a bag of ice for $1.25, and makes 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 which 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)
500 * (.2 * 1.25)
Thus, the grocery store makes a total profit of $125.0 . While this is a reasonable way to solve a problem, it's not quite 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, informations is stored in variables. You can think of variables as containers for storing data. The data stored within a variable is called it's value.
cost_of_ice_bag = 1.25
profit_margin = .2
number_of_bags = 500
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, and we can combine variables using arithmetic operations to create other variables.
Tip: While typing the name of an existing variable in a code cell within Jupyter, you can type the first few characters and press the
Tabkey to autocomplete the variable's name. Try typing
proin a code cell below and press
Tabto autocomplete to
profit_per_bag = cost_of_ice_bag * profit_margin
total_profit = number_of_bags * profit_per_bag
If you try to see the value of a variable that has not been defined i.e. given a value using the assignment statement
variable_name = value, then Python shows an error.
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
Functions: A function is a reusable set of instructions. A function takes one or more inputs, performs certain operations, and often returns an output. Python provides many in-built functions like
print("The grocery store makes a total profit of $", total_profit)
"this is some text"), numbers, variables, mathematical expressions etc. We'll learn more about variables & functions in the next section.
Creating a code cell for each variable or mathematical operation can get tedious. Fortunately, Jupyter allows you write multiple lines of code within a single code cell. Let's rewrite the solution to our word problem within a single cell.
# 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)
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 other 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:
my_favorite_number = 1 # an inline comment
# This comment gets its own line my_least_favorite_number = 3
"""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 oprations for comparing numbers & variables.
||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 comparision operation is either
False (note the uppercase
F). These are special keywords in Python. Let's try out some experiment with comparision operators.
my_favorite_number = 1 my_least_favorite_number = 5 a_neutral_number = 3 num1= 5 num2=10
num1 == 5
# Equality check - True my_favorite_number == 1
# Equality check - False my_favorite_number == my_least_favorite_number
# Not equal check - True my_favorite_number != a_neutral_number
# Not equal check - False a_neutral_number != 3
# Greater than check - True my_least_favorite_number > a_neutral_number
# Greater than check - False my_favorite_number > my_least_favorite_number
# Less than check - True my_favorite_number < 10
# Less than check - False my_least_favorite_number < my_favorite_number
# Greater than or equal check - True my_favorite_number >= 1
# Greater than or equal check - False my_favorite_number >= 3
# Less than or equal check - True 3 + 6 <= 9
# Less than or equal check - False my_favorite_number + a_neutral_number <= 3
Just like arithmetic operations, the result of a comparison opration can also be stored in a variable.
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)
The logical operators
not operate upon conditions and
False values (also known as booleans).
or operate on two conditions, whereas
not operates on a single condition.
and operator returns
True when both the conditions evalute to
True. Otherwise it returns
my_favorite_number > 0 and my_favorite_number <= 3
my_favorite_number < 0 and my_favorite_number <= 3
my_favorite_number > 0 and my_favorite_number >= 3
True and False
True and True
or operator returns
True if at least one of the conditions evalute to
True. It returns
False only if both conditions are
a_neutral_number = 3
a_neutral_number == 3 or my_favorite_number < 0
a_neutral_number != 3 or my_favorite_number < 0
my_favorite_number < 0 or True
False or False
not operator returns
False if a condition is
True if the condition is
not a_neutral_number == 3
not my_favorite_number < 0
Logical operators can be combined to form complex conditions. Use round brackets or parantheses
) to indicate the order in which logical operators should be applied.
(2 > 3 and 4 <= 5) or not (my_favorite_number < 0 and True)
not (True and 0 < 1) or (False and True)
If parantheses are not used, logical operators are applied from left to right.
not True and 0 < 1 or False and True
Experiment with arithmetic, conditional and logical operators in Python using the interactive nature of Jupyter notebook. We will learn more about variables and functions in future tutorials.
Adding explanations using text cells (like this one) is great way to make your notebook informative for other readers, and for yourself, if you need to refer back to it in the future. Double click on a text cell within Jupyter to edit it. In the edit mode, you'll notice that the text looks a little different (for instance the heading has a
## prefix. This text is writted 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 see how to create 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
A bulleted list:
A numbered list:
You can make some text bold using
** e.g. this is some bold text, or make it italic using
* e.g. this is some italic text. You can also create links e.g. this is a link. Images are easily embedded too:
Another really nice feature of Markdown is 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 on an online service like Binder or on your local machine, it's important to save your work from time, so that you can access it later, or share it online. You can upload this notebook to your Jovian.ml account using the
jovian Python library.
First, you need to install the Jovian python library, if it isn't already installed.
!pip install jovian --upgrade --quiet
Next, the library needs to be imported.
Finally, you can run
jovian.commit to capture and upload a snapshot of the notebook.
[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.ml account. You can get the API key from your Jovian.ml profile page after logging in / signing up.
jovian.commit uploads the notebook to your Jovian.ml 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.ml/docs/index.html
Following are some resources to learn about more arithmetic, conditional and logical operations in Python:
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".