Basic Pattern Syntax

Pattern Meaning:

.   Any character except newline
^   Start of string
$   End of string
*   0 or more repetitions
+   1 or more repetitions
?   0 or 1 repetition
{n} Exactly n repetitions
{n,}    n or more
{n,m}   Between n and m

Character Classes

Pattern Meaning:

[abc]   a, b, or c
[^abc]  NOT a, b, or c
[a-z]   Lowercase letters
[A-Z]   Uppercase letters
[0-9]   Digits
[a-zA-Z0-9_]    Alphanumeric + underscore

Special Sequences

Pattern Meaning:

\d  Digit (0–9)
\D  Non-digit
\w  Word char (a-z, A-Z, 0-9, _)
\W  Non-word
\s  Whitespace
\S  Non-whitespace
\b  Word boundary
\B  Not a word boundary

Quantifiers (Greedy vs Lazy)

Pattern Meaning:

*   Greedy (max match)
*?  Lazy (min match)
+?  Lazy version of +
{n,m}?  Lazy range

Example:

re.findall(r"<.*?>", " ")
# ['', '']

Groups & Capturing

Pattern Meaning:

(abc)   Capturing group
(?:abc) Non-capturing group
(?Pabc)   Named group
\1  Backreference
(?P=name)   Named backreference

Example:

m = re.search(r"(?P\w+)", "hello")
m.group("word")  # 'hello'

Alternation

Pattern Meaning:

`a  b`

Example:

re.findall(r"cat|dog", "cat dog bird")
# ['cat', 'dog']

Lookarounds

Pattern Meaning:

(?=...) Positive lookahead
(?!...) Negative lookahead
(?<=...)    Positive lookbehind
(?

Example:
re.findall(r"\w+(?=!)", "Hi! Hello!")
# ['Hi', 'Hello']



Flags



Flag
Meaning




re.IGNORECASE / re.I
Case-insensitive


re.MULTILINE / re.M
^ and $ per line


re.DOTALL / re.S
. matches newline


re.VERBOSE / re.X
Allow comments



Example:
re.search(r"hello", "HELLO", re.I)



Common re Functions
re.search()
Find first match anywhere:
re.search(r"\d+", "abc123")


re.match()
Match at start only:
re.match(r"\d+", "123abc")


re.findall()
Return all matches:
re.findall(r"\d+", "a1b2c3")
# ['1', '2', '3']


re.finditer()
Iterator of match objects:
for m in re.finditer(r"\d+", "a1b2"):
    print(m.group())


re.sub()
Replace matches:
re.sub(r"\d+", "#", "a1b2")
# 'a#b#'


re.split()
Split by regex:
re.split(r"\s+", "a b   c")
# ['a', 'b', 'c']


re.compile()
Precompile pattern:
pattern = re.compile(r"\d+")
pattern.findall("123 abc 456")



Escaping Special Characters
These must be escaped with \:
. ^ $ * + ? { } [ ] \ | ( )


Example:
re.findall(r"\.", "a.b.c")



Raw Strings (Important in Python)
Always use r"" for regex:
r"\n"   # newline in regex
"\\n"   # same but harder to read

---

###Practical Patterns

Email (simple):
[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+

Import + Connect

1
2
3
4

import sqlite3

conn = sqlite3.connect("app.db")
cursor = conn.cursor()

Creates or opens: app.db

In-Memory Database

1

conn = sqlite3.connect(":memory:")

Use for: - Testing - Temporary data - Fast disposable DBs

Create Table

1
2
3
4
5
6
7
8
9

cursor.execute("""
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    age INTEGER
)

Git / GitHub Cheat Sheet

Check where you are

Before doing Git commands, make sure you are inside the correct project folder:

1

pwd

List files:

1

ls

Check Git status:

1

git status

If you see:

1

fatal: not a git repository

you are either in the wrong folder or you have not run git init yet.

Initialize a local Git repo

Use this when your project folder is not yet a Git repo.

1

git init

Set the branch name to main:

1

Variables vs Tags

Variables

{{ variable }}

Output data into HTML.

Example:

1

{{ post.title }}

If the variable inside {{}} is a Python dict, you can access its elements using:

1

{{ variable.key }}

If the variable inside {{}} is a Python list, you can access its elements by index using:

1

{{ variable.0 }}

Nested elements:

1

{{ variable.key.0 }}

Template Tags

{% tag %}

Used for logic / actions.

Core Template Tags

Load Static Files

1

{% load static %}

Required before using static paths.

1

General syntax:

1

python manage.py <command>

Project Setup

Create migrations

1

python manage.py makemigrations

Generate migration files based on model changes.

Apply migrations

1

python manage.py migrate

Apply migrations to the database.

Show migration status

1

python manage.py showmigrations

See applied and pending migrations.

Development Server

Start server

1

python manage.py runserver

1. Variables & Declarations

1
2
3

let x = 10;      // block-scoped (preferred)
const y = 20;    // constant (cannot reassign)
var z = 30;      // function-scoped (avoid)

• const ≠ immutable (objects can still change)
• Always prefer const → fallback to let

2. Data Types

Primitive: string, number, boolean, null, undefined, symbol, bigint

Reference: object, array, function

1
2

typeof "hi"      // "string"
typeof null      // "object" (quirk)

3. Operators

Arithmetic: + - * / % **

Comparison: - == // loose (avoid) - === // strict (preferred) - != !== > < >= <=

Logical: - && || ! - Nullish / Optional - a ?? b // null/undefined fallback - obj?.x // safe access

4. Control Flow

If / Else

1. Basic GET Request

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

fetch("https://api.bytestaq.com/data")
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(err => console.error(err));

// Async/Await
async function getData() {
  try {
    const

1. Headings

# H1
## H2
### H3
#### H4
##### H5
###### H6

2. Text Formatting

*italic* or _italic_        -> italic
**bold** or __bold__        -> bold
***bold italic***   bold    -> italic
~~strikethrough~~           -> text 
`inline code`               -> code

3. Lists

Unordered:

- Item
* Item
+ Item

Ordered:

1. First
2. Second

Nested:

- Item
  - Subitem

4. Links

[Text](https://example.com)

Reference-style: [Text][id]

[id]: https://example.com

5. Images

![Alt text](image.png)

6. Blockquotes

> Quote
>> Nested quote

7. Code Blocks

Inline
`code`

Fenced
 ```python print("Hello") ``` 
 

Indented
    code block

8. Tables

| Name | Age |
|------|-----|
| Alice | 25 |
| Bob   | 30 |

Alignment:
| Left | Center | Right |
|:-----|:------:|------:|

9. Horizontal Rule

---
***
___

10. Task Lists (GitHub / modern tools)

• [x] Done
• [ ] Todo

11. Escaping Characters

*not italic* # not heading

12. HTML Inside Markdown

Markdown allows raw HTML:
<b>Bold</b>
<br>

13. Python-Specific Usage Patterns

Used in tools like pdoc, mkdocstrings:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

def func():
    """
    ### Description
    This function does something.

    **Example:**
    ```python
    func()
    ```
    """

 ```python def hello(): pass ``` 
 

14. Common Mistakes

• Indentation matters in lists and code blocks
• Not all Markdown flavors support all extensions
• HTML may be stripped in some renderers
• LaTeX only works where explicitly supported

17. Quick Reference

# Heading
**bold** *italic*
- list
1. list
[link](url)
![img](src)
`code`
```python
code block
quote

1xx — Informational

Rarely used in frontend/backend code directly

2xx — Success

Example: HTTP/1.1 200 OK

3xx — Redirection

Core Methods Overview

GET — Retrieve Data

Purpose:

Fetch data from the server.

Example: GET /api/users/1

Characteristics:

• No side effects (should not modify state)
• Parameters passed via URL

POST — Create Resource

Purpose:

Send data to create something new.

Example: POST /api/users Body { "name": "Alice" }

Characteristics:

• Not idempotent (calling twice creates duplicates)
• Used for form submissions, API creation

PUT — Replace Resource

Purpose:

Replace entire resource.

Example: PUT /api/users/1 Body { "name": "Alice", "age": 30 }

Characteristics:

• Idempotent (same request = same result)
• Full replacement

PATCH — Partial Update