Python
Getting Started
Introduction
- Python (python.org)
- Python Document (docs.python.org)
- Learn X in Y minutes (learnxinyminutes.com)
- Regex in python (cheatsheets.zip)
Hello World
>>> print("Hello, World!")
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.
Data Types
str | Text |
int, float, complex | Numeric |
list, tuple, range | Sequence |
dict | Mapping |
set, frozenset | Set |
bool | Boolean |
bytes, bytearray, memoryview | Binary |
See: Data Types
Slicing String
>>> msg = "Hello, World!"
>>> print(msg[2:5])
llo
See: Strings
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
File Handling
with open("myfile.txt", "r", encoding='utf8') as file:
for line in file:
print(line)
See: File Handling
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
Plus-Equals
counter = 0
counter += 10 # => 10
counter = 0
counter = counter + 10 # => 10
message = "Part 1."
# => Part 1.Part 2.
message += "Part 2."
f-Strings (Python 3.6+)
>>> website = 'cheatsheets.zip'
>>> f"Hello, {website}"
"Hello, cheatsheets.zip"
>>> num = 10
>>> f'{num} + 10 = {num + 10}'
'10 + 10 = 20'
See: Python F-Strings
Python Built-in Data Types
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))
tupla = (1, 2, 3, 'python')
print(tupla[0]) # Output: 1
print(tupla.count(1)) # Count occurrences
print(tupla.index(2)) # Find index
tupla1 = (1, 2, 3)
tupla2 = ('a', 'b')
len(tuple) → Returns the number of elements.
in → Checks if an element exists in the tuple.
Concatenation (+) → Combines two tuples.
Repetition (*) → Repeats a tuple.
Slicing (tuple[start:end]) → Extracts a subtuple.
print(len(tupla1)) # Output: 3
print(2 in tupla1) # Output: True
print(tupla1 + tupla2) # Output: (1, 2, 3, 'a', 'b')
print(tupla1[1:]) # Output: (2, 3)
# unpacking
a, b, c, d = tupla # Each value goes into a variable
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'
Python Advanced Data Types
Heaps
import heapq
myList = [9, 5, 4, 1, 3, 2]
heapq.heapify(myList) # turn myList into a Min Heap
print(myList) # => [1, 3, 2, 5, 9, 4]
print(myList[0]) # first value is always the smallest in the heap
heapq.heappush(myList, 10) # insert 10
x = heapq.heappop(myList) # pop and return smallest item
print(x) # => 1
Negate all values to use Min Heap as Max Heap
myList = [9, 5, 4, 1, 3, 2]
myList = [-val for val in myList] # multiply by -1 to negate
heapq.heapify(myList)
x = heapq.heappop(myList)
print(-x) # => 9 (making sure to multiply by -1 again)
Heaps are binary trees for which every parent node has a value less than or equal to any of its children. Useful for accessing min/max value quickly. Time complexity: O(n) for heapify, O(log n) push and pop. See: Heapq
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
Python Strings
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"
Slicing string
┌───┬───┬───┬───┬───┬───┬───┐
| m | y | b | a | c | o | n |
└───┴───┴───┴───┴───┴───┴───┘
0 1 2 3 4 5 6 7
-7 -6 -5 -4 -3 -2 -1
>>> s = 'mybacon'
>>> s[2:5]
'bac'
>>> s[0:2]
'my'
>>> s = 'mybacon'
>>> s[:2]
'my'
>>> s[2:]
'bacon'
>>> s[:2] + s[2:]
'mybacon'
>>> s[:]
'mybacon'
>>> s = 'mybacon'
>>> s[-5:-1]
'baco'
>>> s[2:6]
'baco'
With a stride
>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::5]
'11111'
>>> s[4::5]
'55555'
>>> s[::-5]
'55555'
>>> s[::-1]
'5432154321543215432154321'
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'
Formatting
name = "John"
print("Hello, %s!" % name)
name = "John"
age = 23
print("%s is %d years old." % (name, age))
format() Method
txt1 = "My name is {fname}, I'm {age}".format(fname="John", age=36)
txt2 = "My name is {0}, I'm {1}".format("John", 36)
txt3 = "My name is {}, I'm {}".format("John", 36)
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
Python F-Strings (Since Python 3.6+)
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'
Python Lists
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]
Generate
>>> list(filter(lambda x : x % 2 == 1, range(1, 20)))
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> [x ** 2 for x in range (1, 11) if x % 2 == 1]
[1, 9, 25, 49, 81]
>>> [x for x in [3, 4, 5, 6, 7] if x > 5]
[6, 7]
>>> list(filter(lambda x: x > 5, [3, 4, 5, 6, 7]))
[6, 7]
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]
List Slicing
Syntax of list slicing:
a_list[start:end]
a_list[start:end:step]
Slicing
>>> a = ['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>> a[2:5]
['bacon', 'tomato', 'ham']
>>> a[-5:-2]
['egg', 'bacon', 'tomato']
>>> a[1:4]
['egg', 'bacon', 'tomato']
Omitting index
>>> a[:4]
['spam', 'egg', 'bacon', 'tomato']
>>> a[0:4]
['spam', 'egg', 'bacon', 'tomato']
>>> a[2:]
['bacon', 'tomato', 'ham', 'lobster']
>>> a[2:len(a)]
['bacon', 'tomato', 'ham', 'lobster']
>>> a
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>> a[:]
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
With a stride
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>> a[0:6:2]
['spam', 'bacon', 'ham']
>>> a[1:6:2]
['egg', 'tomato', 'lobster']
>>> a[6:0:-2]
['lobster', 'tomato', 'egg']
>>> a
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>> a[::-1]
['lobster', 'ham', 'tomato', 'bacon', 'egg', 'spam']
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
Concatenating
>>> odd = [1, 3, 5]
>>> odd.extend([9, 11, 13])
>>> odd
[1, 3, 5, 9, 11, 13]
>>> odd = [1, 3, 5]
>>> odd + [9, 11, 13]
[1, 3, 5, 9, 11, 13]
Sort & Reverse
>>> li = [3, 1, 3, 2, 5]
>>> li.sort()
>>> li
[1, 2, 3, 3, 5]
>>> li.reverse()
>>> li
[5, 3, 3, 2, 1]
Count
>>> li = [3, 1, 3, 2, 5]
>>> li.count(3)
2
Repeating
>>> li = ["re"] * 3
>>> li
['re', 're', 're']
Python Flow control
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 (ternary operator)
>>> 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")
Python Loops
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
Over Dictionary
johndict = {
"firstname": "John",
"lastname": "Doe",
"age": 30
}
x = johndict.items()
print(x)
# Output: dict_items([('firstname', 'John'),
# ('lastname', 'Doe'),
# ('age', 30)])
for key, value in johndict.items():
print(f"{key} : : {value}")
# Output: firstname : : John
# Output: lastname : : Doe
# Output: age : : 30
Python Comprehensions
Comprehension List
languages = ["html", "go", "rust", "javascript", "python"]
newlist = [x for x in languages if "l" not in x]
# add language for language in languages if "l" not in language
print(newlist) #Output : [ 'go', 'rust', 'javascript', 'python']
# List comprehension avoid this :
oldlist = []
for x in languages:
if "l" not in x:
oldlist.append(x)
print(oldlist) #Output : [ 'go', 'rust', 'javascript', 'python']
Comprehension Dictionary
languages = ["html", "go", "rust", "javascript", "python"]
language_dict = {lang: ('l' not in lang) for lang in languages}
# Key is the language & bool is Value (no offense for html..)
print(language_dict)
# Output: {'html': False, 'go': True, 'rust': True,
# 'javascript': True, 'python': True}
# Dictionary comprehension avoid this :
language_dict2 = {}
for e in languages:
if "l" not in e:
language_dict2[e] = True
else:
language_dict2[e] = False
print(language_dict2)
# Output: {'html': False, 'go': True, 'rust': True,
# 'javascript': True, 'python': True}
Python Functions
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)
@decorator
# Modify or extend behavior of function or class method,
# without changing their actual code.
# Define decorator that will wrap function or method
def handle_errors(func):
def wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except Exception as e:
return print(f"Error : {e}")
return wrapper
# Decorate function or method
@handle_errors
def divide(a, b):
return a / b
divide(10, 0) # Output : Error : division by zero
Python Modules
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)
Python File Handling
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")
Python Classes & Inheritance
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()
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!
@staticmethod
class MyClass:
@staticmethod
def greet(name):
return f"Hello, {name}!"
# No instantiation nedded
# Call via class
print(MyClass.greet("Alice")) # => Hello, Alice!
# Can still call via instance
obj = MyClass()
print(obj.greet("Bob")) # => Hello, Bob!
Python Type Hints (Since Python 3.5)
Variable & Parameter
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
Built-in date type
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 date type (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
Indicate all arguments' type is int.
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
Means returned value type may be int or str.
Keyword argument
def calc_summary(**kwargs: int):
return sum(kwargs.values())
print(calc_summary(a=1, b=2)) # => 3
Indicate all parameters' value type is int.
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
Since Python 3.10
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)
Python Operators
Walrus
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
Date & Time Handling
Current date and time
import datetime
now = datetime.datetime.now()
print(now) # e.g., 2024-04-27 14:35:22.123456
Creating specific date/time objects
import datetime
# Create a date object
d = datetime.date(2024, 4, 27)
print(d) # 2024-04-27
# Create a time object
t = datetime.time(15, 30, 45)
print(t) # 15:30:45
# Create a datetime object
dt = datetime.datetime(2024, 4, 27, 15, 30, 45)
print(dt) # 2024-04-27 15:30:45
Converting between date formats
import datetime
# Convert a string to a datetime object
date_str = "2024-04-27 14:00"
dt_obj = datetime.datetime.strptime(date_str, "%Y-%m-%d %H:%M")
print(dt_obj) # 2024-04-27 14:00:00
# Convert a datetime object to a string
formatted_str = dt_obj.strftime("%d/%m/%Y %H:%M")
print(formatted_str) # 27/04/2024 14:00
Timestamps and Unix time
import datetime
# Get current timestamp
timestamp = datetime.datetime.now().timestamp()
print(timestamp) # e.g., 1714188922.123456
# Convert timestamp back to datetime
dt_from_timestamp = datetime.datetime.fromtimestamp(timestamp)
print(dt_from_timestamp)
Date difference and timedelta
import datetime
date1 = datetime.date(2024, 4, 27)
date2 = datetime.date(2024, 5, 1)
delta = date2 - date1
print(delta.days) # 4
# Using timedelta for date arithmetic
new_date = date1 + datetime.timedelta(days=10)
print(new_date) # 2024-05-07
Miscellaneous
Comments
# 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.
'''
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)
Handle exceptions
try:
# Use "raise" to raise an error
raise IndexError("This is an index error")
except IndexError as e:
pass # Pass is just a no-op. Usually you would do recovery here.
except (TypeError, NameError):
pass # Multiple exceptions can be handled together, if required.
else: # Optional clause to the try/except block. Must follow all except blocks
print("All good!") # Runs only if the code in try raises no exceptions
finally: # Execute under all circumstances
print("We can clean up resources here")
Dispatcher Pattern
# Dispatcher allows dynamic selection and execution of functions based on user input or other runtime conditions
def add(x, y):
return x + y
def subtract(x, y):
return x - y
def multiply(x, y):
return x * y
def divide(x, y):
if y == 0:
return 'Error: Division by zero'
return x / y
# Dispatcher dictionary: maps operation names to their corresponding functions
operations = {
'add': add,
'subtract': subtract,
'multiply': multiply,
'divide': divide
}
# Function to dispatch operation based on operation name
# Common use cases include executing different functions dynamically, such as in calculators, command interpreters, or event handling
def dispatcher(operation_name, x, y):
func = operations.get(operation_name)
if func:
return func(x, y)
else:
return f"Unknown operation: {operation_name}"
# Usage examples
print(dispatcher('add', 5, 3)) # Output: 8
print(dispatcher('multiply', 4, 2)) # Output: 8
print(dispatcher('divide', 10, 0)) # Output: Error: Division by zero
print(dispatcher('mod', 10, 3)) # Output: Unknown operation: mod