Python cheatsheet

Hello World

>> print("Hello, World!")

The famous "Hello World" program in Python

Variables

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

Lists

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

See: Lists

If Else

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

See: Flow control

Loops

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

See: Loops

Functions

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

See: Functions

Arithmetic

result = 10 + 30 # => 40
result = 40 - 10 # => 30
result = 50 * 5  # => 250
result = 16 / 4  # => 4.0 (Float Division)
result = 16 // 4 # => 4 (Integer Division)
result = 25 % 2  # => 1
result = 5 ** 3  # => 125

The / means quotient of x and y, and the // means floored quotient of x and y, also see StackOverflow

Strings

hello = "Hello World"
hello = 'Hello World'
   
multi_string = """Multiline Strings
Lorem ipsum dolor sit amet,
consectetur adipiscing elit """

See: Strings

Numbers

x = 1    # int
y = 2.8  # float
z = 1j   # complex
   
>>> print(type(x))
<class 'int'>

Booleans

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

Lists

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

See: Lists

Tuple

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

Similar to List but immutable

Set

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

Set of unique items/objects

Dictionary

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

Key: Value pair, JSON like object

Casting

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'

Stacks and Queues

from collections import deque
   
q = deque()          # empty
q = deque([1, 2, 3]) # with values
   
q.append(4)     # append to right side
q.appendleft(0) # append to left side
print(q)    # => deque([0, 1, 2, 3, 4])
   
x = q.pop() # remove & return from right
y = q.popleft() # remove & return from left
print(x)    # => 4
print(y)    # => 0
print(q)    # => deque([1, 2, 3])
   
q.rotate(1) # rotate 1 step to the right
print(q)    # => deque([3, 1, 2])

Deque is a double-ended queue with O(1) time for append/pop operations from both sides. Used as stacks and queues. See: Deque

Array-like

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

Get the character at position 1 or last

Looping

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

Loop through the letters in the word "foo"

String Length

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

The len() function returns the length of a string

Multiple copies

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

Check String

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

Concatenates

>>> s = 'spam'
>>> t = 'egg'
>>> s + t
'spamegg'
>>> 'spam' 'egg'
'spamegg'

Input

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

Get input data from console

Join

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

Endswith

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

f-Strings usage

>>> website = 'cheatsheets.zip'
>>> f"Hello, {website}"
"Hello, cheatsheets.zip"
   
>>> 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-Strings Fill Align

>>> 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'

f-Strings Type

>>> f'{10:b}'        # binary type
'1010'
>>> f'{10:o}'        # octal type
'12'
>>> f'{200:x}'       # hexadecimal type
'c8'
>>> f'{200:X}'
'C8'
>>> f'{345600000000:e}' # scientific notation
'3.456000e+11'
>>> f'{65:c}'       # character type
'A'
>>> f'{10:#b}'      # [type] with notation (base)
'0b1010'
>>> f'{10:#o}'
'0o12'
>>> f'{10:#x}'
'0xa'

F-Strings Others

>>> f'{-12345:0=10}'  # negative numbers
'-000012345'
>>> f'{12345:010}'    # [0] shortcut (no align)
'0000012345'
>>> f'{-12345:010}'
'-000012345'
>>> import math       # [.precision]
>>> math.pi
3.141592653589793
>>> f'{math.pi:.2f}'
'3.14'
>>> f'{1000000:,.2f}' # [grouping_option]
'1,000,000.00'
>>> f'{1000000:_.2f}'
'1_000_000.00'
>>> f'{0.25:0%}'      # percentage
'25.000000%'
>>> f'{0.25:.0%}'
'25%'

F-Strings Sign

>>> f'{12345:+}'      # [sign] (+/-)
'+12345'
>>> f'{-12345:+}'
'-12345'
>>> f'{-12345:+10}'
'    -12345'
>>> f'{-12345:+010}'
'-000012345'

Defining

>>> 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]

Append

>>> 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]

Remove

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

Access

>>> 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

Count

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

Repeating

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

Basic

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

One line

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

Else if

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

Match case

x = 1
match x:
   case 0:
      print("zero")
   case 1:
      print("one")
   case _:
      print("multiple")

Basic

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

Prints: 2 3 5 7

With index

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

While

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

Prints: 0 1 2 3

Break

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

Prints: 0 10 20 30 40

Continue

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

Prints: 30 40 60 70

Range

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

With zip()

words = ['Mon', 'Tue', 'Wed']
nums = [1, 2, 3]
# Use zip to pack into a tuple list
for w, n in zip(words, nums):
   print('%d:%s, ' %(n, w))

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

for/else

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

Also see: Python Tips

Basic

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

Return

def add(x, y):
   print("x is %s, y is %s" % (x, y))
   return x + y
   
add(5, 6)    # => 11

Positional arguments

def varargs(*args):
   return args
   
varargs(1, 2, 3)  # => (1, 2, 3)

Type of "args" is tuple.

Keyword arguments

def keyword_args(**kwargs):
   return kwargs
   
# => {"big": "foot", "loch": "ness"}
keyword_args(big="foot", loch="ness")

Type of "kwargs" is dict.

Returning multiple

def swap(x, y):
   return y, x
   
x = 1
y = 2
x, y = swap(x, y)  # => x = 2, y = 1

Default Value

def add(x, y=10):
   return x + y
   
add(5)      # => 15
add(5, 20)  # => 25

Anonymous functions

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

Import modules

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

From a module

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

Import all

from math import *

Shorten module

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

Functions and attributes

import math
dir(math)

Read file

Line by line

with open("myfile.txt") as file:
   for line in file:
      print(line)

With line number

file = open('myfile.txt', 'r')
for i, line in enumerate(file, start=1):
   print("Number %s: %s" % (i, line))

String

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)

Object

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)

Delete a File

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

Check and Delete

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

Delete Folder

import os
os.rmdir("myfolder")

Defining

class MyNewClass:
   pass
   
# Class Instantiation
my = MyNewClass()

Constructors

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

dog = Animal('Woof')
print(dog.voice)    # => Woof

Method

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

Class Variables

class MyClass:
   class_variable = "A class variable!"
   
# => A class variable!
print(MyClass.class_variable)

x = MyClass()

# => A class variable!
print(x.class_variable)

Super() Function

class ParentClass:
   def print_test(self):
      print("Parent Method")
   
class ChildClass(ParentClass):
   def print_test(self):
      print("Child Method")
      # Calls the parent's print_test()
      super().print_test()
   
child_instance = ChildClass()
child_instance.print_test()
# Output:
# Child Method
# Parent Method

repr() method

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

User-defined exceptions

class CustomError(Exception):
       pass

Polymorphism

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

Overriding

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

Inheritance

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!

Variable & Parameter

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

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

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

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

Built-in Data Types

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)

Built-in Data Types (3.10+)

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)

Positional Argument

def calc_summary(*args: int):
   return sum(args)
   
print(calc_summary(3, 1, 4))  # => 8

Returned

def say_hello(name) -> str:
   return "Hello, " + name
   
var = "Python"
print(say_hello(var))  # => Hello, Python

Union Returned

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

Keyword Argument

def calc_summary(**kwargs: int):
   return sum(kwargs.values())
   
print(calc_summary(a=1, b=2))  # => 3

Multiple Returns

def resp200() -> (int, str):
   return 200, "OK"
   
returns = resp200()
print(returns)  # => (200, 'OK')
print(type(returns))  # tuple

Union Returned (3.10+)

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

Property

class Employee:
   name: str
   age: int
   
   def __init__(self, name, age):
      self.name = name
      self.age = age
      self.graduated: bool = False

Self Instance

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

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

Self Instance (3.11+)

from typing import Self
   
class Employee:
   name: str
   age: int
   
   def set_name(self: Self, name) -> Self:
      self.name = name
      return self

Type & Generic

from typing import TypeVar, Type
   
T = TypeVar("T")

# "mapper" is a type, like int, str, MyClass and so on.
# "default" is an instance of type T, such as 314, "string", MyClass() and so on.
# returned is an instance of type T too.
def converter(raw, mapper: Type[T], default: T) -> T:
   try:
      return mapper(raw)
   except:
      return default
   
raw: str = input("Enter an integer: ")
result: int = converter(raw, mapper=int, default=0)

Function

from typing import TypeVar, Callable, Any
   
T = TypeVar("T")

def converter(raw, mapper: Callable[[Any], T], default: T) -> T:
   try:
      return mapper(raw)
   except:
      return default
   
# Callable[[Any], ReturnType] means a function declare like:
# def func(arg: Any) -> ReturnType:
#     pass

# Callable[[str, int], ReturnType] means a function declare like:
# def func(string: str, times: int) -> ReturnType:
#     pass

# Callable[..., ReturnType] means a function declare like:
# def func(*args, **kwargs) -> ReturnType:
#     pass

def is_success(value) -> bool:
   return value in (0, "OK", True, "success")

resp = dict(code=0, message="OK", data=[])
successed: bool = converter(resp["message"], mapper=is_success, default=False)

Walrus Operator

values = [1, "text", True, "", 2]
i = 0

# It assigns a value to a variable and compares it in a boolean expression
while (data := values[i]):
   print(data, end=",")
   i = i + 1

# Expected result: 1, "text", True

Generators

def double_numbers(iterable):
   for i in iterable:
      yield i + i

Generators help you make lazy code.

Generator to List

values = (-x for x in [1,2,3,4,5])
gen_to_list = list(values)
   
# => [-1, -2, -3, -4, -5]
print(gen_to_list)