"Python Basics Course" is a beginner-friendly book that covers the basics
of Python programming as well as more advanced concepts such as
working with data, creating visualizations, and building web applications.
The book is designed to be a hands-on guide, with numerous exercises and
projects to help readers practice and apply what they've learned. The book
covers topics such as:
● Installing Python and running Python code
● Basic data types (strings, lists, dictionaries, etc.)
● Control flow (if-else statements, for and while loops)
● Functions
● Object-oriented programming
● Working with data (reading and writing files, working with CSV files,
etc.)
● Creating visualizations with Python
● Building web applications with Django
The book is geared towards beginner programmers, but it is also suitable
for those with some programming experience who are new to Python. It is a
great resource for those who want to learn the basics of Python
programming quickly and efficiently.
Installing Python and running Python code
Installing Python and running Python code is a simple process. Here are the
steps to install Python and run Python code on a Windows, Mac, or Linux
operating system:
1. Download the latest version of Python from the official Python
website (https://www.python.org/downloads/).

2. Run the installer and follow the prompts to install Python on your
computer. Make sure to select the option to add Python to your
system's PATH environment variable. This will allow you to run Python
from the command line.
3. To verify that Python has been installed successfully, open a
command prompt or terminal window and type "python" (without the
quotes). If Python is installed correctly, you should see the Python
prompt (>>>).
4. To run Python code, you can write your code in a text editor and save
it with a .py file extension. For example, if your code is saved in a file
called "hello.py", you can run it by typing "python hello.py" in the
command prompt or terminal window.
5. You can also run Python code interactively by typing it directly into the
Python prompt (>>>).
6. Some IDEs have inbuilt python interpreter and you can run your
python code by just running the file inside the IDE.
7. You can also use Jupyter notebook
Installing Python and running Python code detailed
Installing Python:
1. Go to the official Python website (python.org) and download the
latest version of Python for your operating system.
2. Run the installer and follow the prompts to install Python on your
computer.
Running Python code:
1. Open the command prompt or terminal on your computer.
2. Type "python" and press enter to start the Python interpreter.

3. You can now enter Python commands and see the results
immediately.
Alternatively, you can create a Python script file with a .py extension and run
it by typing "python [filename].py" in the command prompt or terminal.
You can also use integrated development environment (IDE) like PyCharm,
IDLE, Spyder, Jupyter Notebook, etc. to run your python code. It provides a
more user-friendly interface and additional features like debugging, code
completion, and version control.
Explain Basic data types (strings, lists, dictionaries, etc.)
In Python, there are several basic data types that are commonly used to
store and manipulate data. These include:
1. Strings: A string is a sequence of characters. You can create a string
by enclosing characters in single or double quotes. For example:
○ "Hello, World!"
○ 'Hello, World!'
2. Integers: An integer is a whole number (positive or negative) without
a decimal point. For example:
○ 5
○ -3
3. Floats: A float is a number with a decimal point. For example:

○ 3.14
○ -2.5
4. Lists: A list is an ordered collection of items. Lists are created by
placing a comma-separated sequence of items inside square
brackets. For example:
○ [1, 2, 3, 4, 5]
○ ['apple', 'banana', 'orange']
5. Dictionaries: A dictionary is an unordered collection of key-value
pairs. Dictionaries are created by placing a comma-separated
sequence of key-value pairs inside curly braces. For example:
○ {'name': 'John', 'age': 30}
○ {1: 'one', 2: 'two', 3: 'three'}
6. Tuples:
A tuple is an ordered collection of items. Tuples are similar to lists,
but they are immutable, meaning their values cannot be changed
once created. Tuples are created by placing a comma-separated
sequence of items inside parentheses. For example:
○ (1, 2, 3, 4, 5)
○ ('apple', 'banana', 'orange')
7. Booleans: A boolean value represents a true or false value. The two
boolean values in Python are True and False.
These are some of the basic data types in Python. Each data type has its
own properties and methods that can be used to manipulate and analyze
data.
Examples of using the basic data types in Python:

Strings:
# concatenating strings
name = "John"
age = 30
print("My name is " + name + " and I am " + str(age) + " years old.")
# string indexing
name = "John"
print(name[0]) # prints "J"
# string slicing
name = "John"
print(name[1:3]) # prints "oh"
# string methods
name = "John"
print(name.upper()) # prints "JOHN"
print(name.replace("J", "B")) # prints "Bon"

Lists:
# creating a list
fruits = ['apple', 'banana', 'orange']
# accessing elements in a list
print(fruits[0]) # prints "apple"
# modifying elements in a list
fruits[1] = 'mango'
print(fruits) # prints ['apple', 'mango', 'orange']
# adding elements to a list
fruits.append('kiwi')
print(fruits) # prints ['apple', 'mango', 'orange', 'kiwi']
# removing elements from a list
fruits.remove('mango')

print(fruits) # prints ['apple', 'orange', 'kiwi']
Dictionaries:
# creating a dictionary
person = {'name': 'John', 'age': 30, 'gender': 'male'}
# accessing elements in a dictionary
print(person['name']) # prints "John"
# modifying elements in a dictionary
person['age'] = 35
print(person) # prints {'name': 'John', 'age': 35, 'gender': 'male'}
# adding elements to a dictionary
person['city'] = 'New York'
print(person) # prints {'name': 'John', 'age': 35, 'gender': 'male', 'city': 'New
York'}
# removing elements from a dictionary

del person['city']
print(person) # prints {'name': 'John', 'age': 35, 'gender': 'male'}
Tuples:
# creating a tuple
numbers = (1, 2, 3, 4, 5)
# accessing elements in a tuple
print(numbers[0]) # prints 1
# modifying elements in a tuple
# raises TypeError: 'tuple' object does not support item assignment
numbers[1] = 6
# adding elements to a tuple
# raises TypeError: 'tuple' object has no attribute 'append'
numbers.append(6)

# removing elements from a tuple
# raises TypeError: 'tuple' object doesn't support item deletion
del numbers[2]
Booleans:
# creating a boolean variable
is_student = True
# using a boolean variable in a conditional statement
if is_student:
print("You are a student.")
else:
print("You are not a student.")
# negating a boolean variable
is_student = False
print(not is_student) # prints True

here are some more examples of using Python to solve simple
problems:
1. Calculator
# take input from the user
num1 = float(input("Enter a number: "))
num2 = float(input("Enter another number: "))
# take the operation from the user
operation = input("Enter an operation (+, -, *, /): ")
# perform the operation
if operation == "+":
result = num1 + num2
elif operation == "-":
result = num1 - num2
elif operation == "*":
result = num1 * num2
elif operation == "/":

result = num1 / num2
else:
result = "Invalid operation"
# print the result
print(result)
2. FizzBuzz
# iterate through the range of numbers
for i in range(1, 101):
if i % 3 == 0 and i % 5 == 0:
print("FizzBuzz")
elif i % 3 == 0:
print("Fizz")
elif i % 5 == 0:
print("Buzz")
else:
print(i)

3. Palindrome Checker
# take input from the user
word = input("Enter a word: ")
# convert the word to lowercase
word = word.lower()
# check if the word is a palindrome
if word == word[::-1]:
print("The word is a palindrome.")
else:
print("The word is not a palindrome.")
4. Factorial
# take input from the user
num = int(input("Enter a number: "))

# initialize the result variable
result = 1
# calculate the factorial
for i in range(1, num+1):
result *= i
# print the result
print("The factorial of", num, "is", result)
5. Prime Number Checker
# take input from the user
num = int(input("Enter a number: "))
# check if the number is prime
if num > 1:
for i in range(2, num):

if (num % i) == 0:
print(num, "is not a prime number.")
break
else:
print(num, "is a prime number.")
else:
print(num, "is not a prime number.")
Control flow (if-else statements, for and while loops)
Control flow in Python refers to the order in which the statements in a
program are executed. The two main control flow statements in Python are
if-else statements and loops.
If-else statements:
An if-else statement is used to perform different actions based on different
conditions. The basic syntax for an if-else statement is:
if condition:
# code to be executed if condition is true
else:
# code to be executed if condition is false
For example:

x = 5
if x > 0:
print("x is positive")
else:
print("x is negative")
Loops:
Python provides two types of loops: for loops and while loops.
For loops:
A for loop is used to iterate over a sequence (such as a list, tuple, or string)
and execute a block of code for each item in the sequence.
The basic syntax for a for loop is:
for variable in sequence:
# code to be executed for each item in the sequence
For example:
for i in range(5):
print(i)

While loops:
A while loop is used to repeatedly execute a block of code as long as a
certain condition is true. The basic syntax for a while loop is:
while condition:
# code to be executed while condition is true
For example:
x = 5
while x > 0:
print(x)
x -= 1

It's important to be careful when using loops and make sure that the loop's
stopping condition will eventually be met, otherwise the loop will run
indefinitely and cause an infinite loop.
Functions
In Python, a function is a block of organized, reusable code that is used to
perform a specific task. Functions are useful for breaking down a large
program into smaller, more manageable pieces. Functions can also be used
to avoid repeating the same code multiple times.
To define a function in Python, you use the keyword def, followed by the
function name, a set of parentheses, and a colon. The code inside the
function is indented. The basic syntax for defining a function is:
def function_name(parameters):
# code to be executed

For example:
def greet(name):
print("Hello, " + name + "!")
greet("John") #prints "Hello, John!"
Functions can also take zero or more parameters, and they can also return
a value using the ‘return ‘ statement.
def add(a,b):
return a+b
result = add(2,3)
print(result) # prints 5
Functions can also have default parameter values, so that the user does
not need to specify a value for that parameter.
def greet(name, greeting = "Hello"):

print(greeting + ", " + name + "!")
greet("John") # prints "Hello, John!"
greet("John", "Hi") # prints "Hi, John!"
You can also use the *args and ‘**kwargs’ to pass a variable number of
arguments to a function.
‘*args’ allows you to pass a variable number of non-keyword arguments to
a function and
‘**kwargs’ allows you to pass a variable number of keyword arguments to
a function.
def my_function(*args, **kwargs):
for arg in args:
print(arg)
for key, value in kwargs.items():
print(key, ":", value)

my_function(1, 2, 3, 4, name="John", age=22)
Functions are a fundamental concept in Python and are used extensively in
many Python programs. They help to organize and structure code, make it
more readable, and increase reusability.
Object-oriented programming
Object-oriented programming (OOP) is a programming paradigm that is
based on the concept of "objects", which can be thought of as instances of

a class. A class is a blueprint for an object, and it defines the properties and
methods that an object of that class will have.
In Python, you can define a class using the keyword class, followed by the
class name, and a colon. The code inside the class is indented. The basic
syntax for defining a class is:
class ClassName:
# properties and methods
For example:
class Dog:
def __init__(self, name, breed):
self.name = name
self.breed = breed
def bark(self):

print("Woof!")
Here __init__ is a special method called a constructor. It's used to initialize
the object's properties when it's created.
Once you've defined a class, you can create an object (or instance) of that
class using the class name followed by parentheses.
dog = Dog("Fido", "Golden Retriever")
print(dog.name) # prints "Fido"
dog.bark() # prints "Woof!"
OOP has many concepts like inheritance, polymorphism, encapsulation.
Inheritance is the ability of a class to inherit properties and methods from
another class.
Polymorphism is the ability of an object to take on multiple forms.
Encapsulation is the practice of hiding the internal details of an object and
making it accessible only through its methods.
OOP is widely used in Python and in many other programming languages. It
helps to organize and structure code, make it more reusable, and make it
easier to reason about and understand.

Working with data (reading and writing files, working with CSV files,
etc.)
In Python, working with data often involves reading and writing files, as well
as working with CSV files (comma-separated values).
Reading and writing files:
Python provides several ways to read and write files. The simplest way to
read a file is to use the built-in open() function, which returns a file object
that can be used to read the file. Once you have the file object, you can use
the read() method to read the entire contents of the file, or the readline()
method to read one line at a time.
file = open("example.txt", "r")
print(file.read())
file.close()
To write to a file, you can use the open() function with the mode w or a
which stands for write and append respectively.
file = open("example.txt", "w")
file.write("Hello World!")

file.close()
Working with CSV files:
Working with CSV files:
CSV stands for comma-separated values, and it is a common file format for
storing data. Python provides the csv module that provides functionality to
read and write CSV files.
The csv.reader object can be used to read a CSV file and the csv.writer
object can be used to write to a CSV file
import csv
# Reading a CSV file
with open('example.csv', newline='') as csvfile:
reader = csv.reader(csvfile)
for row in reader:
print(row)

# Writing a CSV file
with open('example.csv', 'w', newline='') as csvfile:
writer = csv.writer(csvfile)
writer.writerow(['Name', 'Age'])
writer.writerow(['John', '22'])
You can also use the pandas library which provides powerful data
manipulation and analysis capabilities. It makes working with CSV files
easy, as you can read and write CSV files using pandas.read_csv() and
pandas.to_csv() functions respectively.
import pandas as pd
#Reading a CSV file
df = pd.read_csv("example.csv")
#Writing a CSV file

df.to_csv("example.csv", index=False)
These are some of the ways to work with data in Python, specifically
reading and writing files, and working with CSV files. There are many other
ways to work with data in Python and different libraries for specific data
formats and data manipulation tasks.
Creating visualizations with Python
There are several libraries in Python that can be used to create
visualizations, including Matplotlib, Seaborn, and Plotly.
Matplotlib is a plotting library for the Python programming language and its
numerical mathematics extension NumPy. It provides an object-oriented
API for embedding plots into applications using general-purpose GUI
toolkits like Tkinter, wxPython, Qt, or GTK.
Seaborn is a library for making statistical graphics in Python. It is built on
top of Matplotlib and provides a high-level interface for drawing attractive
and informative statistical graphics.
Plotly is a Python library that is used to create interactive visualizations. It
allows you to create plots, graphs, and maps using Python and then share
them online.

Pandas and Numpy are also used along with these libraries for handling the
data and doing the required calculations.
You can refer to the documentation of these libraries for more information
on how to use them for creating visualizations.
Building web applications with Django
Django is a popular, high-level web framework for building web applications
with Python. It is a Model-View-Controller (MVC) framework that follows
the "Don't Repeat Yourself" (DRY) principle and encourages the use of
reusable code.
To start building a web application with Django, you will first need to install
it. You can install Django using pip by running the command pip install
Django.
Once Django is installed, you can create a new project by running the
command django-admin startproject projectname. This command will
create a new directory named projectname that will contain the basic file
structure for a Django project.

The main components of a Django project are:
● models.py: where you define the structure of the data in your
application (e.g. the fields and properties of a "Blog" model).
● views.py: where you define the logic for handling requests and
returning responses to the user (e.g. the code that retrieves a list of
all blog posts from the database and sends it to a template to be
rendered).
● urls.py: where you define the URLs for your application and map them
to views.
Django also comes with an automatic admin interface that allows you to
manage your data through a web interface. You can activate it by creating a
superuser and then adding path('admin/', admin.site.urls) to your urls.py.
Django also has built-in support for templates, which are used to separate
the presentation of a web page from the logic that generates the content.
Django also support RESTful API development, with the help of Django
REST framework.
There are many resources available for learning Django, including the
official Django documentation (https://docs.djangoproject.com/) and
various tutorials and books on the subject.

Django is a powerful and versatile web framework that can be used to build
a wide range of web applications, from small personal projects to large
enterprise applications.