def iterator(self):
for boid in self.boids:
for nextBoid in self.boids:
if boid != nextBoid:
# Cohesion: Steer towards average position
if self.distance(boid, nextBoid) <= 200:
newVector = funcs.subtract(
self.getMeanPosition(boid, nextBoid),
boid.position) # Vector to next boid
newAcceleration = funcs.add(
boid.acceleration,
newVector) # New acceleration vector
boid.acceleration = funcs.limit(
newAcceleration,
boid.maxAcceleration) # Limit max acceleration
if self.distance2(boid, self.getMousePosition()) <= 30:
newVector = funcs.subtract(
boid.position,
self.getMousePosition()) # Vector to next boid
newAcceleration = funcs.add(
boid.acceleration,
newVector) # New acceleration vector
boid.acceleration = funcs.limit(
newAcceleration, .01) # Limit max acceleration
if self.distance(boid, nextBoid) <= 20:
newVector = funcs.subtract(
boid.position,
nextBoid.position) # Vector to next boid
newAcceleration = funcs.add(
boid.acceleration,
newVector) # New acceleration vector
boid.acceleration = funcs.limit(
newAcceleration, .01) # Limit max acceleration
if self.distance(boid, nextBoid) <= 30:
newVector = funcs.subtract(
nextBoid.velocity,
boid.velocity) # Vector to next boid
newAcceleration = funcs.add(
boid.acceleration,
newVector) # New acceleration vector
boid.acceleration = funcs.limit(
newAcceleration, .005) # Limit max acceleration
boid.calculatePhysics()
boid.update()
def test_add(self):
# TestCase #1
self.assertEqual(f.add(2, 3), 5)
self.assertEqual(f.add(0, 10), 10)
self.assertEqual(f.add(10, 0), 10)
self.assertEqual(f.add(0, 0), 0)
self.assertEqual(f.add(-2, -3), -5)
self.assertEqual(f.add(2, -2), 0)
self.assertEqual(f.add(-2, 4), 2)
print('\n\n\t.....Welome to the calculator.....\n')
print('Enter the two numbers : A and B\n')
A = int(input('A : '))
B = int(input('B : '))
oop = 1
print(
'Press 1 for adding A+B \nPress 2 for subtrating A-B \nPress 3 for subtracting B-A'
)
print(
'Press 4 for multipying A x B \nPress 5 for dividing A/B \nPress 6 for dividing B/A'
)
while oop != 0:
oop = int(input('Enter Choice : '))
if funcs.validate2(oop):
if oop == 1:
print('\nA + B = ' + str(funcs.add(A, B)))
elif oop == 2:
print('\nA - B = ' + str(funcs.sub(A, B)))
elif oop == 3:
print('\nB - A = ' + str(funcs.sub(B, A)))
elif oop == 4:
print('\nA x B = ' + str(funcs.prod(A, B)))
elif oop == 5:
print('\nA / B = ' + str(funcs.divide(A, B)))
elif oop == 6:
print('\nB / A = ' + str(funcs.divide(B, A)))
else:
print('\n Enter a valid number(0-6) : \n')
print('\t\t......Exiting Calculator.....')
else:
def test_add():
assert f.add(2, 3) == 5
assert f.add(4, 8) == 12
Разделенная область имен. Для обращения к элементу стороннего модуля
необходимо указывать имя модуля при импортировании, а затем, через точку, то, что мы хотим вызвать из
стороннего модуля. Пример:
import funcs
funcs.add(10, 20)
Разделенная область имен имеет ряд преимуществ в тех ситуациях, когда при разработке
могут возникать коллизии. То есть встречаться одинаковые имена в различных модулях.
"""
"""
Для решения проблемы разделения функционала модуля на функционал при вызове и функционал при импортировании,
используют переменную __name___.
__name__ => caller (кто вызвал данный модуль)
__name__ == "__main__" если модуль был запущен напрямую (python module.py)
__name__ == "module" (если модуль был импортирован)
"""
"""
А что если имя модуля длинное или неудобное?
В языке есть способность вешать местоимения на имена импортируемых
модулей.
import funcs as f
"""
import funcs as f
print("Funcs.add():", f.add(10, 20))
print("Funcs.DB_URI:", f.DB_URI)
def test_add(self):
eq_(f.add(1, 2), 3)
eq_(f.add(5, 10), 15)
eq_(f.add(-1, 1), 0)
def test4(self):
f = funcs.add(-2)
self.assertEqual(f(2), 0)
self.assertEqual(f(9), 7)
def test3(self):
f = funcs.add(10)
self.assertEqual(f(2), 12)
self.assertEqual(f(9), 19)
"""
Подгрузка модуля funcs.py с совмещенной областью именования
"""
from funcs import add, sub, mult
def add2(a, b):
print("MY ADD HERE!")
return a**2 + b**3
print("Add:", add(2, 10))
print("Sub:", sub(2, 10))
print("Mult:", mult(3, 4))
import funcs as f
"""
В общем случае процесс модульного тестирования выглядит следующим образом
* выбираются по-очереди все юниты (функции, классы и т.д.)
* затем данные юниты выполняются на каком-то тестовом наборе (предположительно правильном)
* если юнит проходит все тестовые наборы - значит юнит валидный
* целый блок (программный модуль) работает верно <=> каждый юнит валидный
"""
"""
Блок кода, вмещающий в себя набор Test-Case'ов для одного юнита - это один тест
"""
# Test-case #1
if f.add(2, 3) == 5:
print("add(2,3) == 5. Test passed!")
else:
raise ValueError("add(2,3) != 5. Test failed!")
# Test-case #2
if f.add(0, 10) == 10:
print('add(0, 10) == 10. Test passed!')
else:
raise ValueError("add(0,10) != 10. Test failed!")
if f.sub(10, 20) == -10:
print('sub(10, 20) == -10. Test passed!')
else:
raise ValueError("sub(10,20) != -10. Test failed!")
if f.mult(1, 10) == 10:
print('mult(1, 10) == 10. Test passed!')
else:
def test_add():
assert f.add(2, 3) == 5
assert f.add(3, 3) == 6
assert f.add(10, -10) == 0
for i in range(0, 100):
assert f.add(i, i) == 2 * i
def test4(self):
f = funcs.add(-2)
self.assertEqual(f(2), 0)
self.assertEqual(f(9), 7)
def test3(self):
f = funcs.add(10)
self.assertEqual(f(2), 12)
self.assertEqual(f(9), 19)
def test_add(self):
self.assertEqual(f.add(2, 3), 5)
self.assertEqual(f.add(0, 5), 5)
self.assertEqual(f.add(-1, -2), -3)
"""
Подгрузка модуля funcs.py с разделенной областью именования
При импортировании модуля - интерпретатор выполняет целиком
импортируемый модуль, и только после этого возвращает управление
к abuser.py
Если нам лень писать много букав
"""
import funcs as f
def add(a, b):
return a + b**2
print("My add(2,3):", add(2, 3))
print("From funcs add(2,3):", f.add(2, 3))
print("Temp:", f.TEMPERATURE)
