Python

Getting Started

Fundamental Python concepts and syntax for beginners.

Basic Syntax

Python fundamentals including print, variables, comments, and indentation.

Print statement and variables

Demonstrates variable assignment and f-string printing.

Code

1
name = "Python"
2
version = 3.12
3
print(f"Welcome to {name} {version}")

Execution

1
python -c "name = 'Python'; version = 3.12; print(f'Welcome to {name} {version}')"

Output

1
Welcome to Python 3.12

Python uses meaningful whitespace and indentation.
Variables are dynamically typed.

Comments and multiline strings

Shows different comment styles and how to write docstrings.

Code

1
# This is a single-line comment
2

3
"""
4
This is a multiline comment
5
or docstring
6
"""
7

8
message = "Hello"  # inline comment
9
print(message)

Execution

1
python -c "message = 'Hello'; print(message)"

Output

1
Hello

Use '#' for single-line comments.
Use triple quotes for multiline comments or docstrings.

Data Types

Understanding Python's built-in data types and type conversion.

Type casting and checking

Shows type casting and how to check variable types.

Code

1
x = 42
2
y = float(x)
3
z = str(x)
4
print(type(x), type(y), type(z))
5
print(y, z)

Execution

1
python -c "x = 42; y = float(x); z = str(x); print(type(x), type(y), type(z)); print(y, z)"

Output

1
<class 'int'> <class 'float'> <class 'str'>
2
42.0 42

int(), float(), str(), bool() convert between types.
type() returns the data type of a variable.

None and boolean types

Demonstrates None, boolean types, and truthiness.

Code

1
a = None
2
b = True
3
c = False
4
print(type(a), type(b), type(c))
5
print(bool(1), bool(0), bool(""))

Execution

1
python -c "a = None; b = True; c = False; print(bool(1), bool(0), bool(''))"

Output

1
True False False

None represents a null value.
Empty sequences and 0 evaluate to False.

Numbers and Strings

Arithmetic operations, string slicing, and string methods.

Arithmetic operations and string slicing

Shows arithmetic operators and string slicing with start:end:step syntax.

Code

1
x = 10
2
y = 3
3
print(x + y, x - y, x * y, x / y, x // y, x % y, x ** y)
4

5
text = "Python"
6
print(text[0:3], text[-2:], text[::2])

Execution

1
python -c "x = 10; y = 3; print(x + y, x - y, x * y, x / y, x // y, x % y, x ** y); text = 'Python'; print(text[0:3], text[-2:], text[::2])"

Output

1
13 7 30 3.3333333333333335 3 1 1000
2
Pyt on Pto

/ performs float division, // performs integer division.
Negative indices count from the end of the string.

String methods

Demonstrates common string methods like lower(), replace(), split(), and join().

Code

1
text = "HELLO WORLD"
2
print(text.lower())
3
print(text.replace("WORLD", "Python"))
4
print(text.split())
5
print("_".join(["a", "b", "c"]))

Execution

1
python -c "text = 'HELLO WORLD'; print(text.lower()); print(text.replace('WORLD', 'Python')); print(text.split()); print('_'.join(['a', 'b', 'c']))"

Output

1
hello world
2
HELLO Python
3
['HELLO', 'WORLD']
4
a_b_c

String methods are case-sensitive for the method call.
split() returns a list of strings.

Data Structures

Working with lists, tuples, dictionaries, and sets.

Lists

Creating and manipulating ordered, mutable sequences.

List creation and indexing

Demonstrates list creation, indexing, slicing, and the append() method.

Code

1
items = [1, 2, 3, 4, 5]
2
print(items[0], items[-1])
3
print(items[1:3], items[::2])
4
items.append(6)
5
print(items)

Execution

1
python -c "items = [1, 2, 3, 4, 5]; print(items[0], items[-1]); print(items[1:3], items[::2]); items.append(6); print(items)"

Output

1
1 5
2
[2, 3] [1, 3, 5]
3
[1, 2, 3, 4, 5, 6]

Lists are mutable and can be modified after creation.
Use negative indices to access from the end.

List methods and operations

Shows remove(), pop(), and extend() methods.

Code

1
items = [1, 2, 3, 2, 4]
2
items.remove(2)
3
print(items)
4
items.pop()
5
print(items)
6
items.extend([5, 6])
7
print(items)

Execution

1
python -c "items = [1, 2, 3, 2, 4]; items.remove(2); print(items); items.pop(); print(items); items.extend([5, 6]); print(items)"

Output

1
[1, 3, 2, 4]
2
[1, 3, 2]
3
[1, 3, 2, 5, 6]

remove() removes the first occurrence of a value.
pop() removes and returns the last element.
extend() adds multiple elements to the list.

Tuples

Immutable sequences and tuple unpacking.

Tuple creation and unpacking

Creates tuples and demonstrates unpacking values into variables.

Code

1
point = (10, 20)
2
x, y = point
3
print(f"x={x}, y={y}")
4

5
data = (1, 2, 3)
6
print(data[0], data[-1], len(data))

Execution

1
python -c "point = (10, 20); x, y = point; print(f'x={x}, y={y}'); data = (1, 2, 3); print(data[0], data[-1], len(data))"

Output

1
x=10, y=20
2
1 3 3

Tuples are immutable; they cannot be modified after creation.
Unpacking allows assigning tuple values to multiple variables.

Tuple operations

Demonstrates tuple concatenation and repetition.

Code

1
t1 = (1, 2)
2
t2 = (3, 4)
3
t3 = t1 + t2
4
print(t3)
5
print(t3 * 2)
6
print((5,) == (5))

Execution

1
python -c "t1 = (1, 2); t2 = (3, 4); t3 = t1 + t2; print(t3); print(t3 * 2); print((5,) == (5))"

Output

1
(1, 2, 3, 4)
2
(1, 2, 3, 4, 1, 2, 3, 4)
3
False

Use a trailing comma (5,) to create a single-element tuple.

Dictionaries

Key-value pairs and dictionary operations.

Dictionary creation and access

Shows dictionary creation and access using [] and get().

Code

1
person = {"name": "Alice", "age": 30, "city": "NYC"}
2
print(person["name"])
3
print(person.get("age"))
4
print(person.get("email", "Not found"))

Execution

1
python -c "person = {'name': 'Alice', 'age': 30, 'city': 'NYC'}; print(person['name']); print(person.get('age')); print(person.get('email', 'Not found'))"

Output

1
Alice
2
30
3
Not found

Use get() to safely access keys with a default value.
get() returns None if the key is not found and no default is provided.

Dictionary modification and iteration

Demonstrates adding, deleting, and iterating over dictionary entries.

Code

1
d = {"a": 1, "b": 2}
2
d["c"] = 3
3
del d["a"]
4
print(d)
5
print(d.keys(), d.values())
6
for key, value in d.items():
7
  print(f"{key}: {value}")

Execution

1
python -c "d = {'a': 1, 'b': 2}; d['c'] = 3; del d['a']; print(d); print(list(d.keys()), list(d.values())); [(print(f'{k}: {v}')) for k, v in d.items()]"

Output

1
{'b': 2, 'c': 3}
2
dict_keys(['b', 'c']) dict_values([2, 3])
3
b: 2
4
c: 3

Use del to remove key-value pairs.
items() returns tuples of (key, value) pairs.

Sets

Unordered collections of unique elements.

Set creation and operations

Shows set creation (duplicates removed) and add/remove operations.

Code

1
s = {1, 2, 3, 3, 4}
2
print(s)
3
s.add(5)
4
s.remove(2)
5
print(s)

Execution

1
python -c "s = {1, 2, 3, 3, 4}; print(s); s.add(5); s.remove(2); print(s)"

Output

1
{1, 2, 3, 4}
2
{1, 3, 4, 5}

Sets automatically remove duplicates.
Sets are unordered, so iteration order is not guaranteed.

Set operations

Demonstrates union (|), intersection (&), and difference (-) operations.

Code

1
a = {1, 2, 3}
2
b = {3, 4, 5}
3
print(a | b)  # union
4
print(a & b)  # intersection
5
print(a - b)  # difference

Execution

1
python -c "a = {1, 2, 3}; b = {3, 4, 5}; print(a | b); print(a & b); print(a - b)"

Output

1
{1, 2, 3, 4, 5}
2
{3}
3
{1, 2}

Use pipes |, ampersand &, and minus - for set operations.

Control Flow

Conditionals, loops, and list comprehensions.

Conditionals

if/elif/else statements and logical operators.

if/elif/else statements

Shows if/elif/else conditional logic.

Code

1
x = 15
2
if x < 10:
3
  print("Less than 10")
4
elif x < 20:
5
  print("Between 10 and 20")
6
else:
7
  print("20 or more")

Execution

1
python -c "x = 15; print('Between 10 and 20' if x >= 10 and x < 20 else ('Less than 10' if x < 10 else '20 or more'))"

Output

1
Between 10 and 20

Each conditional block must be indented.
Use elif for multiple conditions.

Comparison and logical operators

Demonstrates logical operators (and, or, not) and membership testing (in).

Code

1
x = 5
2
print(x > 3 and x < 10)
3
print(x == 5 or x == 10)
4
print(not (x == 0))
5
print(x in [1, 2, 5, 10])

Execution

1
python -c "x = 5; print(x > 3 and x < 10); print(x == 5 or x == 10); print(not (x == 0)); print(x in [1, 2, 5, 10])"

Output

1
True
2
True
3
True
4
True

Use 'and', 'or', 'not' for boolean operations.
Use 'in' to check membership in lists, strings, etc.

Loops

for and while loops with break and continue.

for loop with range and lists

Shows for loops iterating over ranges and lists.

Code

1
for i in range(3):
2
  print(f"Iteration {i}")
3

4
for item in ["a", "b", "c"]:
5
  print(item)

Execution

1
python -c "for i in range(3): print(f'Iteration {i}'); print('---'); [print(item) for item in ['a', 'b', 'c']]"

Output

1
Iteration 0
2
Iteration 1
3
Iteration 2
4
---
5
a
6
b
7
c

range(n) generates numbers from 0 to n-1.
for loops automatically iterate over sequences.

Loop control with break and continue

Demonstrates break (exit loop) and continue (skip iteration).

Code

1
for i in range(5):
2
  if i == 2:
3
    continue
4
  if i == 4:
5
    break
6
  print(i)

Execution

1
python -c "for i in range(5):\n  if i == 2:\n    continue\n  if i == 4:\n    break\n  print(i)"

Output

continue skips the current iteration.
break exits the loop entirely.

List Comprehensions

Concise syntax for creating and filtering lists.

Basic list comprehension

Shows list comprehension with transformation and filtering.

Code

1
squares = [x**2 for x in range(5)]
2
print(squares)
3

4
evens = [x for x in range(10) if x % 2 == 0]
5
print(evens)

Execution

1
python -c "squares = [x**2 for x in range(5)]; print(squares); evens = [x for x in range(10) if x % 2 == 0]; print(evens)"

Output

1
[0, 1, 4, 9, 16]
2
[0, 2, 4, 6, 8]

List comprehensions are more concise than for loops.
Add if clause for filtering elements.

Nested list comprehension

Demonstrates nested list comprehensions and flattening matrices.

Code

1
matrix = [[i*j for j in range(3)] for i in range(3)]
2
print(matrix)
3

4
flat = [x for row in matrix for x in row]
5
print(flat)

Execution

1
python -c "matrix = [[i*j for j in range(3)] for i in range(3)]; print(matrix); flat = [x for row in matrix for x in row]; print(flat)"

Output

1
[[0, 0, 0], [0, 1, 2], [0, 2, 4]]
2
[0, 0, 0, 0, 1, 2, 0, 2, 4]

Nested comprehensions can be complex; prioritize readability.

Functions and Scope

Defining functions, arguments, and variable scope.

Function Definition

def keyword, parameters, return statements, and docstrings.

Basic function definition

Demonstrates basic function definition with parameters and return statement.

Code

1
def greet(name):
2
  """Greet a person by name."""
3
  return f"Hello, {name}!"
4

5
print(greet("Alice"))

Execution

1
python -c "def greet(name):\n  return f'Hello, {name}!'\nprint(greet('Alice'))"

Output

1
Hello, Alice!

Functions are defined with the def keyword.
Docstrings document function purpose and usage.

Function with default arguments

Shows functions with default parameter values.

Code

1
def add(a, b=0, c=0):
2
  return a + b + c
3

4
print(add(1))
5
print(add(1, 2))
6
print(add(1, 2, 3))

Execution

1
python -c "def add(a, b=0, c=0):\n  return a + b + c\nprint(add(1)); print(add(1, 2)); print(add(1, 2, 3))"

Output

Default parameters must come after required parameters.
Default values are evaluated once at function definition.

Arguments

Positional arguments, keyword arguments, *args, and **kwargs.

Positional and keyword arguments

Shows positional and keyword argument passing.

Code

1
def describe(name, age, city):
2
  return f"{name} is {age} years old and lives in {city}"
3

4
print(describe("Alice", 30, "NYC"))
5
print(describe(name="Bob", city="LA", age=25))

Execution

1
python -c "def describe(name, age, city):\n  return f'{name} is {age} years old and lives in {city}'\nprint(describe('Alice', 30, 'NYC')); print(describe(name='Bob', city='LA', age=25))"

Output

1
Alice is 30 years old and lives in NYC
2
Bob is 25 years old and lives in LA

Keyword arguments can be passed in any order.
Mix positional and keyword arguments by passing positional first.

Variable length arguments (*args and **kwargs)

Demonstrates *args for variable positional arguments and **kwargs for variable keyword arguments.

Code

1
def sum_numbers(*args):
2
  return sum(args)
3

4
def print_info(**kwargs):
5
  for key, value in kwargs.items():
6
    print(f"{key}: {value}")
7

8
print(sum_numbers(1, 2, 3, 4))
9
print_info(name="Alice", age=30, city="NYC")

Execution

1
python -c "def sum_numbers(*args):\n  return sum(args)\ndef print_info(**kwargs):\n  for key, value in kwargs.items():\n    print(f'{key}: {value}')\nprint(sum_numbers(1, 2, 3, 4)); print_info(name='Alice', age=30, city='NYC')"

Output

1
10
2
name: Alice
3
age: 30
4
city: NYC

*args collects positional arguments as a tuple.
**kwargs collects keyword arguments as a dictionary.

Variable Scope

Local, global, and nonlocal variables.

Local and global scope

Shows local variables shadowing global variables.

Code

1
x = "global"
2

3
def func():
4
  x = "local"
5
  print(x)
6

7
func()
8
print(x)

Execution

1
python -c "x = 'global'\ndef func():\n  x = 'local'\n  print(x)\nfunc(); print(x)"

Output

1
local
2
global

Local variables are created when assigned in a function.
Accessing a global variable requires the global keyword to modify it.

Global and nonlocal keywords

Demonstrates global and nonlocal keywords to modify variables from enclosing scopes.

Code

1
x = 0
2

3
def outer():
4
  y = 1
5
  def inner():
6
    nonlocal y
7
    global x
8
    x = 10
9
    y = 2
10
  inner()
11
  print(f"y={y}")
12

13
outer()
14
print(f"x={x}")

Execution

1
python -c "x = 0\ndef outer():\n  y = 1\n  def inner():\n    nonlocal y\n    global x\n    x = 10\n    y = 2\n  inner()\n  print(f'y={y}')\nouter(); print(f'x={x}')"

Output

1
y=2
2
x=10

global allows modifying module-level variables.
nonlocal allows modifying variables in enclosing function scopes.

Object-Oriented Programming

Classes, inheritance, and special methods.

Classes

Class definition, __init__, self, and instance methods.

Basic class definition

Demonstrates class definition with __init__ constructor and instance methods.

Code

1
class Dog:
2
  def __init__(self, name, age):
3
    self.name = name
4
    self.age = age
5

6
  def bark(self):
7
    return f"{self.name} says Woof!"
8

9
dog = Dog("Buddy", 3)
10
print(dog.bark())

Execution

1
python -c "class Dog:\n  def __init__(self, name, age):\n    self.name = name\n    self.age = age\n  def bark(self):\n    return f'{self.name} says Woof!'\ndog = Dog('Buddy', 3); print(dog.bark())"

Output

1
Buddy says Woof!

__init__ is the constructor called when creating an object.
self refers to the instance and must be the first parameter.

Instance attributes and methods

Shows instance attributes and methods that modify object state.

Code

1
class Counter:
2
  def __init__(self):
3
    self.count = 0
4

5
  def increment(self):
6
    self.count += 1
7
    return self.count
8

9
c = Counter()
10
print(c.increment())
11
print(c.increment())
12
print(c.count)

Execution

1
python -c "class Counter:\n  def __init__(self):\n    self.count = 0\n  def increment(self):\n    self.count += 1\n    return self.count\nc = Counter(); print(c.increment()); print(c.increment()); print(c.count)"

Output

Instance attributes are created in __init__ or assigned later.
Methods can access and modify instance attributes.

Inheritance

Class inheritance, super(), and method overriding.

Class inheritance and super()

Shows class inheritance and method overriding.

Code

1
class Animal:
2
  def __init__(self, name):
3
    self.name = name
4

5
  def speak(self):
6
    return f"{self.name} makes a sound"
7

8
class Dog(Animal):
9
  def speak(self):
10
    return f"{self.name} barks"
11

12
dog = Dog("Rex")
13
print(dog.speak())

Execution

1
python -c "class Animal:\n  def __init__(self, name):\n    self.name = name\n  def speak(self):\n    return f'{self.name} makes a sound'\nclass Dog(Animal):\n  def speak(self):\n    return f'{self.name} barks'\ndog = Dog('Rex'); print(dog.speak())"

Output

1
Rex barks

Child classes inherit attributes and methods from parent classes.
Override methods by redefining them in the child class.

Using super() to call parent methods

Demonstrates super() to call parent class methods.

Code

1
class Animal:
2
  def __init__(self, name):
3
    self.name = name
4

5
class Dog(Animal):
6
  def __init__(self, name, breed):
7
    super().__init__(name)
8
    self.breed = breed
9

10
dog = Dog("Buddy", "Golden")
11
print(f"{dog.name} is a {dog.breed}")

Execution

1
python -c "class Animal:\n  def __init__(self, name):\n    self.name = name\nclass Dog(Animal):\n  def __init__(self, name, breed):\n    super().__init__(name)\n    self.breed = breed\ndog = Dog('Buddy', 'Golden'); print(f'{dog.name} is a {dog.breed}')"

Output

1
Buddy is a Golden

super() provides access to parent class methods.
Always call super().__init__() to initialize parent attributes.

Special Methods

__str__, __repr__, __len__, __getitem__, and other dunder methods.

str and repr methods

Shows __str__ for user-friendly representation and __repr__ for development.

Code

1
class Point:
2
  def __init__(self, x, y):
3
    self.x = x
4
    self.y = y
5

6
  def __str__(self):
7
    return f"Point({self.x}, {self.y})"
8

9
  def __repr__(self):
10
    return f"Point(x={self.x}, y={self.y})"
11

12
p = Point(3, 4)
13
print(str(p))
14
print(repr(p))

Execution

1
python -c "class Point:\n  def __init__(self, x, y):\n    self.x = x\n    self.y = y\n  def __str__(self):\n    return f'Point({self.x}, {self.y})'\np = Point(3, 4); print(str(p))"

Output

1
Point(3, 4)

__str__ returns a user-friendly string representation.
__repr__ returns a developer-friendly representation (ideally recreatable).

len and getitem methods

Demonstrates __len__ for len() and __getitem__ for indexing.

Code

1
class SimpleList:
2
  def __init__(self, items):
3
    self.items = items
4

5
  def __len__(self):
6
    return len(self.items)
7

8
  def __getitem__(self, index):
9
    return self.items[index]
10

11
lst = SimpleList([1, 2, 3])
12
print(len(lst))
13
print(lst[0])
14
print(lst[-1])

Execution

1
python -c "class SimpleList:\n  def __init__(self, items):\n    self.items = items\n  def __len__(self):\n    return len(self.items)\n  def __getitem__(self, index):\n    return self.items[index]\nlst = SimpleList([1, 2, 3]); print(len(lst)); print(lst[0]); print(lst[-1])"

Output

__len__ enables len() function on custom objects.
__getitem__ enables indexing and slicing.

String Operations

Slicing, methods, formatting, and regular expressions.

String Slicing

String slicing with start:end:step and negative indexing.

String slicing with indices

Demonstrates string slicing with positive/negative indices and step values.

Code

1
s = "Python"
2
print(s[0:3])
3
print(s[3:])
4
print(s[-3:])
5
print(s[::2])
6
print(s[::-1])

Execution

1
python -c "s = 'Python'; print(s[0:3]); print(s[3:]); print(s[-3:]); print(s[::2]); print(s[::-1])"

Output

1
Pyt
2
hon
3
thon
4
Pto
5
nohtyP

s[start:end] slices from start to end-1.
Negative indices count from the end.
Step value (third parameter) allows skipping characters.

Advanced slicing techniques

Shows practical slicing use cases.

Code

1
s = "Hello World"
2
print(s[6:11])
3
print(s[-5:])
4
print(s[::3])
5
print(s[1::2])

Execution

1
python -c "s = 'Hello World'; print(s[6:11]); print(s[-5:]); print(s[::3]); print(s[1::2])"

Output

1
World
2
World
3
HloWrd
4
elo ol

Slicing is safe even with out-of-range indices.

String Methods

Methods like upper(), lower(), split(), join(), replace(), find(), strip().

Case conversion and whitespace handling

Shows case conversion and whitespace removal methods.

Code

1
s = "  Hello World  "
2
print(s.upper())
3
print(s.lower())
4
print(s.strip())
5
print(s.lstrip())
6
print(s.rstrip())

Execution

1
python -c "s = '  Hello World  '; print(s.upper()); print(s.lower()); print(s.strip()); print(repr(s.lstrip())); print(repr(s.rstrip()))"

Output

1
  HELLO WORLD
2
  hello world
3
Hello World
4
'Hello World  '
5
'  Hello World'

strip() removes leading and trailing whitespace.
lstrip() and rstrip() remove from left and right only.

String splitting, joining, and replacement

Demonstrates split(), join(), replace(), and find() methods.

Code

1
text = "apple,banana,cherry"
2
items = text.split(",")
3
print(items)
4
print("-".join(items))
5
print(text.replace("apple", "orange"))
6
print(text.find("banana"))

Execution

1
python -c "text = 'apple,banana,cherry'; items = text.split(','); print(items); print('-'.join(items)); print(text.replace('apple', 'orange')); print(text.find('banana'))"

Output

1
['apple', 'banana', 'cherry']
2
apple-banana-cherry
3
orange,banana,cherry
4
6

split() returns a list of substrings.
join() concatenates list items with a separator.
find() returns the index of substring or -1 if not found.

String Formatting

f-strings, .format(), % formatting, and string interpolation.

f-strings and .format() method

Shows f-strings (modern) and .format() (older style) formatting.

Code

1
name = "Alice"
2
age = 30
3
city = "NYC"
4

5
print(f"Name: {name}, Age: {age}, City: {city}")
6
print("Name: {}, Age: {}, City: {}".format(name, age, city))
7
print("Name: {0}, Age: {1}, City: {2}".format(name, age, city))

Execution

1
python -c "name = 'Alice'; age = 30; city = 'NYC'; print(f'Name: {name}, Age: {age}, City: {city}')"

Output

1
Name: Alice, Age: 30, City: NYC

f-strings are preferred for their readability and performance.
.format() provides indexed and named placeholders.

Formatting numbers and expressions

Demonstrates formatting with precision, currency, and different bases.

Code

1
pi = 3.14159
2
price = 19.95
3
x = 10
4

5
print(f"Pi: {pi:.2f}")
6
print(f"Price: ${price:.2f}")
7
print(f"Expression: {x * 2}")
8
print(f"Hex: {x:x}")

Execution

1
python -c "pi = 3.14159; price = 19.95; x = 10; print(f'Pi: {pi:.2f}'); print(f'Price: ${price:.2f}'); print(f'Expression: {x * 2}'); print(f'Hex: {x:x}')"

Output

1
Pi: 3.14
2
Price: $19.95
3
Expression: 20
4
Hex: a

Use :f for float formatting with .2f for 2 decimal places.
f-strings support full Python expressions inside {}.

Regular Expressions

Pattern matching with re.match(), re.search(), re.sub(), re.compile().

Basic pattern matching

Shows match(), search(), and findall() for pattern matching.

Code

1
import re
2

3
text = "Hello 123"
4
print(re.match(r'\w+', text))
5
print(re.search(r'\d+', text))
6
print(re.findall(r'\w+', text))

Execution

1
python -c "import re; text = 'Hello 123'; m = re.match(r'\\w+', text); print(m.group() if m else None); m = re.search(r'\\d+', text); print(m.group() if m else None); print(re.findall(r'\\w+', text))"

Output

1
Hello
2
123
3
['Hello', '123']

match() checks at the beginning of the string.
search() finds the first match anywhere in the string.
findall() returns all matches as a list.

Pattern substitution and compilation

Demonstrates sub() for replacement and compile() for reusable patterns.

Code

1
import re
2

3
text = "The date is 2025-02-27"
4
print(re.sub(r'\d+', '#', text))
5

6
pattern = re.compile(r'[a-z]+')
7
print(pattern.findall("abc123def456"))

Execution

1
python -c "import re; text = 'The date is 2025-02-27'; print(re.sub(r'\\d+', '#', text)); pattern = re.compile(r'[a-z]+'); print(pattern.findall('abc123def456'))"

Output

1
The date is #-#-#
2
['abc', 'def']

sub() replaces matches with a replacement string.
compile() creates a pattern object for reuse.

File I/O and Advanced

File operations, context managers, exception handling, and higher-order functions.

File Operations

open(), read(), write(), readlines(), and seek().

Reading and writing files

Demonstrates writing to and reading from files.

Code

1
# Writing to a file
2
with open("example.txt", "w") as f:
3
  f.write("Hello, Python!")
4

5
# Reading from a file
6
with open("example.txt", "r") as f:
7
  content = f.read()
8
  print(content)

Execution

1
python -c "with open('/tmp/example.txt', 'w') as f: f.write('Hello, Python!'); f = open('/tmp/example.txt', 'r'); content = f.read(); f.close(); print(content)"

Output

1
Hello, Python!

Use "w" mode for writing (overwrites existing file).
Use "r" mode for reading.
Always close files or use with statement.

Reading lines and file positioning

Shows readlines() for reading multiple lines.

Code

1
# Writing multiple lines
2
with open("lines.txt", "w") as f:
3
  f.write("Line 1\nLine 2\nLine 3")
4

5
# Reading lines
6
with open("lines.txt", "r") as f:
7
  lines = f.readlines()
8
  for line in lines:
9
    print(line.strip())

Execution

1
python -c "with open('/tmp/lines.txt', 'w') as f: f.write('Line 1\\nLine 2\\nLine 3'); f = open('/tmp/lines.txt', 'r'); lines = f.readlines(); f.close(); [print(line.strip()) for line in lines]"

Output

1
Line 1
2
Line 2
3
Line 3

readlines() returns a list of lines with newline characters.
strip() removes leading/trailing whitespace including newlines.

Context Managers

Using with statement for automatic resource management.

Context manager with open()

Shows how with statement automatically closes files.

Code

1
with open("data.txt", "w") as f:
2
  f.write("Important data")
3
  print(f.closed)
4
print(f.closed)

Execution

1
python -c "f = None; exec('with open(\\\"/tmp/data.txt\\\", \\\"w\\\") as f: f.write(\\\"Important data\\\"); print(f.closed)'); print(f.closed)"

Output

1
False
2
True

with statement ensures cleanup even if exceptions occur.
File is closed when exiting the with block.

Custom context manager

Demonstrates creating custom context managers with @contextmanager decorator.

Code

1
from contextlib import contextmanager
2

3
@contextmanager
4
def timer():
5
  import time
6
  start = time.time()
7
  yield
8
  print(f"Elapsed: {time.time() - start:.2f}s")
9

10
with timer():
11
  sum(range(1000000))

Execution

1
python -c "from contextlib import contextmanager; import time\n@contextmanager\ndef timer():\n  start = time.time()\n  yield\n  print(f'Elapsed: {time.time() - start:.2f}s')\nwith timer(): sum(range(1000000))"

Output

1
Elapsed: 0.01s

@contextmanager simplifies context manager creation.
Code before yield runs on entry, after yield on exit.

Exception Handling

try/except/else/finally blocks and raising exceptions.

try/except blocks

Shows try/except blocks for handling specific exceptions.

Code

1
try:
2
  x = int("not a number")
3
except ValueError as e:
4
  print(f"Error: {e}")
5

6
try:
7
  result = 10 / 0
8
except ZeroDivisionError:
9
  print("Cannot divide by zero")

Execution

1
python -c "try:\n  x = int('not a number')\nexcept ValueError as e:\n  print(f'Error: {e}'); try:\n  result = 10 / 0\nexcept ZeroDivisionError:\n  print('Cannot divide by zero')"

Output

1
Error: invalid literal for int() with base 10: 'not a number'
2
Cannot divide by zero

except block executes if the specific exception occurs.
Use 'as' to capture exception details.

try/except/else/finally

Demonstrates else (no exception) and finally (always executes) blocks.

Code

1
try:
2
  x = 10 / 2
3
except ZeroDivisionError:
4
  print("Error")
5
else:
6
  print(f"Result: {x}")
7
finally:
8
  print("Cleanup")

Execution

1
python -c "try:\n  x = 10 / 2\nexcept ZeroDivisionError:\n  print('Error')\nelse:\n  print(f'Result: {x}')\nfinally:\n  print('Cleanup')"

Output

1
Result: 5.0
2
Cleanup

else block executes if no exception occurs.
finally block always executes for cleanup.

Lambdas and Higher-Order Functions

Lambda functions, map(), filter(), sorted(), and functional programming.

Lambda functions and map()

Demonstrates lambda functions with map() for transformations.

Code

1
squares = list(map(lambda x: x**2, [1, 2, 3, 4]))
2
print(squares)
3

4
add = lambda x, y: x + y
5
print(add(5, 3))

Execution

1
python -c "squares = list(map(lambda x: x**2, [1, 2, 3, 4])); print(squares); add = lambda x, y: x + y; print(add(5, 3))"

Output

1
[1, 4, 9, 16]
2
8

lambda x: expression creates an anonymous function.
map() applies function to each element in a sequence.

filter() and sorted()

Shows filter() for selecting elements and sorted() with custom sort keys.

Code

1
numbers = [1, 2, 3, 4, 5, 6]
2
evens = list(filter(lambda x: x % 2 == 0, numbers))
3
print(evens)
4

5
data = [(3, "c"), (1, "a"), (2, "b")]
6
sorted_data = sorted(data, key=lambda x: x[1])
7
print(sorted_data)

Execution

1
python -c "numbers = [1, 2, 3, 4, 5, 6]; evens = list(filter(lambda x: x % 2 == 0, numbers)); print(evens); data = [(3, 'c'), (1, 'a'), (2, 'b')]; sorted_data = sorted(data, key=lambda x: x[1]); print(sorted_data)"

Output

1
[2, 4, 6]
2
[(1, 'a'), (2, 'b'), (3, 'c')]

filter() keeps elements where the function returns True.
sorted(key=...) allows custom sorting with a function.

Python

Getting Started

Basic Syntax

Accessibility

Best Practices

Common Errors

Keywords

Print statement and variables

Comments and multiline strings

Data Types

Accessibility

Best Practices

Common Errors

Keywords

Type casting and checking

None and boolean types

Numbers and Strings

Accessibility

Best Practices

Common Errors

Keywords

Arithmetic operations and string slicing

String methods

Data Structures

Lists

Accessibility

Best Practices

Common Errors

Keywords

List creation and indexing

List methods and operations

Tuples

Accessibility

Best Practices

Common Errors

Keywords

Tuple creation and unpacking

Tuple operations

Dictionaries

Accessibility

Best Practices

Common Errors

Keywords

Dictionary creation and access

Dictionary modification and iteration

Sets

Accessibility

Best Practices

Common Errors

Keywords

Set creation and operations

Set operations

Control Flow

Conditionals

Accessibility

Best Practices

Common Errors

Keywords

if/elif/else statements

Comparison and logical operators

Loops

Accessibility

Best Practices

Common Errors

Keywords

for loop with range and lists

Loop control with break and continue

List Comprehensions

Accessibility

Best Practices

Common Errors

Keywords

Basic list comprehension

Nested list comprehension

Functions and Scope

Function Definition

Accessibility

Best Practices

Common Errors

Keywords

str and repr methods

len and getitem methods