Python#
#
Introduction#
Python (python.org)
Python Document (docs.python.org)
Learn X in Y minutes (learnxinyminutes.com)
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#
|
Text |
|
Numeric |
|
Sequence |
|
Mapping |
|
Set |
|
Boolean |
|
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#
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#
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
Comments#
# This is a single line comments.