
- [Regex cheatsheet - MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Cheatsheet)
- [Regex cheatsheet - docs.linuxfoundation.org](https://docs.linuxfoundation.org/v2/security-service/manage-false-positives/regular-expressions-cheat-sheet)

## Character classes

| Character | Meaning                      |
| --------- | ---------------------------- |
| `.`       | Any character except newline |
| `\d`      | One digit                    |
| `\D`      | One non-digit                |
| `\s`      | One whitespace               |
| `\S`      | One non-whitespace           |
| `\w`      | One word character           |
| `\W`      | One non-word character       |
| `\t`      | Horizontal tab               |
| `\v`      | Vertical tab                 |
| `\r`      | Carriage return              |
| `\n`      | Newline/Linefeed             |
| `\f`      | Form-feed                    |
| `[\b]`    | Backspace character          |
| `\0`      | NUL character                |
| `\`       | Escape a special character   |

## Assertions

| Character | Meaning                                                              |
| --------- | -------------------------------------------------------------------- |
| `^`       | Start of string                                                      |
| `$`       | End of string                                                        |
| `\b`      | Word boundary                                                        |
| `\B`      | Non-word boundary                                                    |
| `x(?=y)`  | Positive lookahead (Matches "x" only if "x" is followed by "y")      |
| `x(?!y)`  | Negative lookahead (Matches "x" only if "x" is not followed by "y")  |
| `(?<=y)x` | Positive lookbehind (Matches "x" only if "x" is preceded by "y")     |
| `(?<!y)x` | Negative lookbehind (Matches "x" only if "x" is not preceded by "y") |

## Groups and ranges

| Character             | Meaning                                                                                     |
| --------------------- | ------------------------------------------------------------------------------------------- |
| <code>x&#124;y</code> | Either "x" or "y"                                                                           |
| `[xyz]` `[a-c]`       | Any one of the enclosed characters                                                          |
| `[^xyz]` `[^a-c]`     | Anything that is not enclosed in the brackets                                               |
| `(x)`                 | Capturing group (matches "x" and remembers the match)                                       |
| `(?<Name>x)`          | Named capturing group (matches "x" and stores it as "Name")                                 |
| `(?:x)`               | Non-capturing group (matches "x" but does not remember the match)                           |
| `\N`                  | Match the Nth captured group                                                                |
| `\k<Name>`            | Back reference to the last substring matching the named capturing group specified by "Name" |

## Quantifiers

| Character | Meaning                                                           |
| --------- | ----------------------------------------------------------------- |
| `*`       | 0 or more                                                         |
| `+`       | 1 or more                                                         |
| `?`       | 0 or 1                                                            |
| `x{n}`    | Exactly n occurences of x                                         |
| `x{n, m}` | Between n and m occurences of x                                   |
| `x{n,}`   | n or more occurences of x                                         |
| `?`       | Make the quantifier non-greedy (stop as soon as it finds a match) |

## POSIX classes

| Character    | Meaning                          |
| ------------ | -------------------------------- |
| `[:alnum:]`  | Letters and digits               |
| `[:alpha:]`  | Letters                          |
| `[:ascii:]`  | Ascii codes 0 - 127              |
| `[:blank:]`  | Space or tab only                |
| `[:cntrl:]`  | Control characters               |
| `[:digit:]`  | Decimal digits                   |
| `[:graph:]`  | Visible characters, except space |
| `[:upper:]`  | Uppercase letters                |
| `[:lower:]`  | Lowercase letters                |
| `[:word:]`   | Word characters                  |
| `[:print:]`  | Visible characters               |
| `[:punct:]`  | Visible punctuation characters   |
| `[:space:]`  | Whitespace                       |
| `[:xdigit:]` | Hexadecimal digits               |


Regular expressions

[Top]

Character classes

Assertions

Groups and ranges

Quantifiers

POSIX classes


## Firefox

- To set Firefox Developer Edition as `sensible-browser` on Linux:

  First, add Firefox Developer Edition to `update-alternatives`:

  ```shell
  sudo update-alternatives --install /usr/bin/x-www-browser x-www-browser /opt/firefox_dev/firefox/firefox 200
  ```

  (Assuming the executable path `/opt/firefox_dev/firefox/firefox`)

  Then, set it as `sensible-browser`:

  ```shell
  sudo update-alternatives --config x-www-browser
  ```

### `about:config` settings

| Option                                  | Change        | Notes                   |
|-----------------------------------------|---------------|-------------------------|
| `geo.enabled`                           | true -> false |                         |
| `extensions.pocket.enabled`             | true -> false |                         |
| `browser.bookmarks.openInTabClosesMenu` | true -> false |                         |
| `browser.bookmarks.showMobileBookmarks` | true -> false |                         |
| `browser.bookmarks.autoExportHTML`      | false -> true |                         |
| `browser.tabs.loadBookmarksInTabs`      | false -> true |                         |
| `browser.tabs.tabMinWidth`              | 76 -> 100     |                         |
| `browser.tabs.closeTabByDblclick`       | false -> true |                         |
| `browser.tabs.closeWindowWithLastTab`   | true -> false |                         |
| `browser.privatebrowsing.autostart`     | false -> true |                         |
| `browser.urlbar.openintab`              |               |                         |
| `pdfjs.ignoreDestinationZoom`           | false -> true |                         |
| `pdfjs.spreadModeOnLoad`                | -1 -> 2       | Even spreads by default |

### Useful shortcuts

[Firefox keyboard shortcuts](https://support.mozilla.org/en-US/kb/keyboard-shortcuts-perform-firefox-tasks-quickly)

| Shortcut                   | Action                                          |
| -------------------------- | ----------------------------------------------- |
| `Home`                     | Move to the top of the page. (See also: Vimium) |
| `Ctrl-l`                   | Highlight the url bar.                          |
| `Ctrl-Shift-o`             | Open bookmark manager.                          |
| `Ctrl-Shift-b`             | Toggle bookmarks toolbar.                       |
| `Ctrl-b`                   | Toggle bookmarks sidebar.                       |
| `Ctrl-Shift-d`             | Bookmark all open tabs in a folder.             |
| `Ctrl-Shift-a`             | Open addons manager.                            |
| `Ctrl-Shift-Del`           | Clear recent history.                           |
| `Ctrl-Shift-r` / `Ctrl-F5` | Reload the tab and clear the cache.             |
| `Ctrl-Shift-t`             | Undo close tab.                                 |


Browsers


## Common list operations

```python
# Initialize an empty list
>>> s = [] # or
>>> s = list()

# Create a list
>>> s = ["Chess", "Go"]

# Get length of list
>>> len(s)
2

# Add an item to end of list
>>> s.append('Hex')
>>> s
["Chess", "Go", "Hex"]

# Remove an item from end of list
>>> s = ["Chess", "Go", "Monopoly", "Hex"]
>>> s.pop()
"Hex" # Returns the removed item
>>> s
["Chess", "Go", "Monopoly"]
>>> s.pop(1) # Remove item at index 1
"Go"
>>> s
["Chess", "Monopoly"]

# Add an item at an index
>>> s.insert(1, "KenKen")
>>> s
["Chess", "KenKen", "Go"]

# Remove the first item from the list whose value is equal to x
>>> s.remove("Chess")
["KenKen", "Go"]

# Get index of first occurence of item in list
>>> s = ["Monkey", "Carrot", "Red", "Carrot"]
>>> s.index("Carrot")
1

# Get total occurrences of item in list
>>> s = ["Monkey", "Carrot", "Red", "Carrot"]
>>> s.count("Carrot")
2

# Check if an element exists in list
>>> s = ["Chess", "KenKen", "Go"]
>>> "Go" in s
True
>>> "Monopoly" in s
False
>>> "Go" not in s
False

# Concatenate multiple lists
>>> s = ["Chess", "Go"]
>>> s + ["Hex"]
["Chess", "Go", "Hex"]

# Get the smallest/largest item of list
>>> s = [10, 6, 89, 37]
>>> min(s)
6
>>> max(s)
89

# Slicing a list with list[start:end] (end is exclusive)
>>> s = ["Monkey", "Carrot", "Red", "Carrot"]
>>> s[1:3]
['Carrot', 'Red']

# Slicing a list with step with list[start:end:step]
>>> s = [1, 3, 5, 6, 7, 8]
>>> s[1:5:2]
[3, 6]

# Create a shallow copy of list
>>> s_copy = s.copy() # or
>>> s_copy = s[:]

# Create a deep copy of list
>>> import copy
>>> s_deepcopy = copy.deepcopy(s)

# Remove all items from list
>>> s.clear() # or
>>> del s[:]

# Reverse a list
>>> s[::-1] # Returns a new list
>>> s.reverse() # Reverses list in place

# Extend a list by appending all items from another iterable
>>> s = ["Chess", "Go"]
>>> s.extend(["Hex", "Shogi"])
>>> s
["Chess", "Go", "Hex", "Shogi"]

# Sort a list
>>> s = ["Chess", "Go", "Hex", "Shogi"]
>>> s.sort() # Sort list in place
# sorted(s) returns a new sorted list
>>> s
['Chess', 'Go', 'Hex', 'Shogi']
```

## Easter eggs

```plaintext
>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

>>> import antigravity

>>> import __hello__
Hello world!

>>> from __future__ import braces
  File "<stdin>", line 1
SyntaxError: not a chance
```

- [Secret code in Ex Machina (2014)](https://www.reddit.com/r/movies/comments/365f9b/secret_code_in_ex_machina/)

## Snippets

```python
# Multiple assignment
>>> x, y = 2, 3 # or
>>> x, y = (2, 3) # or
>>> x, y, z = 'abd'

# Get Python version
>>> import sys
>>> sys.version
'3.8.10 (default ...)'

# Get Unix timestamp
>>> import time
>>> time.time()
1636620498.0040886

# Check the type of object
>>> n = 34
>>> type(n)
<class 'int'>
>>> st = "Hello, world!"
>>> type(st)
<class 'str'>

# Count the number of unique characters in a string
len(set("stackoverflow"))

# Check if an element in one list exists in another
any(e in list2 for e in list1)
```


Character	Meaning
`.`	Any character except newline
`\d`	One digit
`\D`	One non-digit
`\s`	One whitespace
`\S`	One non-whitespace
`\w`	One word character
`\W`	One non-word character
`\t`	Horizontal tab
`\v`	Vertical tab
`\r`	Carriage return
`\n`	Newline/Linefeed
`\f`	Form-feed
`[\b]`	Backspace character
`\0`	NUL character
`\`	Escape a special character

Character	Meaning
`^`	Start of string
`$`	End of string
`\b`	Word boundary
`\B`	Non-word boundary
`x(?=y)`	Positive lookahead (Matches "x" only if "x" is followed by "y")
`x(?!y)`	Negative lookahead (Matches "x" only if "x" is not followed by "y")
`(?<=y)x`	Positive lookbehind (Matches "x" only if "x" is preceded by "y")
`(?<!y)x`	Negative lookbehind (Matches "x" only if "x" is not preceded by "y")

Character	Meaning
`x\|y`	Either "x" or "y"
`[xyz]` `[a-c]`	Any one of the enclosed characters
`[^xyz]` `[^a-c]`	Anything that is not enclosed in the brackets
`(x)`	Capturing group (matches "x" and remembers the match)
`(?<Name>x)`	Named capturing group (matches "x" and stores it as "Name")
`(?:x)`	Non-capturing group (matches "x" but does not remember the match)
`\N`	Match the Nth captured group
`\k<Name>`	Back reference to the last substring matching the named capturing group specified by "Name"

Character	Meaning
`*`	0 or more
`+`	1 or more
`?`	0 or 1
`x{n}`	Exactly n occurences of x
`x{n, m}`	Between n and m occurences of x
`x{n,}`	n or more occurences of x
`?`	Make the quantifier non-greedy (stop as soon as it finds a match)

Character	Meaning
`[:alnum:]`	Letters and digits
`[:alpha:]`	Letters
`[:ascii:]`	Ascii codes 0 - 127
`[:blank:]`	Space or tab only
`[:cntrl:]`	Control characters
`[:digit:]`	Decimal digits
`[:graph:]`	Visible characters, except space
`[:upper:]`	Uppercase letters
`[:lower:]`	Lowercase letters
`[:word:]`	Word characters
`[:print:]`	Visible characters
`[:punct:]`	Visible punctuation characters
`[:space:]`	Whitespace
`[:xdigit:]`	Hexadecimal digits