Variables

x = 10
y = 'hello'
z = True

Conditionals

if x > y:
    # ...
    pass

elif x < y:
    # ...
    pass

else:
    # ...
    pass

Loops

for i in range(10):
    # ...
    pass

while x < 10:
    # ...
    x += 1

Functions

def my_function():
    # ...
    pass

def my_function(a, b):
    # ...
    pass

def add(a, b):
    return a + b

Lists

my_list = [1, 2, 3, 4, 5]

my_list.append(6)
my_list.remove(1)
my_list.sort()
my_list.reverse()

Dictionaries

my_dict = {'one': 1, 'two': 2, 'three': 3}

my_dict['four'] = 4
del my_dict['one']
keys = my_dict.keys()
values = my_dict.values()

Classes

class MyClass:
    # ...
    pass

class MyClass:
    def __init__(self, x):
        self.x = x

class MySubclass(MyClass):
    # ...
    pass

Error Handling

try:
    # ...
    pass
except Exception as e:
    # ...
    pass
finally:
    # ...
    pass

if x < 0:
    raise ValueError('x must be non-negative')

File I/O

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

with open('file.txt', 'w') as f:
    f.write('Hello, World!')

Modules

import math

from math import sqrt, pow

Generators

def my_generator():
    yield 1
    yield 2
    yield 3

for value in my_generator():
    print(value)

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

squares = (x * x for x in range(10))

Decorators

def my_decorator(func):
    def wrapper():
        print('Before function call')
        func()
        print('After function call')
    return wrapper

@my_decorator
def my_function():
    print('Function called')

my_function()

def my_decorator(func):
    def wrapper():
        # ...
        func()
        # ...
    return wrapper

class MyDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        # ...
        return self.func(*args, **kwargs)

Context Managers

class MyContextManager:
    def __enter__(self):
        # ...
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        # ...

from contextlib import contextmanager

@contextmanager
def my_context():
    print('Entering the context')
    yield
    print('Exiting the context')

with my_context():
    print('Inside the context')

Regular Expressions

import re

pattern = re.compile('pattern')
result = pattern.search('some text')

pattern = re.compile('pattern')
result = pattern.match('some text')

pattern = re.compile('pattern')
result = pattern.findall('some text')

pattern = re.compile('pattern')
result = pattern.sub('replacement', 'some text')

List Comprehensions

squares = [x * x for x in range(10)]

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

Lambda Functions

add = lambda x, y: x + y

sorted_list = sorted(my_list, key=lambda x: x[1])

Slicing

my_list = [0, 1, 2, 3, 4, 5]
sub_list = my_list[1:4]

my_list = [0, 1, 2, 3, 4, 5]
even_indices = my_list[::2]

Sets

my_set = {1, 2, 3}

a = {1, 2, 3}
b = {2, 3, 4}

union = a | b
intersection = a & b
difference = a - b

Tuples

my_tuple = (1, 2, 3)

x, y, z = my_tuple

Namedtuples

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)

Enumerate

my_list = ['a', 'b', 'c']

for idx, item in enumerate(my_list):
    print(idx, item)

Map and Filter

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

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

Threading

import threading

def my_function():
    # ...
    pass

thread = threading.Thread(target=my_function)
thread.start()
thread.join()

asyncio

import asyncio

async def my_coroutine():
    # ...
    pass

async def main():
    await my_coroutine()

asyncio.run(main())

List Comprehensions with Nested Loops

pairs = [(x, y) for x in range(3) for y in range(3)]

Metaclasses

class MyMeta(type):
    def __new__(cls, name, bases, dct):
        # ...
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=MyMeta):
    pass

Conditional Expressions

x = 5
y = 10

max_value = x if x > y else y

Function Arguments

def greet(name, greeting='Hello'):
    print(greeting, name)

greet('John')

def func(*args):
    for arg in args:
        print(arg)

func(1, 2, 3)

def func(**kwargs):
    for key, value in kwargs.items():
        print(key, value)

func(a=1, b=2, c=3)

Assertions

x = 5
assert x > 0, 'x should be positive'

Exception Handling

try:
    x = 1 / 0
except ZeroDivisionError:
    print('Cannot divide by zero')

class MyError(Exception):
    pass

try:
    raise MyError('An error occurred')
except MyError as e:
    print(e)

The Cheat Sheet

Variable Assignment

if

elif

else

for

while

Function Definition

Function Arguments

Function Return

List Creation

List Methods

Dictionary Creation

Dictionary Methods

Class Definition

Constructor

Inheritance

try, except, finally

raise

Read from a file

Write to a file

Importing Modules

Importing specific functions

Basic Generator

Generator function

Generator expression

Basic Decorator

Function decorator

Class decorator

Create a context manager

Basic Context Manager

re module

Search

Match

Find all

Substitute

Basic List Comprehension

List Comprehension with Condition

Basic Lambda Function

Lambda Function as Argument

Basic List Slicing

Slicing with Steps

Set Creation

Set Operations

Tuple Creation

Tuple Unpacking

Namedtuple Creation

Enumerate in Loops

Map

Filter

Threading Basics

Basic asyncio example

List Comprehensions with Nested Loops

Basic Metaclass Example

Ternary Operator

Default Arguments

Variable Arguments

Keyword Arguments

Basic Assertions

Basic Exception Handling

Custom Exceptions