class MyClass(object): x = 1 def __init__(self, y): self.y = y 

# Note that you generally don't need to know the compiling process but knowing where everything comes from # and giving complete answers shows that you truly know what you are talking about. Generally, every compiling process have a two steps. - Analysis - Code Generation. Analysis can be broken into: 1. Lexical analysis (Tokenizes source code) 2. Syntactic analysis (Check whether the tokens are legal or not, tldr, if syntax is correct) for i in 'foo' ^ SyntaxError: invalid syntax We missed ':' 3. Semantic analysis (Contextual analysis, legal syntax can still trigger errors, did you try to divide by 0, hash a mutable object or use an undeclared function?) 1/0 ZeroDivisionError: division by zero These three analysis steps are the responsible for error handlings. The second step would be responsible for errors, mostly syntax errors, the most common error. The third step would be responsible for Exceptions. As we have seen, Exceptions are semantic errors, there are many builtin Exceptions: ImportError ValueError KeyError FileNotFoundError IndentationError IndexError ... You can also have user defined Exceptions that have to inherit from the `Exception` class, directly or indirectly. Basic example: class DividedBy2Error(Exception): def __init__(self, message): self.message = message def division(dividend,divisor): if divisor == 2: raise DividedBy2Error('I dont want you to divide by 2!') return dividend / divisor division(100, 2) >>> __main__.DividedBy2Error: I dont want you to divide by 2! 

class Foo: def __init__(self: object) -> None: pass def __call__(self: object) -> None: print("Called!") f = Foo() f() 

Called! 

x, y = y, x 

def return_sum(): amount_of_numbers = int(input("How many numbers? ")) total_sum = 0 while amount_of_numbers != 0: num = int(input("Input a number. ")) total_sum += num amount_of_numbers -= 1 return total_sum 

li = [2, 5, 6] print("{0:.3f}".format(sum(li)/len(li))) 

numbers = [1, 2, 3, 4, 5] numbers.insert(0, 0) print(numbers) 

numbers_1 = [2, 3, 4, 5] numbers_2 = [0, 1] numbers_1 = numbers_2 + numbers_1 print(numbers_1) 

sorted_li = sorted(li, key=len) 

li.sort(key=len) 

nested_li = [['1', '2', '3'], ['4', '5', '6']] [[int(x) for x in li] for li in nested_li] 

sorted(li1 + li2) 

i, j = 0 merged_li = [] while i < len(li1) and j < len(li2): if li1[i] < li2[j]: merged_li.append(li1[i]) i += 1 else: merged_li.append(li2[j]) j += 1 merged_li = merged_li + merged_li[i:] + merged_li[j:] 

['hmm'] ['hmm', 'hmm'] ['hmm', 'hmm', 'hmm'] 

for item in some_list: print(item) 

for i, item in enumerate(some_list): print(i) 

for i in range(1, len(some_list)): some_list[i] 

for i in some_list[1:]: 

for i in reversed(li): ... 

n = len(li) - 1 while n > 0: ... n -= 1 

li = [[1, 4], [2, 1], [3, 9], [4, 2], [4, 5]] sorted(li, key=lambda l: l[1]) 

li.sort(key=lambda l: l[1) 

nums = [1, 2, 3] letters = ['x', 'y', 'z'] list(zip(nums, letters)) 

number_lists = [[1, 7, 3, 1], [13, 93, 23, 12], [123, 423, 456, 653, 124]] odd_numbers = [] for number_list in number_lists: for number in number_list: if number % 2 == 0: odd_numbers.append(number) print(odd_numbers) 

number_lists = [[1, 7, 3, 1], [13, 93, 23, 12], [123, 423, 456, 653, 124]] odd_numbers = [number for number_list in number_lists for number in number_list if number % 2 == 0] print(odd_numbers) 

brothers_menu = \ [{'name': 'Mario', 'food': ['mushrooms', 'goombas']},{'name': 'Luigi', 'food': ['mushrooms', 'turtles']}] # "Classic" Way def get_food(brothers_menu) -> set: temp = [] for brother in brothers_menu: for food in brother['food']: temp.append(food) return set(temp) # One liner way (Using list comprehension) set([food for bro in x for food in bro['food']]) 

{k: v for k, v in sorted(x.items(), key=lambda item: item[1])} 

dict(sorted(some_dictionary.items())) 

some_dict1.update(some_dict2) 

output ={} string = "a.b.c" path = string.split('.') target = reduce(lambda d, k: d.setdefault(k,{}), path[:-1], output) target[path[-1]] = 1 print(output) 

with open('file.txt', 'w') as file: file.write("My insightful comment") 

import json with open('file.json', 'w') as f: f.write(json.dumps(dict_var)) 

import os print(os.getcwd()) 

import os print(os.path.basename('/dir1/dir2/file1')) # Another way print(os.path.split('/dir1/dir2/file1')[1]) 

import os ## Part 1. # os.path.dirname gives path removing the end component dirpath = os.path.dirname('/dir1/dir2/file1') print(dirpath) ## Part 2. print(os.path.basename(dirpath)) 

def firstRepeatedCharacter(str): chars ={} for ch in str: if ch in chars: return ch else: chars[ch] = 0 

x = "itssssssameeeemarioooooo" y = ''.join(set(x)) 

def permute_string(string): if len(string) == 1: return [string] permutations = [] for i in range(len(string)): swaps = permute_string(string[:i] + string[(i+1):]) for swap in swaps: permutations.append(string[i] + swap) return permutations print(permute_string("abc")) 

from itertools import permutations [''.join(p) for p in permutations("abc")] 

>>> 'One, Two, Three' >>> 'well done' >>> 'cool' 

[i for i in range(1, 10)] 

class Node(object): def __init__(self, data): self.data = data self.next = None 

class LinkedList(object): def __init__(self): self.head = None 

ll = Linkedlist() ll.head = Node(1) ll.head.next = Node(2) ll.head.next.next = Node(3) 

def push_head(self, value): new_node = Node(value) new_node.next = self.head self.head = new_node 

def loop_exists(self): one_step_p = self.head two_steps_p = self.head while(one_step_p and two_steps_p and two_steps_p.next): one_step_p = self.head.next two_step_p = self.head.next.next if (one_step_p == two_steps_p): return True return False 

1. Limit all lines to a maximum of 79 characters. 2. Surround top-level function and class definitions with two blank lines. 3. Use commas when making a tuple of one element 4. Use spaces (and not tabs) for indentation 5. Use 4 spaces per indentation level 

@app.route('/') def home(): return 'main website' 

def home(): return 'main website' app.add_url_rule('/', view_func=home) 

[(1,), (2,), (3,)] 

[(0, 0, 0), (1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)] [] 

def add(num1, num2): return num1 + num2 def sub(num1, num2): return num1 - num2 def mul(num1, num2): return num1*num2 def div(num1, num2): return num1 / num2 operators ={'+': add, '-': sub, '*': mul, '/': div } if __name__ == '__main__': operator = str(input("Operator: ")) num1 = int(input("1st number: ")) num2 = int(input("2nd number: ")) print(operators[operator](num1, num2)) 

def wee(word): return word def oh(f): return f + "Ohh" >>> oh(wee("Wee")) <<< Wee Ohh 

Simple decorator: def deco(f): print(f"Hi I am the{f.__name__}() function!") return f @deco def hello_world(): return "Hi, I'm in!" a = hello_world() print(a) >>> Hi I am the hello_world() function! Hi, I'm in! 

def deco(f): def wrapper(*args, **kwargs): print("Rick Sanchez!") func = f(*args, **kwargs) print("I'm in!") return func return wrapper @deco def f(word): print(word) a = f("************") >>> Rick Sanchez! ************ I'm in! 

import time def deco(f): def wrapper(*args, **kwargs): before = time.time() func = f(*args, **kwargs) after = time.time() print(after-before) return func return wrapper @deco def f(): time.sleep(2) print("************") a = f() >>> 2.0008859634399414 

def n_times(n): def wrapper(f): def inner(*args, **kwargs): for _ in range(n): func = f(*args, **kwargs) return func return inner return wrapper @n_times(4) def f(): print("************") a = f() >>>************ ************ ************ ************ 

class Car: def __init__(self, model, color): self.model = model self.color = color def __eq__(self, other): if not isinstance(other, Car): return NotImplemented return self.model == other.model and self.color == other.color >> a = Car('model_1', 'red') >> b = Car('model_2', 'green') >> c = Car('model_1', 'red') >> a == b False >> a == c True