bregman-arie/python-exercises

print("Hello Amazing", end=" ")
print("World")

print(x + y)
print(x - y)

x = int(input())

if x % 2 == 0:
    print("yay")
else:
    print("nay")

for i in range(n + 1):
    print(i)

for i in range(n + 1):
   if i % 2 == 0:
       print(i)

class SomeClass:
    pass

[int(i) for in in "2 0 1 7".split()]

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!

while True:
    try:
        a = int(input("please enter an integer value: "))
        break
    except ValueError:
        print("Ops! Please enter a valid integer value.")

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

f = Foo()
f()

Called!

x = lambda a: a + 10
print(x(10))

addition = lambda x, y: x + y
print(addition(10, 20))

square = lambda x : x ** 2
print(square(5))

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

ImAString.count(" ")

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