📊 Day 03 : Strings

🎯 Enterprise Objective

Strings are the primary vehicle for text data — the most common data type in real-world datasets. Today we master every aspect of string manipulation, from basic creation to performance optimization. You will learn not just string methods, but professional text processing patterns used in ETL pipelines and data cleaning.

📋 Strategic Overview

A string is an immutable sequence of Unicode characters. You can create strings with single quotes '...', double quotes "...", or triple quotes '''...''' for multi-line text. Raw strings r'...' disable escape character processing.

Common Escape Characters:

• CSV/JSON parsing: Understanding escape characters is essential for parsing data files

• SQL queries: Triple-quoted strings hold multi-line SQL cleanly

• File paths: Raw strings r'C:\data\file.csv' prevent escape issues on Windows

Strings cannot be modified in place. Every operation like .upper() or + creates a new string object. This matters for performance in loops.

Use triple-quoted strings for multi-line SQL queries: query = """SELECT * FROM users WHERE age > 18""". This keeps your code readable.

Strings support zero-based indexing and negative indexing (from the end). Slicing extracts substrings using the syntax s[start:stop:step] where stop is exclusive.

text = 'PYTHON'
#       P  Y  T  H  O  N
#       0  1  2  3  4  5   (positive index)
#      -6 -5 -4 -3 -2 -1  (negative index)

• Column extraction: Extract substrings from fixed-width data: record[0:10] for name field

• Data cleaning: phone[-10:] to extract last 10 digits of phone numbers

• Log parsing: Slice timestamps from log lines: log_line[:19] for ISO datetime

The stop index is exclusive: 'PYTHON'[0:3] gives 'PYT' (indices 0, 1, 2), not 'PYTH'. This is a common source of bugs.

Reverse a string with s[::-1]. Check for palindromes: s == s[::-1].

Python strings have 40+ built-in methods. The most important ones for data work are: upper(), lower(), strip(), replace(), find(), count(), startswith(), and endswith(). All return new strings (immutability).

• Data standardization: name.strip().title() — clean and capitalize names

• Text cleaning: text.replace('\n', ' ').strip() — normalize whitespace

• File filtering: if filename.endswith('.csv'): — filter file types

• Search: .find() returns -1 instead of raising error (safer than .index())

Chain methods for clean data pipelines: name.strip().lower().replace(' ', '_') converts ' John Doe ' to 'john_doe'.

# split: string → list
'a,b,c'.split(',')        # ['a', 'b', 'c']

# join: list → string
','.join(['a', 'b', 'c'])  # 'a,b,c'

• CSV parsing: row.split(',') — manual CSV field extraction

• Log analysis: log_line.split() — split on whitespace for field extraction

• Data export: ','.join(columns) — build CSV rows for output

• Path building: '/'.join(['home', 'user', 'data']) — construct file paths

Use splitlines() for multi-line text: it handles \n, \r\n, and \r correctly across all platforms.

Python offers three formatting approaches: f-strings (Python 3.6+, fastest and most readable), .format(), and %-formatting (legacy). F-strings embed expressions directly inside {} braces.

• Report generation: Formatted tables, aligned columns, currency values

• Logging: f'[{timestamp}] {level}: {message}' — structured log output

• Dashboard metrics: f'{revenue:,.2f}' — professional number formatting

F-strings can contain any Python expression: f'{len(data):,} records processed in {elapsed:.1f}s'. They are evaluated at runtime.

Python strings have built-in validation methods that return True or False. These are essential for input validation and data quality checks before processing.

• Input validation: if user_id.isdigit(): — validate before int conversion

• Data cleaning: Filter rows where a column should be numeric but contains text

• ETL pipelines: Validate data quality before loading into databases

Python 3 strings are Unicode by default (UTF-8). When working with files, APIs, or databases, you must handle encoding correctly. encode() converts str → bytes, decode() converts bytes → str.

text = 'Hello'
bytes_obj = text.encode('utf-8')   # b'Hello'
back = bytes_obj.decode('utf-8')   # 'Hello'

• API responses: JSON/REST APIs often return bytes that need decoding

• File I/O: open(file, encoding='utf-8') — always specify encoding

• International data: Names, addresses, currencies in non-Latin scripts need proper Unicode handling

Reading a file with wrong encoding causes UnicodeDecodeError. Always use encoding='utf-8' or detect encoding with libraries like chardet.

Since strings are immutable, concatenation in loops creates many temporary objects. For building large strings, use list + join or io.StringIO instead of +=. This can be 100x faster for large datasets.

• ETL pipelines: Building CSV output with join() instead of += saves minutes on large datasets

• Report generation: Use join() for assembling multi-line reports

• Memory management: Knowing string interning helps debug identity issues

Python interns small strings and identifiers. 'hello' is 'hello' may be True due to caching, but never rely on this — always use == for comparison.

Theory is useless without muscle memory. Complete these tasks to solidify your understanding.

✅ Instructor's End-of-Day Checklist

• [ ] I understand string immutability and its performance implications.

• [ ] I can use slicing to extract substrings efficiently.

• [ ] I know the difference between .find() (safe) and .index() (raises error).

• [ ] I can use f-strings with format specs for professional output.

• [ ] I understand encoding and can handle UTF-8/bytes conversion.

• [ ] I have completed all 5 practice tasks.

• [ ] I have reviewed all 25 interview questions.