byaj

#нет переменных есть ссылки на значения(имена)
#язык не строгой статической типизации(не C, C++)
#В Python нет ни begin, ни end, ни {} ====> все выполняется Tab

'''
многострочные
коментарии
'''

#Duck typing - Если это выглядит как утка, плавает как утка и
#крякает как утка, то это, вероятно, и есть утка.
#Пример ===> Сравнение 'adc' и 'abd'
# 'abc' < 'abd' - идет сравнение символов - кто старше (дальше в алфавите, тот и сильнее)



#В Python div и mod нормальные
#-11 // 5 = -3
#-11 % 5 = 4



#Арифметика c приоритетом
#1
('2^2 = '+ str(2**2))
('a^(b^c) = ' + str(a**b**c)) #выполнение операций справа налево
#2
('-(x) = ' + str(-x))
#3
('2 / 2 = '+ str(2/2))
('5 mod 2 = '+ str(5%2))
('2 div 2 = '+ str(2//2))
('2 * 2 = '+ str(2*2))
('a / b * c' + str(a/b*c)) #(a/b)*c
#4
('2 + 2 = '+ str(2+2))
('3 - 2 = ' + str(3 - 2))


#boolean - Алгебра логики в питоне
my_bool_true = True
my_bool_true = bool(10)
my_bool_true = bool('some')

my_bool_false = False
my_bool_false = bool(0)
my_bool_false = bool('')
my_bool_false = bool()





#Вывод ==> print
print('Hello world!') #вывод => Hello world!
#печать "" в python
print('Hello \"world\"!') #вывод => Hello "world"!
#Raw strings
print(r"Hello \nWorld!") #вывод => Hello \nWorld! -> вывел и \n
#Формат вывода
print("%10d" % (10)) #вывод => ********10 (пробел вместо *) (d == int, как в С++)
print(4 / 3) #вывод => 1.3333333333333333
print("%.4f" % (4/3)) #вывод => 1.3333 (% кол-во_целых_чисел . кол-во_чисел_после_запятой тип_числа) (f == float, как в С++)
print("%.4f, %.2f" % (1.33334, 153*0.43)) #вывод => 1.3333, 65.79
#Формат ==> format
print("{}, {} and {}".format('one', 1, 'I')) #вывод => 'one, 1 and I' (вместо {} вставлются значения после format)
print("{1}, {2} and {0}".format('one', 1, 'I')) #вывод => '1, I and one' (вставка по индексу one = 0, 1 = 1, I = 2)

left = "fork"
right = "knife"
print(f"Rules: left = {left}, right = {right}")#вывод => Rules: left = fork, right = knife (также вызов по формату, но с известнми переменнми)
#end and sep
#end == конец
list_for_example = [1, 2, 3, 4]
for i in range( len( list_for_example )):
print( list_for_example[i], end =' ' )
"""
вывод:
1 2 3 4
при помощи end можно выводить каждый элемент не с новой строки, а по интервалу в end
"""

#sep == separate == разделять
list_for_example = [1, 2, 3, 4]
for i in range(len(list_for_example) - 1):
print(list_for_example[i],list_for_example[i+1], sep = ' ')
"""
вывод:
1 2
2 3
3 4
при помощи sep можно задовать интервал между выводимыми элементами
"""



#Ввод = input
n = input() #ввод значения переменной n с клавиатуры
n = int(input()) #при вводе с клавиатуры, значение переделывается в integer при помощи int перед input()
a,b = input().split() #ф-ция split() для разделения введенных значений
"""
у а и b свои значения
ввод:
1 2
a = 1
b = 2
"""
#как переделать несколько вводимых значений к типу int ===> map
a, b = map(int, input().split())#ф-ция map берет ф-цию как 1 аргумент и преминяет её ко всем объектам 2 аргумента
s = input().split() #ввод: 1 2 3, тогда s = [1, 2, 3]
#связь split и join
x = str.split("apple, orange, pear", ", ") #['apple', 'orange', 'pear']
x = str.join(" <|=|> ", x) #apple <|=|> orange <|=|> pear
x = "apple, orange, pear".split(", ") #['apple', 'orange', 'pear']
x = " ? ".join(x) #apple ? orange ? pear


#Комплексные числа
complex(x,y) #=====> x + yj (где x - реальная,y - мнимая)
z = complex(x,y) #====> z = x +yj
z.conjugate #======> z = x - yj ---> обратное
z.imag #======> y
z.real #=======> x
#комплексные числа можно сравнивать


#Циклы
#работа цикла for
#берется переменная - первопроходец
#и идёт по определённой последовательности
#for
for j in "hello world":
print(j*2, end = ' ')
"""
вывод:
hh ee ll ll oo ww oo rr ll dd
"""
#Остановка for - break (бряк) при определённых условиях останавливает цикл
for j in 'Hello world':
if j == 'w':
break
print(j*2, end = '')
"""
вывод:
HHeelllloo
"""
#Пропуск указанной буквы - continue (продолжать) пропускает итерацию
for j in 'Hello world':
if j == 'w':
continue
print(j*2, end = '')
"""
вывод:
HHeelllloo oorrlldd
пропущенна буква w
"""
#Сам for c рассписыванием шага
for i in range(0, -7 , -1):#range(начало , конец(всегда на 1 меньше([0,-1,-2,-3,-4,-5,-6])), шаг)
print(i)
#работа цикла while
#while истинное_выражение
i = 3
while i > 0:
print(i, end = ' ')
i -= 1
"""
вывод:
3 2 1
пока i > 0
"""




#Список - последовательность элементов (в списке можно хранить несколько типов данных === отличие от массивов)
#Индексы элементов --> [0, len(list) - 1]
#Обозначение
k = [1 , 2, 'x', 88]
k = list(1 , 2, 'x', 88)

#len - кол-во элементов в списке
len(l)

#Рамки списка
a = [n]*m # списка на m элементов , начальное значение элементов - n
a = [n] + [n] + [n]... --> m раз #конкатинация

#Задание случайного элемента в списке и их вывод
a = [randint(0,100) for i in range(0,n)]
for i in range(0,n,1):
print(a[i], end = ' ')


#append - добавление элемента в конец списка
l = []
print("Добавление элементов 23 и 34 в l")
l.append(23)
l.append(34)
print (l)


#extend - соединение списков
b = [1]
l. extend(b)
print ("L + B = " + str(l))



#вставить элемент по индексу
n = int(input("Введите номер индекса для элемента 666 "))
l.insert(n,666)
print(l)



#удаление элемента равного значению в ()
g =int(input("Введите значение для его удаления "))
l.remove(g)
print (l)


#удаление i-го элемента (если ()- пуста, то
#функция удаляет последний элемент)
l.pop(0)
print (l)


#вывод индекса элемента
print("вывод индекса элемента, равного 22")
print(l.index(22))


#Колличество элементов, равным значению в ()
print("Колличество элементов, равных 11")
print(l.count(11))

#Сортировка списка по возрастанию
l.sort()
print(str(l)+"сортировка по возрастанию ")



#заполнение списка
a = []
n = int(input('Введите кол-во элементов в массиве: ')) # считываем количество элемент в списке
for i in range(n):
n_e = int(input()) # считываем введенный элемент
a.append(n_e) # добавляем его в список
print(a)

#Заполнение массива в строку с n элементами
a = input().split()
for i in range(n):
a[i] = int(a[i])

#ф-ция join
a = ['red', 'green', 'blue']
print(' '.join(a))
# вернёт red green blue
print(''.join(a))
# вернёт redgreenblue
print('***'.join(a))
# вернёт red***green***blue


#list comprehentions
a = [x**2 for x in range(10)]
# эквивалентно
a=[]
for x in range(10):
a.append(x**2)

#Пример
a = [1,2,3,4,5,6,7,12,11,4,5,7]
b = []
for i in a:
if x % 2 == 0:
b.append(x**2)
#эквивалентно
a = [1,2,3,4,5,6,7,12,11,4,5,7]
b = [x**2 for x in a if x % 2 == 0 ]





#модуль черепаха - просто по приколу
import turtle
turtle.reset()

#задержка экрана
turtle.getscreen()._root.mainloop()

#Закрашивание
turtle.color("black")
turtle.begin_fill()
turtle.end_fill()




#Срезы
#item[START:STOP:STEP] берёт срез от номера START, до STOP (не включая его), с шагом STEP
a = [1, 3, 8, 7]
print(a[:]) #вывод => [1, 3, 8, 7]
print(a[1:]) #вывод => [3, 8, 7]
print(a[::2]) #вывод => [1, 8]




#Кортежи(tuple) - списки, которые нельзя изменять, но весят кортежи меньше
a = (43, 56, 45.23, 'd')#- кортеж
b = [43, 56, 45.23, 'd']#- список
#проверка на затрату памяти
print(a.__sizeof__() ) #28
print(b.__sizeof__() ) #36
a = tuple("hello world")
print(a) #вывод => ('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')





#Словари (dict)
d = {1: 265} #В словаре вместо i-того элемента берется ключ ===> d = {ключ : элемент}
d = dict (popp = 265) #В словаре вместо i-того элемента берется ключ ===> d = dict ('ключ' = элемент)
print(d)
d['popp'] = 1 # переприсваивание значения элемента с ключом popp
print(d)

print(d[1]) #Вывод элемента под ключём
print(d) # {1:265} - вывод элементов с ключами


d = dict ([( 23,54 ) , (24,55) ])
print(d) # вывод {23: 54, 24: 55}

d = dict.fromkeys (['a' , 'b']) # создание ключей
d = dict.fromkeys (['a' , 'b'], 1 ) # присваивание ключам одно занчение ===> {'a':1 , 'b':1}
# удобство в том, кто под ключом можно создавать еще списки

#добавление эл-тов в словарь => ф-ция update
x = {"one": 1, 2: "two"}
print(x) #{'one': 1, 2: 'two'}
x.update({"three": 3})
print(x) #{'one': 1, 2: 'two', 'three': 3}






#Работа с фалами input и output
fin = open("input.txt")
fout = open("output.txt","w")

a, b = map(int, fin.readline().split())
fout.write(str(a+b))

fin.close()
fout.close()



#Ф-ция ord - возвращает числовое представление для указанного символа
ord('A') # 65
ord('1') # 49




#Функции
def название_функции(элементы функции): #Лучше длинные названия,
#для лёгкого чтения в будущем
"""
Многострочная
Документ
Строка
""" #при вызове help выведится документ строка ==> help(название_функции)
тело функции
return результат функции


def func(x,a):
res = x + a
return res
print(func('Hello',' World')) #Hello World



def func(*args):
return args
func(1, 2, 3, 'abc') #Вывод ===> (1, 2, 3, 'abc')



def func(**kwargs):
return kwargs
func(a=1, b=2, c=3) #Вывод ===> {'a': 1, 'c': 3, 'b': 2}


#Функции можно приравнивать
def h():
print('Hello')
f = h
f() #вывод ==> Hello


def Max2(x,y):
if x > y:
return x
return y
'''
можно не ставить else, ведь
если бы if сработал, то второго return не
было бы
'''







#Объектно-ориентированное программирование
#Создаём класс под именем Demo
class Demo:
one = 42
two = "heyho"
def three(self):
return self

x = Demo.one #имя_класса.объект_в_классе
print(x) #42
x = Demo.two
print(x)# 'heyho'
x = Demo.three
print(x) # <function Demo.three at 0x00F69B70>
demo = "x"
x = Demo.three(demo) is demo # "x" == "x"
demo = Demo()
x = demo.three() is demo #<__main__.Demo object at 0x006CAFD0> is <__main__.Demo object at 0x006CAFD0>


#Создаём класс под именем Demo2 и наследуем объекты из Demo
class Demo2(Demo):
two = "lol"

x = Demo2.one #42
x = Demo2.two #"lol" , not "heyho"
demo2 = Demo2()
x = demo2.three() is demo2




#создаём класс Shape c функцией volume, которая будет возвращать ошибку
class Shape:
def volume(self):
raise NotImplementedError("Volume is not implemented")



#создаём класс Сuboid c наследованием Shape
class Cuboid(Shape):
"""
метод __init__
данный метод принимает 3 значения и
записывает их как отсортированный список
в переменную self.dimenions
"""
def __init__(self, width, height, depth):
self.dimensions = sorted([width, height, depth])

"""
ф-ция volume
расчёт объема
"""
def volume(self):
d = self.dimensions
return d[0] * d[1] * d[2]
"""
метод __eq__
данный метод сравнивает два значения -> self и other
"""
def __eq__(self, other):
return self.dimensions == other.dimensions


#Примеры
x = Cuboid(1, 2, 3).volume()
print(x) #6
x = Cuboid(1, 2, 3) == Cuboid(1, 3, 2) #[1, 2, 3] == [1, 2, 3] т.к списки сортируются
print(x) #True


#создаём класс Сylinder c наследованием Shape
class Cylinder(Shape):
"""
метод __init__
данный метод принимает 2 значения и
записывает их в переменные
self.radius и self.height
"""
def __init__(self, radius, height):
self.radius = radius
self.height = height

"""
ф-ция volume
расчёт объема
"""
def volume(self):
pi = 3.1415
return pi * self.radius ** 2 * self.height


class Body(Shape):
"""
метод __init__
данный метод принимает 2 значения и
записывает их как отсортированный список
в переменную self.dimenions
"""
def __init__(self, density):
self.density = density
"""
ф-ция mass
расчёт массы
"""
def mass(self):
return self.density * self.volume()

print(Body(density=1000).mass()) #NotImplementedError: Volume is not implemented



class Brick(Cuboid, Body):
def __init__(self, width, height, depth, density):
Cuboid.__init__(self, width, height, depth)
Body.__init__(self, density)

x = Brick(1, 2, 3, 1000).mass()


class Pillar(Cylinder, Body):
def __init__(self, radius, height, density):
Cylinder.__init__(self, radius, height)
Body.__init__(self, density)

x = Pillar(1, 1, 1000).mass()

x = Pillar.__mro__ #метод __mro__ показывает все наследованные классы
x = Brick.__mro__#метод __mro__ показывает все наследованные классы


# P.S Almost nobody actually uses multiple inheritance if there are
class SaneBody:
def __init__(self, shape, density):
self.shape = shape
self.density = density

def mass(self):
return self.shape.volume() * self.density

def volume(self):
# Even if we do need a volume we implement it like this
return self.shape.volume()


class SaneBrick(SaneBody):
def __init__(self, width, height, depth, density):
SaneBody.__init__(self, Cuboid(width, height, depth), density)






golden_card = {"owner": "J.Bergstein",
"rank": "golden",
"points": 0}

bronze_card = {"owner": "A.White",
"rank": "bronze",
"points": 0}


def apply_points(card, price):
points_used = card["points"] if card["points"] < price else price
card["points"] -= points_used
return price - points_used


def apply_sale(card, price):
if card["rank"] == "bronze":
sale = 0.02
elif card["rank"] == "silver":
sale = 0.05
elif card["rank"] == "golden":
sale = 0.1
else:
sale = 0
return price * (1 - sale)


def score_points(card, price):
if card["rank"] == "bronze":
point_factor = 0.02
elif card["rank"] == "silver":
point_factor = 0.03
elif card["rank"] == "golden":
point_factor = 0.05
if price >= 10000:
point_factor *= 2
else:
point_factor = 0.01
card["points"] += price * point_factor


def transact(card, initial_price, use_points=False):
final_price = initial_price
if use_points:
final_price = apply_points(card, final_price)
final_price = apply_sale(card, final_price)
score_points(card, final_price)
return final_price


def print_cashiers_check(price, card, use_points=False):
print("=" * 20)
print("Total price:")
print(transact(card, price, use_points))
if card["rank"] == "golden":
print("Have a nice day")
print(card["owner"])
print("=" * 20)


print_cashiers_check(150, golden_card)
print_cashiers_check(15000, golden_card)
print_cashiers_check(150, golden_card, use_points=True)
print_cashiers_check(100, bronze_card)

broken_card = {"lol": "no"}
try:
print_cashiers_check(100, broken_card)
except Exception as e:
pass


def create_card(owner, rank):
return {
"owner": owner,
"rank": rank,
"points": 0
}


print_cashiers_check(100, create_card("J.K.Chan", "silver"))
# still could screw up assigning rank

# What if we want to add platinum card? if/else apocalypse
# Solution to group if/else in one bundle?

# We will re-define all functions, and remove old ones just so we catch an exception if we forget something
del create_card
del print_cashiers_check
del transact
del apply_sale
# del apply_points - doesn't change
del score_points


def create_plebian_card(owner):
card = {
"owner": owner,
"rank": None,
"points": 0,
"sale": 0,
"point_factor": 0.01,
# add available actions on cards
"apply_points": apply_points,
"apply_sale": apply_sale,
"score_points": score_points,
"transact": transact
}
return card


def apply_sale(card, price):
return price * (1 - card["sale"])


def score_points(card, price):
card["points"] += price * card["point_factor"]


def transact(card, initial_price, use_points=False):
final_price = initial_price
if use_points:
final_price = card["apply_points"](card, final_price)
final_price = card["apply_sale"](card, final_price)
card["score_points"](card, final_price)
return final_price


def print_cashiers_check(price, card, use_points=False):
print("=" * 20)
print("Total price:")
print(card["transact"](card, price, use_points))
if card["rank"] == "golden":
print("Have a nice day")
print(card["owner"])
print("=" * 20)


plebian = create_plebian_card("Simpleton")
print_cashiers_check(150, plebian)
print_cashiers_check(15000, plebian)
print_cashiers_check(150, plebian, use_points=True)


def create_bronze_card(owner):
card = create_plebian_card(owner)
card["rank"] = "bronze"
card["sale"] = 0.02
card["point_factor"] = 0.02
return card


bronze = create_bronze_card("E.R.Normalguy")
print_cashiers_check(150, bronze)
print_cashiers_check(15000, bronze)
print_cashiers_check(150, bronze, use_points=True)


def create_silver_card(owner):
card = create_plebian_card(owner)
card["rank"] = "silver"
card["sale"] = 0.05
card["point_factor"] = 0.03
return card


silver = create_silver_card("J.Wealthy")
print_cashiers_check(150, silver)
print_cashiers_check(15000, silver)
print_cashiers_check(150, silver, use_points=True)


def score_points_golden(card, price):
point_factor = card["point_factor"]
if price >= 10000:
point_factor *= 2
card["points"] += price * point_factor


def create_golden_card(owner):
card = create_plebian_card(owner)
card["rank"] = "golden"
card["sale"] = 0.1
card["point_factor"] = 0.05
card["score_points"] = score_points_golden
return card


golden = create_golden_card("L.R.Hampton III")
print_cashiers_check(150, golden)
print_cashiers_check(15000, golden)
print_cashiers_check(150, golden, use_points=True)


class Card:

def __init__(self, owner):
self.owner = owner
self.sale = 0.0
self.point_factor = 0.01
self.points = 0

def apply_points(self, price):
points_used = self.points if self.points < price else price
self.points -= points_used
return price - points_used

def apply_sale(self, price):
return price * (1 - self.sale)

def score_points(self, price):
self.points += price * self.point_factor

def transact(self, initial_price, use_points=False):
final_price = initial_price
if use_points:
final_price = self.apply_points(final_price)
final_price = self.apply_sale(final_price)
self.score_points(final_price)
return final_price


class BronzeCard(Card):

def __init__(self, owner):
Card.__init__(self, owner)
self.sale = 0.02
self.point_factor = 0.02


class SilverCard(Card):

def __init__(self, owner):
Card.__init__(self, owner)
self.sale = 0.05
self.point_factor = 0.03


class GoldenCard(Card):

def __init__(self, owner):
Card.__init__(self, owner)
self.sale = 0.1
self.point_factor = 0.05

def score_points(self, price):
point_factor = self.point_factor
if price >= 10000:
point_factor *= 2
self.points += price * point_factor


def print_cashiers_check(price, card=None, use_points=False):
if card is None:
card = Card("")
print("=" * 20)
print("Total price:")
print(card.transact(price, use_points))
if isinstance(card, GoldenCard):
print("Have a nice day")
print(card.owner)
print("=" * 20)


golden_card = GoldenCard("J.Bergstein")
print_cashiers_check(150, golden_card)
print_cashiers_check(15000, golden_card)
print_cashiers_check(150, golden_card, use_points=True)
bronze_card = BronzeCard("A.White")
print_cashiers_check(150, bronze_card)
print_cashiers_check(150)


x = type(golden_card)
x = x == GoldenCard