Add Python notes

python/sqlalchemy/core.py

@@ -64,7 +64,9 @@ with engine.begin() as conn:
 # SELECT
 from sqlalchemy import select
 
-stmt = select(user_table).where(user_table.c.name == 'spongebob')
+stmt = select(user_table).where(user_table.c.name == 'spongebob')  # Where accepts binary expression
+print('Where clause: ', user_table.c.name == 'spongebob')
+print('Type of where clause: ', type(user_table.c.name == 'spongebob'))
 with engine.connect() as conn:
     for row in conn.execute(stmt):
         print(row)

python/sqlalchemy/orm.py

@@ -44,11 +44,86 @@ engine = create_engine("sqlite+pysqlite:///:memory:", future=True)
 Base.metadata.create_all(engine)
 
 
+session = Session(engine)
+
+
+# INSERT
+print('-----insert-----')
+squidward = User(name="squidward", fullname="Squidward Tentacles")
+krabs = User(name="ehkrabs", fullname="Eugene H. Krabs")
+spongebob = User(name='spongebob', fullname='Spongebob Squarepants')
+
+session.add(squidward)
+session.add(krabs)
+session.add(spongebob)
+print('new: ', session.new)
+
+saved_krabs = session.get(User, 2)
+print('krabs: ', saved_krabs)
+print('krabs is krabs: ', saved_krabs is krabs)
+session.commit()  # All changes are applied only after commit
+
+
 
 
 # SELECT
+print('-----select-----')
 from sqlalchemy import select
-stmt = select(User).where(User.name == 'spongebob')
+
-with Session(engine) as conn:
+stmt = select(User)
-    for row in conn.execute(stmt):
+first = session.execute(stmt).first()
-        print(row)
+print(firs)
+
+_all = session.execute(stmt).scalars().all()
+print(_all)
+
+
+
+# UPDATE
+print('-----update-----')
+from sqlalchemy import update
+
+# Unit of work
+squid = session.execute(select(User).filter_by(name='squidward')).scalar_one()
+print('fetched squidward: ', squid)
+squid.fullname = 'Squidward Octopus'
+print('squid modified: ', squid in session.dirty)
+print('new squid status: ', session.execute(select(User).where(User.name == 'squidward')).first())
+
+# ORM enabled
+session.execute(
+    update(User).
+    where(User.name == "squidward").
+    values(fullname="Sandy Octopus Extraordinaire")
+)
+print('Squid after bulk update: ', squid.fullname)
+
+
+
+# DELETE
+print('-----delete-----')
+from sqlalchemy import delete
+
+krabs = session.get(User, 2)
+session.delete(krabs)
+session.execute(select(User).where(User.name == "ehkrabs")).first()
+print('Krabs present: ', krabs in session)
+
+# orm-enabled
+squidward = session.get(User, 1)
+session.execute(delete(User).where(User.name == "squidward"))
+print('Squidward present: ', squidward in session)
+
+
+
+# ROLLBACK
+print('-----rollback-----')
+print(squid.__dict__)
+session.rollback()
+print(squid.__dict__)
+squid.fullname
+print(squid.__dict__)
+print('Krabs present: ', krabs in session)
+
+
+session.close()

python/графы/дейкстра.py

@@ -0,0 +1,122 @@
+graph = {
+	1: {
+		2: 7,
+		3: 9,
+		6: 14
+	},
+	2: {
+		1: 7,
+		3: 10,
+		4: 15
+	},
+	3: {
+		1: 9,
+		2: 10,
+		4: 11,
+		6: 2
+	},
+	4: {
+		2: 15,
+		3: 11,
+		5: 6,
+	},
+	5: {
+		4: 6,
+		6: 9,
+	},
+	6: {
+		1: 14,
+		5: 9,
+		3: 2
+	}
+}
+
+
+class GraphPoint:
+	def __init__(self, graph, number, routes):
+		self.graph = graph
+		self.number = number
+		self.routes = routes
+		self.visited = False
+		self.minimum_range = 9999
+
+
+	def get_unvisited_neighbours(self):
+		neighbours = []
+		for number in self.routes.keys():
+			point = self.graph.get_point(number)
+			if not point.visited:
+				neighbours.append(point)
+		return neighbours
+
+
+	def get_range(self, point):
+		return self.routes[point.number]
+
+
+	def get_all_neighbours(self):
+		neighbours = [self.graph.get_point(x) for x in self.routes.keys()]
+		return neighbours
+
+
+
+class Graph:
+	def __init__(self, data):
+		self.data = data
+		self.points = {}
+
+		for number, routes in data.items():
+			self.points[number] = GraphPoint(self, number, routes)
+
+		self.points[1].minimum_range = 0
+
+
+	def get_point(self, number):
+		point = self.points.get(number)
+
+		if point is None:
+			raise ValueError(f"Graph has no point with number {number}")
+
+		return point
+
+
+
+myGraph = Graph(graph)
+
+
+start = myGraph.get_point(1)
+queue = []
+queue.append(start)
+
+
+while len(queue) > 0:
+	current_point = min(queue, key=lambda x: x.minimum_range)
+	queue.remove(current_point)
+	current_point.visited = True
+
+	for neighbour in current_point.get_unvisited_neighbours():
+		new_range = current_point.minimum_range + current_point.get_range(neighbour)
+
+		if new_range < neighbour.minimum_range:
+			neighbour.minimum_range = new_range
+
+		queue.append(neighbour)
+
+
+
+path = []
+pos = myGraph.get_point(5)
+
+
+while pos != start:
+	for neighbour in pos.get_all_neighbours():
+		if neighbour.get_range(pos) + neighbour.minimum_range == pos.minimum_range:
+			path.append(pos)
+			pos = neighbour
+			break
+
+path.append(start)
+
+for i in path[::-1]:
+	print(i.number)
+# No comments here. Good l_ck!

python/графы/поиск в глубину.py

@@ -0,0 +1,176 @@
+# Матрица смежности
+# [y][x] - существование пути (ребра) из y в x (опционально - вместо существования bool вес int)
+# При нумерации с 1 при этом методе существует несоответствие номеров узлов и индексов (индекс = номер - 1)
+graph = (
+	(0, 1, 1, 0, 0, 0, 1),
+	(1, 0, 1, 1, 0, 0, 0),
+	(1, 1, 0, 0, 0, 0, 0),
+	(0, 1, 0, 0, 1, 0, 0),
+	(0, 0, 0, 1, 0, 1, 0),
+	(0, 0, 0, 0, 1, 0, 1),
+	(1, 0, 0, 0, 0, 1, 0)
+)
+
+
+#  Поиск в глубину
+
+visited_nodes = [0, 0, 0, 0, 0, 0, 0]  # 1 - обнаружена, 2 - посещена
+
+queue = []  # Список узлов, которые нужно посетить
+queue.append(0)  # Стартовый узел
+
+while len(queue):  # Пока есть узлы, которые надо посетить
+	node1 = queue.pop(-1)
+	visited_nodes[node1] = 2
+
+	for node2 in range(6, -1, -1):  # С последнего к первому. от 6 до 0 включительно
+		if graph[node1][node2] == 1 and visited_nodes[node2] == 0:  # Узел смежный и не обнаружен
+			queue.append(node2)
+			visited_nodes[node2] = 1
+
+
+# Поиск первого пути в невзвешенном графе (из точки 3 в 5)
+
+class Edge:
+	def __init__(self, begin, end):
+		self.begin = begin
+		self.end = end
+
+	def __str__(self):
+		return f"Edge({self.begin + 1}, {self.end + 1})"
+
+
+def find_edges(graph, starting_point, stopping_point):
+	visited_nodes = [0, 0, 0, 0, 0, 0, 0]  # 1 - обнаружена, 2 - посещена
+	edges = []
+
+	queue = []  # Список узлов, которые нужно посетить
+	queue.append(starting_point)  # Стартовый узел
+	while len(queue):  # Пока есть узлы, которые надо посетить
+		node1 = queue.pop(-1)
+		visited_nodes[node1] = 2
+		print('Checking node %s' % node1)
+
+		for node2 in range(6, -1, -1):
+			print(f'Checking path to {node2}')
+			if graph[node1][node2] == 1 and visited_nodes[node2] == 0:  # Узел смежный и не обнаружен
+				print('Path exists and is undetected. Saving')
+
+				queue.append(node2)
+				visited_nodes[node2] = 1
+				edges.append(Edge(node1, node2))
+
+				if node2 == stopping_point:
+					print('Found stop, returning')
+					return edges
+
+	return edges
+
+
+start = 2
+req = 4
+edges = find_edges(graph, start, req)
+
+print('\nResulting list: ')
+for i in edges:
+	print(i)
+
+print("\nPath:")
+while len(edges):
+	edge = edges.pop(-1)
+	if edge.end == req:
+		req = edge.begin
+		print(edge)
+
+
+
+# ==================================================================
+
+
+
+# Список смежности
+# ключ - номер узла, значение - список узлов, с которыми есть связь
+print('\n\n\n\n\n\nСписок смежности')
+
+graph = {
+	1: (2, 3, 7),
+	2: (1, 3, 4),
+	3: (1, 2),
+	4: (2, 5),
+	5: (4, 6),
+	6: (5, 7),
+	7: (1, 6)
+}
+
+
+# Поиск в глубину
+visited_nodes = [0, 0, 0, 0, 0, 0, 0]  # 1 - обнаружена, 2 - посещена
+
+queue = []
+queue.append(1)
+
+while len(queue):
+	node1 = queue.pop(-1)
+	visited_nodes[node1 - 1] = 2
+
+	for node2 in graph.get(node1)[::-1]:
+		# Проверка на смежность в этом методе не нужна, потому что в списке уже содержатся смежные узлы.
+		if visited_nodes[node2 - 1] == 0:
+			visited_nodes[node2 - 1] = 1
+			queue.append(node2)
+
+
+
+# Поиск первого пути в невзвешенном графе (из точки 3 в 5)
+
+class Edge:
+	def __init__(self, begin, end):
+		self.begin = begin
+		self.end = end
+
+	def __str__(self):
+		return f"Edge({self.begin}, {self.end})"
+
+
+def find_edges(graph, starting_point, stopping_point):
+	visited_nodes = [0, 0, 0, 0, 0, 0, 0]  # 1 - обнаружена, 2 - посещена
+
+	queue = []
+	queue.append(starting_point)
+	edges = []
+
+	while len(queue):
+		node1 = queue.pop(-1)
+		visited_nodes[node1 - 1] = 2
+		print(f'Checking node {node1}')
+
+		for node2 in graph.get(node1)[::-1]:
+			print(f'Checking existing path to {node2}')
+			# Проверка на смежность в этом методе не нужна, потому что в списке уже содержатся смежные узлы.
+			if visited_nodes[node2 - 1] == 0:
+				print('Path is undetected. Saving')
+
+				visited_nodes[node2 - 1] = 1
+				queue.append(node2)
+				edges.append(Edge(node1, node2))
+
+				if node2 == stopping_point:
+					print('Found stop, returning')
+					return edges
+
+	return edges
+
+
+start = 3
+req = 5
+edges = find_edges(graph, start, req)
+print('\nResulting list: ')
+for i in edges:
+	print(i)
+
+print("\nPath:")
+while len(edges):
+	edge = edges.pop(-1)
+	if edge.end == req:
+		req = edge.begin
+		print(edge)

python/графы/поиск в ширину.py

@@ -0,0 +1,178 @@
+# Матрица смежности
+# [y][x] - существование пути (ребра) из y в x (опционально - вместо существования bool вес int)
+# При нумерации с 1 при этом методе существует несоответствие номеров узлов и индексов (индекс = номер - 1)
+graph = (
+	(0, 1, 1, 0, 0, 0, 1),
+	(1, 0, 1, 1, 0, 0, 0),
+	(1, 1, 0, 0, 0, 0, 0),
+	(0, 1, 0, 0, 1, 0, 0),
+	(0, 0, 0, 1, 0, 1, 0),
+	(0, 0, 0, 0, 1, 0, 1),
+	(1, 0, 0, 0, 0, 1, 0)
+)
+
+
+# Поиск в ширину
+
+visited_nodes = [0, 0, 0, 0, 0, 0, 0]  # 1 - обнаружена, 2 - посещена
+
+queue = []  # Список узлов, которые нужно посетить
+queue.append(0)  # Стартовый узел
+
+while len(queue):  # Пока есть узлы, которые надо посетить
+	node1 = queue.pop(0)
+	visited_nodes[node1] = 2
+
+	for node2 in range(7):
+		if graph[node1][node2] == 1 and visited_nodes[node2] == 0:  # Узел смежный и не обнаружен
+			queue.append(node2)
+			visited_nodes[node2] = 1
+
+
+
+# Поиск кратчайшего пути в невзвешенном графе (из точки 3 в 5)
+
+class Edge:
+	def __init__(self, begin, end):
+		self.begin = begin
+		self.end = end
+
+	def __str__(self):
+		return f"Edge({self.begin + 1}, {self.end + 1})"
+
+
+def find_edges(graph, starting_point, stopping_point):
+	visited_nodes = [0, 0, 0, 0, 0, 0, 0]  # 1 - обнаружена, 2 - посещена
+	edges = []
+
+	queue = []  # Список узлов, которые нужно посетить
+	queue.append(starting_point)  # Стартовый узел
+	while len(queue):  # Пока есть узлы, которые надо посетить
+		node1 = queue.pop(0)
+		visited_nodes[node1] = 2
+		print('Checking node %s' % node1)
+
+		for node2 in range(7):
+			print(f'Checking path to {node2}')
+			if graph[node1][node2] == 1 and visited_nodes[node2] == 0:  # Узел смежный и не обнаружен
+				print('Path exists and is undetected. Saving')
+
+				queue.append(node2)
+				visited_nodes[node2] = 1
+				edges.append(Edge(node1, node2))
+
+				if node2 == stopping_point:
+					print('Found stop, returning')
+					return edges
+
+	return edges
+
+
+start = 2
+req = 4
+edges = find_edges(graph, start, req)
+
+print('\nResulting list: ')
+for i in edges:
+	print(i)
+
+print("\nPath:")
+while len(edges):
+	edge = edges.pop(-1)
+	if edge.end == req:
+		req = edge.begin
+		print(edge)
+
+
+
+
+# ==================================================================
+
+
+
+# Список смежности
+# ключ - номер узла, значение - список узлов, с которыми есть связь
+print('\n\n\n\n\n\nСписок смежности')
+
+graph = {
+	1: (2, 3, 7),
+	2: (1, 3, 4),
+	3: (1, 2),
+	4: (2, 5),
+	5: (4, 6),
+	6: (5, 7),
+	7: (1, 6)
+}
+
+
+# Поиск в ширину
+visited_nodes = [0, 0, 0, 0, 0, 0, 0]  # 1 - обнаружена, 2 - посещена
+
+queue = []
+queue.append(1)
+
+while len(queue):
+	node1 = queue.pop()
+	visited_nodes[node1 - 1] = 2
+
+	for node2 in graph.get(node1):
+		# Проверка на смежность в этом методе не нужна, потому что в списке уже содержатся смежные узлы.
+		if visited_nodes[node2 - 1] == 0:
+			visited_nodes[node2 - 1] = 1
+			queue.append(node2)
+
+
+
+# Поиск кратчайшего пути в невзвешенном графе (из точки 3 в 5)
+
+class Edge:
+	def __init__(self, begin, end):
+		self.begin = begin
+		self.end = end
+
+	def __str__(self):
+		return f"Edge({self.begin}, {self.end})"
+
+
+def find_edges(graph, starting_point, stopping_point):
+	visited_nodes = [0, 0, 0, 0, 0, 0, 0]  # 1 - обнаружена, 2 - посещена
+
+	queue = []
+	queue.append(starting_point)
+	edges = []
+
+	while len(queue):
+		node1 = queue.pop(0)
+		visited_nodes[node1 - 1] = 2
+		print(f'Checking node {node1}')
+
+		for node2 in graph.get(node1):
+			print(f'Checking existing path to {node2}')
+			# Проверка на смежность в этом методе не нужна, потому что в списке уже содержатся смежные узлы.
+			if visited_nodes[node2 - 1] == 0:
+				print('Path is undetected. Saving')
+
+				visited_nodes[node2 - 1] = 1
+				queue.append(node2)
+				edges.append(Edge(node1, node2))
+
+				if node2 == stopping_point:
+					print('Found stop, returning')
+					return edges
+
+	return edges
+
+
+start = 3
+req = 5
+edges = find_edges(graph, start, req)
+print('\nResulting list: ')
+for i in edges:
+	print(i)
+
+print("\nPath:")
+while len(edges):
+	edge = edges.pop(-1)
+	if edge.end == req:
+		req = edge.begin
+		print(edge)

python/классы/class.py

@@ -0,0 +1,40 @@
+class car:
+	name = "None"
+	weight = 1000
+	speed = 200
+
+	#__init__ нужен, чтобы сразу задать объекту нужные параметры
+	#Инициализация при создании
+	def __init__(self, name, weight, speed):
+		self.name = name
+		self.weight = weight
+		self.speed = speed
+		print(f"{self.name} едет со скоростью {self.speed}")
+
+	#self необходим для того, Чтобы отличать методы от функций, которые не привязаны к какому-то классу/объекту,
+	#поддерживать полиморфизм. Self - это что-то типа параметра метода.
+	def set(self, name, weight, speed):
+		self.name = name
+		self.weight = weight
+		self.speed = speed
+
+#Класс наследник создаётся так:
+class truck(car):
+	wheels = 8
+	def __init__(self):
+		pass
+
+
+man = truck()
+man.wheels = 12
+print(man.wheels)
+#классы - наследники имеют доступ к методам из оригинального класса
+man.set(weight = 10000, name = "Man", speed = 200)
+
+Audi = car("Audi", 2000, 320)
+Audi.set(weight = 2000, name = "Audi", speed = 320)
+print(Audi.name)
+
+Shkoda = car("Shkoda", 1800, 235)
+Shkoda.set(weight = 1800, name = "Shkoda", speed = 235)
+print (Shkoda.name)

python/модули/from.py

@@ -0,0 +1,3 @@
+#Можно подключить только 1 функцию из модуля
+from random import randint as random
+print(random(1,20))

python/модули/модули.py

@@ -0,0 +1,16 @@
+#Подключение модуля, связанного с математикой
+import math
+#as позволяет в будущем использовать модуль при помощи псевдонима
+import random as r
+
+
+
+#вывод числа e
+print(math.e)
+#вывод числа пи
+print(math.pi)
+#вывод косинуса
+print(math.cos(30))
+
+
+print(r.randint(0, 20))

python/основы/if.py

@@ -0,0 +1,13 @@
+num = int (input ("Number: "))
+
+#Операции с переменными в if: >, <, ==, !=, >=, <=
+if num > 0:
+	print('Положительное')
+#Elif это следующий if, который выполняется если предыдущей неверный.
+elif num == 0:
+	print('Равно 0')
+#Else выплняется если ни if, ни один из elseif не являются верными
+else:
+	print('Отрицательное')
+
+input()

python/основы/действия.py

@@ -0,0 +1,20 @@
+#сложение
+print (2+3)
+
+#вычитание
+print (6-8)
+
+#умножение
+print (6*2)
+
+#деление
+print (9/3)
+
+#возведение в степень
+print (3**5)
+
+#деление без остатка
+print (11//3)
+
+#Остаток деления
+print(3%2)

python/основы/переменные.py

@@ -0,0 +1,55 @@
+name = "Oleg"
+
+#К строковым переменным применимы действия, подразумевающие порядок расположения
+print(f'длина {len(name)}')
+print(f'Буква {name[0]}')
+
+#Методы, уникальные для строк:
+print(name.find('le')) #Поиск позиции
+Fname = name.replace('eg', 'ga') #Замена позиции
+print(Fname)
+print(name.upper()) #Преобразование регистра
+print(name.isalpha()) #Проверяет, все ли символы - буквы
+print('214'.isdigit()) #Проверяет, все ли символы - цифры
+
+#f нужна, чтобы выводить переменные
+print(f'My name is {name}')
+
+#Но можно обойтись и без неё
+print("My name is", name)
+
+#input значит, что переменной присвоятся введенные с клавиатуры данные
+#("") после input выводит надпись, прямо после которой будет осуществляться ввод (Enter: 4)
+#Чтобы надпись не выводилась, скобки нужно оставить пустыми. Но сами скобки обязательны
+num = input("Enter1: ")
+num2 = input("Enter2: ")
+#здесь вводятся данные типа string, поэтому при использовании + они присоединяются
+res = num + num2
+print(res)
+
+
+#для использования integer нужно использовать int()
+num = int(input("Enter1: "))
+num2 = int( input("Enter2: "))
+res = num + num2
+print(res)
+
+
+#float() позволяет вводить десятичные числа
+num = float(input("Enter1: "))
+num2 = float( input("Enter2: "))
+res = num + num2
+print(res)
+
+
+# += 20 - прибавить 20 к переменной, так же и с остальными действиями
+res += 20
+print(f'E1+E2+20={res}')
+res = num + num2
+res -= 20
+print(f'E1+E2-20={res}')
+
+print(res)
+res -= 1
+print(res)
+input()

python/основы/преобразование в десятичную сист.py

@@ -0,0 +1,2 @@
+print(int(bin(11), 2))
+#число в двоичной системе (bin(11)) преобразовывается в целое число с указанием основы системы (2)

python/основы/форматирование.py

@@ -0,0 +1,48 @@
+#Слева указать спецификаторы после знака %, справа указать то, на что эти спецификаторы заменить
+#d = десятичное число, s = строка
+formating = "That's %d %s bird" % (1, "dead")
+print(formating)
+
+x = 1234
+#%[(name)][flags][width][.precision]спец
+# name = ключ в словаре. При указании * для width и precision значение возьмётся из элемента в списке входных значений
+#-10 = отступ слева. при указании отриц. числа превращается в отступ справа
+#06 = поле становится равным 6 и добавляются вводные нули вместо отсутпа
+res = "integers: ...%d...%-10d...%06d" % (x, x, x)
+print(res)
+
+#f = вещественное число
+#. используется для определения кол-ва знаков после запятой
+res = "%f...%.2f" % (1/3.0, 1/3.0)
+print(res)
+
+#Использование словаря:
+formating = "%(number)d %(text)s" % {"number" : 1, "text" : "spam"}
+print("\n", formating)
+
+#*****************************************Методы форматирования*****************************************
+
+#Могут использоваться именованные аргументы или номера аргументов
+template = "{motto}, {0} and {food}"
+print(template.format("ham", motto="spam", food="eggs"))
+
+import sys
+#Для ссылки на объект в словаре необходимо указать положение словаря в списке входных значений (1) и ключ объекта в квадратных скобках [spam]
+#Для ссылки на атрибут объекта нужно применить точку (.platform)
+template = "My {1[spam]} runs {0.platform}".format(sys, {"spam": "laptop"})
+print(template)
+
+somelist = list("spam")
+#Использование отрицательных значений внутри строки формата приводит к ошибке
+#Также нельзя создавать срезы внутри строки формата
+#Поэтому объект нужно указать вне строки.                          | 
+template = "first = {0[0]}, last = {1}".format(somelist, somelist[-1])
+print(template)
+
+#Синтаксис точного форматирования: {fieldname!conversionflag:formatspec}
+#Синтаксис formatspec: [[fill]align][sign][#][0][width][.precision][typecode] (В квадратных скобках необязательные компоненты)
+#< = выравнивание слева, > = выравнивание справа
+print("\n{0:>10} = {1:<10}".format("spam", 123.4567))
+
+#Извлечение значения из списка аргументов:
+print("{0:.{1}f}".format(3.14159, 2))

python/списки/list.py

@@ -0,0 +1,75 @@
+#В списки можно втроить другие списки
+#Индекс первого элемента - 0
+lis = [23, 15, 's', ['h', 'e', '1',]]
+print(lis)
+print(lis[2])
+print(lis[3])
+print(lis[3][1])
+print("\n")
+
+
+for i in lis:
+	print(i)
+
+
+for i in range(0, 4):
+	lis[i] *= 2
+print(lis)
+
+#Добавление элемента в список
+lis.append(2011)
+print(lis)
+
+#Удаление элемента из списка
+#по значению
+lis.remove(46)
+print(lis)
+#по индексу
+lis.pop(0)
+print(lis)
+
+#Вставка элемента в определённое место
+#1 - индекс, 9 - элемент
+lis.insert(1, 9)
+print(lis)
+
+#Узнать индекс элемента
+print(lis.index(9))
+
+#Вывод элементов в конце списка
+print("Индекс числа", lis[-1]," = ", lis.index(2011))
+
+#Вывод определённой части списка (Среза) (Старт:финиш:шаг)
+print(lis[1:-2:1])
+print(lis[2:])
+print(lis[2:len(lis)])
+
+#Очистка списка
+lis.clear()
+print(lis)
+
+#В списки можно вкладывать списки, тем самым создавая матрицы
+M = [[1, 2, 3],
+	 [4, 5, 6],
+	 [7, 8, 9]]
+print('\n', M)
+
+#Генератор, возвращающий суммы элементов строк
+G = (sum(elements) for elements in M) 
+#Вызов в соответствии с протоколом итераций
+print(next(G))
+print(next(G))
+#То же, но по другому
+summ = list(map(sum, M))
+print(summ)
+
+#Вывод столбца
+#Получить  элементы row[1]  из  каждой  строки  матрицы M  исоздать  из  них  новый  список
+#Здесь переменной row присваивается элемент списка M (который сам является списком), а переменной col2
+#присваивается 2 элемент списка row. И так для каждого элемента списка M.
+col2 = [row[1] for row in M]
+print(col2)
+
+#Генератор списков
+doubles = [c * 2 for c in 'spam']
+print(doubles)

python/списки/tuple.py

@@ -0,0 +1,12 @@
+#Кортежи можно вводить в круглых скобках, без скобок, или словом tuple
+a = (23, 16, 'Hi')
+print(a)
+
+a = 24, 17, 'qq'
+print(a)
+
+a = tuple ('Hello')
+print(a)
+
+#В кортежах нельзя менять отдельные символы. Только выводить
+print(a[1])

python/списки/множества.py

@@ -0,0 +1,38 @@
+#Множества создаются при помощи set
+#В множествах нет повторяющихся элементов
+#Также есть frozenset, он создаёт множества, которые нельзя менять (как кортежи)
+a = set('hello')
+print(a)
+
+#Множества также можно создать при помощи фигурных скобок, не используя set
+a = {'h', 'e', 'l', 'o'}
+print(a)
+
+"""
+С множествами можно выполнять множество операций: находить объединение, пересечение...
+
+len(s) - число элементов в множестве (размер множества).
+x in s - принадлежит ли x множеству s.
+set.isdisjoint(other) - истина, если set и other не имеют общих элементов.
+set == other - все элементы set принадлежат other, все элементы other принадлежат set.
+set.issubset(other) или set <= other - все элементы set принадлежат other.
+set.issuperset(other) или set >= other - аналогично.
+set.union(other, ...) или set | other | ... - объединение нескольких множеств.
+set.intersection(other, ...) или set & other & ... - пересечение.
+set.difference(other, ...) или set - other - ... - множество из всех элементов set, не принадлежащие ни одному из other.
+set.symmetric_difference(other); set ^ other - множество из элементов, встречающихся в одном множестве, но не встречающиеся в обоих.
+set.copy() - копия множества.
+И операции, непосредственно изменяющие множество:
+
+set.update(other, ...); set |= other | ... - объединение.
+set.intersection_update(other, ...); set &= other & ... - пересечение.
+set.difference_update(other, ...); set -= other | ... - вычитание.
+set.symmetric_difference_update(other); set ^= other - множество из элементов, встречающихся в одном множестве, но не встречающиеся в обоих.
+set.add(elem) - добавляет элемент в множество.
+set.remove(elem) - удаляет элемент из множества. KeyError, если такого элемента не существует.
+set.discard(elem) - удаляет элемент, если он находится в множестве.
+set.pop() - удаляет первый элемент из множества. Так как множества не упорядочены, нельзя точно сказать, какой элемент будет первым.
+set.clear() - очистка множества.
+set.sort() - сортировка по возрастанию
+set.reverse() - сортировка по убыванию
+"""

python/списки/словарь.py

@@ -0,0 +1,29 @@
+#Словари могут вводиться в фигурных скобках
+s = {'число': 24, 'надпись': 'inscription'}
+print(s['число'])
+
+#.keys и .values возвращают итерируемые объекты. Для получения списков нужно использовать list()
+print(list(s.keys()), s.values())
+
+#Могут при помощи dict.
+d = dict(lazy="q", hardworking="Greetings")
+print(d['lazy'])
+
+#Могут при помощи dictfromkeys. При этом всем ключам присваивается одно значение. Его можно и не указывать
+f = dict.fromkeys(['a', 'b', 'c'], 1)
+print(f)
+
+#D = dict(zip(keyslist, valslist))
+var_zip = dict(zip(['food', 'tool'], ['spam', 'wrench']))
+print(var_zip)
+
+#Генератор словарей
+D = {k: v for (k, v) in zip(['food', 'tool'], ['SPAM', 'WRENCH'])}
+print(D)
+
+#in позволяет проверить наличие ключа в словаре
+if not 'd' in f:
+	print('В словаре f нет элемента с ключём d')
+
+#get возвращает элемент словаря, а если его нет - указанное значение
+print(f.get('x', 20))

python/файлы/data_file.txt

@@ -0,0 +1,3 @@
+spam
+egg
+Italia

python/файлы/objects.txt

@@ -0,0 +1,2 @@
+41,42,43
+[1, 5, 10]&{'food': 'spam', 'tool': 'wrench'}

python/файлы/пикл.py

@@ -0,0 +1,13 @@
+#Файл нельзя называть pickle
+
+import pickle
+
+#Сохранение объектов в файлах при помощи pickle
+F = open("obj.pkl", "wb")
+D = {'meal': 'burger', 'genius': 'heiakim'}
+pickle.dump(D, F)
+F.close()
+
+#Чтение объектов
+F = open('obj.pkl', 'rb')
+print(pickle.load(F))

python/файлы/файлы.py

@@ -0,0 +1,84 @@
+#создание файлов. w - write
+text_file = open('data_file.txt', 'w')
+
+#Запись в файл
+text_file.write('Hello\n')
+text_file.write('World')
+
+#Закрытие файла
+text_file.close()
+
+#По умолчанию файлы открываются в режиме r - read
+text_file = open('data_file.txt')
+
+#Чтение из файла. (в скобках можно указать кол-во символов для чтения)
+print(text_file.read())
+
+print('\n')
+
+#Чтение одной строки. (в скобках можно указать кол-во символов для чтения)
+text_file = open('data_file.txt')
+S = text_file.readline()
+S = text_file.readline()
+print(S)
+
+print('\n')
+
+#Чтение файла в список строк
+text_file = open('data_file.txt')
+L = text_file.readlines()
+print(L)
+
+print('\n')
+
+#Запись строк из списка в файл
+text_file = open('data_file.txt', 'w')
+tmp_list = ['spam\n', 'egg\n', 'Italia']
+text_file.writelines(tmp_list)
+
+text_file = open('data_file.txt')
+print(text_file.read())
+
+
+print('\n****************')
+
+#Итератор файла
+text_file = open('data_file.txt')
+for S in text_file:
+	print(S * 2)
+
+print('****************\n')
+
+#Изменяет текущую позицию в файле для следующей операции, смещая ее на N байтов от начала файла.
+text_file = open('data_file.txt')
+text_file.seek(7)
+print(text_file.read())
+
+print('\n')
+
+#Запись объектов
+objects = open('objects.txt', 'w')
+L =  [1, 5, 10]
+X, Y, Z = 41, 42, 43
+D = {'food': 'spam', 'tool': 'wrench'}
+objects.write('{0},{1},{2}\n'.format(X, Y, Z))
+objects.write(str(L) + '&' + str(D) + '\n')
+objects = open('objects.txt')
+print(objects.read())
+
+#Чтение объектов
+objects = open('objects.txt')
+line = objects.readline()
+#Удаление символа конца строки
+line = line.rstrip()
+print(line)
+
+numbers = line.split(',')
+L = [int(x) for x in numbers]
+print(L)
+
+line = objects.readline()
+line = line.rstrip()
+elements = line.split('&')
+result = [eval(x) for x in elements]
+print(result)

python/функции/NOK.py

@@ -0,0 +1,21 @@
+def nok (a,b):
+	c=a
+	d=b
+	ia=1
+	ib=1
+
+	while c != d:
+		if c < d:
+			ia += 1
+			c = a*ia
+		else:
+			ib+=1
+			d = b*ib
+		
+	print(c, d)
+	return c
+
+z = int(input('a: '))
+x = int(input('b: '))
+nok(z, x)
+input()

python/функции/NOK2.py

@@ -0,0 +1,88 @@
+import operator
+import functools
+prime = [2, 3]
+
+def simple(a):
+	num = a[-1]+1
+	tr = False
+	while tr != True:
+		for i in range(2, num):
+			if num%i == 0:
+				tr = False
+				num += 1
+				break
+			else:
+				tr = True
+	a.append(num)
+#	print(f'В список добавлено число {num}')
+
+
+
+def NOK(x,y):
+	if x > y:
+		difx = True
+	else:
+		difx=False
+
+	arrayx=[]
+	arrayy=[]
+	counter=0
+	while x!=1:
+		for i in range(counter, len(prime)):
+			if prime[i]>(x/2):
+				arrayx.append(x)
+				x=1
+				break
+			if x%prime[i]==0:
+				x //= prime[i]
+				arrayx.append(prime[i])
+				counter=0
+				i=0
+				break
+
+		if (x>1) and (i==(len(prime)-1)):
+			simple(prime)
+			counter=i
+
+	counter=0
+	while y!=1:
+		for i in range(counter, len(prime)):
+			if prime[i]>(y/2):
+				arrayy.append(y)
+				y=1
+				break
+			if y%prime[i]==0:
+				y//=prime[i]
+				arrayy.append(prime[i])
+				counter=0
+				i=0
+				break
+
+		if (y>1) and (i==(len(prime)-1)):
+			simple(prime)
+			counter=i
+		
+	print(arrayx, arrayy)
+
+	count_ax = 0
+	y_second = list(arrayy)
+	x_second = list(arrayx)
+	for i in range(0, len(arrayy)):
+		for for_x in range(0, len(x_second)):
+			if arrayy[i] == x_second[for_x]:
+				y_second.remove(arrayy[i])
+				x_second.remove(arrayy[i])
+				break
+
+
+	result_array = y_second + arrayx
+	result = functools.reduce(operator.mul, result_array, 1)
+	print(result_array, result)
+	return result
+
+		
+
+first = int(input())
+second = int(input())
+print(NOK(first,second))
+input()

python/функции/def.py

@@ -0,0 +1,33 @@
+# Функции создаются при помощи def Имя (Список параметров)
+
+#В тройных кавычках содержится описание функции
+def division (dividend, divisor):
+	"""Делит делимое на делитель"""
+	if divisor != 0:
+		z = dividend/divisor
+		#return возвращает результат функции. Без него результатом будет None
+		#также есть pass, при использовании которого функция ничего не возвращает
+		return z
+	else:
+		print('На 0 делить нельзя')
+
+#Просмотр описания функции
+print(division.__doc__)
+
+print(division(18,6))
+
+def gcd(a, b):
+   "Нахождение НОД"
+   while a != 0:
+      a,b = b%a,a # параллельное определение. Не смотря на то, что b написано после a, переменной b всё равно присваивается старое значение a
+      print(a,b)
+   print(b)
+   return b
+gcd(2,3)
+
+
+#вместо списка параметров можно написать *args, тогда кол-во параметров определится само
+def test(*args):
+	print(args)
+	pass
+test(23, "hi", 4221)

python/функции/lambda.py

@@ -0,0 +1,2 @@
+mult = lambda x, y: x * y
+print(mult(2, 5))

python/функции/Нахождение простых чисел.py

@@ -0,0 +1,35 @@
+prime = [2, 3]
+print(prime)
+
+
+
+num = prime[-1]+1
+tr = False
+while tr != True:
+	for i in range(2, num):
+		if num%i == 0:
+			tr = False
+			print(num, i, tr)
+			num += 1
+			break
+		else:
+			tr = True
+			print(num, i, tr)
+
+prime.append(num)
+
+
+
+for z in range(1, 1500):
+	num = prime[-1]+1
+	tr = False
+	while tr != True:
+		for i in range(2, (num//2)):
+			if num%i == 0:
+				tr = False
+				num += 1
+				break
+			else:
+				tr = True
+	prime.append(num)
+print(prime)

python/циклы/for.py

@@ -0,0 +1,9 @@
+#Здесь переменная f объявляется сразу в цикле
+#В данном цикле f присваивается каждый элемент из множества символов, заданных после in
+for f in 'Hi!':
+	print (f * 2)
+
+#for с числами. Последнее число не обрабатывается: будет идти от 10 до 19
+#range (Старт, финиш, шаг)
+for k in range(10, 20):
+	print (k)

python/циклы/while.py

@@ -0,0 +1,6 @@
+#Переменная создаётся до цикла
+i = 0
+#Цикл выполняется, пока условие является истинным.
+while i < 10:
+	print(i)
+	i += 2