OpenAI Glossary Cheat Sheet

🤖 Artificial General Intelligence (AGI): AGI refers to a hypothetical 🌌 GPT-4: GPT-4 is a more advanced version of the GPT series,
AI that can perform any intellectual task a human being can do, expected to have larger model size and enhanced capabilities
demonstrating human-like cognitive abilities across diverse domains. compared to its predecessors.
🚀 Singularity: A theoretical point in the future when AI 🏋️ Pre-training: Pre-training is the initial phase of training a deep
advancements lead to rapid, uncontrollable, and transformative learning model on a large dataset, often unsupervised
changes in society, potentially surpassing human comprehension.
🎛️ Fine-tuning: Fine-tuning is the process of adapting a pre-
🛡️ AI Safety: AI safety is the study and practice of building AI trained model for a specific task by training it on labeled data
systems that operate securely and align with human values, ensuring related to that task, refining its performance.
that they benefit humanity without causing harm.
🎯 Zero-shot learning: Zero-shot learning is a machine learning
🧭 Alignment Problem: The alignment problem is the challenge of approach where a model can make predictions or complete tasks
designing AI systems that understand and act upon human intentions, without being explicitly trained on that task's data.
values, and goals, rather than optimizing for unintended objectives.
🧪 Few-shot learning: Few-shot learning is a machine learning
🧠 OpenAI: OpenAI is an AI research organization that focuses on approach where a model can quickly adapt to new tasks by
developing artificial general intelligence (AGI) that benefits everybody. learning from a small number of labeled examples.
💡 Deep Learning: Deep learning is a subfield of machine learning 📜 Token: A token is a unit of text, such as a word or subword, that
that uses artificial neural networks to model complex patterns and serves as input to a language model.
make predictions or decisions based on input data.
🔪 Tokenizer: A tokenizer is a tool that breaks down text into
🕸️ Artificial Neural Network: An artificial neural network is a individual tokens for processing by a language model.
computational model inspired by the human brain's structure and 🖼️ Context window: The context window is the maximum number
function, consisting of interconnected nodes called neurons that of tokens that a language model can process in a single pass,
process and transmit information. determining its ability to capture context in input data.
🎓 Supervised Learning: Supervised learning is a machine learning
💡 Prompts: Prompts are input text given to a language model to
approach where a model is trained on a dataset containing input- generate a response or complete a specific task.
output pairs, learning to predict outputs based on new inputs.
🎨 Prompt Engineering: Prompt engineering is the process of
🌐 Unsupervised Learning: Unsupervised learning is a machine designing effective prompts to elicit desired responses from
learning approach where a model learns patterns and structures within language models, improving their utility and reliability.
input data without explicit output labels, often through clustering or
dimensionality reduction. 🤖 ChatGPT: ChatGPT is a conversational AI model developed by
OpenAI based on the GPT architecture, designed to generate
🎮 Reinforcement Learning from Human Feedback (RLHF): RLHF human-like responses in text-based conversations.
is a method that combines reinforcement learning with human
feedback, allowing AI models to learn from and adapt to human 📚 InstructGPT: InstructGPT is an AI model developed by
preferences and values. OpenAI, designed to follow instructions given in prompts, enabling
it to generate more task-specific and accurate responses.
💬 Natural Language Processing (NLP): NLP is a field of AI that
focuses on enabling computers to understand, interpret, and generate 🔧 OpenAI API: The OpenAI API is a service provided by OpenAI
human language. that allows developers to access and utilize their AI models, such
as ChatGPT, for various applications.
📚 Large Language Models: Large language models are AI models
trained on vast amounts of text data, capable of understanding and 🎨 DALL-E: DALL-E is an AI model developed by OpenAI that
generating human-like text. generates images from textual descriptions, combining natural
language understanding with image generation capabilities.
⚙️ Transformer: The Transformer is a deep learning architecture
designed for sequence-to-sequence tasks, known for its self-attention 🐍 LaMDA: LaMDA is Google's conversational AI model designed
mechanism that helps capture long-range dependencies in data. to engage in open-domain conversations, understanding and
generating responses for a wide range of topics.
👁️ Attention mechanism: Attention mechanisms in neural networks
enable models to weigh the importance of different input elements 🧭 Midjourney: AI program and service that generates images
relative to one another, improving their ability to capture context. from natural language descriptions, called "prompts", similar to
OpenAI's DALL-E and Stable Diffusion
🔄 Self-attention: Self-attention is a type of attention mechanism
used in transformers that allows the model to relate different positions 🌊 Stable Diffusion: A deep learning, text-to-image model
of a single sequence. released in 2022 and used to generate detailed images conditioned
on text descriptions. Also used for inpainting, outpainting, and
📖 BERT (Bidirectional Encoder Representations from generating image-to-image translations guided by a text prompt.
Transformers): BERT is a pre-trained transformer-based model
developed by Google for natural language understanding tasks, which 📈 Diffusion models: Diffusion models are a class of models that
can be fine-tuned for specific applications. represent the spread of information, influence, or other phenomena
through a network.
🚀 GPT (Generative Pre-trained Transformer): GPT is a series of AI
models developed by OpenAI, designed for natural language 🔄 Backpropagation: Backpropagation is a widely-used
processing tasks and capable of generating coherent, contextually optimization algorithm in neural networks that minimizes the error
relevant text. between predicted outputs and true outputs by adjusting the
model's weights.
🌐 GPT-3.5: GPT-3.5 is an intermediate version of the GPT series,
bridging the gap between GPT-3 and GPT-4 in terms of model size
and capabilities.

Cheat Sheet Download Link: https://blog.finxter.com/openai-glossary/

 Python OpenAI API Cheat Sheet
Full Blog Tutorial: https://blog.finxter.com/openapi-cheat-sheet/

Getting Started Using GPT-4

Installation (CMD, Terminal, Shell, Powershell) system = 'You only reply in emojis!'
pip install openai prompt = 'Who are you?'
# or
pip3 install openai res = openai.ChatCompletion.create(
model="gpt-4",
First Prompt messages=[
import os {"role": "system",
import openai "content": system},
{"role": "user",
# Create, copy, and paste your API key here: "content": prompt}
openai.api_key = "sk-123456789" ],
max_tokens=100,
response = openai.Completion.create( temperature=1.2)
model="text-davinci-003",
prompt="2+2=", print(res['choices'][0]['message']['content'])
temperature=0, max_tokens=10) # Answer:

JSON Output Format Generating Images Programmatically with DALL-E

{"choices": [ prompt = "An oil painting of a dancing robot
{ in the style of Monet"
"finish_reason": "stop",
"index": 0, response = openai.Image.create(
"logprobs": null, prompt=prompt,
"text": "4\n\n2+2=4" n=1,
} size="256x256")
],
"created": 1682409707, url = response["data"][0]["url"]
"id": "cmpl-797uNKSjEKE5cMlod1MeXkueIetkC", print(url)
"model": "text-davinci-003", # https://...
"object": "text_completion",
"usage": {
"completion_tokens": 8, Resolution Price
"prompt_tokens": 4, 1024x1024 $0.020 / image
"total_tokens": 12
} 512x512 $0.018 / image
}
256x256 $0.016 / image

Example Sentiment Analysis Arguments Python OpenAI API Call

prompt = """Do sentiment analysis on the ✓ model: Specifies the model version, e.g., 'gpt-4.0-turbo'.
following text. Text: 'Oh, I just adore how ✓ prompt: The input text for the model to process (e.g., question)
the sun shines so brightly at 5 a.m., waking ✓ max_tokens: Maximum tokens in the response. Roughly
me up every single morning!'""" equates to number of words.
✓ temperature: Controls output randomness (0 to 1). Higher
response = openai.Completion.create( value leads to more random replies.
engine="text-davinci-003", ✓ top_p: Nucleus sampling strategy (0 to 1). Model will only
prompt=prompt, consider subset of tokens whose probability exceeds top_p.
max_tokens=200, ✓ n: Number of independent completions to explore.
n=1, ✓ stream: Use streaming mode (True or False) to return results
stop=None, incrementally (e.g., for real-time apps).
temperature=0.5 ✓ echo: Include input prompt in output (True or False).
) ✓ stop: Stopping sequence(s) for generation (string or list of
strings).
sentiment = response.choices[0].text.strip() ✓ presence_penalty: Penalizes similar tokens in output.
print(sentiment) ✓ frequency_penalty: Penalizes frequent tokens in output.
# Sentiment: Positive

Download 11 FREE Python + OpenAI ChatGPTCheat Sheets:

https://blog.finxter.com/subscribe/
 Python Cheat Sheet: Keywords
“​A puzzle a day to learn, code, and play​” → Visit ​finxter.com

Keyword Description Code example

False​, ​True Data values from the data type Boolean False​ == (​1 ​> ​2​), ​True​ == (​2 ​> ​1​)

and​, ​or​, ​not Logical operators: x, y = ​True​, ​False

(x ​and​ y)​ → both x and y must be True (x ​or​ y) == ​True​ ​# True
(x ​or​ y)​ → either x or y must be True (x ​and​ y) == ​False​ ​ True
#
(​not​ x)​ → x must be false (​not​ y) == ​True​ ​ True
#

break Ends loop prematurely while​(​True​):

​break​ ​# no infinite loop
print(​"hello world"​)

continue Finishes current loop iteration while​(​True​):

​continue
print(​"43"​) ​# dead code

class Defines a new class → a real-world concept class​ ​Beer​:

(object oriented programming) ​def​ ​__init__​(self)​:
self.content = ​1.0
def Defines a new function or class method. For latter, ​def​ ​drink​(self)​:
first parameter (“self”) points to the class object. self.content = ​0.0
When calling class method, first parameter is implicit.
becks = Beer() ​# constructor - create class
becks.drink() ​# beer empty: b.content == 0

if​, ​elif​, ​else Conditional program execution: program starts with x = int(input(​"your value: "​))
“if” branch, tries the “elif” branches, and finishes with if​ x > ​3​: print(​"Big"​)
“else” branch (until one branch evaluates to True). elif​ x == ​3​: print(​"Medium"​)
else​: print(​"Small"​)

for​, ​while # For loop declaration # While loop - same semantics

for​ i ​in​ [​0​,​1​,​2​]: j = ​0
print(i) while​ j < ​3​:
print(j)
j = j + ​1

in Checks whether element is in sequence 42​ ​in​ [​2​, ​39​, ​42​] ​# True

is Checks whether both elements point to the same y = x = 3

object x​ ​is​ ​y​ ​# True
[​3​] ​is​ [​3​] ​# False

None Empty value constant ​ ​()​:

def​ f
x = ​2
f() ​is​ ​None​ ​# True

lambda Function with no name (anonymous function) (lambda​ x: x + ​3)(3)​ ​# returns 6

return Terminates execution of the function and passes the def​ i​ ncrementor​(x)​:
flow of execution to the caller. An optional value after ​return​ x + ​1
the return keyword specifies the function result. incrementor(​4​) ​# returns 5
 Python Cheat Sheet: Basic Data Types
“​A puzzle a day to learn, code, and play​” → Visit ​finxter.com
Description Example

Boolean The Boolean data type is a truth value, either ## 1. Boolean Operations
​ alse​.
True​ ​or F x, y = ​True​, ​False
print(x ​and​ ​not​ y) ​# True
The Boolean operators ordered by priority: print(​not​ x ​and​ y ​or​ x) ​# True
not​ x​ ​ → “if x is False, then x, else y”
x ​and​ y​ → “if x is False, then x, else y” ## 2. If condition evaluates to False
x ​or​ y​ ​ → “if x is False, then y, else x” if​ ​None​ ​or​ ​0​ ​or​ ​0.0​ ​or​ ​''​ ​or​ [] ​or​ {} ​or​ set():
​# None, 0, 0.0, empty strings, or empty
These comparison operators evaluate to ​True​: ​# container types are evaluated to False
1​ < ​2​ ​and​ ​0​ <= ​1​ ​and​ ​3​ > ​2​ ​and​ ​2​ >=​2​ ​and
print(​"Dead code"​) ​# Not reached
1​ == ​1​ ​and​ ​1​ != ​0​ ​# True

Integer, An integer is a positive or negative number ## 3. Arithmetic Operations

Float without floating point (e.g. ​3​). A float is a x, y = ​3​, ​2
positive or negative number with floating point print(x + y) ​# = 5
precision (e.g.​ ​3.14159265359​). print(x - y) ​# = 1
print(x * y) ​# = 6
The ‘​//​’ operator performs integer division. print(x / y) ​# = 1.5
The result is an integer value that is rounded print(x // y) ​# = 1
toward the smaller integer number print(x % y) ​# = 1s
(e.g. 3​ ​ // ​2​ == ​1​). print(-x) ​# = -3
print(abs(-x)) ​# = 3
print(int(​3.9​)) ​# = 3
print(float(​3​)) ​# = 3.0
print(x ** y) ​# = 9

String Python Strings are sequences of characters. ## 4. Indexing and Slicing

s = ​"The youngest pope was 11 years old"
The four main ways to create strings are the print(s[​0​]) ​# 'T'
following. print(s[​1​:​3​]) ​# 'he'
print(s[​-3​:​-1​]) ​# 'ol'
1. Single quotes print(s[​-3​:]) ​# 'old'
'Yes' x = s.split() ​# creates string array of words
2. Double quotes print(x[​-3​] + ​" "​ + x[​-1​] + ​" "​ + x[​2​] + ​"s"​)
"Yes"
# '11 old popes'
3. Triple quotes (multi-line)
"""Yes
## 5. Most Important String Methods
We Can"""
y = ​" This is lazy\t\n "
4. String method
print(y.strip()) ​# Remove Whitespace: 'This is lazy'
str(​5​) == ​'5'​ ​# True
print(​"DrDre"​.lower()) ​# Lowercase: 'drdre'
5. Concatenation
print(​"attention"​.upper()) ​# Uppercase: 'ATTENTION'
"Ma"​ + ​"hatma"​ ​# 'Mahatma'
print(​"smartphone"​.startswith(​"smart"​)) ​# True
print(​"smartphone"​.endswith(​"phone"​)) ​# True
print(​"another"​.find(​"other"​)) ​# Match index: 2
These are whitespace characters in strings.
print(​"cheat"​.replace(​"ch"​, ​"m"​)) ​# 'meat'
● Newline \​ n
print(​','​.join([​"F"​, ​"B"​, ​"I"​])) ​# 'F,B,I'
● Space ​ s
\
print(len(​"Rumpelstiltskin"​)) ​# String length: 15
● Tab ​ t
\ print(​"ear"​ ​in​ ​"earth"​) ​# Contains: True
 Python Cheat Sheet: Classes
“​A puzzle a day to learn, code, and play​” → Visit ​finxter.com
Description Example

Classes A class encapsulates data and functionality: data as class​ ​Dog​:

attributes, and functionality as methods. It is a blueprint """ Blueprint of a dog """
for creating concrete instances in memory.
# class variable shared by all instances
species = [​"canis lupus"​]

def​ ​__init__​(self, name, color)​:

self.name = name
self.state = ​"sleeping"
self.color = color

def​ ​command​(self, x)​:

if​ x == self.name:
self.bark(​2​)
elif​ x == ​"sit"​:
Instance You are an instance of the class human. An instance is a self.state = " ​ sit"
concrete implementation of a class: all attributes of an else​:
instance have a fixed value. Your hair is blond, brown, or self.state = " ​ wag tail"
black--but never unspecified.
def​ ​bark​(self, freq)​:
Each instance has its own attributes independent of for​ i ​in​ range(freq):
other instances. Yet, class variables are different. These print(​"["​ + self.name
are data values associated with the class, not the + ​"]: Woof!"​)
instances. Hence, all instance share the same class
variable ​species ​in the example.
​ black"​)
bello = Dog(​"bello"​, "
Self The first argument when defining any method is always alice = Dog(​"alice"​, "​ white"​)
the ​self ​argument. This argument specifies the
​ black
print(bello.color) #
instance on which you call the method.
print(alice.color) #​ white
self ​gives the Python interpreter the information about
the concrete instance. To ​define ​a method, you use s ​ elf bello.bark(​1​) ​# [bello]: Woof!
​ n instance
to modify the instance attributes. But to ​call a
method, you do not need to specify ​self​. alice.command(​"sit"​)
print(​"[alice]: "​ + alice.state)
Creation You can create classes “on the fly” and use them as # [alice]: sit
logical units to store complex data types.
bello.command(​"no"​)
class​ ​Employee()​: print(​"[bello]: "​ + bello.state)
pass # [bello]: wag tail
employee = Employee()
employee.salary = ​122000 alice.command(​"alice"​)
employee.firstname = ​"alice" # [alice]: Woof!
employee.lastname = ​"wonderland" # [alice]: Woof!

print(employee.firstname + ​" " bello.species += [​"wulf"​]

+ employee.lastname + ​" " print(len(bello.species)
+ str(employee.salary) + ​"$"​) == len(alice.species)) ​# True (!)
# alice wonderland 122000$
 Python Cheat Sheet: Functions and Tricks
“​A puzzle a day to learn, code, and play​” → Visit ​finxter.com
Description Example Result

A map(func, iter) Executes the function on all elements of list(map(​lambda​ x: x[​0​], [​'red'​, [​'r'​, ​'g'​, ​'b'​]
D the iterable 'green'​, ​'blue'​]))
V
A map(func, i1, ..., Executes the function on all k elements of list(map(​lambda​ x, y: str(x) + ​' '​ + [​'0 apples'​, ​'2
ik) the k iterables y + ​'s'​ , [​0​, ​2​, ​2​], [​'apple'​, oranges'​, ​'2
N
C 'orange'​, ​'banana'​])) bananas'​]
E
string.join(iter) Concatenates iterable elements ' marries '​.join(list([​'Alice'​, 'Alice marries Bob'
D separated by ​string 'Bob'​]))

F filter(func, Filters out elements in iterable for which list(filter(​lambda​ x: ​True​ ​if​ x>​17 [​18​]
U iterable) function returns ​False​ ​(or 0) else​ ​False​, [​1​, ​15​, ​17​, ​18​]))
N
C string.strip() Removes leading and trailing print(​" \n \t 42 \t "​.strip()) 42
T whitespaces of string
I
O sorted(iter) Sorts iterable in ascending order sorted([​8​, ​3​, ​2​, ​42​, ​5​]) [​2​, ​3​, ​5​, ​8​, ​42​]
N
sorted(iter, Sorts according to the key function in sorted([​8​, ​3​, 2 ​ ​, ​42​, ​5​], key=​lambda [​42​, ​2​, ​3​, ​5​, ​8​]
S
key=key) ascending order x: ​0​ ​if​ x==​42​ e​ lse​ x)

help(func) Returns documentation of ​func help(str.upper()) '... to uppercase.'

zip(i1, i2, ...) Groups the i-th elements of iterators ​i1, list(zip([​'Alice'​, ​'Anna'​], [​'Bob'​, [(​'Alice'​, ​'Bob'​),
i2, ...​ together 'Jon'​, ​'Frank'​])) (​'Anna'​, ​'Jon'​)]

Unzip Equal to: 1) unpack the zipped list, 2) zip list(zip(*[(​'Alice'​, ​'Bob'​), [(​'Alice'​, ​'Anna'​),
the result (​'Anna'​, ​'Jon'​)])) (​'Bob'​, ​'Jon'​)]

enumerate(iter) Assigns a counter value to each element list(enumerate([​'Alice'​, ​'Bob'​, [(​0​, ​'Alice'​), (​1​,
of the iterable 'Jon'​])) 'Bob'​), (​2​, ​'Jon'​)]

T python -m http.server Want to share files between PC and phone? Run this command in PC’s shell. <P> is any port number 0–65535. Type <
R <P> IP address of PC>:<P> in the phone’s browser. You can now browse the files in the PC directory.
I
C Read comic import​ antigravity Open the comic series xkcd in your web browser
K
S
Zen of Python import​ this '...Beautiful is better than ugly. Explicit is ...'

Swapping numbers Swapping variables is a breeze in Python. ​ Jane'​, ​'Alice'

a, b = ' a = ​'Alice'
No offense, Java! a, b = b, a b = '​ Jane'

Unpacking arguments Use a sequence as function arguments def​ ​f​(x, y, z)​:​ return​ x + y * z
via asterisk operator *. Use a dictionary f(*[​1​, ​3​, ​4​]) 13
(key, value) via double asterisk operator ** f(**{​'z'​ : ​4​, ​'x'​ : ​1​, ​'y'​ : 3
​ ​}) 13

Extended Unpacking Use unpacking for multiple assignment a, *b = [​1​, ​2​, ​3​, ​4​, ​5​] a = ​1
feature in Python b = [​2​, ​3​, ​4, 5​]

Merge two dictionaries Use unpacking to merge two dictionaries x={​'Alice'​ : ​18​} z = {​'Alice'​: ​18​,
into a single one y={​'Bob'​ : ​27​, ​'Ann'​ : ​22​} 'Bob'​: ​27​, ​'Ann'​: ​22​}
z = {**x,**y}
 Python Cheat Sheet: 14 Interview Questions
“​A puzzle a day to learn, code, and play​” → Visit ​finxter.com

Question Code Question Code

Check if list l = [​3​, ​3​, ​4​, ​5​, ​2​, ​111​, ​5​] Get missing def​ g​ et_missing_number​(lst):
contains print(​111​ ​in​ l) ​# True number in ​return​ set(range(lst[len(lst)​-1​])[​1:
​ ]) - set(l)
integer x [1...100] l = list(range(​1​,​100​))
l.remove(​50​)
print(get_missing_number(l)) ​# 50

Find duplicate def​ ​find_duplicates​(elements): Compute def​ i ​ ntersect​(lst1, lst2):

number in duplicates, seen = set(), set() the res, lst2_copy = [], lst2[:]
integer list ​for​ element ​in​ elements: intersection ​for​ el ​in​ lst1:
​if​ element ​in​ seen: of two lists ​if​ el ​in​ lst2_copy:
duplicates.add(element) res.append(el)
seen.add(element) lst2_copy.remove(el)
​return​ list(duplicates) ​return​ res

Check if two def​ i​ s_anagram​(s1, s2): Find max l = [​4​, ​3​, ​6​, 3
​ ​, ​4,
​ ​888​, ​1,
​ ​-11​, ​22​, ​3]
​
strings are ​return​ set(s1) == set(s2) and min in print(max(l)) # ​ 888
anagrams print(is_anagram(​"elvis"​, ​"lives"​)) ​# True unsorted list print(min(l)) # ​ -11

Remove all lst = list(range(​10​)) + list(range(​10​)) Reverse def​ ​reverse​(string):

duplicates from lst = list(set(lst)) string using ​if​ len(string)<=​1​: r
​ eturn​ string
list print(lst) recursion ​return​ reverse(string[​1​:])+string[​0​]
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] print(reverse(​"hello"​)) ​# olleh

Find pairs of def​ ​find_pairs​(l, x): Compute a, b = ​0​, ​1

integers in list pairs = [] the first n n = ​10
so that their ​for​ (i, el_1) ​in​ enumerate(l): Fibonacci for​ i ​in​ range(n):
sum is equal to ​for​ (j, el_2) ​in​ enumerate(l[i+​1​:]): numbers print(b)
integer x ​if​ el_1 + el_2 == x: a, b = b, a+b
pairs.append((el_1, el_2)) # 1, 1, 2, 3, 5, 8, ...
​return​ pairs

Check if a def​ ​is_palindrome​(phrase): Sort list with def​ ​qsort​(L):

string is a ​return​ phrase == phrase[::​-1​] Quicksort ​if​ L == []: ​return​ []
palindrome print(is_palindrome(​"anna"​)) ​# True algorithm ​return​ qsort([x ​for​ x ​in​ L[​1​:] ​if​ x< L[​0​]]) + L[​0​:1
​ ​] +
qsort([x ​for​ x ​in​ L[​1​:] ​if​ x>=L[​0​]])
lst = [​44​, ​33​, 2​ 2​, 5
​ ​, ​77​, ​55​, ​999​]
print(qsort(lst))
# [5, 22, 33, 44, 55, 77, 999]

Use list as # as a list ... Find all def​ ​get_permutations​(w):

stack, array, l = [​3​, ​4​] permutation ​if​ len(w)<=​1​:
and queue l += [​5​, ​6​] ​# l = [3, 4, 5, 6] s of string ​return​ set(w)
smaller = get_permutations(w[​1: ​ ])
# ... as a stack ... perms = set()
l.append(​10​) ​# l = [4, 5, 6, 10] ​for​ x ​in​ smaller:
l.pop() ​# l = [4, 5, 6] ​for​ pos ​in​ range(​0,
​ len(x)+​1​):
perm = x[:pos] + w[​0​] + x[pos:]
# ... and as a queue perms.add(perm)
l.insert(​0​, ​5​) ​# l = [5, 4, 5, 6] ​return​ perms
l.pop() ​# l = [5, 4, 5] print(get_permutations(​"nan"​))
# {'nna', 'ann', 'nan'}
 Python Cheat Sheet: NumPy
“​A puzzle a day to learn, code, and play​” → Visit ​finxter.com
Name Description Example

a.shape The shape attribute of NumPy array a keeps a tuple of a = np.array([[​1​,​2​],[​1​,​1​],[​0​,​0​]])

integers. Each integer describes the number of elements of print(np.shape(a)) ​# (3, 2)
the axis.

a.ndim The ndim attribute is equal to the length of the shape tuple. print(np.ndim(a)) ​# 2

* The asterisk (star) operator performs the Hadamard product, a = np.array([[​2​, 0

​ ​], [​0​, ​2​]])
i.e., multiplies two matrices with equal shape element-wise. b = np.array([[​1​, 1​ ​], [​1​, ​1​]])
print(a*b) ​# [[2 0] [0 2]]

np.matmul(a,b), a@b The standard matrix multiplication operator. Equivalent to the print(np.matmul(a,b))
@ operator. # [[2 2] [2 2]]

np.arange([start, ]stop, Creates a new 1D numpy array with evenly spaced values print(np.arange(​0​,​10​,​2​))
[step, ]) # [0 2 4 6 8]

np.linspace(start, stop, Creates a new 1D numpy array with evenly spread elements print(np.linspace(​0​,​10​,​3​))
num=​50​) within the given interval # [ 0. 5. 10.]

np.average(a) Averages over all the values in the numpy array a = np.array([[​2​, ​0​], [​0​, ​2​]])
print(np.average(a)) ​# 1.0

<slice> = <val> Replace the <slice> as selected by the slicing operator with a = np.array([​0​, ​1​, ​0​, 0
​ ​, ​0​])
the value <val>. a[::​2​] = ​2
print(a) ​ [2 1 2 0 2]
#

np.var(a) Calculates the variance of a numpy array. a = np.array([​2​, ​6​])

print(np.var(a)) ​# 4.0

np.std(a) Calculates the standard deviation of a numpy array print(np.std(a)) ​# 2.0

np.diff(a) Calculates the difference between subsequent values in fibs = np.array([​0​, 1

​ ​, ​1​, ​2​, ​3​, ​5​])
NumPy array a print(np.diff(fibs, n=​1​))
# [1 0 1 1 2]

np.cumsum(a) Calculates the cumulative sum of the elements in NumPy print(np.cumsum(np.arange(​5​)))

array a. # [ 0 1 3 6 10]

np.sort(a) Creates a new NumPy array with the values from a a = np.array([​10​,​3​,​7​,​1​,​0​])
(ascending). print(np.sort(a))
# [ 0 1 3 7 10]

np.argsort(a) Returns the indices of a NumPy array so that the indexed a = np.array([​10​,​3​,​7​,​1​,​0​])
values would be sorted. print(np.argsort(a))
# [4 3 1 2 0]

np.max(a) Returns the maximal value of NumPy array a. a = np.array([​10​,​3​,​7​,​1​,​0​])

print(np.max(a)) ​# 10

np.argmax(a) Returns the index of the element with maximal value in the a = np.array([​10​,​3​,​7​,​1​,​0​])
NumPy array a. print(np.argmax(a)) ​# 0

np.nonzero(a) Returns the indices of the nonzero elements in NumPy array a = np.array([​10​,​3​,​7​,​1​,​0​])
a. print(np.nonzero(a)) ​# [0 1 2 3]
 ChatGPT Prompting Cheat Sheet
How Prompt Engineering Works Rule #4 – First try without examples, then try giving
Note: Prompt engineering designs and optimizes prompts for some examples.
language models.
Extract brand names from the text below.
It's important in NLP and language generation. Prompt formats
guide the model and can be used for tasks like product Text: {your text here}
descriptions or conversational AI.
Brand names:
Reliable prompt formats exist, but exploring new formats is
encouraged.
Extract brand names from the texts below.
"{your input here}" is a placeholder for text or context
Text 1: Finxter and YouTube are tech companies. Google
Rules of Thumb and Examples is too.
Brand names 2: Finxter, YouTube, Google
Rule #1 – Instructions at beginning and ### or """ to ###
separate instructions or context
Text 2: If you like tech, you’ll love Finxter!
Brand names 2: Finxter
Rewrite the text below in more engaging language. ###

{your input here} Text 3: {your text here}

Brand names 3:
Rewrite the text below in more engaging language.
Rule #5 – Fine-tune if Rule #4 doesn’t work
Text: """
{your input here} Fine-tuning improves model performance by training on more examples,
resulting in higher quality results, token savings, and lower latency requests.
"""
GPT-3 can intuitively generate plausible completions from few examples,
known as few-shot learning.
Rule #2 – Be specific and detailed about the desired Fine-tuning achieves better results on various tasks without requiring
context, outcome, length, format, and style. examples in the prompt, saving costs and enabling lower-latency requests.
Example Training Data
Write a short story for kids {"prompt":"<input>", "completion":"<ideal output>"}
{"prompt":"<input>", "completion":"<ideal output>"}
{"prompt":"<input>", "completion":"<ideal output>"}
Write a funny soccer story for kids that teaches the
...
kid that persistence is key for success in the style of
Rowling.
Rule #6 – Be specific. Omit needless words.
Rule #3 – Give examples of desired output format ChatGPT, write a sales page for my company selling sand
in the desert, please write only a few sentences,
nothing long and complex
Extract house pricing data from the following text.

Text: """ Write a 5-sentence sales page, sell sand in the desert.
{your text containing pricing data}
""" Rule #7 – Use leading words to nudge the model
towards a pattern
Extract house pricing data from the following text.
Write a Python function that plots my net worth over 10
Desired format: """ years for different inputs on the initial investment
House 1 | $1,000,000 | 100 sqm and a given ROI
House 2 | $500,000 | 90 sqm
... (and so on) # Python function that plots net worth over 10
""" # years for different inputs on the initial
# investment and a given ROI
Text: """
{your text containing pricing data} import matplotlib
"""
def plot_net_worth(initial, roi):

Bonus Prompt – Let ChatGPT Design the Optimal Prompt

New models are created frequently, and the performance of subsequent models can be an order of
magnitude. You are a robot for creating prompts. You need to gather information about the user’s
goals, examples of preferred output, and any other relevant contextual information.

The prompt should contain all the necessary information provided to you. Ask the user more
questions until you are sure you can create an optimal prompt.

Your answer should be clearly formatted and optimized for ChatGPT interactions. Be sure to start
by asking the user about the goals, the desired outcome, and any additional information you may
need.
 The Ultimate Python Cheat Sheet
Keywords Basic Data Structures
Keyword Description Code Examples Type Description Code Examples

Boolean The Boolean data type is ## Evaluates to True:

False, Boolean data type False == (1 > 2)
either True or False. 1<2 and 0<=1 and 3>2 and 2>=2 and 1==1
True True == (2 > 1)
Boolean operators are and 1!=0
ordered by priority:
Logical operators ## Evaluates to False:
not → and → or
and, → Both are true True and True # True bool(None or 0 or 0.0 or '' or [] or
or, → Either is true True or False # True {} or set())
not → Flips Boolean not False # True
Rule: None, 0, 0.0, empty strings, or empty container
1, 2, 3 types evaluate to False
break Ends loop prematurely while True:
break # finite loop Integer, An integer is a positive or ## Arithmetic Operations
Float negative number without x, y = 3, 2
continue Finishes current loop iteration while True: decimal point such as 3. print(x + y) # = 5
continue print(x - y) # = 1
print("42") # dead code A float is a positive or print(x * y) # = 6
negative number with print(x / y) # = 1.5
class Defines new class class Coffee: floating point precision print(x // y) # = 1
# Define your class such as 3.1415926. print(x % y) # = 1
print(-x) # = -3
def Defines a new function or class def say_hi(): Integer division rounds print(abs(-x)) # = 3
method. print('hi') toward the smaller integer print(int(3.9)) # = 3
(example: 3//2==1). print(float(3)) # = 3.0
if, Conditional execution: x = int(input("ur val:")) print(x ** y) # = 9
elif, - “if” condition == True? if x > 3: print("Big")
else - "elif" condition == True? elif x == 3: print("3") String Python Strings are ## Indexing and Slicing
- Fallback: else branch else: print("Small") sequences of characters. s = "The youngest pope was 11 years"
s[0] # 'T'
String Creation Methods: s[1:3] # 'he' Slice [::2]
for, # For loop # While loop does same
while for i in [0,1,2]: j = 0 1. Single quotes s[-3:-1] # 'ar'
print(i) while j < 3: >>> 'Yes' s[-3:] # 'ars' 1 2 3 4
print(j); j = j + 1 2. Double quotes
>>> "Yes" x = s.split() 0 1 2 3
in Sequence membership 42 in [2, 39, 42] # True 3. Triple quotes (multi-line) x[-2] + " " + x[2] + "s" # '11 popes'
>>> """Yes
is Same object memory location y = x = 3 We Can""" ## String Methods
x is y # True 4. String method y = " Hello world\t\n "
[3] is [3] # False >>> str(5) == '5' y.strip() # Remove Whitespace
True "HI".lower() # Lowercase: 'hi'
None Empty value constant print() is None # True 5. Concatenation "hi".upper() # Uppercase: 'HI'
>>> "Ma" + "hatma" "hello".startswith("he") # True
lambda Anonymous function (lambda x: x+3)(3) # 6 'Mahatma' "hello".endswith("lo") # True
"hello".find("ll") # Match at 2
return Terminates function. Optional def increment(x): Whitespace chars: "cheat".replace("ch", "m") # 'meat'
return value defines function return x + 1 Newline \n, ''.join(["F", "B", "I"]) # 'FBI'
result. increment(4) # returns 5 Space \s, len("hello world") # Length: 15
Tab \t "ear" in "earth" # True

Complex Data Structures

Type Description Example Type Description Example

List Stores a sequence of l = [1, 2, 2] Dictionary Useful data structure for cal = {'apple' : 52, 'banana' : 89,
elements. Unlike strings, you print(len(l)) # 3 storing (key, value) pairs 'choco' : 546} # calories
can modify list objects (they're
Reading Read and write elements by print(cal['apple'] < cal['choco'])
mutable).
and specifying the key within the # True
Adding Add elements to a list with (i) [1, 2].append(4) # [1, 2, 4] writing brackets. Use the keys() cal['cappu'] = 74
elements append, (ii) insert, or (iii) list [1, 4].insert(1,9) # [1, 9, 4] elements and values() functions to print(cal['banana'] < cal['cappu'])
concatenation. [1, 2] + [4] # [1, 2, 4] access all keys and values of # False
the dictionary
print('apple' in cal.keys()) # True
Removal Slow for lists [1, 2, 2, 4].remove(1) # [2, 2, 4]
print(52 in cal.values()) # True
Reversing Reverses list order [1, 2, 3].reverse() # [3, 2, 1]
Dictionary You can access the (key, for k, v in cal.items():
Sorting Sorts list using fast Timsort [2, 4, 2].sort() # [2, 2, 4] Iteration value) pairs of a dictionary print(k) if v > 500 else ''
with the items() method. # 'choco'
Indexing Finds the first occurrence of [2, 2, 4].index(2)
an element & returns index. # index of item 2 is 0 Member- Check with the in keyword if basket = {'apple', 'eggs',
Slow worst case for whole list [2, 2, 4].index(2,1) ship set, list, or dictionary contains 'banana', 'orange'}
traversal. # index of item 2 after pos 1 is 1 operator an element. Set membership print('eggs' in basket) # True
is faster than list membership. print('mushroom' in basket) # False
Stack Use Python lists via the list stack = [3]
operations append() and pop() stack.append(42) # [3, 42] List & set List comprehension is the l = ['hi ' + x for x in ['Alice',
stack.pop() # 42 (stack: [3]) comprehe concise Python way to create 'Bob', 'Pete']]
stack.pop() # 3 (stack: []) nsion lists. Use brackets plus an # ['Hi Alice', 'Hi Bob', 'Hi Pete']
expression, followed by a for
Set An unordered collection of basket = {'apple', 'eggs', clause. Close with zero or l2 = [x * y for x in range(3) for y
unique elements (at-most- 'banana', 'orange'} more for or if clauses. in range(3) if x>y] # [0, 0, 2]
once) → fast membership O(1) same = set(['apple', 'eggs', Set comprehension works
squares = { x**2 for x in [0,2,4]
'banana', 'orange']) similar to list comprehension.
if x < 4 } # {0, 4}

Subscribe to the 11x FREE Python Cheat Sheet Course:

https://blog.finxter.com/python-cheat-sheets/
 Python Cheat Sheet: Complex Data Types
“A puzzle a day to learn, code, and play” → Visit finxter.com
Description Example

List A container data type that stores a l = [1, 2, 2]

sequence of elements. Unlike strings, lists print(len(l)) # 3
are mutable: modification possible.

Adding Add elements to a list with (i) append, (ii) [1, 2, 2].append(4) # [1, 2, 2, 4]
elements insert, or (iii) list concatenation. [1, 2, 4].insert(2,2) # [1, 2, 2, 4]
The append operation is very fast. [1, 2, 2] + [4] # [1, 2, 2, 4]

Removal Removing an element can be slower. [1, 2, 2, 4].remove(1) # [2, 2, 4]

Reversing This reverses the order of list elements. [1, 2, 3].reverse() # [3, 2, 1]

Sorting Sorts a list. The computational complexity [2, 4, 2].sort() # [2, 2, 4]

of sorting is superlinear in the no. list
elements.

Indexing Finds the first occurrence of an element in [2, 2, 4].index(2) # index of element 2 is "0"
the list & returns its index. Can be slow as [2, 2, 4].index(2,1) # index of el. 2 after pos 1 is "1"
the whole list is traversed.

Stack Python lists can be used intuitively as stack = [3]

stacks via the two list operations append() stack.append(42) # [3, 42]
and pop(). stack.pop() # 42 (stack: [3])
stack.pop() # 3 (stack: [])

Set A set is an unordered collection of unique basket = {'apple', 'eggs', 'banana', 'orange'}
elements (“at-most-once”). same = set(['apple', 'eggs', 'banana', 'orange'])

Dictionary The dictionary is a useful data structure for calories = {'apple' : 52, 'banana' : 89, 'choco' : 546}
storing (key, value) pairs.

Reading and Read and write elements by specifying the print(calories['apple'] < calories['choco']) # True
writing key within the brackets. Use the keys() and calories['cappu'] = 74
elements values() functions to access all keys and print(calories['banana'] < calories['cappu']) # False
values of the dictionary. print('apple' in calories.keys()) # True
print(52 in calories.values()) # True

Dictionary You can access the (key, value) pairs of a for k, v in calories.items():
Looping dictionary with the items() method. print(k) if v > 500 else None # 'choco'

Membership Check with the ‘in’ keyword whether the basket = {'apple', 'eggs', 'banana', 'orange'}
operator set, list, or dictionary contains an element. print('eggs' in basket) # True
Set containment is faster than list print('mushroom' in basket) # False
containment.

List and Set List comprehension is the concise Python # List comprehension
Comprehens way to create lists. Use brackets plus an l = [('Hi ' + x) for x in ['Alice', 'Bob', 'Pete']]
ion expression, followed by a for clause. Close print(l) # ['Hi Alice', 'Hi Bob', 'Hi Pete']
with zero or more for or if clauses. l2 = [x * y for x in range(3) for y in range(3) if x>y]
print(l2) # [0, 0, 2]
Set comprehension is similar to list # Set comprehension
comprehension. squares = { x**2 for x in [0,2,4] if x < 4 } # {0, 4}