Python Programming for Absolute Beginners

1. Introduction to Programming
Programming is the process of writing instructions that tell a computer what
to do. These instructions, called code, enable software applications and
hardware devices to perform tasks[1]. In simple terms, programming is
giving the computer a recipe to follow step by step. As Southern New
Hampshire University explains, “computer programming is the process that
professionals use to write code that instructs how a computer, application or
software program performs. At its most basic, computer programming is a
set of instructions to facilitate specific actions”[1].
A program can range from something simple like adding two numbers to as
complex as controlling game worlds or processing sensor data. The key idea
is that a programmer breaks down problems into clear, logical steps, and
uses a programming language (like Python) to translate those steps into
code the computer can execute.
Key Points:
- Instructions: A program is essentially a list of instructions or commands.
- Language: We use programming languages (like Python, Java, C++) to
write these instructions in a form humans can read and computers can run.
- Goal: Ultimately, programming lets us automate tasks, perform
calculations, and create software that makes computers useful for solving
problems.

2. Installing Python and Setting Up Your Environment

Before writing code, you must install Python on your computer. Python is
available for Windows, macOS, and Linux. Most systems either come with
Python or make installation straightforward. The official Python for Beginners
guide notes that “Installing Python is generally easy” and that many
operating systems already include Python[2].
Installing Python:
1. Windows: Download the latest Python installer from python.org and run
it. Ensure you check “Add Python to PATH” on Windows to make Python
accessible from the command line.
2. macOS: Install via the official installer or a package manager like
Homebrew (brew install python3).
3. Linux: Use your distribution’s package manager (e.g. sudo apt install
python3 on Ubuntu) or build from source.
After installation, you can verify by opening a terminal or command prompt
and typing python --version (or python3 --version). It should display the
version number.
Setting up a Code Editor/IDE: While Python comes with a simple
development environment called IDLE, many beginners prefer using a more
powerful editor or IDE. VS Code and Jupyter Notebook are popular choices
(discussed in the next section). Once Python is installed, make sure your
chosen editor is configured to use the Python interpreter you installed.
Table: Python Versions and Compatibility

Python Version Major Features

2.x Legacy version (end-of-life
reached).
3.x Current version line. Supports
modern features.

Tip: Always use Python 3 for new projects, as Python 2 is outdated.

3. Integrated Development Environments (IDEs) and

Editors
An IDE (Integrated Development Environment) is a software application
that provides tools to write, edit, and run code. For beginners, choosing an
IDE can make learning easier.
 IDLE: This is Python’s built-in IDE. It is simple and cross-platform. IDLE
comes with every Python installation and provides a basic editor and
interactive shell[3]. As the Python documentation notes, “IDLE is
Python’s Integrated Development and Learning Environment.” It
includes features like syntax highlighting and an interactive shell to
test code quickly[3].

 Visual Studio Code (VS Code): A free, popular code editor by

Microsoft. With the official Python extension, VS Code becomes a
powerful Python IDE[4]. Microsoft’s guide explains that adding the
Python extension “turns VS Code into a great, lightweight Python
editor.” VS Code offers features like debugging, IntelliSense code
completion, and an integrated terminal. Many beginners like its
friendly interface and extensive documentation.

 Jupyter Notebook: An interactive coding environment, especially

popular for data science and education. The Jupyter Notebook lets you
write code in cells and execute them one by one, showing output right
below the cell. It also supports rich text (Markdown), images, and
charts alongside code. The official Jupyter documentation describes it
 as “an interactive environment for writing and running code”, making
it easy to experiment and see results immediately[5]. This instant
feedback helps beginners understand what their code does.

Tips for Beginners:

- Choose one IDE or editor and stick with it while learning, so you don't
have to learn the interface on top of the language.
- Interactive mode: Both IDLE and Jupyter provide interactive shells. You
can type python (or idle) in a terminal to try Python commands and see
immediate results – great for experimenting.
- Syntax highlighting: Most editors highlight Python keywords, which helps
avoid mistakes (like forgetting a colon).

4. Your First Python Script

Let’s write a simple Python program. The classic first program is “Hello,
World!”, which just prints a message to the screen. In Python, you can do
this using the built-in print() function[6].
print("Hello, World!")

When you run this code (by saving it in a file like hello.py and running
python hello.py in a terminal), it will output:

Hello, World!

In this example, print() is a function that outputs text to the screen. We

pass the string "Hello, World!" as an argument. A tutorial explains that the
built-in print() function “prints the string Hello, world! on our screen”[6].
Exercise 1: Try changing the message inside print(). For instance,
print("Welcome to Python!") and run it.

Common Mistakes:
- Forgetting quotes: print(Hello) will cause an error because Hello is not
defined (it needs quotes to be a string).
- Indentation errors at this simple level are rare, but remember: Python uses
indentation to define code blocks.
Diagram:
Figure: Flowchart of an if-else statement execution (see Chapter 6).
(Flowcharts will be discussed in control flow chapters.)

5. Variables and Data Types

A variable is a name that refers to a value stored in memory. You can think
of variables as labeled boxes where you put data. In Python, you create a
variable by assigning a value with the = operator; there is no need to declare
the variable’s type in advance. For example:

x = 5 # stores the integer 5 in variable x

name = "Alice" # stores the string "Alice" in variable name

As W3Schools explains, “Variables are containers for storing data values.”

They note that “Python has no command for declaring a variable. A variable
is created the moment you first assign a value to it.”[7]. This means x = 5
automatically creates x as an integer variable with value 5.
Data Types: Each variable has a type of data it holds. Common data types
in Python include:
- Integers: Whole numbers, e.g. 5, -42.
- Floats: Decimal numbers, e.g. 3.14, -0.001.
- Strings: Text enclosed in quotes, e.g. "hello".
- Booleans: Logical values True or False.
- None: A special type representing “no value.”
According to W3Schools, “a data type is an important concept, since
variables can store data of different types, and different types can do
different things”[8]. Some examples:

age = 20 # age is an integer

price = 19.99 # price is a float
message = "Hi!" # message is a string
flag = True # flag is a boolean

You can check a variable’s type using the built-in type() function:
print(type(age)) # <class 'int'>
print(type(message))# <class 'str'>

Tips:
- Use clear variable names (e.g. user_age rather than just a) to make your
code readable.
- Remember Python is dynamically typed: you can reassign a variable to a
different type later (e.g. x = 5 then x = "five").
Common Mistakes:
- Starting variable names with a number (e.g. 1st_place) is invalid.
- Mixing tabs and spaces in code (especially for indentation) causes errors.
Stick to spaces (Python’s default is 4 spaces per indent) or configure your
editor consistently.
6. Control Flow: Conditional Statements and Loops
6.1 Conditional Statements (if, elif, else)

Programs often need to make decisions. In Python, we use if, elif, and else
to control which code runs based on conditions. A condition is a boolean
expression (an expression that is True or False).
age = 18
if age >= 18:
print("You can vote.")
else:
print("You are too young to vote.")

If age >= 18 is true, the first print runs; otherwise the else block runs. The
structure of an if-else statement can be shown in a flowchart (see
diagram). In code, after if comes a condition and a colon, and the following
indented lines are the block that executes if the condition is true.
Figure: Flowchart of a simple if...else statement.
This flowchart illustrates an if...else decision: if the condition is true, one
block of statements executes; otherwise the other block executes.
W3Schools notes “The else keyword catches anything which isn’t caught by
the preceding conditions”[9]. You can also check multiple conditions using
elif (short for “else if”):

x = 10
if x < 0:
print("Negative")
elif x == 0:
print("Zero")
else:
print("Positive")

Here, Python checks x < 0 first. If it’s false, it checks x == 0 (using the elif).
If none of the conditions match, it falls to the else block. As explained, “the
elif keyword is Python's way of saying 'if the previous conditions were not
true, then try this condition’”[10].
Key points:
- Keywords: if, elif, else.
- Conditions use comparison operators (<, >, ==, !=, etc.) and logical
operators (and, or, not).
- Indentation matters: code inside the if or else must be indented the same
amount.
Example:
score = 85
if score >= 90:
grade = 'A'
elif score >= 80:
grade = 'B'
else:
grade = 'C or lower'
print("Grade:", grade)

Common Mistakes:
- Forgetting a colon (:) after the if or else line.
- Incorrect indentation: Python will raise an “IndentationError” if blocks aren’t
properly indented.

6.2 Loops
For Loops
A for loop repeats a block of code for each item in a sequence (like a list,
tuple, or string). Its general form is:
for item in sequence:
# do something with item

For example, to print each number in a list:

numbers = [1, 2, 3]
for num in numbers:
print(num)

This will print 1, then 2, then 3 on separate lines.

The tutorialspoint documentation explains that “The for loop in Python
provides the ability to loop over the items of any sequence”, such as lists or
strings[11]. The loop variable (num above) takes on each value from the
sequence in order.
Figure: Flowchart of a for loop iterating over a sequence.
The flowchart shows a for loop: for each element in the sequence, the loop
body executes, then the loop moves to the next element, until all are
processed.
Another example:
for char in "hello":
print(char, end=' ')

This will print: h e l l o

While Loops
A while loop repeats as long as a condition is true. For example:

count = 0
while count < 5:
print(count)
count = count + 1

This prints 0,1,2,3,4 and then stops when count reaches 5. GeeksforGeeks
describes that “a while loop in Python is a control flow statement that allows
you to execute a block of code repeatedly as long as a specified condition
remains true”[12].
Flowchart of a while loop: first the condition is checked, if true the loop body
runs, then it repeats; if false, the loop exits.
Figure: Flowchart of a while loop.
Common Mistakes:
- Forgetting to update the loop variable in a while loop can cause an infinite
loop. Always ensure the condition will eventually become false, or use break.
- Using the wrong sequence: if you modify the list while looping, results may
be unexpected.
Control Flow Tips:
 Use break to exit a loop early, and continue to skip to the next
iteration.
 For loops are simpler when you know how many times or exactly which
elements to iterate. While loops are useful for repeating until a
condition changes (like user input validation).

7. Functions and Modules

7.1 Functions
A function is a reusable block of code that performs a specific task. You
define a function using def, and then call it by name. For example:
def greet(name):
print("Hello, " + name + "!")

greet("Alice") # outputs: Hello, Alice!

This defines a function greet that takes one parameter name and prints a
greeting. When we call greet("Alice"), it runs the code inside. As W3Schools
states: “A function is a block of code which only runs when it is called. You
can pass data, known as parameters, into a function. A function can return
data as a result.”[13].
Function Return Values
A function can send back a value using return:
def add(a, b):
return a + b

result = add(3, 5) # result is 8

Here, add returns the sum of its arguments. If a function doesn’t use return,
it returns None by default.
Benefits of Functions:
- Modularity: Break complex tasks into smaller pieces.
- Reusability: Write code once, call it multiple times.
- Clarity: Functions with descriptive names help read code.
Common Mistakes:
 Indent the body of the function under the def line.
 Remember to call the function; defining it does nothing until called.
 Parameters vs. arguments: what you name in def f(x) (parameter) vs.
what you pass when calling f(10) (argument).
7.2 Modules
A module in Python is a file containing Python definitions and statements
(e.g. functions, classes, variables) that can be imported into other Python
code. For example, you might have mymath.py with functions add() and
multiply(). In another script you can do import mymath and use
mymath.add(2,3).

Modules help organize code. W3Schools explains: “A module can contain

definitions of functions, as already described, but also variables of all
types.”[14] By importing, you can reuse code across multiple programs. The
Python Standard Library itself is a collection of useful modules (like math,
random, datetime, etc.). Use the import statement:

import math
print(math.sqrt(16)) # uses the math module's sqrt function

You can also import specific items:

from math import pi, cos

print(pi, cos(pi/3))

Tips:
- Save your module file with a .py extension.
- Keep module names short and meaningful.
- Avoid naming your file the same as a standard library (like random.py or
math.py) to prevent conflicts.

8. Basic Data Structures

Python has built-in data structures to store collections of values. The
simplest are:
 List: An ordered collection of elements (which can be of mixed types).
Lists are defined with square brackets []. Example: [1, 2, 3, 3]. Lists
can contain duplicates[15].
 Tuple: Like a list but immutable (cannot be changed after creation).
Tuples use parentheses (). Example: (10, 20, 30). They are indexed
(ordered) like lists but, as GeeksforGeeks notes, “the main difference
… is [that a] tuple is immutable, unlike the Python list”[16].
 Dictionary: A collection of key:value pairs. Keys are unique, and you
look up values by key. Defined with braces, e.g. {"name": "Alice",
"age": 20}. Values can be any type. Dataquest explains “A Python
dictionary is a collection of key:value pairs”[17].
 Set: An unordered collection of unique elements (no duplicates).
Defined with braces or set(). Example: {1, 2, 3}. Sets automatically
remove duplicates[18].
Data Ordered/ Syntax Can Have
Structure Immutable Example Duplicates
List Ordered, my_list = [1, Yes
mutable 2, 2, 3]
Tuple Ordered, my_tuple = Yes
immutable (1, 2, 3)
Dictionary Keys my_dict = Keys unique,
unordered* {"k": "v"} values can
duplicate
Set Unordered, my_set = {1, No (unique
mutable 2, 3} only)

*Keys in a dictionary are not ordered (in older Python versions), but values
are accessed by key. In Python 3.7+ insertion order of keys is preserved.
Common Operations:
- Lists: indexing (my_list[0]), slicing (my_list[1:3]), appending
(my_list.append(x)), loops, etc.
- Dictionaries: Access by key (my_dict["k"]), adding (my_dict["new"] =
value), deleting (del my_dict["k"]).
- Sets: Add (my_set.add(x)), remove (my_set.remove(x)), union/intersection
(my_set | other_set).
Common Mistakes:
- Mixing up brackets: [] for lists, () for tuples, {} for dicts/sets.
- Remembering that tuples cannot be modified (trying my_tuple[0] = 5
causes an error).

9. File Handling
Python can read from and write to files. The key function is open()[19]. You
open a file and get a file object, then read/write. Example:
file = open("data.txt", "r") # open for reading
content = file.read()
file.close()

 The first argument to open() is the filename (string).

 The second argument is the mode: 'r' for read, 'w' for write
(overwrite), 'a' for append.
After opening a file in read mode, you can use file.read(), file.readline(),
or iterate over lines with a loop. In write mode, use file.write("text") to
add content. Always close the file with file.close() when done, or use a
with statement which does it automatically:

with open("data.txt", "w") as file:

file.write("Hello\n")
# no need to call close()

As W3Schools points out, “The key function for working with files in Python is
the open() function”[19].
Tip: Using with open(...) as file: is recommended because it ensures the
file is properly closed even if errors occur.
Common Mistakes:
- Forgetting to close a file can lead to data not being saved.
- Using the wrong mode: e.g., 'r' when you needed to write, will cause an
error if the file doesn’t exist.

10. Error Handling

Programs often encounter errors (exceptions). Python has a mechanism to
catch and handle these using try and except. For example:
try:
result = 10 / 0
except ZeroDivisionError:
print("Cannot divide by zero!")

If an error occurs in the try block, Python jumps to the corresponding except
block. If no error occurs, the except block is skipped. According to
W3Schools, “When an error occurs, Python will normally stop and generate
an error message. These exceptions can be handled using the try
statement.”[20].
You can catch specific error types (like ZeroDivisionError) or use a general
except: to catch any error. You can also use else: to run code when no
exception occurs, and finally: for code that should run no matter what (e.g.
closing resources).
Example:
try:
age = int(input("Enter your age: "))
except ValueError:
print("Invalid number entered.")
else:
print(f"You entered: {age}")
finally:
print("Input attempt complete.")

Common Mistakes:
- Having no except block at all will cause the program to crash on error.
- Catching too broad exceptions (e.g. using a bare except:) can hide bugs.
It’s better to catch specific exceptions.

11. Object-Oriented Programming (OOP) Basics

Python supports OOP. In OOP, you create classes (blueprints) and objects
(instances of classes). According to W3Schools, “A Class is like an object
constructor, or a ‘blueprint’ for creating objects.”[21].
Example:
class Person:
def __init__(self, name, age):
self.name = name # attribute
self.age = age

def greet(self):
print(f"Hi, I'm {self.name} and I'm {self.age} years old.")

p1 = Person("Alice", 30)
p1.greet() # Hi, I'm Alice and I'm 30 years old.

 class Person: defines a new class.

 The __init__ method (constructor) sets up each object with name and
age.
 self refers to the current object.
 p1 is an instance (object) of the class Person.
In OOP, you organize code into classes to model real-world entities. Each
object has attributes (data) and methods (functions).
Tip: Start OOP by thinking about what your objects are and what data they
hold.

12. Useful Standard Libraries

Python comes with many standard libraries. Three beginner-friendly libraries
to explore are:
 math: Provides mathematical functions and constants (e.g.
math.sqrt(), math.pi). The math module is “a built-in library that
contains a collection of mathematical functions and constants”[22]. For
example, math.pi gives an accurate value of π, and math.sqrt(x)
computes the square root. You must import math before using these.

 random: Used for generating random numbers. For instance,

random.random() returns a random float between 0 and 1. The random
module “helps add randomness to your programs, like in games or
simulations”[23]. After import random, you can use random.randint(a,
b) to get a random integer between a and b.

 turtle: A simple drawing library. It simulates a “turtle” that moves

around the screen drawing lines. For beginners, it’s a fun way to learn
loops and geometry. The official documentation notes that turtle
graphics were “created as an educational tool” and that it allows
learners to “encounter programming concepts … with instant, visible
feedback”[24]. For example, import turtle; turtle.forward(100)
moves the turtle forward 100 pixels, drawing a line.

Experimenting with these libraries can make learning fun: try using math to
compute areas of circles, random to simulate dice rolls, or turtle to draw
shapes.

13. Tips, Common Mistakes, and Best Practices

 Indentation Errors: Python uses indentation (spaces) to define code
blocks. Be consistent (4 spaces is standard). Mixing tabs and spaces
will cause errors.
 Syntax: Missing colons (:) or unmatched quotes are common syntax
errors. Read error messages to find the line and issue.
 Print for Debugging: Use print() statements to inspect variable
values while learning.
 Readability: Use clear variable and function names. Python’s
philosophy (PEP 20) emphasizes readability.
 Comments: Use # to add comments explaining your code. This helps
both you and others understand your program later.
  Documentation: Many Python concepts have official documentation
or tutorials. Don’t hesitate to look up Python’s official docs or tutorials
for clarification.

14. Exercises and Small Projects

At the end of each chapter, practice helps reinforce learning. Here are a few
suggestions:
 After Chapter 4 (First Script): Exercise: Modify your “Hello, World!”
program to ask the user for their name (use input()) and greet them.
 After Chapter 5 (Variables/Data Types): Exercise: Write a program
that stores your birth year in a variable and calculates your current
age.
 After Chapter 6 (Control Flow): Exercise: Write a program that asks
for a number and tells the user if it is even or odd using an if
statement. Then, Project: Create a number guessing game that picks a
random number (use random.randint()) and prompts the user to guess
until they get it right, giving hints like “too low” or “too high.”
 After Chapter 7 (Functions/Modules): Exercise: Write a function
is_prime(n) that returns True if n is a prime number, else False. Tip:
Use loops inside the function.
 After Chapter 8 (Data Structures): Exercise: Given a list of
numbers, use a loop to compute the sum and average. Project: Create
a simple phonebook dictionary where keys are names and values are
phone numbers; write code to look up a number by name.
 After Chapter 9 (File Handling): Exercise: Write to a file called
log.txt the current date and time each time you run the program (use
datetime module) and then read back and display the contents.
 After Chapter 10 (OOP): Exercise: Define a class Rectangle with
attributes width and height and a method to compute area. Create two
instances and print their areas.
 After Chapter 11 (Error Handling): Exercise: Prompt the user for a
number and convert it to an integer. Use try/except to catch non-
numeric input and ask again.
 After Chapter 12 (Libraries): Exercise: Use the math module to
compute the factorial of a number (hint: math.factorial). Project: Use
the turtle module to draw a geometric pattern (like a spiral or star).
Each exercise is at a beginner level but encourages applying what you’ve
learned. Try them out to solidify your understanding!

15. Resources and Further Learning

This e-book has covered foundational Python concepts from installation to
basic libraries. Python has an extensive ecosystem. As next steps, consider:
- Online Tutorials: The Python official tutorial and websites like W3Schools
and GeeksforGeeks have many examples.
- Books for Beginners: Look for beginner-friendly Python books (physical or
free online).
- Practice: Join coding challenge sites (like HackerRank or Codewars) to
solve simple Python problems.
- Community: Ask questions on forums (like Stack Overflow) or in local user
groups if you’re stuck.
Python’s readability and community support make it a great first
programming language. Happy coding, and enjoy your programming
journey!
Sources: Python’s official documentation and learning resources[25][3][5]
[7][8][26][27][28][13][14][19][21][20][22][23][24][29][10][9]. Images and
flowcharts are from Tutorialspoint and [GeeksforGeeks].

[1] What is Computer Programming? | SNHU

https://www.snhu.edu/about-us/newsroom/stem/what-is-computer-
programming
[2] [25] Python For Beginners | Python.org
https://www.python.org/about/gettingstarted/
[3] IDLE — Python editor and shell — Python 3.13.7 documentation
https://docs.python.org/3/library/idle.html
[4] Getting Started with Python in VS Code
https://code.visualstudio.com/docs/python/python-tutorial
[5] Running Code — Jupyter Notebook 7.4.5 documentation
https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/
Running%20Code.html
[6] Python Program to Print Hello world!
https://www.programiz.com/python-programming/examples/hello-world
[7] Python Variables
https://www.w3schools.com/python/python_variables.asp
[8] Python Data Types
https://www.w3schools.com/python/python_datatypes.asp
[9] [10] [26] [29] Python Conditions
https://www.w3schools.com/python/python_conditions.asp
[11] Python For Loops
https://www.tutorialspoint.com/python/python_for_loops.htm
[12] Python While Loop: Explained with While Loop Flowchart
https://intellipaat.com/blog/tutorial/python-tutorial/python-while-loops/
[13] Python Functions
https://www.w3schools.com/python/python_functions.asp
[14] Python Modules
https://www.w3schools.com/python/python_modules.asp
[15] [18] Sets vs. Lists - Python - GeeksforGeeks
https://www.geeksforgeeks.org/python/sets-vs-lists-python/
[16] Tuple Operations in Python - GeeksforGeeks
https://www.geeksforgeeks.org/python/tuples-in-python/
[17] Python Dictionaries: A Comprehensive Tutorial (with 52 Code Examples)
https://www.dataquest.io/blog/python-dictionaries/
[19] Python File Open
https://www.w3schools.com/python/python_file_handling.asp
[20] Python Try Except
https://www.w3schools.com/python/python_try_except.asp
[21] Python Classes
https://www.w3schools.com/python/python_classes.asp
[22] Python Math Module - GeeksforGeeks
https://www.geeksforgeeks.org/python/python-math-module/
[23] Python Random - random() Function - GeeksforGeeks
https://www.geeksforgeeks.org/python/python-random-function/
[24] turtle — Turtle graphics — Python 3.13.7 documentation
https://docs.python.org/3/library/turtle.html
[27] Python For Loops
https://www.w3schools.com/python/python_for_loops.asp
[28] Python While Loops
https://www.w3schools.com/python/python_while_loops.asp