Python Programming Tutorial

What is a Variable?

In Python, a variable is a container that holds data. Think of it as a label or a name assigned to a value in your program's memory, allowing you to refer to that value later.

Declaring Variables in Python

The syntax to declare a variable in Python is:

variable_name = value
  

Example:

age = 23
name = "Alice"
height = 5.7
  

Types of Values (Data Types)

• Integer (int): Whole numbers, e.g., 5, 100
• Float (float): Decimal numbers, e.g., 3.14, 5.0
• String (str): Text, e.g., "Hello", "Python"
• Boolean (bool): True or False values, e.g., True, False

Memory Representation of Variables

When you declare a variable, Python:

1. Allocates memory for that variable in the computer's memory.
2. Associates the variable name with this memory address.

Example memory representation:

Updating Variables

Variables in Python are dynamically typed and can be reassigned to a new value, even of a different type:

x = 5  # x is an integer
x = "five"  # Now, x is a string

Scope of Variables

Python has two main variable scopes:

• Global Variables: Declared outside functions and accessible throughout the program.
• Local Variables: Declared within functions and only accessible within that function.

x = 10  # Global variable

def my_function():
    y = 5  # Local variable
    print(y)

print(x)  # Works
my_function()  # Works
print(y)  # Error, y is not accessible here

Constants in Python

In Python, constants are typically written in uppercase to distinguish them from regular variables. For example:

PI = 3.14159

While Python doesn’t enforce immutability for constants, by convention we treat them as unchangeable.

Python Data Types

Data types classify the kind of data a variable holds, determining how it can be used.

Python Keywords

Keywords are reserved words with special meaning in Python, defining the program's structure and control flow.

Python Literals

Literals represent fixed values directly assigned to variables. They come in several types, including numbers, strings, and booleans.

Python Operators

Operators perform actions on variables and values. They include arithmetic, comparison, logical, assignment, and more.

Python Comments

Comments are annotations in code ignored by the interpreter. Use them to explain complex parts of code.

Python If-Else Statement

The if-else statement is a control flow structure that allows code to make decisions based on conditions. It’s like setting rules: if a condition is met, do one thing; otherwise, do another.

age = 18

if age >= 18:
    print("You are eligible to vote.")
else:
    print("You are not eligible to vote.")

Python Loops

Loops help us repeat a block of code multiple times. Python supports two main types of loops: for loop and while loop.

Python For Loop

A for loop is perfect for iterating over a sequence of items, such as a list or a string. Each item in the sequence is processed one at a time.

numbers = [1, 2, 3, 4, 5]

for number in numbers:
    print("Number:", number)

Python While Loop

The while loop repeats a block of code as long as a specified condition is True. It’s especially useful when we don't know beforehand how many times we want to repeat an action.

number = 1

while number <= 5:
    print("Number:", number)
    number += 1

Python Break Statement

The break statement allows us to exit a loop prematurely, regardless of the loop’s condition. This is helpful when we want to stop the loop based on a certain event or condition.

numbers = [1, 3, 5, 8, 10]

for num in numbers:
    if num % 2 == 0:
        print("First even number:", num)
        break

Python Continue Statement

The continue statement skips the current iteration of the loop and moves to the next one. It’s useful when we want to ignore certain items in a loop.

for i in range(1, 10):
    if i % 3 == 0:
        continue
    print(i)

Python Pass

The pass statement acts as a placeholder in Python. It allows you to define blocks of code that you’ll implement later, without causing errors. Often used in loops, functions, or classes under development.

def unfinished_function():
    pass  # TODO: Add function code later

for i in range(5):
    if i < 3:
        pass  
    else:
        print("Value is:", i)

Python Strings

Strings are sequences of characters used for textual data in Python. They are immutable, meaning they cannot be changed once created. Python provides numerous built-in string methods for manipulation.

text = "Hello, Python World!"
# Convert to lowercase
print(text.lower())  

# Convert to uppercase
print(text.upper())  

# Replace substring
print(text.replace("World", "Universe"))  

Python String Functions

In Python, strings are a sequence of characters, and they come with a variety of built-in methods to perform common operations. These string functions are incredibly useful for handling and manipulating textual data.

Let's explore some commonly used string functions:

• upper(): Converts all characters in the string to uppercase.
• lower(): Converts all characters in the string to lowercase.
• strip(): Removes leading and trailing whitespace characters from the string.
• replace(): Replaces a specified substring with another substring.
• split(): Splits the string into a list based on a delimiter (default is space).
• find(): Searches for a substring within the string and returns the index of its first occurrence.
• join(): Joins the elements of an iterable into a single string with a specified delimiter.

Example Code:

# Example of Python String Functions
text = "Hello, World!"

# Convert to uppercase
print(text.upper())

# Output: "HELLO, WORLD!"



# Convert to lowercase
print(text.lower()) 

# Output: "hello, world!"


# Strip leading and trailing spaces
print(text.strip())  

# Output: "Hello, World!"


# Replace a substring
print(text.replace("World", "Python"))  

# Output: "  Hello, Python!  "


# Split the string into a list
words = text.split()
print(words)  

# Output: ['Hello,', 'World!']



# Find the position of a substring
print(text.find("World"))  

# Output: 8



# Join elements of a list into a string
word_list = ['Hello', 'Python']
print(" ".join(word_list))  

# Output: "Hello Python"

Python Lists

Lists are mutable, ordered collections that can contain elements of any data type. They are dynamic and allow various operations such as adding, removing, and modifying elements.

fruits = ["apple", "banana", "cherry"]

fruits.append("orange")  # Add element

print(fruits[1])  # Access second element


fruits.remove("banana")  # Remove element
print(fruits)

Python Tuples

Tuples are immutable collections, used to store data that should not change. They are useful for read-only data, ensuring that no accidental modifications occur.

colors = ("red", "green", "blue")

print(colors[0])  # Access first element

# Attempting to modify will cause an error
# colors[0] = "yellow"  # Error: Tuples are immutable

Python List Vs Tuple

Lists are mutable and allow changes after creation, while tuples are immutable. Use lists when data needs modification and tuples for static data.

  # List Example
  my_list = [1, 2, 3]

  my_list[1] = 20  # List is mutable


  # Tuple Example
  my_tuple = (1, 2, 3)

  # my_tuple[1] = 20  # Error: Tuple is immutable

Python Sets

Sets are unordered collections with no duplicate values, useful for mathematical operations like unions and intersections.

numbers = {1, 2, 3, 3, 4}

print(numbers)  #Output: {1, 2, 3, 4}

numbers.add(5)  # Add an element


print(numbers)

Python Dictionary

Dictionaries are collections of key-value pairs, enabling fast retrieval by key.

person = {"name": "Alice", "age": 25}

print(person["name"])  # Access by key

person["age"] = 26  # Update value

print(person)

Python Functions

Functions are reusable blocks of code that encapsulate specific logic. They help in making the code modular and readable.

def greet(name):
        return f"Hello, {name}"

print(greet("Alice"))

Python Lambda Functions

Lambda functions are anonymous, single-expression functions used for short, simple operations.

multiply = lambda x, y: x * y

print(multiply(2, 3))

Python Built-in Functions

Python comes with a set of built-in functions that you can use without needing to import any additional libraries. These functions provide essential utilities for working with data, performing mathematical operations, interacting with the environment, and more.

Some of the most commonly used built-in functions in Python are:

• print(): Prints the specified message to the console or other standard output device.
• len(): Returns the length (the number of items) of an object.
• type(): Returns the type of the specified object.
• int(), float(), str(): Converts a given value to an integer, float, or string respectively.
• range(): Generates a sequence of numbers, often used in loops.
• max(), min(): Returns the largest and smallest item in an iterable or among two or more arguments.
• sum(): Returns the sum of all items in an iterable (e.g., a list).
• sorted(): Returns a sorted list of the specified iterable’s elements.
• input(): Reads a line of text input from the user.

Example Code:

# Example of Python Built-in Functions

# Using print to output to console
print("Hello, Python!")

# Getting the length of a string
text = "Hello, Python!"
print(len(text))  # Output: 14

# Checking the type of a variable
x = 10
print(type(x))  # Output: 

# Converting values between types
num = "10"
print(int(num))  # Output: 10

# Creating a range of numbers
for i in range(5):
    print(i)  # Output: 0 1 2 3 4

# Finding the max and min of a list
numbers = [1, 5, 3, 9]
print(max(numbers))  # Output: 9
print(min(numbers))  # Output: 1

# Summing a list of numbers
print(sum(numbers))  # Output: 18

# Sorting a list
print(sorted(numbers))  # Output: [1, 3, 5, 9]

# Taking input from user
name = input("Enter your name: ")
print("Hello, " + name)

Python Files I/O

File I/O allows reading and writing files, enabling persistent storage of data.

with open("example.txt", "w") as file:
        file.write("Hello, file!")


with open("example.txt", "r") as file:
        content = file.read()
        print(content)

Python Modules

Modules are files containing Python code that you can import and use in other programs.

Python Exceptions

Exceptions are errors that can be handled with try-except blocks, allowing programs to manage unexpected conditions.

Python Date

The datetime module provides classes to manipulate date and time in Python.

Python Regex

Regular expressions are sequences of characters that define search patterns, useful for pattern matching and string validation.

Python OOPs

Object-Oriented Programming (OOP) in Python is a programming paradigm that structures code into reusable objects. Objects are instances of classes, which can have properties (attributes) and methods (functions). OOP makes code modular, easier to debug, and allows complex software to be more manageable.

Python OOP Concepts

Python’s OOP includes four main concepts: Encapsulation (bundling data and methods), Inheritance (reusing and extending existing code), Polymorphism (using a single interface in different forms), and Abstraction (hiding complexity to make interfaces simpler).

Python Object Class

A class is a blueprint for creating objects. It defines a set of attributes and methods that the objects created from the class will have. When an instance of a class is created, it is called an object.

Python Constructors

A constructor in Python is defined by the __init__ method and is called automatically when an object is created. It initializes the object’s properties and sets up its initial state.

Python Inheritance

Inheritance allows a class (child class) to inherit attributes and methods from another class (parent class). This helps in code reusability and hierarchy building.

Abstraction in Python

Abstraction means exposing only the relevant information to the outside world and hiding the internal implementation details. In Python, abstraction is achieved using abstract classes and interfaces from the abc module.

Encapsulation in Python

Encapsulation is the concept of bundling data and methods within a class and restricting direct access to some attributes. In Python, we can create private attributes using a single or double underscore before the variable name.

Polymorphism in Python

Polymorphism allows us to define methods in child classes that have the same name as methods in the parent class. This allows the same method to operate on different objects in a unique way.