Python Programming

Beginner — Learn the Basics First

Python is one of the most beginner-friendly programming languages. Its clear syntax and strong community support make it an excellent first language. This guide walks you through all the foundational concepts every new programmer needs to know — from installing Python to writing functions.

---

Introduction to Python

What is Python?

Python is a high-level, interpreted programming language that emphasizes code readability. Designed by Guido van Rossum and released in 1991, Python has grown to become one of the most popular programming languages globally. It supports multiple programming paradigms, such as object-oriented, procedural, and functional programming.

Its simplicity allows beginners to focus on learning programming logic rather than complicated syntax. Whether you’re building a website, automating tasks, analyzing data, or experimenting with AI, Python provides the tools and flexibility to do it all.

Installing Python and Setting Up IDEs

Before you write any code, you need to install Python. Visit the official Python website and download the latest version compatible with your operating system. During installation, make sure to check the box labeled “Add Python to PATH” — this ensures you can run Python from the command line.

To make coding easier, it’s best to use an Integrated Development Environment (IDE). IDEs like VS Code, PyCharm, or Thonny provide features such as syntax highlighting, auto-completion, and debugging tools that help beginners code efficiently.

Running Your First Python Script

Once Python is installed and your IDE is ready, it’s time to write your first program. Open your IDE, create a new file called hello.py, and type the following:

Save the file and run it. The output will be:

This simple line demonstrates how Python uses the print() function to display information on the screen. You’re now officially a Python programmer!

---

Basic Syntax and Variables

Variables and Data Types

Variables store data in memory, allowing your programs to operate on that data. In Python, you don’t need to declare the type of a variable — it’s determined dynamically when the code runs.

Python supports four basic data types:

• int: Whole numbers

• float: Numbers with decimals

• str: Text

• bool: True or False values

Naming Conventions

Naming variables well improves code readability. Follow these practices:

• Use lowercase letters and underscores: user_name

• Avoid special characters and spaces

• Do not use Python keywords like def, class, or if

Type Casting

Python allows conversion between types using built-in functions:

This process, called type casting, is essential when dealing with user input or performing mathematical operations.

---

Input & Output

The input() and print() Functions

Python allows user interaction through the input() function and displays information using print().

Here, input() collects user input as a string, and print() displays a message.

String Formatting Techniques

Readable code often involves formatting strings neatly.

Python provides multiple ways to format strings. Among them, f-strings are the most modern and readable option.

Using f-strings (Recommended)
This method is concise and preferred in Python 3.6+:

Using the .format() method

Introduced in Python 3.0, this approach allows placeholders to be replaced by values:

Using % formatting

This older style is similar to C-style formatting:

Although all three work, f-strings are generally the clearest and fastest.
Each method has its use case, but f-strings offer the cleanest syntax and best performance.

---

Operators

Arithmetic and Comparison Operators

Python uses standard arithmetic operators:

• + (addition)

• - (subtraction)

• * (multiplication)

• / (division)

• ** (exponentiation)

And comparison operators:

• == (equal to)

• != (not equal to)

• <, >, <=, >=

Assignment and Logical Operators

Assignment uses =, and can be combined with arithmetic:

Logical operators include:

• and

• or

• not

Identity and Membership Operators

is checks object identity, and in checks for membership within sequences.

---

Conditional Statements

Using if, elif, and else

Conditions allow programs to make decisions.

Nested Conditions

Python supports nesting for complex logic:

Although nesting is powerful, too much of it can reduce code clarity.

---

Loops

for and while Loops

Use loops to repeat actions.

for loop:

while loop:

break, continue, and pass

These control flow keywords alter loop behavior:

Use them carefully to avoid confusing logic.

---

Data Structures

Lists

Lists in Python are ordered collections of items.
Here’s an example:

You can modify lists after creating them, as they are mutable. Additionally, they can store elements of different data types, including strings, numbers, or even other lists.

Tuples

Tuples are like lists but immutable:

They’re great for storing fixed-size collections.

Sets

Sets store unique, unordered items:

They automatically remove duplicates.

Dictionaries

Dictionaries in Python store key-value pairs, making them ideal for representing structured data.
For example:

They allow you to access values efficiently using keys, rather than relying on index positions.
Thanks to this flexibility, dictionaries are widely used for configurations, JSON-like data, and lookups.

---

Functions

Defining and Calling Functions

Functions reduce repetition and improve code clarity.

Parameters and Return Values

Functions can accept multiple parameters and return results:

Using *args and **kwargs

To accept a variable number of arguments:

These tools make your functions more flexible and reusable.

---

Intermediate — Strengthen Your Core Knowledge

At this stage in your Python journey, you’re ready to deepen your understanding of the language. You’ll now explore Python’s more powerful built-in features, write cleaner and more efficient code, and organize your programs for reusability and scalability.

---

String Manipulation

String Methods: split(), replace(), find(), and More

Strings are essential in almost every Python program. Python includes many built-in methods to manipulate string data without the need for external libraries.

• split() breaks a string into a list of words or characters.

  text = "Learn Python Programming" words = text.split() print(words) # ['Learn', 'Python', 'Programming']

  1 2 3

  text = "Learn Python Programming" words = text.split() print(words)  # ['Learn', 'Python', 'Programming']

• replace() swaps a part of the string with another.

  sentence = "I love Java" updated = sentence.replace("Java", "Python") print(updated) # I love Python

  1 2 3

  sentence = "I love Java" updated = sentence.replace("Java", "Python") print(updated)  # I love Python

• find() returns the index of the first occurrence of a substring.

  message = "Intermediate Python" print(message.find("Python")) # 13

  1 2	message = "Intermediate Python" print(message.find("Python"))  # 13

Other useful string methods include lower(), upper(), strip(), startswith(), and endswith(). Together, they help you clean, search, and format string data efficiently.

Slicing and Indexing

Python allows you to access parts of a string using indexing and slicing. Indexing starts at 0.

Slicing extracts a substring:

These tools are critical when working with textual data, especially in automation and data processing tasks.

---

List and Dictionary Comprehensions

Writing Concise Loops

List comprehensions offer a compact way to generate lists.

This syntax reduces boilerplate code and improves readability.

Conditional Logic Inside Comprehensions

List comprehensions also support if conditions:

Similarly, you can use dictionary comprehensions to construct dictionaries dynamically:

Comprehensions promote clean, expressive code that’s easy to maintain.

---

Error Handling in Python

try, except, finally

Errors, or exceptions, occur when the program encounters something unexpected. Python lets you handle such cases gracefully using try, except, and finally.

• The try block contains the code that might cause an error.

• The except block defines how to handle specific exceptions.

• The finally block always executes, whether an error occurred or not.

Custom Exceptions

In some cases, built-in exceptions are not enough. You can define your own:

By creating custom exceptions, your code becomes more descriptive and user-friendly.

---

Modules and Packages

Using import, from, and as

Modules are Python files containing reusable functions, classes, or variables. You can import them into your project in multiple ways.

Creating and Using Your Own Modules

You can organize your functions into modules. Create a file called utils.py:

Then import and use it in another file:

This promotes code reusability and better structure.

pip and Installing Third-Party Packages

pip is Python’s package installer. You can use it to install external libraries.

After installation, import and use the package:

Packages dramatically expand what Python can do, from web development to machine learning.

---

File Handling in Python

Reading and Writing Files

Python provides the open() function to interact with files.

The with statement ensures files are automatically closed after usage.

Working with CSV and JSON

For structured data, use the csv and json modules.

CSV Example:

JSON Example:

These formats are widely used in APIs and data exchange between applications.

---

Object-Oriented Programming (OOP) in Python

Classes and Objects

OOP is a paradigm where code is organized using “objects”, which are instances of “classes”. A class acts as a blueprint.

Constructors (__init__)

The constructor initializes object properties when an instance is created.

Inheritance, Encapsulation, Polymorphism

These are core principles of OOP:

• Inheritance allows a class to acquire properties from another class:

  class Animal: def speak(self): print("Animal sound") class Cat(Animal): def speak(self): print("Meow") kitty = Cat() kitty.speak() # Meow

  1 2 3 4 5 6 7 8 9 10

  class Animal:     def speak(self):         print("Animal sound")   class Cat(Animal):     def speak(self):         print("Meow")   kitty = Cat() kitty.speak()  # Meow

• Encapsulation restricts direct access to data:

  class BankAccount: def __init__(self): self.__balance = 0 # private variable def deposit(self, amount): self.__balance += amount def get_balance(self): return self.__balance

  1 2 3 4 5 6 7 8 9

  class BankAccount:     def __init__(self):         self.__balance = 0  # private variable       def deposit(self, amount):         self.__balance += amount       def get_balance(self):         return self.__balance

• Polymorphism allows methods to be redefined by child classes.

  for animal in [Cat(), Animal()]: animal.speak()

  1 2	for animal in [Cat(), Animal()]:     animal.speak()

Understanding self, __str__, and __repr__

• self represents the current instance.

• __str__() defines what print() should return for an object.

• __repr__() provides a representation useful for debugging.

  class Book: def __init__(self, title): self.title = title def __str__(self): return f"Book title: {self.title}" def __repr__(self): return f"Book('{self.title}')" b = Book("Python Basics") print(b) # Book title: Python Basics print(repr(b)) # Book('Python Basics')

  1 2 3 4 5 6 7 8 9 10 11 12 13

  class Book:     def __init__(self, title):         self.title = title       def __str__(self):         return f"Book title: {self.title}"       def __repr__(self):         return f"Book('{self.title}')"   b = Book("Python Basics") print(b)        # Book title: Python Basics print(repr(b))  # Book('Python Basics')

---

Advanced — Master Python

Once you’re confident with Python basics and intermediate concepts, it’s time to level up. The advanced features of Python empower you to write efficient, elegant, and scalable code. From custom iterators to multithreading, these topics will help you think like a professional Python developer.

---

Iterators and Generators

iter() and next()

In Python, an iterator is an object that represents a stream of data. You can iterate through this stream one element at a time using next().

Any object with a __iter__() method is iterable, and any object with a __next__() method is an iterator.

yield and Custom Generator Functions

Generators simplify the process of creating iterators. Rather than storing all elements in memory, a generator yields items one at a time.

Compared to lists, generators are memory-efficient and perfect for processing large datasets or streams.

---

Decorators in Python

Function Decorators

A decorator is a function that modifies the behavior of another function. This is useful for adding logging, access control, caching, and more — without modifying the original function’s code.

Here, @logger wraps the greet function to add extra behavior.

Chaining Decorators

You can apply multiple decorators to a single function. They execute in the order they’re stacked.

This approach provides a modular and flexible way to enhance functions.

---

Lambda Functions and Functional Programming in Python

lambda, map(), filter(), and reduce()

Lambda functions are anonymous, one-line functions that are especially useful in functional programming.

map() applies a function to every item in a list:

filter() selects items based on a condition:

reduce() (from functools) applies a rolling computation:

These techniques promote clean, declarative code that focuses on what rather than how.

---

Regular Expressions (Regex)

Using the re Module

The re module allows pattern-based string processing using regular expressions.

Pattern Matching, Groups, Substitution

• re.match() checks from the start of a string.

• re.search() finds the first match anywhere.

• re.findall() returns all matches.

Grouping captures parts of the match:

Substitution replaces parts of a string:

Regex is invaluable for validating emails, parsing logs, and cleaning data.

---

Working with Dates and Time

The datetime Module

Python’s datetime module enables precise manipulation of dates and times.

Timestamps, Formatting, Parsing

You can convert between strings and datetime objects:

For Unix timestamps:

Understanding time zones and durations (timedelta) becomes essential for scheduling and analytics applications.

---

Multithreading and Multiprocessing in Python

threading and multiprocessing Modules

Python allows concurrent execution of code using threads or processes.

• Multithreading is useful for I/O-bound tasks (e.g., file reading).

• Multiprocessing is best for CPU-bound tasks (e.g., computation-heavy).

Multithreading Example:

Multiprocessing Example:

When and Why to Use Them

Use threads when tasks spend time waiting (e.g., downloading). Use processes when tasks require intense computation. This distinction helps optimize resource use and performance.

---

Advanced OOP Concepts in Python

Class Methods and Static Methods

A class method takes the class as its first argument and is defined using @classmethod.

A static method doesn’t take instance or class as its argument.

Multiple Inheritance

Python supports multiple inheritance, allowing a class to inherit from more than one base class.

Magic Methods (__add__, __len__, etc.)

Magic methods provide special behavior for built-in operations.

These methods include __add__, __str__, __eq__, and more — allowing your classes to behave like native types.

---

Working with APIs

Using requests to Fetch Data

Python’s requests library simplifies API communication.

Consuming REST APIs

REST APIs provide access to external data and services. You send HTTP requests and receive responses, often in JSON format.

You can also send POST requests:

Parsing JSON Responses

The .json() method converts the raw JSON string into a Python dictionary. From there, you can easily access and manipulate the data.

---

---