PYTHON2

class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __iter__(self):
        return self

    def next(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]


rev = Reverse('spam')
for char in rev:
     print char

--------------------------------------------------------------------------------------------------------------

class Kabel:
    def __init__(self,p1,p2):
        self.p1 = p1
        self.p2 = p2
    def __str__(self):
        return 'p1:{}, p2:{}'.format(self.p1,self.p2)
    def __repr__(self):
        return self.__str__()
    def __add__(self, other):
        return self.p1 + other.p1

k1 = Kabel(21,12)
k2 = Kabel(34,43)

print(k1.__add__(k2))

print(k1)



--------------------------------------------------------------------------------------------------------------


class Window():
    def __init__(self,wysokosc,szerokosc):
        self.wysokosc = wysokosc
        self.szerokosc = szerokosc
    def __str__(self):
        return 'Szerokosc: {} , wysokosc: {}'.format(self.wysokosc,self.szerokosc)
    def __repr__(self):
        return self.__str__()
    def __lt__(self,other):
        return self.wysokosc * self.szerokosc < other.wysokosc*other.szerokosc

ok1 = Window(6,5)
ok2 = Window(5,3)

windowslist = [ok1, ok2]
print(sorted(windowslist))



--------------------------------------------------------------------------------------------------------------

GEN PODSTTAWOWY

def my_generator(start ,stop,step):
    current_value = start
    while True:
        current_return = current_value
        if current_value <= stop:
            return
        current_value -= step
        yield current_return

my_gen = my_generator(start = 10, stop =2 ,step = 2)


for value in my_gen:
    print(value)


--------------------------------------------------------------------------------------------------------------

MOJ GEN


def my_generator(start ,stop,step):
    current_value = start
    while True:
        if start > 0:
            print("This is an odd number.")
            if step % 2 == 0:
                step = step + 1
                current_return = current_value
                if current_value <= stop:
                    return
                current_value -= step
                yield current_return
            else:
                current_return = current_value
                if current_value <= stop:
                    return
                current_value -= step
                yield current_return




my_gen = my_generator(start = 30, stop =2 ,step = 4)


for value in my_gen:
    print(value)







--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------






KLASY


class TempMeasurement:
    def __init__(self, temp_1, temp_2):       #<-- Konstruktorem wprowadzamy dane do klasy!!!
        self.temp_1 = temp_1
        self.temp_2 = temp_2
    def temp_combinations(self):
        output_list = []
        for i in range(self.temp_1+1):
            for j in range(self.temp_2 + 1):
                output_list.append((i,j))                #<-- W taki sposob mozna doadawc krotke do listy
        return output_list
    def __str__(self):              #<-- Przy printowaniu funkcji wyskoczy to co tu
        return "Temperatura 1: " + str(self.temp_1) + "Temperatura 2: " + str(self.temp_2)

temp_measurement_1 = TempMeasurement(2,3)

print(temp_measurement_1)
print(temp_measurement_1.temp_combinations())





--------------------------------------------------------------------------------------------------------------



class Measurment:
    def __init__(self, p1, p2):
        self.p1 = p1
        self.p2 = p2
    def __str__(self):
        return str(self.p1) + " " + str(self.p2)
    def __repr__(self):
        return self.__str__()
    def __lt__(self,other):           #<-- Definiuje w jaki sposob sort ma porownywac obiekty
        return self.p2 < other.p2


measure1 = Measurment(1, 5)
measure2 = Measurment(5, 4)
mesaures = [measure1, measure2]

print(sorted(mesaures))





--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------



GENERATORY



def counter(start, stop, step):
	current_value = start
	while True:
		current_return = current_value
		if current_value >= stop:
			return                  #<-- Return pozwala na wyjscie z nieskonczonej pętli
		current_value += step
		yield current_return


for i in counter(0, 10,2):
	print(i)





--------------------------------------------------------------------------------------------------------------




def my_generator(start ,stop,step):
    current_value = start
    while True:
        current_return = current_value
        if current_value <= stop:
            return
        current_value -= step
        yield current_return

my_gen = my_generator(start = 10, stop =2 ,step = 2)

for value in my_gen:
    print(value)




--------------------------------------------------------------------------------------------------------------


FUNKCJE WEW.

list = [1,2,3,4,5,6,7]
def my_multiply(number):
    def inner_func(list):
        return [number * item for item in list]
    return inner_func

number_1 = 2
number_2 = 5

list = [1,4,5,6]

inner_1 = my_multiply(number_1)

print(inner_1(list))


--------------------------------------------------------------------------------------------------------------




ef multiply_my(list):
    def inner(number):
        return [number * item for item in list]
    return inner

list = [1,5,2,5,2]
test = multiply_my(list)
print(test(5))



--------------------------------------------------------------------------------------------------------------




DEKORATORY



def my_decorator(func):
    def wrapper(arg):
        print("Hello Decorator")
        return func(arg)
    return wrapper


@my_decorator
def DecoratorTest(arg):
    def print_me():
        print(arg)
    return print_me()


DecoratorTest("Ten element bedzie dekorowany")





--------------------------------------------------------------------------------------------------------------





def my_decorator(func):
    def wrapper():
        print("Hello Decorator")
        return func()
    return wrapper

@my_decorator
def DecoratorTest():
    def print_me():
        print("Test")
    return print_me()

DecoratorTest("Ten element bedzie dekorowany")




--------------------------------------------------------------------------------------------------------------


XDDDDDDDDDDDDDDDDDDDDDDDDDDDD


def zad9(input_dict, input_list):
	for item in input_list:
		if item not in input_dict.keys():
			raise ValueError("Key " + str(item) + " does not exist.")

dict_1 = {'a': 5, 'b': 7, 'c': 4}
dict_2 = {'a': 5, 'b': 7, 'd': 5}
input_list = {'a', 'b', 'c'}

try:
    zad9(dict_2, input_list)
    print("Ok")
except ValueError as e:
    print("ValueError")
    print(e)
except Exception as e:
    print(e)


def our_decorator(input_function):
	def inner_function(*args):
		if len(args[0]) != len(args[1]):
			raise ValueError("Vectors must be the same length.")
		return input_function(*args)
	return inner_function


class VectorExample():
	def __init__(self, input_list):
		self.vector = input_list
	def __str__(self):
		return str(self.vector)
	@our_decorator
	def foreach(self, other, input_function):
		return VectorExample([input_function(self.vector[i], other.vector[i]) for i in range(len(self.vector))])
	def __add__(self, other):
		return self.foreach(other, lambda a, b: a + b)
	def __sub__(self, other):
		return self.foreach(other, lambda a, b: a - b)
	def __mul__(self, other):
		return self.foreach(other, lambda a, b: a * b)
	def __truediv__(self, other):
		return self.foreach(other, lambda a, b: a / b)
	def __len__(self):
		return len(self.vector)


vector_1 = VectorExample([1, 2, 3, 4])
vector_2 = VectorExample([-1, 3, -2, 1])
vector_3 = VectorExample([1, 2, 3, 0])
vector_4 = VectorExample([1, 2, 3])

print(vector_1)
print(vector_2)
print(vector_1 + vector_2)
print(vector_1 - vector_2)
print(vector_1 * vector_2)
print(vector_1 / vector_2)


try:
	print(vector_1 / vector_2)
	print("Success")
except Exception as e:
	print(e)

print(vector_1 + vector_4)

print("The End")