Common usage

Variables and Operators

Variable Declaration and Assignment

`python

Variable assignment

Multiple assignment

Variable naming rules

Invalid variable names (will cause errors)

123name = "invalid" # Cannot start with number

my-var = "invalid" # Cannot contain hyphens

class = "invalid" # Cannot use reserved keywords

Operators

#### Arithmetic Operators

| Operator | Name | Example | Result | |----------|------|---------|--------| | + | Addition | 5 + 3 | 8 | | - | Subtraction | 5 - 3 | 2 | | | Multiplication | 5 3 | 15 | | / | Division | 10 / 3 | 3.333... | | // | Floor Division | 10 // 3 | 3 | | % | Modulus | 10 % 3 | 1 | | | Exponentiation | 2 3 | 8 |

`python

Arithmetic operations

print(f"{a} + {b} = {a + b}") # 10 + 3 = 13 print(f"{a} - {b} = {a - b}") # 10 - 3 = 7 print(f"{a} {b} = {a b}") # 10 * 3 = 30 print(f"{a} / {b} = {a / b}") # 10 / 3 = 3.333... print(f"{a} // {b} = {a // b}") # 10 // 3 = 3 print(f"{a} % {b} = {a % b}") # 10 % 3 = 1 print(f"{a} {b} = {a b}") # 10 3 = 1000 `

#### Comparison Operators

| Operator | Name | Example | Result | |----------|------|---------|--------| | == | Equal to | 5 == 5 | True | | != | Not equal to | 5 != 3 | True | | > | Greater than | 5 > 3 | True | | < | Less than | 3 < 5 | True | | >= | Greater than or equal | 5 >= 5 | True | | <= | Less than or equal | 3 <= 5 | True |

#### Logical Operators

| Operator | Description | Example | |----------|-------------|---------| | and | Returns True if both operands are True | True and False → False | | or | Returns True if at least one operand is True | True or False → True | | not | Returns opposite boolean value | not True → False |

`python

Logical operators example

can_drive = age >= 18 and has_license print(f"Can drive: {can_drive}") # True

needs_transport = not has_car or age < 16 print(f"Needs transport: {needs_transport}") # True `

#### Assignment Operators

| Operator | Example | Equivalent | |----------|---------|------------| | = | x = 5 | x = 5 | | += | x += 3 | x = x + 3 | | -= | x -= 3 | x = x - 3 | | = | x = 3 | x = x * 3 | | /= | x /= 3 | x = x / 3 | | %= | x %= 3 | x = x % 3 | | = | x = 3 | x = x 3 |

Control Flow

Conditional Statements

#### if, elif, else

`python

Basic if statement

if-else statement

if-elif-else statement

print(f"Your grade is: {grade}") `

#### Nested Conditions

`python

Nested if statements

if weather == "sunny": if temperature > 20: print("Perfect day for outdoor activities!") else: print("Sunny but a bit cold") else: print("Not a sunny day")

Complex conditions

if age >= 18 and income >= 30000 and credit_score >= 650: print("Loan approved") else: print("Loan denied") `

Loops

#### for Loop

`python

Basic for loop

for loop with range

range with start, stop, step

for loop with enumerate

#### while Loop

`python

Basic while loop

while loop with user input

Infinite loop prevention

#### Loop Control Statements

| Statement | Description | Usage | |-----------|-------------|-------| | break | Exits the loop completely | Used to terminate loop early | | continue | Skips current iteration | Used to skip to next iteration | | pass | Does nothing (placeholder) | Used as syntactic placeholder |

`python

break example

continue example

pass example

Functions

Functions are reusable blocks of code that perform specific tasks.

Function Definition and Calling

`python

Basic function definition

Calling the function

Function with parameters

greet_person("Alice") # Output: Hello, Alice!

Function with multiple parameters

sum_result = add_numbers(5, 3) print(sum_result) # Output: 8 `

Function Parameters and Arguments

#### Default Parameters

`python def greet_with_title(name, title="Mr./Ms."): print(f"Hello, {title} {name}!")

greet_with_title("Smith") # Hello, Mr./Ms. Smith! greet_with_title("Johnson", "Dr.") # Hello, Dr. Johnson! `

#### Keyword Arguments

`python def create_profile(name, age, city, occupation): return f"{name}, {age} years old, works as {occupation} in {city}"

Positional arguments

Keyword arguments

print(profile1) print(profile2) `

#### Variable-Length Arguments

`python

*args - Variable number of positional arguments

print(calculate_sum(1, 2, 3)) # 6 print(calculate_sum(1, 2, 3, 4, 5)) # 15

kwargs - Variable number of keyword arguments

create_student(name="Alice", age=20, major="Computer Science", gpa=3.8) `

Lambda Functions

`python

Lambda function (anonymous function)

Lambda with multiple arguments

Using lambda with built-in functions

Filter with lambda

Scope and Global Variables

`python

Global variable

def function_scope(): # Local variable local_var = "I am local" print(global_var) # Can access global variable print(local_var) # Can access local variable

function_scope()

print(local_var) # This would cause an error

Modifying global variable

def increment(): global counter counter += 1

increment() increment() print(counter) # 2 `

Data Structures

Lists

Lists are ordered, mutable collections that can store different data types.

`python

Creating lists

List operations

Modifying lists

List slicing

#### List Methods

| Method | Description | Example | |--------|-------------|---------| | append(item) | Add item to end | list.append("new") | | insert(index, item) | Insert item at index | list.insert(0, "first") | | remove(item) | Remove first occurrence | list.remove("item") | | pop(index) | Remove and return item | list.pop(0) | | index(item) | Find index of item | list.index("item") | | count(item) | Count occurrences | list.count("item") | | sort() | Sort list in place | list.sort() | | reverse() | Reverse list in place | list.reverse() |

Tuples

Tuples are ordered, immutable collections.

`python

Creating tuples

Accessing tuple elements

Tuple unpacking

Tuples are immutable

coordinates[0] = 15 # This would cause an error

Tuple methods

Dictionaries

Dictionaries store key-value pairs and are mutable.

`python

Creating dictionaries

Accessing dictionary values

Modifying dictionaries

Dictionary methods

Iterating through dictionary

#### Dictionary Methods

| Method | Description | Example | |--------|-------------|---------| | get(key, default) | Get value or default | dict.get("key", "default") | | keys() | Get all keys | dict.keys() | | values() | Get all values | dict.values() | | items() | Get key-value pairs | dict.items() | | pop(key) | Remove and return value | dict.pop("key") | | update(other) | Update with another dict | dict.update(other_dict) | | clear() | Remove all items | dict.clear() |

Sets

Sets are unordered collections of unique elements.

`python

Creating sets

Set operations

Set mathematical operations

print(set1.union(set2)) # {1, 2, 3, 4, 5, 6} print(set1.intersection(set2)) # {3, 4} print(set1.difference(set2)) # {1, 2}

Checking membership

File Handling

Reading Files

`python

Reading entire file

Reading line by line

Reading lines into a list

Writing Files

`python

Writing to file (overwrites existing content)

Appending to file

Writing multiple lines

File Modes

| Mode | Description | Usage | |------|-------------|-------| | "r" | Read only | Default mode for reading | | "w" | Write only | Overwrites existing file | | "a" | Append only | Adds to end of file | | "r+" | Read and write | File must exist | | "w+" | Write and read | Creates new file | | "x" | Exclusive creation | Fails if file exists |

Working with CSV Files

`python import csv

Reading CSV file

Writing CSV file

with open("output.csv", "w", newline="") as file: csv_writer = csv.writer(file) csv_writer.writerows(data)

Working with CSV dictionaries

Error Handling

Try-Except Blocks

`python

Basic exception handling

Multiple exceptions in one except block

Catching all exceptions

Finally and Else Clauses

`python

try-except-else-finally

print(divide_numbers(10, 2)) # Division successful! This always executes 5.0 print(divide_numbers(10, 0)) # Cannot divide by zero! This always executes None `

Common Exception Types

| Exception | Description | Example | |-----------|-------------|---------| | ValueError | Invalid value for operation | int("abc") | | TypeError | Wrong data type | "hello" + 5 | | IndexError | List index out of range | list[10] when list has 5 items | | KeyError | Dictionary key not found | dict["nonexistent"] | | FileNotFoundError | File doesn't exist | open("missing.txt") | | ZeroDivisionError | Division by zero | 10 / 0 |

Raising Custom Exceptions

`python

Raising built-in exceptions

Custom exception classes

def process_data(data): if not data: raise CustomError("Data cannot be empty") return data.upper()

Using custom exceptions

Object-Oriented Programming

Classes and Objects

`python

Basic class definition

Creating objects (instances)

print(person1.introduce()) # Hi, I'm Alice and I'm 25 years old. print(person1.have_birthday()) # Happy birthday! Alice is now 26. `

Class Attributes and Methods

`python class BankAccount: # Class attribute (shared by all instances) bank_name = "Python Bank" interest_rate = 0.02 def __init__(self, account_holder, initial_balance=0): # Instance attributes self.account_holder = account_holder self.balance = initial_balance self.transaction_history = [] def deposit(self, amount): if amount > 0: self.balance += amount self.transaction_history.append(f"Deposited: ${amount}") return f"Deposited ${amount}. New balance: ${self.balance}" else: return "Deposit amount must be positive" def withdraw(self, amount): if amount > self.balance: return "Insufficient funds" elif amount > 0: self.balance -= amount self.transaction_history.append(f"Withdrew: ${amount}") return f"Withdrew ${amount}. New balance: ${self.balance}" else: return "Withdrawal amount must be positive" def get_balance(self): return f"Current balance: ${self.balance}" @classmethod def set_interest_rate(cls, new_rate): cls.interest_rate = new_rate @staticmethod def validate_account_number(account_number): return len(str(account_number)) == 10

Using the class

Inheritance

`python

Base class

Derived class

class Cat(Animal): def __init__(self, name, color): super().__init__(name, "Cat") self.color = color def make_sound(self): return f"{self.name} meows!" def climb(self): return f"{self.name} climbs the tree!"

Using inheritance

print(dog.info()) # Buddy is a Dog print(dog.make_sound()) # Buddy barks! print(dog.fetch()) # Buddy fetches the ball!

print(cat.info()) # Whiskers is a Cat print(cat.make_sound()) # Whiskers meows! print(cat.climb()) # Whiskers climbs the tree! `

Encapsulation

`python class Student: def __init__(self, name, student_id): self.name = name self._student_id = student_id # Protected attribute self.__grades = [] # Private attribute def add_grade(self, grade): if 0 <= grade <= 100: self.__grades.append(grade) else: raise ValueError("Grade must be between 0 and 100") def get_average(self): if self.__grades: return sum(self.__grades) / len(self.__grades) return 0 def get_grades(self): return self.__grades.copy() # Return copy to prevent external modification def __str__(self): # String representation return f"Student: {self.name} (ID: {self._student_id})"

Using encapsulation

print(student) # Student: Alice (ID: 12345) print(f"Average grade: {student.get_average():.2f}") # Average grade: 85.00 print(f"Grades: {student.get_grades()}") # Grades: [85, 92, 78]

Cannot directly access private attributes

print(student.__grades) # This would cause an AttributeError

Modules and Packages

Importing Modules

`python

Different ways to import

Using imported modules

Creating Custom Modules

Create a file named my_module.py:

`python

my_module.py

def calculate_area(length, width): return length * width

PI = 3.14159

class Calculator: def add(self, a, b): return a + b def multiply(self, a, b): return a * b `

Using the custom module:

`python

main.py

print(greet("World")) # Hello, World! print(f"Area: {my_module.calculate_area(5, 3)}") # Area: 15 print(f"PI value: {PI}") # PI value: 3.14159

calc = my_module.Calculator() print(calc.add(5, 3)) # 8 `

Standard Library Modules

| Module | Description | Common Usage | |--------|-------------|--------------| | os | Operating system interface | File operations, environment variables | | sys | System-specific parameters | Command line arguments, exit | | datetime | Date and time handling | Current time, date calculations | | random | Random number generation | Random numbers, choices | | json | JSON encoder/decoder | Working with JSON data | | re | Regular expressions | Pattern matching | | urllib | URL handling | Web requests |

`python

Examples of standard library usage

OS module

Datetime module

JSON module

parsed_data = json.loads(json_string) print(parsed_data["name"]) # Alice

Random module

This comprehensive guide covers the fundamental concepts of Python programming. Each section builds upon previous knowledge and provides practical examples that you can run and modify. Practice these concepts by writing your own programs and experimenting with the code examples provided.