Python Basics – Comprehensive Study
Notes
A structured introductory reference covering Python syntax, programming concepts, data
types, control flow, functions, collections, exceptions, modules, and basic file handling.
1. Introduction to Python
Python is a high-level, general-purpose programming language known for readable syntax
and a large standard library. It is widely used in software development, automation, data
analysis, artificial intelligence, scientific computing, web development, and education.
Python programs are usually written in text files with the .py extension and executed by a
Python interpreter.
Python emphasizes readability. Indentation is significant because it defines blocks of code.
Unlike languages that use braces to mark blocks, Python normally uses consistent
indentation after statements such as if, for, while, and def. Comments begin with the #
character and are ignored when the program runs.
2. Variables and Assignment
A variable is a name referring to a value. Assignment is performed with the equals sign. For
example, age = 18 associates the name age with the integer value 18. Python variables do
not require a type declaration before assignment.
A variable can later refer to a value of another type. Meaningful names make programs
easier to understand. Names are case-sensitive, so total, Total, and TOTAL are different
identifiers. Python identifiers can contain letters, digits, and underscores, but they cannot
begin with a digit.
Multiple assignment can be used when appropriate, such as x, y = 10, 20. Python also
supports assigning the same value to multiple names. Avoid using names that conflict with
important built-in functions such as list, str, or sum.
3. Numbers and Basic Types
Common built-in Python types include int, float, complex, bool, str, list, tuple, set, and dict.
Integers represent whole numbers, while floating-point values represent numbers with
decimal components. Boolean values are True and False.
Arithmetic operators include + for addition, - for subtraction, * for multiplication, / for
division, // for floor division, % for remainder, and ** for exponentiation. Parentheses can
be used to control the order of operations.
The type() function can be used to inspect the type of a value. Conversion functions such as
int(), float(), str(), and bool() can convert compatible values. Conversion should be used
carefully because not every string or value can be converted successfully.
4. Strings
A string is a sequence of characters enclosed in single or double quotation marks. Triple-
quoted strings can span multiple lines. Strings support indexing and slicing. For example, if
text is "Python", text[0] refers to the first character and text[1:4] produces a portion of the
string.
Useful string methods include lower(), upper(), strip(), replace(), split(), and join(). The
len() function returns the number of characters.
Formatted strings, commonly called f-strings, provide a convenient way to insert
expressions into text. For example, f"Score: {score}" creates a string containing the current
value of score. Strings are immutable, meaning an existing string is not changed in place
when a string method is used; instead, a new string is generally produced.
5. Input and Output
The print() function displays information. It accepts multiple arguments and supports
options such as sep and end. The input() function reads text entered by the user and returns
it as a string.
When numeric input is required, the returned string can be converted using int() or float().
Programs should validate input when incorrect values could cause errors or unexpected
behavior.
Clear output is important in interactive programs. Labels and meaningful messages help
users understand what the program is asking for and what result it has produced.
6. Conditional Statements
Conditional statements allow a program to make decisions. The basic structure uses if,
followed by an indented block. elif can test additional conditions, and else can handle the
remaining case.
Comparison operators include ==, !=, <, <=, >, and >=. Logical operators and, or, and not
combine or modify conditions. Python also supports membership operators such as in and
not in.
Conditions evaluate to truth values. Many objects have a useful truth value, so empty
collections and zero are generally treated as false in Boolean contexts. Explicit comparisons
can make complicated conditions easier to understand.
7. For Loops
A for loop iterates through items in an iterable. Common iterables include lists, strings,
tuples, dictionaries, sets, and ranges. The range() function is useful when a sequence of
integers is required.
For example, range(5) represents a sequence beginning at zero and ending before five. A
loop can process each value in the sequence. The break statement stops a loop early, while
continue skips the remaining statements for the current iteration.
Loops are fundamental for processing collections, calculating totals, searching for values,
and repeating operations a known number of times.
8. While Loops
A while loop repeats a block while its condition remains true. It is useful when the number
of repetitions is not known in advance.
A while loop should normally make progress toward eventually becoming false. Otherwise,
the program can enter an infinite loop. break can be used to leave the loop when a
particular condition occurs.
When choosing between for and while, use a for loop when naturally iterating over an
iterable, and use a while loop when repetition depends primarily on a changing condition.
9. Lists
Lists are ordered, mutable collections. They can contain values of different types and can be
changed after creation. Items are accessed by index, starting from zero.
Important list methods include append(), extend(), insert(), remove(), pop(), clear(), sort(),
and reverse(). Slicing can retrieve a portion of a list. Lists can also contain other lists,
allowing nested structures.
List comprehensions provide a compact way to create lists from iterable data. They are
useful when the transformation is simple and readable, but a normal loop may be clearer for
complicated logic.
10. Tuples
Tuples are ordered collections that are generally immutable after creation. They can be
useful for representing a fixed group of related values.
Tuples support indexing and slicing like strings and lists. They can be unpacked into
separate variables when the number of values matches the number of target names.
Because tuples are immutable, they are useful when a collection should not be accidentally
modified. A tuple may contain mutable objects, however, so immutability applies to the
tuple structure rather than recursively to every object it references.
11. Dictionaries
Dictionaries store key-value pairs. A key is used to retrieve its associated value. Keys should
be hashable, and common key types include strings, integers, and tuples containing suitable
values.
Useful dictionary operations include accessing values by key, adding or updating entries,
removing entries, and iterating through keys, values, or key-value pairs. The get() method
can retrieve a value while providing a default when the key is absent.
Dictionaries are particularly useful for representing structured records, counting
occurrences, lookup tables, and configuration data.
12. Sets
A set is an unordered collection of unique elements. Sets are useful for removing duplicates
and performing mathematical set operations.
Common operations include union, intersection, difference, and symmetric difference.
Membership testing with in is also useful.
Sets require their elements to be hashable. Mutable collections such as lists cannot normally
be individual set elements, while immutable values such as integers and strings can be used.
13. Functions
Functions organize reusable logic. A function is defined with def, followed by a name,
parentheses for parameters, and an indented body. A function can return a result with
return.
Parameters allow a function to work with different input values. Default parameters
provide fallback values. Functions should generally have a clear purpose and a descriptive
name.
Breaking a large program into functions improves readability, testing, maintenance, and
reuse. A function can call other functions, allowing complex programs to be built from
smaller components.
14. Scope
Scope determines where a variable name can be accessed. Variables created inside a
function are normally local to that function. Names defined outside functions can belong to
an enclosing or global scope.
Using local variables where possible reduces accidental interactions between unrelated
parts of a program. Python resolves names through a defined sequence of scopes.
Understanding scope is especially important when functions use parameters, local
variables, nested functions, or variables defined at module level.
15. Exceptions and Error Handling
Programs sometimes encounter errors while running. Python represents many runtime
problems as exceptions. Examples include ValueError, TypeError, IndexError, KeyError,
and ZeroDivisionError.
The try and except statements allow a program to respond to expected exceptions. else can
run when no exception occurs, and finally can run whether or not an exception occurred.
Exception handling should be specific enough to address expected problems without
silently hiding unrelated programming errors. Clear error messages make debugging easier.
16. Modules and Packages
A module is a Python file containing definitions and executable statements that can be
imported into another program. Python's standard library contains many useful modules,
including math, random, datetime, pathlib, and json.
The import statement makes module functionality available. Importing only what is
required can make code easier to read. External packages can add additional functionality
and are commonly installed with Python's package management tools.
Organizing larger programs into modules helps separate responsibilities and makes code
easier to maintain.
17. File Handling
Python can read from and write to files. The open() function provides access to a file, and
using a with statement is recommended because it ensures the file is properly closed.
Common modes include r for reading, w for writing, a for appending, and x for creating a
new file when it does not already exist. Text can be read using methods such as read() or
readline(), and written using write().
File paths can be handled conveniently with pathlib. Programs that process files should
consider encoding, missing files, permissions, and malformed content.
18. Object-Oriented Programming Basics
Python supports object-oriented programming. A class defines a structure and behavior for
objects. Objects are instances of classes.
The __init__ method is commonly used to initialize object attributes. Instance methods
receive self as their first parameter. Classes can encapsulate related data and operations.
Object-oriented design is useful for larger applications where modeling entities and their
behavior makes the program easier to understand. Not every small Python program needs
classes; simple functions and data structures are often sufficient.
19. Useful Programming Practices
Readable code is easier to debug and maintain. Use descriptive names, consistent
indentation, small focused functions, and comments where they add useful context. Avoid
unnecessary duplication.
Test programs with normal cases as well as boundary and invalid inputs. When debugging,
isolate the smallest section that reproduces the problem and inspect values at important
points.
Version control systems such as Git can track changes to source code. Virtual environments
can isolate project dependencies and help prevent different projects from interfering with
one another.
20. Practice Questions
1. What is the difference between a list and a tuple?
2. When would you use a dictionary instead of a list?
3. What is the purpose of a function?
4. Explain the difference between == and =.
5. What does range(10) produce for a for loop?
6. Why can an infinite while loop occur?
7. What is an exception?
8. Why is a with statement useful for file handling?
9. What is the purpose of a module?
10. Write a small program that accepts several numbers and calculates their average.
Practice is one of the best ways to strengthen programming skills. After learning syntax,
focus on solving progressively harder problems, reading error messages, and explaining
why your code works.
Conclusion
These notes provide a foundation for beginning Python programming. The next step is to
practice by writing small programs, working with data structures, learning algorithms, and
gradually building projects. Consistent practice is more valuable than memorizing syntax
alone.