# This is a comment
"""
This is a docstring or multi-line comment
"""

x = 10
name = 'Alice'

x = 5
x = 'hello' # allowed, x is now a string

my_list = [1, 2, 3]
my_tuple = (1, 2, 3)

print(type(5)) # <class 'int'>
print(isinstance(5, int)) # True

if value is None:
 print('No value')

a = [1, 2]
b = [1, 2]
print(a == b) # True
print(a is b) # False

name = input('Enter your name: ')
age = int(input('Enter your age: '))

name = 'Tom'
print(f'Hello, {name}! You are {2024-1999} years old.')

print(7 / 2) # 3.5
print(7 // 2) # 3

print(2 ** 3) # 8

print(10 % 3) # 1

if age < 13:
 print('Child')
elif age < 20:
 print('Teenager')
else:
 print('Adult')

for i in range(5):
 print(i)

for i in range(2, 10, 2):
 print(i) # 2 4 6 8

i = 0
while i < 5:
 print(i)
 i += 1

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

def greet(name='Guest'):
 return f'Hello, {name}'

def greet(name, greeting):
 print(f'{greeting}, {name}')
greet(greeting='Hi', name='Tom')

square = lambda x: x * x
print(square(5)) # 25

def add(a, b):
 """Return the sum of a and b."""
 return a + b

print(len('Hello')) # 5

full = 'Hello' + ' ' + 'World'

s = 'Hello World'
print(s[0:5]) # 'Hello'
print(s[-5:]) # 'World'

s = 'hello'
print(s[::-1]) # 'olleh'

if 'World' in 'Hello World':
 print('found')

parts = 'a,b,c'.split(',') # ['a', 'b', 'c']

result = ', '.join(['a', 'b', 'c']) # 'a, b, c'

print('  hello  '.strip()) # 'hello'

print('hello.py'.endswith('.py')) # True

nums = [1, 2]
nums.append(3) # [1, 2, 3]

nums = [1, 2, 3]
nums.remove(2) # [1, 3]
nums.pop() # removes last, returns 3

person = {'name': 'Alice', 'age': 30}

age = person.get('age', 0)

for key, value in person.items():
 print(key, value)

a = [1, 2]
a.append([3, 4]) # [1, 2, [3, 4]]
b = [1, 2]
b.extend([3, 4]) # [1, 2, 3, 4]

for i, val in enumerate(['a', 'b', 'c']):
 print(i, val)

class Dog:
 def __init__(self, name):
 self.name = name
 def bark(self):
 return f'{self.name} says woof'

class Animal:
 def eat(self):
 print('Eating')
class Dog(Animal):
 pass

try:
 result = 10 / 0
except ZeroDivisionError as e:
 print(f'Error: {e}')
finally:
 print('Done')

import math
from math import sqrt
import numpy as np

python -m venv myenv
source myenv/bin/activate # Linux/Mac
myenv\Scripts\activate # Windows

pip install requests

with open('data.txt', 'r') as f:
 content = f.read()

with open('log.txt', 'a') as f:
 f.write('New log entry\n')

from pathlib import Path
if Path('config.txt').exists():
 print('File found')

import json
data = json.loads('{"name": "Tom"}')
json_str = json.dumps(data)

if []: print('truthy')
else: print('falsy') # prints 'falsy'

sorted(words, key=len) # sort strings by length

for i, val in enumerate(['a','b','c'], start=1):
 print(i, val) # 1 a, 2 b, 3 c

if __name__ == '__main__':
 main()

if (n := len(data)) > 10:
 print(f'List is too long: {n} elements')

def greet(name: str) -> str:
 return f'Hello, {name}'

while True:
 process()
 if not condition:
 break

def demo(*args, **kwargs):
 print(args)
 print(kwargs)
demo(1, 2, name='Tom')

counter = 0
def increment():
 global counter
 counter += 1

def outer():
 count = 0
 def inner():
 nonlocal count
 count += 1
 inner()
 return count

def make_multiplier(factor):
 def multiply(x):
 return x * factor
 return multiply
times3 = make_multiplier(3)
print(times3(5)) # 15

def logger(func):
 def wrapper(*args, **kwargs):
 print(f'Calling {func.__name__}')
 return func(*args, **kwargs)
 return wrapper

@logger
def greet():
 print('Hello')

def factorial(n):
 return 1 if n <= 1 else n * factorial(n - 1)

def add(a: int, b: int) -> int:
 return a + b

'{} is {} years old'.format('Tom', 25)

squares = [x**2 for x in range(10) if x % 2 == 0]

squares = {x: x**2 for x in range(5)}

unique_lengths = {len(word) for word in ['cat', 'dog', 'ox']}

gen = (x**2 for x in range(1000000)) # lazy, memory-efficient

unique = list(dict.fromkeys([3, 1, 2, 1, 3])) # [3, 1, 2]

counts = {}
counts.setdefault('a', 0)
counts['a'] += 1

from collections import defaultdict
counts = defaultdict(int)
counts['apple'] += 1 # no KeyError

from collections import Counter
c = Counter(['a', 'b', 'a', 'c', 'a'])
print(c.most_common(1)) # [('a', 3)]

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p.x, p.y)

import copy
original = [[1, 2], [3, 4]]
shallow = copy.copy(original)
deep = copy.deepcopy(original)

people = [{'name': 'Bob', 'age': 25}, {'name': 'Amy', 'age': 22}]
people.sort(key=lambda p: p['age'])

a, b, c = (1, 2, 3)
first, *rest = [1, 2, 3, 4] # first=1, rest=[2,3,4]

merged = {**dict1, **dict2}
merged2 = dict1 | dict2 # Python 3.9+

print(all(x > 0 for x in [1, 2, 3])) # True
print(any(x < 0 for x in [1, 2, -3])) # True

names = ['Alice', 'Bob']
ages = [30, 25]
for name, age in zip(names, ages):
 print(name, age)

squares = list(map(lambda x: x**2, [1,2,3]))
evens = list(filter(lambda x: x % 2 == 0, [1,2,3,4]))

from functools import reduce
total = reduce(lambda a, b: a + b, [1, 2, 3, 4]) # 10

class Dog:
 species = 'Canine' # class attribute
 def __init__(self, name):
 self.name = name # instance attribute

class Dog(Animal):
 def __init__(self, name):
 super().__init__()
 self.name = name

class Flying:
 def move(self): print('Fly')
class Swimming:
 def move(self): print('Swim')
class Duck(Flying, Swimming):
 pass

class Point:
 def __repr__(self):
 return f'Point({self.x}, {self.y})'
 def __str__(self):
 return f'({self.x}, {self.y})'

class Point:
 def __eq__(self, other):
 return self.x == other.x and self.y == other.y

class Circle:
 def __init__(self, radius):
 self._radius = radius
 @property
 def area(self):
 return 3.14159 * self._radius ** 2

class Circle:
 @property
 def radius(self):
 return self._radius
 @radius.setter
 def radius(self, value):
 if value < 0:
 raise ValueError('Radius cannot be negative')
 self._radius = value

class MyClass:
 @classmethod
 def create(cls):
 return cls()
 @staticmethod
 def helper():
 return 'helper'

from abc import ABC, abstractmethod
class Shape(ABC):
 @abstractmethod
 def area(self): pass

class Vector:
 def __init__(self, x, y):
 self.x, self.y = x, y
 def __add__(self, other):
 return Vector(self.x + other.x, self.y + other.y)

from dataclasses import dataclass
@dataclass
class Point:
 x: int
 y: int

class InsufficientFundsError(Exception):
 pass
raise InsufficientFundsError('Not enough balance')

try:
 value = int(user_input)
except ValueError:
 print('Invalid input')
else:
 print(f'You entered {value}')

try:
 risky_operation()
except (ValueError, TypeError) as e:
 print(f'Error: {e}')

with open('file.txt') as f:
 data = f.read()
# file automatically closed here

assert age >= 0, 'Age cannot be negative'

it = iter([1, 2, 3])
print(next(it)) # 1
print(next(it)) # 2

def count_up(n):
 i = 1
 while i <= n:
 yield i
 i += 1
for num in count_up(5):
 print(num)

from itertools import chain
combined = list(chain([1,2], [3,4])) # [1,2,3,4]

from pathlib import Path
p = Path('data') / 'file.txt'
print(p.suffix, p.parent)

import csv
with open('data.csv') as f:
 reader = csv.DictReader(f)
 for row in reader:
 print(row)

import pickle
with open('data.pkl', 'wb') as f:
 pickle.dump(my_object, f)

import threading
def worker():
 print('Working')
t = threading.Thread(target=worker)
t.start()
t.join()

from multiprocessing import Process
def worker():
 print('Working')
p = Process(target=worker)
p.start()
p.join()

import asyncio
async def main():
 await asyncio.sleep(1)
 print('Done')
asyncio.run(main())

from concurrent.futures import ThreadPoolExecutor
with ThreadPoolExecutor(max_workers=4) as executor:
 results = list(executor.map(process_item, items))

import re
if re.search(r'\d+', 'Order 123'):
 print('Contains a number')

re.findall(r'\d+', 'a1 b22 c333') # ['1', '22', '333']

re.sub(r'\d+', '#', 'Order 123 shipped') # 'Order # shipped'

m = re.search(r'(\d{3})-(\d{4})', '555-1234')
print(m.group(1), m.group(2)) # '555' '4234' style access

pattern = r'\d+\s\w+'

pattern = re.compile(r'\d+')
pattern.findall('a1 b2')

import unittest
class TestMath(unittest.TestCase):
 def test_add(self):
 self.assertEqual(1 + 1, 2)
if __name__ == '__main__':
 unittest.main()

def test_add():
 assert 1 + 1 == 2

import pytest
@pytest.fixture
def sample_data():
 return [1, 2, 3]
def test_sum(sample_data):
 assert sum(sample_data) == 6

from unittest.mock import patch
with patch('module.some_function', return_value=42):
 result = module.some_function()

def process(data):
 breakpoint()
 return data * 2

import logging
logging.basicConfig(level=logging.INFO)
logging.info('Application started')

import timeit
print(timeit.timeit('sum(range(100))', number=10000))

from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
 return n if n < 2 else fib(n-1) + fib(n-2)

from functools import partial
square = partial(pow, exp=2)
# or: cube = partial(pow, 2, 3)

def add(a, b, c):
 return a + b + c
args = [1, 2, 3]
print(add(*args))

__all__ = ['public_function', 'PublicClass']

import subprocess
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)

for i in range(5):
 if i == 10:
 break
else:
 print('Loop completed without break')

def add_item(item, items=[]): # BUG: shared list
 items.append(item)
 return items

def repeat(times):
 def decorator(func):
 def wrapper(*args, **kwargs):
 for _ in range(times):
 func(*args, **kwargs)
 return wrapper
 return decorator

@repeat(3)
def say_hi():
 print('Hi')

from functools import wraps
def logger(func):
 @wraps(func)
 def wrapper(*args, **kwargs):
 return func(*args, **kwargs)
 return wrapper

import sys
sys.setrecursionlimit(2000)

def modify(lst):
 lst.append(4) # affects caller's list
 lst = [9,9,9] # does not affect caller's reference
my_list = [1,2,3]
modify(my_list) # my_list becomes [1,2,3,4]

class Base:
 def __init__(self):
 self.__secret = 42 # becomes _Base__secret

class Point:
 __slots__ = ('x', 'y')
 def __init__(self, x, y):
 self.x = x
 self.y = y

class Meta(type):
 def __new__(cls, name, bases, dct):
 return super().__new__(cls, name, bases, dct)
class MyClass(metaclass=Meta):
 pass

class Multiplier:
 def __init__(self, factor):
 self.factor = factor
 def __call__(self, x):
 return x * self.factor
triple = Multiplier(3)
print(triple(5)) # 15

try:
 int('abc')
except ValueError as e:
 raise RuntimeError('Conversion failed') from e

class Timer:
 def __enter__(self):
 self.start = time.time()
 return self
 def __exit__(self, exc_type, exc_val, exc_tb):
 print(f'Elapsed: {time.time() - self.start}')

from contextlib import contextmanager
@contextmanager
def timer():
 start = time.time()
 yield
 print(f'Elapsed: {time.time() - start}')

def inner():
 yield 1
 yield 2
def outer():
 yield from inner()
 yield 3

class Countdown:
 def __init__(self, start):
 self.current = start
 def __iter__(self):
 return self
 def __next__(self):
 if self.current <= 0:
 raise StopIteration
 self.current -= 1
 return self.current + 1

lock = threading.Lock()
with lock:
 shared_counter += 1

from functools import singledispatch
@singledispatch
def process(arg):
 print('default')
@process.register
def _(arg: int):
 print('int handler')

import module
module.some_function = lambda: 'patched'

class Singleton:
 _instance = None
 def __new__(cls):
 if cls._instance is None:
 cls._instance = super().__new__(cls)
 return cls._instance

from typing import Protocol
class Sized(Protocol):
 def __len__(self) -> int: ...