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

In the following block of code x is a class attribute while self.y is a instance attribute

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!

Exceptions: Errors detected during execution are called Exceptions.

Handling Exception: When an error occurs, or exception as we call it, Python will normally stop and generate an error message.
Exceptions can be handled using try and except statement in python.

Example: Following example asks the user for input until a valid integer has been entered.
If user enter a non-integer value it will raise exception and using except it will catch that exception and ask the user to enter valid integer again.

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

For more details about errors and exceptions follow this https://docs.python.org/3/tutorial/errors.html

It is used to emulate callable objects. It allows a class instance to be called as a function.

• Example code:

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

f = Foo()
f()

• Result:

Called!

A lambda expression is an 'anonymous' function, the difference from a normal defined function using the keyword `def`` is the syntax and usage.

The syntax is:

lambda[parameters]: [expresion]

Examples:

• A lambda function add 10 with any argument passed.

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

• An addition function

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

• Squaring function

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

Generally it is considered a bad practice under PEP 8 to assign a lambda expresion, they are meant to be used as parameters and inside of other defined functions.

x, y = y, x

First you ask the user for the amount of numbers that will be use. Use a while loop that runs until amount_of_numbers becomes 0 through subtracting amount_of_numbers by one each loop. In the while loop you want ask the user for a number which will be added a variable each time the loop runs.

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

• One item:

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

• Multiple items or list:

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)

Or without creating a new list:

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)

Another way:

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)

Using range like this

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

Another way is using slicing

for i in some_list[1:]:

Method 1

for i in reversed(li):
    ...

Method 2

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

or

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

nums = [1, 2, 3]
letters = ['x', 'y', 'z']

list(zip(nums, letters))

From Docs: "List comprehensions provide a concise way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable, or to create a subsequence of those elements that satisfy a certain condition.".

It's better because they're compact, faster and have better readability.

• For loop:

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)

• List comprehesion:

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

While you iterate through the characters, store them in a dictionary and check for every character whether it's already in the dictionary.

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

Short way (but probably not acceptable in interviews):

from itertools import permutations

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

Detailed answer can be found here: http://codingshell.com/python-all-string-permutations

You can use the "count" method like this:

ImAString.count(" ")

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

One way is:

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

The reason we need to implement in the first place, it's because a linked list isn't part of Python standard library.
To implement a linked list, we have to implement two structures: The linked list itself and a node which is used by the linked list.

Let's start with a node. A node has some value (the data it holds) and a pointer to the next node

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

Now the linked list. An empty linked list has nothing but an empty head.

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

Now we can start using the linked list

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

What we have is:

| 1 | -> | 2 | -> | 3 |

Usually, more methods are implemented, like a push_head() method where you insert a node at the beginning of the linked list

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

Let's use the Floyd's Cycle-Finding algorithm:

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

PEP8 is a list of coding conventions and style guidelines for Python

5 style guidelines:

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

There are multiple ways to map a URL with a function in Python.

• Decorator: you can use python decorators. In this case we're using app. This app decorator is the instance of the Flask class. And route it's a method of this class.

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

• add_url_rule method: This is a method of the Flask class. We can also use it for map the URL with a function.

def home():
  return 'main website'

app.add_url_rule('/', view_func=home)