инфо

#нет переменных есть ссылки на значения(имена)
#язык не строгой статической типизации(не C, C++)


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

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

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

#Арифметика 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))

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

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

#Сравнение
== , >=,>,<,<=,!=
--------------------------------------------------------------------------------------------------------------------------------------------------------

#Вывод ======> Функция print
print('Hello world!!!') #Hello world!!!
print('Hello \"world\"!!!') #Hello "world"!!!
--------------------------------------------------------------------------------------------------------------------------------------------------------

#Преобразование переменных при вводе
a, b, c = map(int, input().split())
--------------------------------------------------------------------------------------------------------------------------------------------------------

# на вход подаётся строка
# 1 2 3
s = input() # s == '1 2 3'
a = s.split() # a == ['1', '2', '3']
print(a)
--------------------------------------------------------------------------------------------------------------------------------------------------------


#Цикл FOR
#for
for j in "hello world":
print(j*2, end = ' ')

#Остановка for
for j in 'Hello world':
if j == 'w':
break
print(j*2, end = '')

#Пропуск указанной буквы
for j in 'Hello world':
if j == 'w':
continue
print(j*2, end = '')

for i in range(0, -7 , -1):#range(начало , конец(всегда на 1 меньше([0,-1,-2,-3,-4,-5,-6])), шаг)
print(i)

for i in range(1,6):#1 ==> 5
--------------------------------------------------------------------------------------------------------------------------------------------------------

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

#списки (тип list) (не массив)
k = []
lis = [1 , 2, 'x', 88]
k = lis
print (k)
l = []
print(l)
len(L) – возвращает число элементов в списке L
max(L) – возвращает максимальное значение в списке L
min(L) – возвращает минимальное значение в списке L
sum(L) – возвращает сумму значений в списке L
sorted(L) – возвращает копию списка L, в котором элементы упорядочены
по возрастанию. Не изменяет список L



>>> colors=['red', 'orange', 'green']
>>> colors.extend(['black','blue']) # расширяет список списком
>>> colors
['red', 'orange', 'green', 'black', 'blue']
>>> colors.append('purple') # добавляет элемент в список
>>> colors
['red', 'orange', 'green', 'black', 'blue', 'purple']
>>> colors.insert(2,'yellow') # добавляет элемент в указанную позицию
>>> colors
['red', 'orange', 'yellow', 'green', 'black', 'blue', 'purple']
>>> colors.remove('black') # удаляет элемент из списка
>>> colors
['red', 'orange', 'yellow', 'green', 'blue', 'purple']
>>> colors.count('red') # считает количество повторений аргумента метода
1
>>> colors.index('green') # возвращает позицию в списке аргумента метода
3
>>> colors
['red', 'orange', 'yellow', 'green', 'blue', 'purple']
>>> colors.pop() # удаляет и возвращает последний элемент списка
'purple'
>>> colors
['red', 'orange', 'yellow', 'green', 'blue']
>>> colors.reverse() # список в обратном порядке
>>> colors
['blue', 'green', 'yellow', 'orange', 'red']
>>> colors.sort() # сортирует список (вспомните о сравнении строк)
>>> colors
['blue', 'green', 'orange', 'red', 'yellow']
>>> colors.clear() # очищает список. Метод появился в версии 3.3. Аналог del color[:]
>>> colors
[]
#Задание списка
a = []
for i in range(1,15):
a.append(i)
print( a)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1

#Рамки массива
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 = ' ')

b = [22 , 11 , 11]
print ("b = " + str(b))

#extend - соединение списков
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)


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


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

#Сортировка списка по возрастанию и убыванию
l.sort()
print(str(l)+"сортировка по возрастанию ")
l.reverse()
print(str(l)+"сортировка по убыванию ")
#Len - кол-во элементов в списке
len(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


#lambda
l = [1, 2, 3, 4, 5, 6, 7]
list(map(lambda x: x**3, l))
print(l) [1, 8, 27, 64, 125, 216, 343]

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



#Срезы —-------— #item[start:stop:step]
l = [34, 'sd', 56, 34.34]
print(l[:3])#исчезнет 34.34, тк l[3] = 34.34
--------------------------------------------------------------------------------------------------------------------------------------------------

#Пример интересного вывода —> sep
n = int(input())
for i in range(n):
print(i+1, i+2 ,sep = ' ')
# вывод пар чисел с промежутком, указанным в sep



#модуль черепаха
import turtle
turtle.reset()

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

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





#модуль graphics
import graphics as gr
window = gr.GraphWin("war-136",300, 300) #создание окна для рисовалки



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



#Словари (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}
# удобство в том, кто под ключом можно создавать еще списки


#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()
#Пример (делится ли число на 10)

#V1 ==> if
x = int(input( ))
if (x % 10 == 0):
flag = True

#V2
x = int(input())
flag = (x % 10 == 0)



#Пример (есть ли в последовательности чисел число которое делится на 10)
flag = False
n = int(input())
for i in range(n):
x = int(input())
flag = (x % 10 == 0) or flag
#Если flag был хоть один раз True, то он True до конца
#Надо поднять и держать flag если такое число есть
print(flag)



#Пример(есть ли в последовательности чисел число которое не делится на 10)
flag = True
n = int(input())
for i in range(n):
x = int(input())
flag = (x % 10 == 0) and flag
#Если flag был хоть один раз False, то он False до конца
#Надо опустить flag если такое число есть
print(flag)




#Работа с фалами 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()



#Функции
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 не
было бы
'''
--------------------------------------------------------------------------------------------------------------------------------------------------
#Комплексные числа
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
#комплексные числа можно сравнивать


#Тип объекта
type(имя_переменной)




#Динамическое программирование
#Кузнечик от 1 до n с ходом +1 и +2
#допрыгать до n используя +1 и +2 можно только из n-1(+1) и n-2(+2) =>
#K(n) = K(n-1)+K(n-2) —-> рекурентная функция
def traj_num(N):
K =[0,1] + [0]*N
for i in range(2,N+1,1):
K[i] = K[i-2] + K[i -1]
return K[n]
#Если нельзя наступать на определённые клетки и есть вариант +3
def count_trajectories(N,allowed:list): #allowed - массив из позволенных для шага клеток
K =[0,1,int(allowed[2])] + [0] * N-3
for i in range(3,N+1,1):
if allowed[i]: #if True
K[i] = K[i-1] + K[i-2] + K[i-3]
return K[N]