Python cheatsheet

>>> print("Hello, World!")
Hello, World!

The famous "Hello World" program in Python

age = 18      # age is of type int
name = "John" # name is now of type str
print(name)

Python can't declare a variable without assignment.

>>> msg = "Hello, World!"
>>> print(msg[2:5])
llo

See: Strings

mylist = []
mylist.append(1)
mylist.append(2)
for item in mylist:
    print(item) # prints out 1,2

See: Lists

num = 200
if num > 0:
    print("num is greater than 0")
else:
    print("num is not greater than 0")

See: Flow control

for item in range(6):
    if item == 3: break
    print(item)
else:
    print("Finally finished!")

See: Loops

>>> def my_function():
...     print("Hello from a function")
...
>>> my_function()
Hello from a function

See: Functions

counter = 0
counter += 10           # => 10
counter = 0
counter = counter + 10  # => 10

message = "Part 1."

# => Part 1.Part 2.
message += "Part 2."   

>>> website = 'Quickref.ME'
>>> f"Hello, {website}"
"Hello, Quickref.ME"

>>> num = 10
>>> f'{num} + 10 = {num + 10}'
'10 + 10 = 20'

See: Python F-Strings

hello = "Hello World"
hello = 'Hello World'

multi_string = """Multiline Strings
Lorem ipsum dolor sit amet,
consectetur adipiscing elit """

See: Strings

my_bool = True 
my_bool = False

bool(0)     # => False
bool(1)     # => True

list1 = ["apple", "banana", "cherry"]
list2 = [True, False, False]
list3 = [1, 5, 7, 9, 3]
list4 = list((1, 5, 7, 9, 3))

See: Lists

my_tuple = (1, 2, 3)
my_tuple = tuple((1, 2, 3))

Similar to List but immutable

set1 = {"a", "b", "c"}   
set2 = set(("a", "b", "c"))

a == {1, 2, 3}

assert a | {2, 3, 4} == {1, 2, 3, 4}
assert a & {2, 3, 4} == {2, 3}
assert a - {2, 3, 4} == {1}
assert a ^ {2, 3, 4} == {1, 4}

a.update({2, 3, 4})

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

Set of unique items/objects

>>> empty_dict = {}
>>> a = {"one": 1, "two": 2, "three": 3}
>>> a["one"]
1
>>> a.keys()
('one', 'two', 'three')
>>> a.values()
(1, 2, 3)
>>> a.update({"four": 4})
>>> a.keys()
('one', 'two', 'three', 'four')
>>> a['four']
4

Key: Value pair, JSON like object

#Integers

x = int(1)   # x will be 1
y = int(2.8) # y will be 2
z = int("3") # z will be 3

#Floats

x = float(1)     # x will be 1.0
y = float(2.8)   # y will be 2.8
z = float("3")   # z will be 3.0
w = float("4.2") # w will be 4.2

#Strings

x = str("s1") # x will be 's1'
y = str(2)    # y will be '2'
z = str(3.0)  # z will be '3.0'

>>> hello = "Hello, World"
>>> print(hello[1])
e
>>> print(hello[-1])
d

Get the character at position 1 or last

>>> for char in "foo":
...     print(char)
f
o
o

Loop through the letters in the word "foo"

>>> hello = "Hello, World!"
>>> print(len(hello))
13

The len() function returns the length of a string

>>> s = '===+'
>>> n = 8
>>> s * n
'===+===+===+===+===+===+===+===+'

>>> s = 'spam'
>>> s in 'I saw spamalot!'
True
>>> s not in 'I saw The Holy Grail!'
True

>>> name = input("Enter your name: ")
Enter your name: Tom
>>> name
'Tom'

Get input data from console

>>> "#".join(["John", "Peter", "Vicky"])
'John#Peter#Vicky'

>>> "Hello, world!".endswith("!")
True

>>> website = 'Quickref.ME'
>>> f"Hello, {website}"
"Hello, Quickref.ME"

>>> num = 10
>>> f'{num} + 10 = {num + 10}'
'10 + 10 = 20'

>>> f"""He said {"I'm John"}"""
"He said I'm John"

>>> f'5 {"{stars}"}'
'5 {stars}'
>>> f'{{5}} {"stars"}'
'{5} stars'

>>> name = 'Eric'
>>> age = 27
>>> f"""Hello!
...     I'm {name}.
...     I'm {age}."""
"Hello!\n    I'm Eric.\n    I'm 27."

it is available since Python 3.6, also see: Formatted string literals

>>> f'{"text":10}'     # [width]
'text      '
>>> f'{"test":*>10}'   # fill left
'******test'
>>> f'{"test":*<10}'   # fill right
'test******'
>>> f'{"test":*^10}'   # fill center
'***test***'
>>> f'{12345:0>10}'    # fill with numbers
'0000012345'

a = 10
assert f'{a:>10}' == '        10'
assert f'{a:<10}' == '10        '
assert f'{a:^10}' == '    10    '
assert f'{a:<10.2f}' == '10.00     '
assert f'{a:>10.2f}' == '     10.00'

assert f'{a:010}' == '0000000010'
assert f'{a:010d}' == '0000000010'
assert f'{a:010f}' == '010.000000'
assert f'{a:010.2f}' == '0000010.00'

>>> li1 = []
>>> li1
[]
>>> li2 = [4, 5, 6]
>>> li2
[4, 5, 6]
>>> li3 = list((1, 2, 3))
>>> li3
[1, 2, 3]
>>> li4 = list(range(1, 11))
>>> li4
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> li = []
>>> li.append(1)
>>> li
[1]
>>> li.append(2)
>>> li
[1, 2]
>>> li.append(4)
>>> li
[1, 2, 4]
>>> li.append(3)
>>> li
[1, 2, 4, 3]

>>> li = ['bread', 'butter', 'milk']
>>> li.pop()
'milk'
>>> li
['bread', 'butter']
>>> del li[0]
>>> li
['butter']

>>> li = ['a', 'b', 'c', 'd']
>>> li[0]
'a'
>>> li[-1]
'd'
>>> li[4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

>>> li = [3, 1, 3, 2, 5]
>>> li.count(3)
2

>>> li = ["re"] * 3
>>> li
['re', 're', 're']

num = 5
if num > 10:
    print("num is bigger than 10.")
elif num < 10:
    print("num is smaller than 10.")
else:
    print("num is indeed 10.")

>>> a = 330
>>> b = 200
>>> r = "a" if a > b else "b"
>>> print(r)
a

value = True
if not value:
    print("Value is False")
elif value is None:
    print("Value is None")
else:
    print("Value is True")

primes = [2, 3, 5, 7]
for prime in primes:
    print(prime)

Prints: 2 3 5 7

animals = ["dog", "cat", "mouse"]
# enumerate() adds counter to an iterable
for i, value in enumerate(animals):
    print(i, value)

Prints: 0 dog 1 cat 2 mouse

x = 0
while x < 4:
    print(x)
    x += 1  # Shorthand for x = x + 1

Prints: 0 1 2 3

x = 0
for index in range(10):
    x = index * 10
    if index == 5:
    	break
    print(x)

Prints: 0 10 20 30 40

for index in range(3, 8): 
    x = index * 10
    if index == 5:
    	continue
    print(x)

Prints: 30 40 60 70

for i in range(4):
    print(i) # Prints: 0 1 2 3

for i in range(4, 8):
    print(i) # Prints: 4 5 6 7

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

words = ['Mon', 'Tue', 'Wed']
nums = [1, 2, 3]

# Use zip to pack two iterables
for w, n in zip(words, nums):
    print(f"{n}:{w}", end=", ")

Prints: 1:Mon, 2:Tue, 3:Wed,

nums = [60, 70, 30, 110, 90]
for n in nums:
    if n > 100:
        print(f"{n} is bigger than 100")
        break
else:
    print("Not found!")

Also see: Python Tips

def hello_world():  
    print('Hello, World!')

def add(x, y):
    print(f"x is {x}, y is {y}")
    return x + y

add(5, 6)    # => 11

def varargs(*args):
    return args

varargs(1, 2, 3)  # => (1, 2, 3)

Type of "args" is tuple.

def keyword_args(**kwargs):
    return kwargs

# => {"big": "foot", "loch": "ness"}
keyword_args(big="foot", loch="ness")

Type of "kwargs" is dict.

def swap(x, y):
    return y, x

x = 1
y = 2
x, y = swap(x, y)  # => x = 2, y = 1

def add(x, y=10):
    return x + y

add(5)      # => 15
add(5, 20)  # => 25

# => True
(lambda x: x > 2)(3)

# => 5
(lambda x, y: x ** 2 + y ** 2)(2, 1)

import math
print(math.sqrt(16))  # => 4.0

from math import ceil, floor
print(ceil(3.7))   # => 4.0
print(floor(3.7))  # => 3.0

from math import *

import math as m

# => True
math.sqrt(16) == m.sqrt(16)

import math
dir(math)

#Write a string

contents = {"aa": 12, "bb": 21}
with open("myfile1.txt", "w") as file:
    file.write(str(contents))

#Read a string

with open('myfile1.txt', "r") as file:
    contents = file.read()
print(contents)

#Write an object

contents = {"aa": 12, "bb": 21}
with open("myfile2.txt", "w+") as file:
    file.write(json.dumps(contents))

#Read an object

with open('myfile2.txt', "r+") as file:
    contents = json.load(file)
print(contents)

import os
os.remove("myfile.txt")

import os
if os.path.exists("myfile.txt"):
    os.remove("myfile.txt")
else:
    print("The file does not exist")

import os
os.rmdir("myfolder")

class MyNewClass:
    pass

# Class Instantiation
my = MyNewClass()

class Animal:
    def __init__(self, voice):
        self.voice = voice
 
cat = Animal('Meow')
print(cat.voice)    # => Meow
 
dog = Animal('Woof') 
print(dog.voice)    # => Woof

class Dog:

    # Method of the class
    def bark(self):
        print("Ham-Ham")
 
charlie = Dog()
charlie.bark()   # => "Ham-Ham"

class Employee:
    def __init__(self, name):
        self.name = name
 
    def __repr__(self):
        return self.name
 
john = Employee('John')
print(john)  # => John

class CustomError(Exception):
    pass

class ParentClass:
    def print_self(self):
        print('A')
 
class ChildClass(ParentClass):
    def print_self(self):
        print('B')
 
obj_A = ParentClass()
obj_B = ChildClass()
 
obj_A.print_self() # => A
obj_B.print_self() # => B

class ParentClass:
    def print_self(self):
        print("Parent")
 
class ChildClass(ParentClass):
    def print_self(self):
        print("Child")
 
child_instance = ChildClass()
child_instance.print_self() # => Child

class Animal: 
    def __init__(self, name, legs):
        self.name = name
        self.legs = legs
        
class Dog(Animal):
    def sound(self):
        print("Woof!")
 
Yoki = Dog("Yoki", 4)
print(Yoki.name) # => YOKI
print(Yoki.legs) # => 4
Yoki.sound()     # => Woof!

string: str = "ha"
times: int = 3


# wrong hit, but run correctly
result: str = 1 + 2
print(result)  # => 3


def say(name: str, start: str = "Hi"):
    return start + ", " + name

print(say("Python"))  # => Hi, Python

from typing import Dict, Tuple, List

bill: Dict[str, float] = {
    "apple": 3.14,
    "watermelon": 15.92,
    "pineapple": 6.53,
}
completed: Tuple[str] = ("DONE",)
succeeded: Tuple[int, str] = (1, "SUCCESS")
statuses: Tuple[str, ...] = (
    "DONE", "SUCCESS", "FAILED", "ERROR",
)
codes: List[int] = (0, 1, -1, -2)

bill: dict[str, float] = {
    "apple": 3.14,
    "watermelon": 15.92,
    "pineapple": 6.53,
}
completed: tuple[str] = ("DONE",)
succeeded: tuple[int, str] = (1, "SUCCESS")
statuses: tuple[str, ...] = (
    "DONE", "SUCCESS", "FAILED", "ERROR",
)
codes: list[int] = (0, 1, -1, -2)

def calc_summary(*args: int):
    return sum(args)

print(calc_summary(3, 1, 4))  # => 8

Indicate all arguments' type is int.

def say_hello(name) -> str:
    return "Hello, " + name

var = "Python"
print(say_hello(var))  # => Hello, Python

from typing import Union

def resp200(meaningful) -> Union[int, str]:
    return "OK" if meaningful else 200

Means returned value type may be int or str.

def calc_summary(**kwargs: int):
    return sum(kwargs.values())

print(calc_summary(a=1, b=2))  # => 3

Indicate all parameters' value type is int.

def resp200() -> (int, str):
    return 200, "OK"

returns = resp200()
print(returns)  # => (200, 'OK')
print(type(returns))  # tuple

def resp200(meaningful) -> int | str:
    return "OK" if meaningful else 200

Since Python 3.10

class Employee:
    name: str
    age: int

    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.graduated: bool = False

class Employee:
    name: str

    def set_name(self, name) -> "Employee":
        self.name = name
        return self

    def copy(self) -> 'Employee':
        return type(self)(self.name)

from typing import Self

class Employee:
    name: str
    age: int

    def set_name(self: Self, name) -> Self:
        self.name = name
        return self

# This is a single line comments.

""" Multiline strings can be written
    using three "s, and are often used
    as documentation.
"""

''' Multiline strings can be written
    using three 's, and are often used
    as documentation.
'''

>>> def f(n):
...    for i in range(n):
...        yield i
>>> list(f(5))
[0, 1, 2, 3, 4]
>>>
>>> def g(n):
...     yield from range(n)
>>> list(g(4))
[0, 1, 2, 3]

Generators help you make lazy code.