Type conversion

Safe conversion with error handling

Control Structures

Conditional Statements

`python

Basic if-elif-else structure

Ternary operator (conditional expression)

Multiple conditions

Loops

#### For Loops

`python

Iterating over a list

Using range()

for i in range(1, 6): # 1 to 5 print(f"Number: {i}")

for i in range(0, 10, 2): # 0, 2, 4, 6, 8 print(f"Even number: {i}")

Enumerate for index and value

Dictionary iteration

#### While Loops

`python

Basic while loop

While loop with user input

#### Loop Control Statements

| Statement | Purpose | Example | |-----------|---------|---------| | break | Exit loop completely | if condition: break | | continue | Skip to next iteration | if condition: continue | | else | Execute if loop completes normally | for...: else: print("Done") |

`python

Loop control examples

Functions in Python

Function Definition and Calling

`python def greet(name, greeting="Hello"): """ Greet a person with a custom message. Args: name (str): Person's name greeting (str): Greeting message (default: "Hello") Returns: str: Formatted greeting message """ return f"{greeting}, {name}!"

Function calls

Function Parameters and Arguments

| Parameter Type | Description | Example | |----------------|-------------|---------| | Positional | Arguments passed by position | func(a, b, c) | | Keyword | Arguments passed by name | func(a=1, b=2) | | Default | Parameters with default values | def func(a, b=10): | | Variable Length | Accept any number of arguments | def func(args, *kwargs): |

`python def flexible_function(required, default_param="default", args, *kwargs): """Demonstrate different parameter types.""" print(f"Required: {required}") print(f"Default: {default_param}") print(f"Extra positional args: {args}") print(f"Extra keyword args: {kwargs}")

Example calls

Lambda Functions

`python

Lambda function syntax

Using lambda with built-in functions

Sorting with lambda

File Operations

Reading Files

`python def read_file_methods(): """Demonstrate different ways to read files.""" # Method 1: Basic file reading file = open("example.txt", "r") content = file.read() file.close() # Method 2: Using with statement (recommended) with open("example.txt", "r") as file: content = file.read() print(content) # Method 3: Reading line by line with open("example.txt", "r") as file: for line_number, line in enumerate(file, 1): print(f"Line {line_number}: {line.strip()}") # Method 4: Reading all lines into a list with open("example.txt", "r") as file: lines = file.readlines() return [line.strip() for line in lines] `

Writing Files

`python def write_file_examples(): """Demonstrate different ways to write files.""" # Writing text to file with open("output.txt", "w") as file: file.write("Hello, World!\n") file.write("This is line 2\n") # Appending to file with open("output.txt", "a") as file: file.write("This line is appended\n") # Writing multiple lines lines = ["Line 1\n", "Line 2\n", "Line 3\n"] with open("output.txt", "w") as file: file.writelines(lines) `

File Operation Modes

| Mode | Description | File Pointer | Creates File | |------|-------------|--------------|--------------| | 'r' | Read only | Beginning | No | | 'w' | Write only (overwrites) | Beginning | Yes | | 'a' | Append only | End | Yes | | 'r+' | Read and write | Beginning | No | | 'w+' | Read and write (overwrites) | Beginning | Yes | | 'x' | Create and write (fails if exists) | Beginning | Yes | | 'b' | Binary mode (combine with others) | - | - |

File Path Operations

`python import os import pathlib

def file_path_operations(): """Demonstrate file path operations.""" # Using os module current_dir = os.getcwd() file_path = os.path.join(current_dir, "data", "file.txt") # Check if file/directory exists if os.path.exists(file_path): print(f"File size: {os.path.getsize(file_path)} bytes") # Using pathlib (modern approach) path = pathlib.Path("data") / "file.txt" if path.exists(): print(f"File size: {path.stat().st_size} bytes") print(f"Parent directory: {path.parent}") print(f"File extension: {path.suffix}") `

Error Handling

Try-Except Blocks

`python def safe_division(a, b): """Safely divide two numbers with error handling.""" try: result = a / b return result except ZeroDivisionError: print("Error: Cannot divide by zero!") return None except TypeError: print("Error: Both arguments must be numbers!") return None except Exception as e: print(f"Unexpected error: {e}") return None else: print("Division completed successfully") finally: print("Division operation attempted") `

Common Exception Types

| Exception | Description | Common Causes | |-----------|-------------|---------------| | ValueError | Invalid value for operation | int("abc"), math.sqrt(-1) | | TypeError | Wrong data type | "string" + 5, len(42) | | IndexError | List index out of range | list[10] when list has 5 elements | | KeyError | Dictionary key not found | dict["nonexistent_key"] | | FileNotFoundError | File doesn't exist | Opening non-existent file | | AttributeError | Object has no attribute | "string".nonexistent_method() | | ImportError | Module import failed | import nonexistent_module |

Custom Exception Handling

`python class CustomError(Exception): """Custom exception class.""" def __init__(self, message, error_code=None): super().__init__(message) self.error_code = error_code

def validate_age(age): """Validate age with custom exception.""" if not isinstance(age, int): raise CustomError("Age must be an integer", "TYPE_ERROR") if age < 0: raise CustomError("Age cannot be negative", "VALUE_ERROR") if age > 150: raise CustomError("Age seems unrealistic", "RANGE_ERROR") return True

Usage

Best Practices and Code Organization

PEP 8 Style Guide

`python

Good: Clear variable names

Bad: Unclear variable names

Good: Function naming

Good: Class naming

Good: Constants

Code Organization Structure

`python #!/usr/bin/env python3 """ Script Description: Brief description of what the script does Author: Your Name Date: Creation date Version: 1.0 """

Standard library imports

Third-party imports

Local imports

Constants

Global variables (use sparingly)

class MyClass: """Class docstring.""" pass

def utility_function(): """Utility function docstring.""" pass

def main(): """Main function that orchestrates the script execution.""" # Main script logic here pass

if __name__ == "__main__": main() `

Documentation Best Practices

`python def process_data(data, format_type="json", validate=True): """ Process data according to specified format and validation rules. This function takes raw data and processes it according to the specified format type. It can optionally validate the data before processing. Args: data (dict or list): Raw data to be processed format_type (str, optional): Output format ('json', 'csv', 'xml'). Defaults to 'json'. validate (bool, optional): Whether to validate data before processing. Defaults to True. Returns: str: Processed data in the specified format Raises: ValueError: If data format is invalid TypeError: If data is not dict or list Examples: >>> data = {"name": "Alice", "age": 30} >>> result = process_data(data, format_type="json") >>> print(result) '{"name": "Alice", "age": 30}' >>> data_list = [1, 2, 3, 4, 5] >>> result = process_data(data_list, format_type="csv") >>> print(result) '1,2,3,4,5' """ pass `

Advanced Script Examples

File Processing Script

`python #!/usr/bin/env python3 """ File Processing Script Processes text files and generates statistics. """

import os import sys import argparse from collections import Counter import re

class FileProcessor: """Handles file processing operations.""" def __init__(self, file_path): """Initialize with file path.""" self.file_path = file_path self.content = "" self.stats = {} def read_file(self): """Read file content.""" try: with open(self.file_path, 'r', encoding='utf-8') as file: self.content = file.read() return True except FileNotFoundError: print(f"Error: File '{self.file_path}' not found") return False except PermissionError: print(f"Error: Permission denied for file '{self.file_path}'") return False def analyze_content(self): """Analyze file content and generate statistics.""" if not self.content: return lines = self.content.split('\n') words = re.findall(r'\b\w+\b', self.content.lower()) self.stats = { 'total_characters': len(self.content), 'total_lines': len(lines), 'total_words': len(words), 'unique_words': len(set(words)), 'average_line_length': sum(len(line) for line in lines) / len(lines) if lines else 0, 'most_common_words': Counter(words).most_common(10) } def generate_report(self): """Generate and return analysis report.""" if not self.stats: return "No statistics available" report = f""" File Analysis Report for: {self.file_path} {'=' * 50} Total Characters: {self.stats['total_characters']:,} Total Lines: {self.stats['total_lines']:,} Total Words: {self.stats['total_words']:,} Unique Words: {self.stats['unique_words']:,} Average Line Length: {self.stats['average_line_length']:.2f}

Most Common Words: {'-' * 20} """ for word, count in self.stats['most_common_words']: report += f"{word:<15} {count:>5}\n" return report def save_report(self, output_file): """Save report to file.""" report = self.generate_report() try: with open(output_file, 'w', encoding='utf-8') as file: file.write(report) print(f"Report saved to: {output_file}") except Exception as e: print(f"Error saving report: {e}")

def main(): """Main function.""" parser = argparse.ArgumentParser(description='Analyze text files') parser.add_argument('file', help='Path to the text file to analyze') parser.add_argument('-o', '--output', help='Output file for report') parser.add_argument('-v', '--verbose', action='store_true', help='Verbose output') args = parser.parse_args() if args.verbose: print(f"Processing file: {args.file}") processor = FileProcessor(args.file) if not processor.read_file(): sys.exit(1) processor.analyze_content() if args.output: processor.save_report(args.output) else: print(processor.generate_report())

if __name__ == "__main__": main() `

Web Scraping Script

`python #!/usr/bin/env python3 """ Web Scraping Script Scrapes data from websites and saves to file. """

import requests from bs4 import BeautifulSoup import csv import time import logging from urllib.parse import urljoin, urlparse

Configure logging

class WebScraper: """Web scraping utility class.""" def __init__(self, base_url, headers=None, delay=1): """Initialize scraper with base URL and options.""" self.base_url = base_url self.delay = delay self.session = requests.Session() # Set default headers default_headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36' } self.session.headers.update(headers or default_headers) def fetch_page(self, url): """Fetch a single page.""" try: response = self.session.get(url, timeout=10) response.raise_for_status() return response.text except requests.RequestException as e: logging.error(f"Error fetching {url}: {e}") return None def parse_content(self, html, selectors): """Parse HTML content using CSS selectors.""" soup = BeautifulSoup(html, 'html.parser') data = {} for key, selector in selectors.items(): elements = soup.select(selector) if elements: data[key] = [elem.get_text(strip=True) for elem in elements] else: data[key] = [] return data def scrape_multiple_pages(self, urls, selectors, output_file): """Scrape multiple pages and save to CSV.""" all_data = [] for i, url in enumerate(urls, 1): logging.info(f"Scraping page {i}/{len(urls)}: {url}") html = self.fetch_page(url) if html: data = self.parse_content(html, selectors) all_data.append(data) # Be respectful to the server time.sleep(self.delay) # Save to CSV self.save_to_csv(all_data, output_file) def save_to_csv(self, data_list, filename): """Save scraped data to CSV file.""" if not data_list: logging.warning("No data to save") return # Get all unique keys all_keys = set() for data in data_list: all_keys.update(data.keys()) with open(filename, 'w', newline='', encoding='utf-8') as csvfile: writer = csv.writer(csvfile) # Write header writer.writerow(list(all_keys)) # Write data for data in data_list: row = [] for key in all_keys: values = data.get(key, []) row.append('; '.join(values) if values else '') writer.writerow(row) logging.info(f"Data saved to {filename}")

def main(): """Main function demonstrating web scraping.""" # Example: Scraping news headlines urls = [ "https://example-news-site.com/page1", "https://example-news-site.com/page2", ] selectors = { 'headlines': 'h2.headline', 'authors': '.author-name', 'dates': '.publish-date' } scraper = WebScraper("https://example-news-site.com", delay=2) scraper.scrape_multiple_pages(urls, selectors, "news_data.csv")

if __name__ == "__main__": main() `

Debugging and Testing

Debugging Techniques

`python import pdb import logging

Configure logging for debugging

def debug_example_function(numbers): """Function with debugging examples.""" logging.debug(f"Function called with: {numbers}") # Print debugging print(f"DEBUG: Processing {len(numbers)} numbers") # Assertion for debugging assert isinstance(numbers, list), "Input must be a list" assert len(numbers) > 0, "List cannot be empty" result = [] for i, num in enumerate(numbers): # Breakpoint for debugging if num < 0: pdb.set_trace() # Debugger will stop here processed = num * 2 result.append(processed) logging.debug(f"Processed item {i}: {num} -> {processed}") return result

Using try-except for debugging

Simple Testing

`python def test_functions(): """Simple test function.""" # Test cases test_cases = [ ([1, 2, 3], [2, 4, 6]), ([0, -1, 5], [0, -2, 10]), ([], []) ] for i, (input_data, expected) in enumerate(test_cases): try: result = debug_example_function(input_data) if result == expected: print(f"Test {i+1}: PASSED") else: print(f"Test {i+1}: FAILED - Expected {expected}, got {result}") except Exception as e: print(f"Test {i+1}: ERROR - {e}")

Run tests

Command Line Arguments

Using argparse

`python import argparse import sys

def create_argument_parser(): """Create and configure argument parser.""" parser = argparse.ArgumentParser( description='Example script with command line arguments', epilog='Example: python script.py -f input.txt -o output.txt --verbose' ) # Positional arguments parser.add_argument('input_file', help='Input file path') # Optional arguments parser.add_argument('-o', '--output', help='Output file path', default='output.txt') parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose output') parser.add_argument('--format', choices=['json', 'csv', 'txt'], default='txt', help='Output format') parser.add_argument('-n', '--number', type=int, default=10, help='Number of items to process') return parser

def main(): """Main function using command line arguments.""" parser = create_argument_parser() args = parser.parse_args() # Use arguments if args.verbose: print(f"Processing file: {args.input_file}") print(f"Output file: {args.output}") print(f"Format: {args.format}") print(f"Number of items: {args.number}") # Your script logic here process_file(args.input_file, args.output, args.format, args.number)

def process_file(input_file, output_file, format_type, num_items): """Process file based on arguments.""" # Implementation here pass

if __name__ == "__main__": main() `

Common Python Libraries for Scripting

Essential Libraries Overview

| Library | Purpose | Installation | Common Use Cases | |---------|---------|--------------|------------------| | os | Operating system interface | Built-in | File operations, environment variables | | sys | System-specific parameters | Built-in | Command line args, exit codes | | json | JSON data handling | Built-in | API responses, configuration files | | csv | CSV file handling | Built-in | Data import/export | | datetime | Date and time operations | Built-in | Timestamps, date calculations | | re | Regular expressions | Built-in | Text pattern matching | | requests | HTTP library | pip install requests | Web APIs, downloading files | | pandas | Data manipulation | pip install pandas | Data analysis, CSV/Excel processing | | pathlib | Object-oriented file paths | Built-in (Python 3.4+) | Modern path handling |

Library Usage Examples

`python

Working with dates

def date_operations(): """Demonstrate date operations.""" now = datetime.now() yesterday = now - timedelta(days=1) print(f"Current time: {now.strftime('%Y-%m-%d %H:%M:%S')}") print(f"Yesterday: {yesterday.strftime('%Y-%m-%d')}")

JSON operations

CSV operations

This comprehensive guide provides a solid foundation for writing Python scripts. Start with simple scripts and gradually incorporate more advanced features as you become comfortable with the basics. Remember to follow best practices, handle errors gracefully, and document your code thoroughly for maintainability.