Blender для начинающих/Python практика: различия между версиями

Материал из Викиучебника — открытых книг для открытого мира
Содержимое удалено Содержимое добавлено
м орфография
м <source> -> <syntaxhighlight> (phab:T237267)
Строка 2: Строка 2:
=Алгебраические задачи=
=Алгебраические задачи=
==Перестановка значений переменных==
==Перестановка значений переменных==
<source lang="python">
<syntaxhighlight lang="python">
def Swap(a, b):
def Swap(a, b):
a = a + b
a = a + b
b = a - b
b = a - b
a = a - b
a = a - b
</syntaxhighlight>
</source>
==Циклы==
==Циклы==
Пусть, имеется переменная a, значение которой после цикла while надо узнать. Пусть, inc - число, на которое увеличивается a. B - переменная, задающая условие в цикле:
Пусть, имеется переменная a, значение которой после цикла while надо узнать. Пусть, inc - число, на которое увеличивается a. B - переменная, задающая условие в цикле:
<source lang="python">
<syntaxhighlight lang="python">
while a знак B:
while a знак B:
a = a + inc
a = a + inc
</syntaxhighlight>
</source>
inc - независимая переменная. Значение a приближается к значению B.
inc - независимая переменная. Значение a приближается к значению B.
# Если неравенство нестрогое, то после цикла a = a + inc*(abs(B - a) // inc + 1).
# Если неравенство нестрогое, то после цикла a = a + inc*(abs(B - a) // inc + 1).
Строка 26: Строка 26:
==Расположение точки на диагонали==
==Расположение точки на диагонали==
Пусть, имеется точка A(x, y), то будет или нет она располагается на диагонали, можно будет узнать так:
Пусть, имеется точка A(x, y), то будет или нет она располагается на диагонали, можно будет узнать так:
<source lang="python">if math.fabs(x) == math.fabs(y):
<syntaxhighlight lang="python">if math.fabs(x) == math.fabs(y):
print("Точка на диагонали")</source>
print("Точка на диагонали")</syntaxhighlight>
math.fabs(x) возвращает модуль числа x.
math.fabs(x) возвращает модуль числа x.


==Точка находится под прямой==
==Точка находится под прямой==
Пусть, имеется точка A(x, y), где x, y - нецелые числа. Уравнение прямой '''y = kx + b'''. Функция, возвращающая y в зависимости от x:
Пусть, имеется точка A(x, y), где x, y - нецелые числа. Уравнение прямой '''y = kx + b'''. Функция, возвращающая y в зависимости от x:
<source lang="python">def getY(x, k, b):
<syntaxhighlight lang="python">def getY(x, k, b):
return k*x+b</source>
return k*x+b</syntaxhighlight>
Узнать ниже ли точка прямой или нет, можно, подставив ее x в уравнение прямой:
Узнать ниже ли точка прямой или нет, можно, подставив ее x в уравнение прямой:
<source lang="python">if y < getY(x, y, k):
<syntaxhighlight lang="python">if y < getY(x, y, k):
print("Точка под прямой.")</source>
print("Точка под прямой.")</syntaxhighlight>


==Точка на прямой==
==Точка на прямой==
Пусть, имеется точка A(x, y), где x, y - нецелые числа. Узнать на прямой ли точка или нет, можно, подставив ее x в уравнение прямой:
Пусть, имеется точка A(x, y), где x, y - нецелые числа. Узнать на прямой ли точка или нет, можно, подставив ее x в уравнение прямой:
<source lang="python">if y == getY(x, y, k):
<syntaxhighlight lang="python">if y == getY(x, y, k):
print("Точка на прямой.")</source>
print("Точка на прямой.")</syntaxhighlight>
==Точка над прямой==
==Точка над прямой==
Пусть, имеется точка A(x, y), где x, y - нецелые числа. Узнать выше прямой ли точка или нет, можно, подставив ее x в уравнение прямой:
Пусть, имеется точка A(x, y), где x, y - нецелые числа. Узнать выше прямой ли точка или нет, можно, подставив ее x в уравнение прямой:
<source lang="python">if y > getY(x, y, k):
<syntaxhighlight lang="python">if y > getY(x, y, k):
print("Точка над прямой.")</source>
print("Точка над прямой.")</syntaxhighlight>
==Вычисление k перпендикулярной прямой==
==Вычисление k перпендикулярной прямой==
Пусть, имеется точки A(x, y) и A(x2, y2), задающие прямые, где x, y - нецелые числа. То зная k первой прямой вычислить k для второй можно следующим образом:
Пусть, имеется точки A(x, y) и A(x2, y2), задающие прямые, где x, y - нецелые числа. То зная k первой прямой вычислить k для второй можно следующим образом:
<source lang="python">import math
<syntaxhighlight lang="python">import math
k2 = math.tan(math.atan(k)+90)
k2 = math.tan(math.atan(k)+90)
</syntaxhighlight>
</source>
==Вычисление координат точки пересечения прямых==
==Вычисление координат точки пересечения прямых==
Пусть, прямые задаются такими уравнениями:
Пусть, прямые задаются такими уравнениями:
Строка 59: Строка 59:
# x(k1 - k2) = b2 - b1
# x(k1 - k2) = b2 - b1
Следовательно, x = (b2 - b1)/(k1 - k2). Таким образом, узнать координаты точки пересечения прямых можно так:
Следовательно, x = (b2 - b1)/(k1 - k2). Таким образом, узнать координаты точки пересечения прямых можно так:
<source lang="python">
<syntaxhighlight lang="python">
x = (b2 - b1)/(k1 - k2)
x = (b2 - b1)/(k1 - k2)
y = k1*x + b1 # Без разницы, в уравнение какой прямой подставлять.
y = k1*x + b1 # Без разницы, в уравнение какой прямой подставлять.
</syntaxhighlight>
</source>
==Вычисление коэффициента наклона прямой==
==Вычисление коэффициента наклона прямой==
Пусть, прямая проходит через две точки: A(x, y) и B(x1, y1). Причем, точка B лежит правее и выше точки A. Тогда вычисление коэффициента k для уравнения прямой будет выглядеть следующим образом:
Пусть, прямая проходит через две точки: A(x, y) и B(x1, y1). Причем, точка B лежит правее и выше точки A. Тогда вычисление коэффициента k для уравнения прямой будет выглядеть следующим образом:
<source lang="python">
<syntaxhighlight lang="python">
k = (y1 - y)/(x1 - x)
k = (y1 - y)/(x1 - x)
</syntaxhighlight>
</source>


=Столкновения=
=Столкновения=
==Окружность с окружностью==
==Окружность с окружностью==
Если расстояние между радиусами окружностей больше суммы их радиусов, то они не пересекаются:
Если расстояние между радиусами окружностей больше суммы их радиусов, то они не пересекаются:
<source lang="python">
<syntaxhighlight lang="python">
import math
import math
if (math.sqrt((circle1.x - circle2.x)**2 + (circle1.y - circle2.y)**2) >= circle1.r + circle2.r):
if (math.sqrt((circle1.x - circle2.x)**2 + (circle1.y - circle2.y)**2) >= circle1.r + circle2.r):
print("Окружности не пересекаются.")
print("Окружности не пересекаются.")
</syntaxhighlight>
</source>
Здесь circle1 и circle2 - окружности.
Здесь circle1 и circle2 - окружности.


Строка 90: Строка 90:
::::Отрезки не пересекаются.
::::Отрезки не пересекаются.
Пусть, есть две точки, составляющих первый отрезок: A(x, y) и B(x1, y1). Пусть, есть две точки, составляющие второй отрезок: C(x2, y2) и D(x3, y3). Пусть, точки расположены по оси +X в таком порядке: A, B, C, D.
Пусть, есть две точки, составляющих первый отрезок: A(x, y) и B(x1, y1). Пусть, есть две точки, составляющие второй отрезок: C(x2, y2) и D(x3, y3). Пусть, точки расположены по оси +X в таком порядке: A, B, C, D.
<source lang="python">
<syntaxhighlight lang="python">
if ((x1 >= x3) and (x1 <= x4)) or ((x >= x3) and (x <= x4)):
if ((x1 >= x3) and (x1 <= x4)) or ((x >= x3) and (x <= x4)):
intersectX = (b2 - b1)/(k1 - k2)
intersectX = (b2 - b1)/(k1 - k2)
Строка 99: Строка 99:
else:
else:
print('Отрезки не пересекаются.')
print('Отрезки не пересекаются.')
</syntaxhighlight>
</source>
Данная схема будет корректно работать лишь в том случае, если ни один из отрезков не перпендикулярен оси X.
Данная схема будет корректно работать лишь в том случае, если ни один из отрезков не перпендикулярен оси X.


Строка 107: Строка 107:
[[File:Buttonsys.jpg|frameless]]<br>
[[File:Buttonsys.jpg|frameless]]<br>
Границей любой кнопки обычно является прямоугольник, поэтому проверка на принадлежность точки A(x, y) этому прямоугольнику можно задать следующим условием:
Границей любой кнопки обычно является прямоугольник, поэтому проверка на принадлежность точки A(x, y) этому прямоугольнику можно задать следующим условием:
<source lang="python">if (A.x >= button.x) and (A.y >= button.y) and (A.x <= button.x + button.width) and (A.y <= button.y + button.heigth):</source>
<syntaxhighlight lang="python">if (A.x >= button.x) and (A.y >= button.y) and (A.x <= button.x + button.width) and (A.y <= button.y + button.heigth):</syntaxhighlight>
# A.x - X координата точки
# A.x - X координата точки
# A.y - Y координата точки
# A.y - Y координата точки
Строка 117: Строка 117:
==Ползунки==
==Ползунки==
Любой ползунок представляет собой два прямоугольника. Первый - границы ползунка, второй - значение ползунка. Напишем функцию, которая определит лежит ли точка в границах первого прямоугольника «border»:
Любой ползунок представляет собой два прямоугольника. Первый - границы ползунка, второй - значение ползунка. Напишем функцию, которая определит лежит ли точка в границах первого прямоугольника «border»:
<source lang="python">def intersect(A, border):
<syntaxhighlight lang="python">def intersect(A, border):
if (A.x >= border.x) and (A.y >= border.y) and (A.x <= border.x + border.width) and (A.y <= border.y + border.heigth):
if (A.x >= border.x) and (A.y >= border.y) and (A.x <= border.x + border.width) and (A.y <= border.y + border.heigth):
return True
return True
else:
else:
return False</source>
return False</syntaxhighlight>
Пусть, Вы перемещайте ползунок, то код для обработки изменения значения ползунка будет следующий:
Пусть, Вы перемещайте ползунок, то код для обработки изменения значения ползунка будет следующий:
<source lang="python">if cursor.x < border.x:
<syntaxhighlight lang="python">if cursor.x < border.x:
value.x = border.x
value.x = border.x
elif cursor.x > border.x + border.width:
elif cursor.x > border.x + border.width:
value.x = border.x + border.width
value.x = border.x + border.width
else:
else:
value.x = cursor.x</source>
value.x = cursor.x</syntaxhighlight>
=Архитектура игровых классов=
=Архитектура игровых классов=
При написании проекта следует определить будет ли он 2D или 3D игрой. С учетом этого, следует строить архетиктуру классов проекта.
При написании проекта следует определить будет ли он 2D или 3D игрой. С учетом этого, следует строить архетиктуру классов проекта.
==2D игры - пример архитектуры классов==
==2D игры - пример архитектуры классов==
<source lang="Python">class Object
<syntaxhighlight lang="Python">class Object
# свойства
# свойства
x_position, y_position, width, height, fill_color, border_color, border_width, filled, bordered
x_position, y_position, width, height, fill_color, border_color, border_width, filled, bordered
Строка 140: Строка 140:
class Dynamic(Object)
class Dynamic(Object)
# свойства
# свойства
mass, radius</source>
mass, radius</syntaxhighlight>
Здесь основные свойства объекта занесены в один класс «Object», так как их мало.
Здесь основные свойства объекта занесены в один класс «Object», так как их мало.


==3D игры - пример архитектуры==
==3D игры - пример архитектуры==
Так как 3D игры - игры с более навороченной графикой, то было бы предпочтительнее использовать такую систему классов:
Так как 3D игры - игры с более навороченной графикой, то было бы предпочтительнее использовать такую систему классов:
<source lang="Python">class Material
<syntaxhighlight lang="Python">class Material
# свойства
# свойства
fill_color, border_color, border_width, filled, bordered</source>
fill_color, border_color, border_width, filled, bordered</syntaxhighlight>
<source lang="Python">class Object
<syntaxhighlight lang="Python">class Object
# свойства
# свойства
x_position, y_position, width, height
x_position, y_position, width, height
Строка 158: Строка 158:
class Dynamic(Object)
class Dynamic(Object)
# свойства
# свойства
mass, radius</source>
mass, radius</syntaxhighlight>
=Калькулятор=
=Калькулятор=
Пусть, наш калькулятор поддерживает выражения вида a±b, a/b и a*b. Пусть, a, b € [0; 9]. Код калькулятора будет следующий:
Пусть, наш калькулятор поддерживает выражения вида a±b, a/b и a*b. Пусть, a, b € [0; 9]. Код калькулятора будет следующий:
<source lang="python">
<syntaxhighlight lang="python">
while True:
while True:
text = input()
text = input()
Строка 179: Строка 179:
else:
else:
print("Недопустимая операция.")
print("Недопустимая операция.")
</syntaxhighlight>
</source>


=Сортировки=
=Сортировки=
Строка 194: Строка 194:
==Сортировка при помощи функций списков==
==Сортировка при помощи функций списков==
Самый неудачный, но возможный вариант сортировки представлен ниже:
Самый неудачный, но возможный вариант сортировки представлен ниже:
<source lang="python">
<syntaxhighlight lang="python">
def SortList(a):
def SortList(a):
b = list()
b = list()
Строка 202: Строка 202:
a.remove(m)
a.remove(m)
return b
return b
</syntaxhighlight>
</source>
Недостатки:
Недостатки:
# Используется два списка.
# Используется два списка.
Строка 212: Строка 212:
# Проходим по списку несколько раз, чтобы правильно отсортировать все элементы в правильном порядке. Не всегда после n-ной итерации все элементы списка будут отсортированы.
# Проходим по списку несколько раз, чтобы правильно отсортировать все элементы в правильном порядке. Не всегда после n-ной итерации все элементы списка будут отсортированы.
# Сначала мы ищем минимальный элемент во всем списке, потом - в его оставшейся части.
# Сначала мы ищем минимальный элемент во всем списке, потом - в его оставшейся части.
<source lang="python">
<syntaxhighlight lang="python">
def SortList(a):
def SortList(a):
for i in range(0, len(a)):
for i in range(0, len(a)):
Строка 219: Строка 219:
a[j], a[j - 1] = a[j - 1], a[j]
a[j], a[j - 1] = a[j - 1], a[j]
return a
return a
</syntaxhighlight>
</source>
<source lang="python">
<syntaxhighlight lang="python">
def SortList(a):
def SortList(a):
for i in range(len(a) - 1, -1):
for i in range(len(a) - 1, -1):
Строка 227: Строка 227:
a[j], a[j + 1] = a[j + 1], a[j]
a[j], a[j + 1] = a[j + 1], a[j]
return a
return a
</syntaxhighlight>
</source>
[[File:Sort1.jpg|frameless]]
[[File:Sort1.jpg|frameless]]


==Сортировка выбором==
==Сортировка выбором==
[[File:Sort2e.jpg|frameless]]
[[File:Sort2e.jpg|frameless]]
<source lang="python">
<syntaxhighlight lang="python">
def SortList(a):
def SortList(a):
for i in range(0, len(a)):
for i in range(0, len(a)):
Строка 239: Строка 239:
a[i], a[j] = a[j], a[i]
a[i], a[j] = a[j], a[i]
return a
return a
</syntaxhighlight>
</source>
# Переменные i и j изменяются в одном направлении - увеличиваются.
# Переменные i и j изменяются в одном направлении - увеличиваются.
# Сравнивая с все элементы списка, стоящие после a[i], с a[i], мы находим минимум из множества значений (a[i], a[len(a)-1]]. При следующей итерации новый минимум будет искаться из оставшихся элементов, поэтому следующий минимум будет больше предыдущего минимума.
# Сравнивая с все элементы списка, стоящие после a[i], с a[i], мы находим минимум из множества значений (a[i], a[len(a)-1]]. При следующей итерации новый минимум будет искаться из оставшихся элементов, поэтому следующий минимум будет больше предыдущего минимума.
Строка 247: Строка 247:
# Переменные i и j изменяются в разных направлениях.
# Переменные i и j изменяются в разных направлениях.
# Осуществляем меньше итераций, чем в сортировке пузырьком, так как мы не проходим уже отсортированные пары элементов, поскольку отсортировали их на более ранних итерациях цикла for.
# Осуществляем меньше итераций, чем в сортировке пузырьком, так как мы не проходим уже отсортированные пары элементов, поскольку отсортировали их на более ранних итерациях цикла for.
<source lang="python">
<syntaxhighlight lang="python">
def SortList(a):
def SortList(a):
for i in range(1, len(a)):
for i in range(1, len(a)):
Строка 255: Строка 255:
j -= 1
j -= 1
return a
return a
</syntaxhighlight>
</source>
# В «range(1, len(a))» первым элементом множества значений установил 1, чтобы не проверять лишний раз условие «while j > 0 and a[j] < a[j - 1]».
# В «range(1, len(a))» первым элементом множества значений установил 1, чтобы не проверять лишний раз условие «while j > 0 and a[j] < a[j - 1]».
# Условие «j > 0» требуется для того, чтобы предотвратить выход j - 1 за границы списка.
# Условие «j > 0» требуется для того, чтобы предотвратить выход j - 1 за границы списка.


==Алгоритм создания множеств==
==Алгоритм создания множеств==
<source lang="python">
<syntaxhighlight lang="python">
def NewSet(a):
def NewSet(a):
for i in range(0, len(a)):
for i in range(0, len(a)):
Строка 270: Строка 270:
j += 1
j += 1
return a
return a
</syntaxhighlight>
</source>
Пусть, мы должны сравнивать все элементы списка с a[j]. Из этого следует то, что не все элементы со значением a[j] были удалены. Но это противоречит тому, что написано в теле цикла:
Пусть, мы должны сравнивать все элементы списка с a[j]. Из этого следует то, что не все элементы со значением a[j] были удалены. Но это противоречит тому, что написано в теле цикла:
<source lang="python">
<syntaxhighlight lang="python">
while j < len(a):
while j < len(a):
if a[j] == a[i]:
if a[j] == a[i]:
Строка 278: Строка 278:
else:
else:
j += 1
j += 1
</syntaxhighlight>
</source>
Таким образом, мы должны сравнивать все элементы с a[i], стоящие после a[i].
Таким образом, мы должны сравнивать все элементы с a[i], стоящие после a[i].


=Другие алгоритмы=
=Другие алгоритмы=
==Разделение строки по символам==
==Разделение строки по символам==
<source lang="python">
<syntaxhighlight lang="python">
sym = []
sym = []
sym.append(' ')
sym.append(' ')
Строка 298: Строка 298:
i += 1
i += 1
wI += 1
wI += 1
</syntaxhighlight>
</source>


==Алгоритм нахождения НОК==
==Алгоритм нахождения НОК==
НОК - наибольший общий делитель чисел M и N.
НОК - наибольший общий делитель чисел M и N.
<ol>
<ol>
<li><source lang="python">
<li><syntaxhighlight lang="python">
def NOK(a, b):
def NOK(a, b):
while a != 0 and b != 0:
while a != 0 and b != 0:
Строка 311: Строка 311:
b = b % a
b = b % a
return a + b
return a + b
</syntaxhighlight>
</source>
Выводим сумму, так не знаем в какой переменной именно хранится НОК. Значение одной из двух переменных после последней итерации будет равно 0.</li>
Выводим сумму, так не знаем в какой переменной именно хранится НОК. Значение одной из двух переменных после последней итерации будет равно 0.</li>
<li>Ниже используется правило «Если M>N, то НОД(М, N) = НОД(М - N, N)». Докажем правило. Пусть, K - один из общих делителей двух чисел, а m и n - числа, на которые умножается K, то M = mK, N = nK. Следовательно:
<li>Ниже используется правило «Если M>N, то НОД(М, N) = НОД(М - N, N)». Докажем правило. Пусть, K - один из общих делителей двух чисел, а m и n - числа, на которые умножается K, то M = mK, N = nK. Следовательно:
# M - N = mK - nK
# M - N = mK - nK
# M - N = K(m - n)
# M - N = K(m - n)
<source lang="python">
<syntaxhighlight lang="python">
def NOK(a, b):
def NOK(a, b):
while a != b:
while a != b:
Строка 324: Строка 324:
b = b - a
b = b - a
return a
return a
</syntaxhighlight>
</source>
Выводим a, так как a == b после последней итерации цикла.</li>
Выводим a, так как a == b после последней итерации цикла.</li>
</ol>
</ol>
Строка 330: Строка 330:
==Выборка элементов==
==Выборка элементов==
Пусть, a - список, состоящий из чисел. Следует выбрать только те числа, которые лежат в диапазонах: [1; 10], [21; 30] и т. д. Количество интервалов определяется переменной inters.
Пусть, a - список, состоящий из чисел. Следует выбрать только те числа, которые лежат в диапазонах: [1; 10], [21; 30] и т. д. Количество интервалов определяется переменной inters.
<source lang="python">
<syntaxhighlight lang="python">
def Get(a, inters):
def Get(a, inters):
for i in range(len(a)):
for i in range(len(a)):
Строка 347: Строка 347:
i += 20
i += 20
return count
return count
</syntaxhighlight>
</source>
Сортируем список для того, чтобы не выполнять во второй группе циклов лишние итерации.
Сортируем список для того, чтобы не выполнять во второй группе циклов лишние итерации.
<!--==Диапазоны==
<!--==Диапазоны==
<ol>
<ol>
<li>Пусть, есть диапазон размером s и начинающийся с a. Если мы стоим на элементе a, то попасть на последний элемент диапазона мы можем так:
<li>Пусть, есть диапазон размером s и начинающийся с a. Если мы стоим на элементе a, то попасть на последний элемент диапазона мы можем так:
<source lang="python">a[i + s - 1]</source></li>
<syntaxhighlight lang="python">a[i + s - 1]</syntaxhighlight></li>
<li>Пусть, есть диапазоны, располагающиеся на одинаковом расстоянии. Переменная d - количество элементов между диапазонами. Переход от первого элемента n-ого диапазона к первому элементу n + 1-ого диапазона будет выглядеть так:
<li>Пусть, есть диапазоны, располагающиеся на одинаковом расстоянии. Переменная d - количество элементов между диапазонами. Переход от первого элемента n-ого диапазона к первому элементу n + 1-ого диапазона будет выглядеть так:
<source lang="python">a[i + s + d]</source></li>
<syntaxhighlight lang="python">a[i + s + d]</syntaxhighlight></li>
<li>Пусть, есть диапазоны, располагающиеся на одинаковом расстоянии. Переменная d - количество элементов между диапазонами. m - смещение первого элемента первого диапазона относительно 0. Переход от первого элемента n-ого диапазона к первому элементу n + 1-ого диапазона будет выглядеть так:
<li>Пусть, есть диапазоны, располагающиеся на одинаковом расстоянии. Переменная d - количество элементов между диапазонами. m - смещение первого элемента первого диапазона относительно 0. Переход от первого элемента n-ого диапазона к первому элементу n + 1-ого диапазона будет выглядеть так:
<source lang="python">a[i + s + d + m]</source></li>
<syntaxhighlight lang="python">a[i + s + d + m]</syntaxhighlight></li>
<li>Пусть, есть диапазоны, располагающиеся на одинаковом расстоянии. Переменная d - количество элементов между диапазонами. m - смещение первого элемента первого диапазона относительно 0. Переход от первого элемента n-ого диапазона к первому элементу n + k-ого диапазона будет выглядеть так:
<li>Пусть, есть диапазоны, располагающиеся на одинаковом расстоянии. Переменная d - количество элементов между диапазонами. m - смещение первого элемента первого диапазона относительно 0. Переход от первого элемента n-ого диапазона к первому элементу n + k-ого диапазона будет выглядеть так:
<source lang="python">a[i + (s + d)*k + m]</source></li>
<syntaxhighlight lang="python">a[i + (s + d)*k + m]</syntaxhighlight></li>
</ol>
</ol>
-->
-->
Строка 364: Строка 364:
==Удаление элементов==
==Удаление элементов==
Пусть, есть список a, из которого надо удалить n элементов, начиная с i-ого элемента. Код удаления элементов будет следующий:
Пусть, есть список a, из которого надо удалить n элементов, начиная с i-ого элемента. Код удаления элементов будет следующий:
<source lang="python">
<syntaxhighlight lang="python">
def Delete(a, i, n):
def Delete(a, i, n):
b = []
b = []
Строка 375: Строка 375:
return ''.join(b)[:len(b) - n:]
return ''.join(b)[:len(b) - n:]
</syntaxhighlight>
</source>


==Сортировка по алфавиту==
==Сортировка по алфавиту==
Строка 381: Строка 381:
# Создать список, определяющий номер каждой первой буквы каждой строки в алфавите.
# Создать список, определяющий номер каждой первой буквы каждой строки в алфавите.
# Отсортировать два списка.
# Отсортировать два списка.
<source lang="python">
<syntaxhighlight lang="python">
def SortList(a):
def SortList(a):
alph = 'abcdefgijklmnopqrstuvwxyz'
alph = 'abcdefgijklmnopqrstuvwxyz'
Строка 397: Строка 397:
a[i], a[j] = a[j], a[i]
a[i], a[j] = a[j], a[i]
return a
return a
</syntaxhighlight>
</source>
Вариант с кэшированием уже найденных символов:
Вариант с кэшированием уже найденных символов:
<source lang="python">
<syntaxhighlight lang="python">
def SortList(a):
def SortList(a):
alph = 'abcdefgijklmnopqrstuvwxyz'
alph = 'abcdefgijklmnopqrstuvwxyz'
Строка 421: Строка 421:
a[i], a[j] = a[j], a[i]
a[i], a[j] = a[j], a[i]
return a
return a
</syntaxhighlight>
</source>
===Сортировка словаря===
===Сортировка словаря===
Сам словарь отсортировать невозможно напрямую.
Сам словарь отсортировать невозможно напрямую.
<source lang="python">
<syntaxhighlight lang="python">
def SortList(d):
def SortList(d):
a = d.keys()
a = d.keys()
Строка 441: Строка 441:
a[i], a[j] = a[j], a[i]
a[i], a[j] = a[j], a[i]
return a
return a
</syntaxhighlight>
</source>
===Поиск подстроки===
===Поиск подстроки===
<source lang="python">
<syntaxhighlight lang="python">
def Find(Str, substr):
def Find(Str, substr):
k = 0 # Количество равных символов.
k = 0 # Количество равных символов.
Строка 461: Строка 461:
else:
else:
return -1
return -1
</syntaxhighlight>
</source>
====Поиск подстроки по шаблону====
====Поиск подстроки по шаблону====
Для каждого символа строки Str мы задаем список допустимых для него значений.
Для каждого символа строки Str мы задаем список допустимых для него значений.
<source lang="python">
<syntaxhighlight lang="python">
def Find(Str, patternL):
def Find(Str, patternL):
k = 0 # Количество равных символов.
k = 0 # Количество равных символов.
Строка 482: Строка 482:
else:
else:
return -1
return -1
</syntaxhighlight>
</source>
Пример использования:
Пример использования:
<source lang="python">
<syntaxhighlight lang="python">
Find('a1b324a2b124',[['a', 'b'], ['1']])
Find('a1b324a2b124',[['a', 'b'], ['1']])
</syntaxhighlight>
</source>


===Удаление подстроки===
===Удаление подстроки===
# В условии «(len(Str) > len(substr)) and (len(substr) != 0)» не пишем «and (len(Str) != 0)», так как часть условия «len(Str) > len(substr)» исключает это условие.
# В условии «(len(Str) > len(substr)) and (len(substr) != 0)» не пишем «and (len(Str) != 0)», так как часть условия «len(Str) > len(substr)» исключает это условие.
# i меняется от 0 до суммы разности длин строк и единицы, так как последнее значение в функции «range(0, len(Str) - len(substr) + 1)» не включается.
# i меняется от 0 до суммы разности длин строк и единицы, так как последнее значение в функции «range(0, len(Str) - len(substr) + 1)» не включается.
<source lang="python">
<syntaxhighlight lang="python">
def DeleteSubstr(Str, substr):
def DeleteSubstr(Str, substr):
k = 0 # Количество равных символов.
k = 0 # Количество равных символов.
Строка 517: Строка 517:
else:
else:
return -1
return -1
</syntaxhighlight>
</source>
<source lang="python">
<syntaxhighlight lang="python">
def DeleteSubstrs(Str, substr):
def DeleteSubstrs(Str, substr):
k = 0 # Количество равных символов.
k = 0 # Количество равных символов.
Строка 544: Строка 544:
else:
else:
return -1
return -1
</syntaxhighlight>
</source>
<source lang="python">
<syntaxhighlight lang="python">
def DeleteSubstrs(Str, substr):
def DeleteSubstrs(Str, substr):
s = Str
s = Str
Строка 551: Строка 551:
s = DeleteSubstr(s, substr)
s = DeleteSubstr(s, substr)
return s
return s
</syntaxhighlight>
</source>
==Поиск корня==
==Поиск корня==
Нахождение квадратного корня:
Нахождение квадратного корня:
<source lang="python">
<syntaxhighlight lang="python">
import math
import math
def Sqrt(x):
def Sqrt(x):
Строка 565: Строка 565:
a = a*1.5
a = a*1.5
return a
return a
</syntaxhighlight>
</source>
Нахождение корня n-ной степени:
Нахождение корня n-ной степени:
<source lang="python">
<syntaxhighlight lang="python">
import math
import math
def Sqrt(x, n):
def Sqrt(x, n):
Строка 577: Строка 577:
a = a*1.5
a = a*1.5
return a
return a
</syntaxhighlight>
</source>


=Четность и нечетность элемента в списке=
=Четность и нечетность элемента в списке=

Версия от 15:47, 16 апреля 2020



- перейти к комбинациям клавиш.
- перейти к первому необязательному для изучения разделу.
- переход к следующей по курсу главе (порядок глав не совпадает с порядком глав по содержанию).

CTRL+ALT+U

CTRL+U

SHIFT+S

CTRL+Q

A

R

G

S

SHIFT+D

ALT+D

CTRL+NUMPAD+

CTRL+NUMPAD-

SHIFT+L

SHIFT+G

ALT+M

F

CTRL+ALT+SHIFT+C

SHIFT+S

D

T

I

Shift+B

B

C

Одни из главных классов Python: bpy.ops | bpy.data | bpy.types.ID

Рендеринг Рендер-ферма
Отсечение Шейдер
Трассировка лучей Сжатие текстур

Расположение элементов интерфейса


Ссылки на материалы
Возможно, Вас заинтересует следующее:
О Blender 2.76 Скачать Blender 2.76

Алгебраические задачи

Перестановка значений переменных

def Swap(a, b):
    a = a + b
    b = a - b
    a = a - b

Циклы

Пусть, имеется переменная a, значение которой после цикла while надо узнать. Пусть, inc - число, на которое увеличивается a. B - переменная, задающая условие в цикле:

while a знак B:
    a = a + inc

inc - независимая переменная. Значение a приближается к значению B.

  1. Если неравенство нестрогое, то после цикла a = a + inc*(abs(B - a) // inc + 1).
  2. Если неравенство строгое, то рассматриваются два случая:
    1. Если B % inc != 0, то a = a + inc*(abs(B - a) // inc + 1).
    2. Если B % inc == 0, то a = a + inc*(abs(B - a) // inc).

Таким образом, если неравенство нестрогое или неравенство строгое и остаток от деления B на inc не равен 0, то a = a + inc*(abs(B - a) // inc + 1), а во всех остальных случаях a = a + inc*(abs(B - a) // inc)

Если a = B и неравенство нестрогое, то переменная a = a + inc.

Геометрические задачи

Расположение точки на диагонали

Пусть, имеется точка A(x, y), то будет или нет она располагается на диагонали, можно будет узнать так:

if math.fabs(x) == math.fabs(y):
    print("Точка на диагонали")

math.fabs(x) возвращает модуль числа x.

Точка находится под прямой

Пусть, имеется точка A(x, y), где x, y - нецелые числа. Уравнение прямой y = kx + b. Функция, возвращающая y в зависимости от x:

def getY(x, k, b):
    return k*x+b

Узнать ниже ли точка прямой или нет, можно, подставив ее x в уравнение прямой:

if y < getY(x, y, k):
    print("Точка под прямой.")

Точка на прямой

Пусть, имеется точка A(x, y), где x, y - нецелые числа. Узнать на прямой ли точка или нет, можно, подставив ее x в уравнение прямой:

if y == getY(x, y, k):
    print("Точка на прямой.")

Точка над прямой

Пусть, имеется точка A(x, y), где x, y - нецелые числа. Узнать выше прямой ли точка или нет, можно, подставив ее x в уравнение прямой:

if y > getY(x, y, k):
    print("Точка над прямой.")

Вычисление k перпендикулярной прямой

Пусть, имеется точки A(x, y) и A(x2, y2), задающие прямые, где x, y - нецелые числа. То зная k первой прямой вычислить k для второй можно следующим образом:

import math
k2 = math.tan(math.atan(k)+90)

Вычисление координат точки пересечения прямых

Пусть, прямые задаются такими уравнениями:

  1. y1 = k1*x + b1
  2. y2 = k2*x + b2

Приравняв их, получим: k1*x + b1 = k2*x + b2.

  1. k1*x - k2*x = b2 - b1
  2. x(k1 - k2) = b2 - b1

Следовательно, x = (b2 - b1)/(k1 - k2). Таким образом, узнать координаты точки пересечения прямых можно так:

x = (b2 - b1)/(k1 - k2)
y = k1*x + b1 # Без разницы, в уравнение какой прямой подставлять.

Вычисление коэффициента наклона прямой

Пусть, прямая проходит через две точки: A(x, y) и B(x1, y1). Причем, точка B лежит правее и выше точки A. Тогда вычисление коэффициента k для уравнения прямой будет выглядеть следующим образом:

k = (y1 - y)/(x1 - x)

Столкновения

Окружность с окружностью

Если расстояние между радиусами окружностей больше суммы их радиусов, то они не пересекаются:

import math
if (math.sqrt((circle1.x - circle2.x)**2 + (circle1.y - circle2.y)**2) >= circle1.r + circle2.r):
    print("Окружности не пересекаются.")

Здесь circle1 и circle2 - окружности.

Пересечение отрезков


Схема определения пересечения отрезков выглядит так:

Если проекции отрезков на ось X пересекаются:

Найти точку пересечения прямых, на которых лежат отрезки.
Если координата точки пересечения принадлежит одновременно двум проекциям отрезков на ось X, то:
Отрезки пересекаются.
Иначе:
Отрезки не пересекаются.

Пусть, есть две точки, составляющих первый отрезок: A(x, y) и B(x1, y1). Пусть, есть две точки, составляющие второй отрезок: C(x2, y2) и D(x3, y3). Пусть, точки расположены по оси +X в таком порядке: A, B, C, D.

if ((x1 >= x3) and (x1 <= x4)) or ((x >= x3) and (x <= x4)):
    intersectX = (b2 - b1)/(k1 - k2)
    if ((intersectX >= x) and (intersectX <= x1)) or ((intersectX >= x2) and (intersectX <= x3)):
        print('Отрезки пересекаются.')
    else:
        print('Отрезки не пересекаются.')
else:
    print('Отрезки не пересекаются.')

Данная схема будет корректно работать лишь в том случае, если ни один из отрезков не перпендикулярен оси X.

Принципы написания UI

Аббревиатура «UI» расшифровывается на русский язык как «пользовательский интерфейс».

Кнопки


Границей любой кнопки обычно является прямоугольник, поэтому проверка на принадлежность точки A(x, y) этому прямоугольнику можно задать следующим условием:

if (A.x >= button.x) and (A.y >= button.y) and (A.x <= button.x + button.width) and (A.y <= button.y + button.heigth):
  1. A.x - X координата точки
  2. A.y - Y координата точки
  3. button.x - X координата левого верхнего угла прямоугольника
  4. button.y - Y координата левого верхнего угла прямоугольника
  5. button.width - ширина прямоугольника
  6. button.height - высота прямоугольника

Ползунки

Любой ползунок представляет собой два прямоугольника. Первый - границы ползунка, второй - значение ползунка. Напишем функцию, которая определит лежит ли точка в границах первого прямоугольника «border»:

def intersect(A, border):
    if (A.x >= border.x) and (A.y >= border.y) and (A.x <= border.x + border.width) and (A.y <= border.y + border.heigth):
        return True
    else:
        return False

Пусть, Вы перемещайте ползунок, то код для обработки изменения значения ползунка будет следующий:

if cursor.x < border.x:
    value.x = border.x
elif cursor.x > border.x + border.width:
    value.x = border.x + border.width
else:
    value.x = cursor.x

Архитектура игровых классов

При написании проекта следует определить будет ли он 2D или 3D игрой. С учетом этого, следует строить архетиктуру классов проекта.

2D игры - пример архитектуры классов

class Object
    # свойства
    x_position, y_position, width, height, fill_color, border_color, border_width, filled, bordered
    class Lamp(Object)
        # свойства
        energy, distance
    class Dynamic(Object)
        # свойства
        mass, radius

Здесь основные свойства объекта занесены в один класс «Object», так как их мало.

3D игры - пример архитектуры

Так как 3D игры - игры с более навороченной графикой, то было бы предпочтительнее использовать такую систему классов:

class Material
    # свойства
    fill_color, border_color, border_width, filled, bordered
class Object
    # свойства
    x_position, y_position, width, height
    # ссылка на объект:
    material
    class Lamp(Object)
        # свойства
        energy, distance
    class Dynamic(Object)
        # свойства
        mass, radius

Калькулятор

Пусть, наш калькулятор поддерживает выражения вида a±b, a/b и a*b. Пусть, a, b € [0; 9]. Код калькулятора будет следующий:

while True:
    text = input()
    if len(text) != 3:
        print("Длина строки не равна 3.")
    else:
        a = int(text[0])
        b = int(text[2])
        if text[1] == "+":
            print(a + b)
        elif text[1] == "-":
            print(a - b)
        elif text[1] == "/":
            print(a / b)
        elif text[1] == "*":
            print(a * b)
        else:
            print("Недопустимая операция.")

Сортировки

Диски

Пусть, имеем три палки «A», «B» и «C», причем изначально все диски лежат на «A». Следует отсортировать диски по возрастанию (от верхнего к нижниму), если мы можем видеть только верхние диски.

Пока на палке «A» находится не ноль дисков:

Перекинуть верхний диск с «A» на «B».
Повторить цикл такое количество раз, которое равно n (n - количество дисков на «A»):
Если диск на «B» меньше, чем на «A», то скинуть диск с «A» на «B».
Перекинуть диск с «B» на «C».
Перекинуть такое количество дисков с «B» на «A», которое равно n - m (n - количество всех дисков на «B», а m - количество циклов, уменьшенное на единицу).
Перекинуть диск с «C» на «B».

Сортировка при помощи функций списков

Самый неудачный, но возможный вариант сортировки представлен ниже:

def SortList(a):
    b = list()
    for i in range(0, len(a)):
        m = a.min(a)
        b.append(m)
        a.remove(m)
    return b

Недостатки:

  1. Используется два списка.
  2. Слишком много используется встроенных функций.
  3. Медленная сортировка.

Использование встроенных в Python функций не гарантирует быструю скорость работы алгоритма.

Сортировка пузырьком

  1. Проходим по списку несколько раз, чтобы правильно отсортировать все элементы в правильном порядке. Не всегда после n-ной итерации все элементы списка будут отсортированы.
  2. Сначала мы ищем минимальный элемент во всем списке, потом - в его оставшейся части.
def SortList(a):
    for i in range(0, len(a)):
        for j in range(len(a) - 1, i, -1):
            if a[j] < a[j-1]:
                a[j], a[j - 1] = a[j - 1], a[j]
    return a
def SortList(a):
    for i in range(len(a) - 1, -1):
        for j in range(0, i):
            if a[j] < a[j + 1]:
                a[j], a[j + 1] = a[j + 1], a[j]
    return a

Сортировка выбором

def SortList(a):
    for i in range(0, len(a)):
        for j in range(i + 1, len(a)):
            if a[i] > a[j]:
                a[i], a[j] = a[j], a[i]
    return a
  1. Переменные i и j изменяются в одном направлении - увеличиваются.
  2. Сравнивая с все элементы списка, стоящие после a[i], с a[i], мы находим минимум из множества значений (a[i], a[len(a)-1]]. При следующей итерации новый минимум будет искаться из оставшихся элементов, поэтому следующий минимум будет больше предыдущего минимума.

Сортировка вставками

Отличается от сортировки пузырьком тем, что:

  1. Переменные i и j изменяются в разных направлениях.
  2. Осуществляем меньше итераций, чем в сортировке пузырьком, так как мы не проходим уже отсортированные пары элементов, поскольку отсортировали их на более ранних итерациях цикла for.
def SortList(a):
    for i in range(1, len(a)):
        j = i
        while (j > 0) and (a[j] < a[j - 1]):
            a[i], a[j] = a[j], a[i]
            j -= 1
    return a
  1. В «range(1, len(a))» первым элементом множества значений установил 1, чтобы не проверять лишний раз условие «while j > 0 and a[j] < a[j - 1]».
  2. Условие «j > 0» требуется для того, чтобы предотвратить выход j - 1 за границы списка.

Алгоритм создания множеств

def NewSet(a):
    for i in range(0, len(a)):
        j = i + 1
        while j < len(a):
            if a[j] == a[i]:
                a.remove(a[j])
            else:
                j += 1
    return a

Пусть, мы должны сравнивать все элементы списка с a[j]. Из этого следует то, что не все элементы со значением a[j] были удалены. Но это противоречит тому, что написано в теле цикла:

while j < len(a):
    if a[j] == a[i]:
        a.remove(a[j])
    else:
        j += 1

Таким образом, мы должны сравнивать все элементы с a[i], стоящие после a[i].

Другие алгоритмы

Разделение строки по символам

sym = []
sym.append(' ')
sym.append(';')
words = []
wI = 0
s = input()
i = 0
while i < len(s):
    while (i < len(s)) and (s[i] in sym):
        i += 1
    while (i < len(s)) and not (s[i] in sym):
        sym[wI] = sym[wI] + s[i]
        i += 1
    wI += 1

Алгоритм нахождения НОК

НОК - наибольший общий делитель чисел M и N.

  1. def NOK(a, b):
        while a != 0 and b != 0:
            if a > b:
                a = a % b
            else:
                b = b % a
        return a + b
    
    Выводим сумму, так не знаем в какой переменной именно хранится НОК. Значение одной из двух переменных после последней итерации будет равно 0.
  2. Ниже используется правило «Если M>N, то НОД(М, N) = НОД(М - N, N)». Докажем правило. Пусть, K - один из общих делителей двух чисел, а m и n - числа, на которые умножается K, то M = mK, N = nK. Следовательно:
    1. M - N = mK - nK
    2. M - N = K(m - n)
    def NOK(a, b):
        while a != b:
            if a > b:
                a = a - b
            else:
                b = b - a
        return a
    
    Выводим a, так как a == b после последней итерации цикла.

Выборка элементов

Пусть, a - список, состоящий из чисел. Следует выбрать только те числа, которые лежат в диапазонах: [1; 10], [21; 30] и т. д. Количество интервалов определяется переменной inters.

def Get(a, inters):
    for i in range(len(a)):
        for j in range(i + 1, len(a)):
            if a[j - 1] > a[j]:
                a[j], a[j - 1] = a[j - 1], a[j]
    
    i = 1
    count = 0
    while i <= inters*20:
        j = 0
        while (j < len(a)) and (a[j] <= i + 9):
            if (a[j] >= i) and (a[j] <= i + 9):
                count += 1
            j += 1
        i += 20
    return count

Сортируем список для того, чтобы не выполнять во второй группе циклов лишние итерации.

Удаление элементов

Пусть, есть список a, из которого надо удалить n элементов, начиная с i-ого элемента. Код удаления элементов будет следующий:

def Delete(a, i, n):
    b = []
    
    for i2 in range(0, len(a)):
        b.append(a[i2])
    
    for i2 in range(i, len(b) - n):
        b[i2] = b[i2 + n]
    
    return ''.join(b)[:len(b) - n:]

Сортировка по алфавиту

Пусть, a - список, который следует отсортировать по алфавиту. Алгоритм:

  1. Создать список, определяющий номер каждой первой буквы каждой строки в алфавите.
  2. Отсортировать два списка.
def SortList(a):
    alph = 'abcdefgijklmnopqrstuvwxyz'
    b = []
    for s in a:
        i = 0
        while s[0].lower() != alph[i]:
            i += 1
        b.append(i)
    
    for i in range(0, len(a)):
        for j in range(i + 1, len(a)):
            if b[i] > b[j]:
                b[i], b[j] = b[j], b[i]
                a[i], a[j] = a[j], a[i]
    return a

Вариант с кэшированием уже найденных символов:

def SortList(a):
    alph = 'abcdefgijklmnopqrstuvwxyz'
    K = {}
    b = []
    
    for s in a:
        i = 0
        try:
            b.append(K[s[0]])
        except KeyError:
            while s[0].lower() != alph[i]:
                i += 1
            K[s[0]] = alph[i]
            b.append(i)
    
    for i in range(0, len(a)):
        for j in range(i + 1, len(a)):
            if b[i] > b[j]:
                b[i], b[j] = b[j], b[i]
                a[i], a[j] = a[j], a[i]
    return a

Сортировка словаря

Сам словарь отсортировать невозможно напрямую.

def SortList(d):
    a = d.keys()
    alph = 'abcdefgijklmnopqrstuvwxyz'
    b = []
    for s in a:
        i = 0
        while s[0].lower() != alph[i]:
            i += 1
        b.append(i)
    
    for i in range(0, len(a)):
        for j in range(i + 1, len(a)):
            if b[i] > b[j]:
                b[i], b[j] = b[j], b[i]
                a[i], a[j] = a[j], a[i]
    return a

Поиск подстроки

def Find(Str, substr):
    k = 0 # Количество равных символов.
    if (len(Str) > len(substr)) and (len(substr) != 0):
        for i in range(0, len(Str) - len(substr) + 1):
            if k != len(substr):
                for j in range(0, len(substr)):
                    if substr[j] != Str[j + i]:
                        break
                    else:
                        k += 1
                if k == len(substr):
                    return i
                else:
                    k = 0
        return -1
    else:
        return -1

Поиск подстроки по шаблону

Для каждого символа строки Str мы задаем список допустимых для него значений.

def Find(Str, patternL):
    k = 0 # Количество равных символов.
    if (len(Str) > len(patternL)) and (len(patternL) != 0):
        for i in range(0, len(Str) - len(patternL) + 1):
            if k != len(patternL):
                for j in range(0, len(patternL)):
                    if not Str[j + i] in patternL[j]:
                        break
                    else:
                        k += 1
                if k == len(patternL):
                    return i
                else:
                    k = 0
        return -1
    else:
        return -1

Пример использования:

Find('a1b324a2b124',[['a', 'b'], ['1']])

Удаление подстроки

  1. В условии «(len(Str) > len(substr)) and (len(substr) != 0)» не пишем «and (len(Str) != 0)», так как часть условия «len(Str) > len(substr)» исключает это условие.
  2. i меняется от 0 до суммы разности длин строк и единицы, так как последнее значение в функции «range(0, len(Str) - len(substr) + 1)» не включается.
def DeleteSubstr(Str, substr):
    k = 0 # Количество равных символов.
    if (len(Str) > len(substr)) and (len(substr) != 0):
        for i in range(0, len(Str) - len(substr) + 1):
            if k != len(substr):
                for j in range(0, len(substr)):
                    if substr[j] != Str[j + i]:
                        break
                    else:
                        k += 1
                if k == len(substr):
                    b = []
                    
                    for i2 in range(0, len(Str)):
                        b.append(Str[i2])
                    
                    for i2 in range(i, len(Str) - len(substr)):
                        b[i2] = b[i2 + len(substr)]
                    
                    return ''.join(b)[:len(b) - len(substr):]
                else:
                    k = 0
        return -1
    else:
        return -1
def DeleteSubstrs(Str, substr):
    k = 0 # Количество равных символов.
    if (len(Str) > len(substr)) and (len(substr) != 0):
        for i in range(0, len(Str) - len(substr) + 1):
            if k != len(substr):
                for j in range(0, len(substr)):
                    if substr[j] != Str[j + i]:
                        break
                    else:
                        k += 1
                if k == len(substr):
                    b = []
                    
                    for i2 in range(0, len(Str)):
                        b.append(Str[i2])
                    
                    for i2 in range(i, len(Str) - len(substr)):
                        b[i2] = b[i2 + len(substr)]
                    
                    Str = ''.join(b)[:len(b) - len(substr):]
                else:
                    k = 0
        return Str
    else:
        return -1
def DeleteSubstrs(Str, substr):
    s = Str
    while DeleteSubstr(s, substr) != -1:
        s = DeleteSubstr(s, substr)
    return s

Поиск корня

Нахождение квадратного корня:

import math
def Sqrt(x):
    a = 0.5*x
    if 
    while math.floor(a**2) != x:
        if a**2 > x:
            a = a*0.5
        elif a**2 < x:
            a = a*1.5
    return a

Нахождение корня n-ной степени:

import math
def Sqrt(x, n):
    a = 0.5*x
    while math.floor(a**n) != x:
        if a**n > x:
            a = a*0.5
        elif a**n < x:
            a = a*1.5
    return a

Четность и нечетность элемента в списке

Индекс, с которого начинается отсчет Формула для нечетных элементов Формула для четных элементов
четный индекс % 2 == 0 индекс % 2 != 0
нечетный индекс % 2 != 0 индекс % 2 == 0
  1. Если считать от четного индекса, то у нечетных элементов будут четные индексы, а у четных - нечетные.
  2. Если считать от нечетного индекса, то у нечетных элементов будут нечетные индексы, а у четных - четные.