Study & Dev | Blog Archive | Программируем трехмерную графику с Irrlicht . Часть 8

Программируем трехмерную графику с Irrlicht . Часть 8

August 8, 2007

Эффективное программирование 3d-приложений с помощью Irrlicht и jython. Часть 8

В прошлый раз мы учились выводить на экран надписи в irrlicht, изучали методы работы со строками текста (модуль string). Сегодня мы отложим немного в сторону irrlicht и продолжим изучать собственные средства python|jython. Сложность наших примеров будет с каждым разом возрастать и нам необходимы способы оперировать большим количеством сложноорганизованной информации. Т.е. нам нужен механизм группировки множества переменных в централизованные группы и нужны способы выполнять ВЗАИМОСВЯЗАННЫЕ действия сразу над множеством этих переменных.

Например, если у нас есть объект машинка, то мы не можем ее представлять как множество переменных, например, задающих координаты, цвет, скорость, количество бензина - ПООТДЕЛЬНОСТИ. Мы должны объединить эти переменные в единое целое и работать как с единым целым, так, если координаты машинки изменились, то очевидно, что количество топлива должно автоматически уменьшиться. Итак, наша сегодняшняя тема - это работа со списками и классами.

Но сначала мы вернемся еще немного назад и вспомним, как в части 6 мы работали с пользовательскими функциями. Нам осталось разобраться с тем, как функция взаимодействует с переменными, которые находятся (т.е. были созданы вне ее тела). Вот пример для рассмотрения.

```
import sys
```
```
import math 
```

# подключаем модуль math в нем есть функция извлечения квадратного корня - sqrt

# создаем функцию вычисляющую корни квадратного уравнения

```
def calcRoots (a,b,c):
```

    d = b**b - 4*a*c # вычисляем определитель

    if d > 0: # и сравниваем его с “0”

```
        return (
```

            (-b + math.sqrt(d))/(2*a), (-b - math.sqrt(d))/(2*a)

```
        )
```
```
    elif d == 0:
```
```
        return ((-b )/(2*a))
```
```
    else:
```
```
        return ()
```

# создаем функцию выполняющую модификацию двух переданных переменных a,b

```
def modify (a , b):
```
```
    a = 11
```
```
    b = 12
```

    g = a + b # здесь мы пытаемся изменить некоторую переменную g

# создав эти две функции, вызовем их

```
print calcRoots(1, 6 ,3)
```
```
print type( calcRoots(1, 6 ,3) )
```
```
a = 1 
```

# создаем три переменные с такими же именами как и те которые используются внутри функции modify

```
b = 2
```
```
g = 3
```
```
modify (a, b)
```
```
print ' a = ' , a
```
```
print ' b = ' , b
```
```
print ' g = ' , g
```
```
print ' d = ' , d
```

Вот результат выполнения программы.

(104.98611021793498, -110.98611021793498)

```
<type 'tuple'>
```
```
 a =  1
```
```
 b =  2
```
```
 g =  3
```
```
 d =
```
```
Traceback (most recent call last):
```
```
  File "a5.py", line 35, in ?
```
```
    print ' d = ' , d
```
```
NameError: name 'd' is not defined
```

Начнем анализ вышеприведенного кода с рассмотрения функции modify. Эта функция получает в качестве своих параметров две переменные a,b. Внимание, до вызова функции я в теле программы создал эти переменные со значениями 1 и 2, также была создана переменная g, но, и это важно, которая не передается внутрь функции modify. После вызова modify, внутри которой я присваиваю всем трем переменным (двум переданным как аргументы функции и еще одной g) новые значения, я вывожу чему же равны эти переменные. Они не изменились, так a = 1, b =2 , g = 3. Отсюда вывод, что функция не может изменить те переменные, которые были созданы вовне ее. Если функция создаст какую-то переменную, то это будет ее локальная переменная, которая исчезнет, как только функция завершит работу. Так, например, произошло с переменной d, которая была создана внутри функции calcRoots. Попытка распечатать d за пределами функции calcRoots привела к ошибке.

Более того, пример с функцией calcRoots, ищущей корни квадратного уравнения ставит перед нами нетривиальную проблему. Как известно у квадратного уравнения всегда есть два корня. Просто если детерминант равен нулю, то они совпадают, а если D < 0, то корни лежат в плоскости комплексных чисел (в примере я упростил, положив как в школьном курсе математике, что если D < 0, то корней нет). Следовательно, мне необходим способ вернуть из функции два, один, ноль чисел, в зависимости от того чему равен дискриминант. Написать друг за дружкой два оператора return, надеясь, мол, сколько return-ов, столько и возвращаемых переменных, не пойдет. Как только сработает первый return, то выполнение функции тут же прекратится.

На этот случай в python есть такой тип данных как tuple. Именно это слово будет напечатано после вызова: print type( calcRoots(1, 6 ,3) ). Так мы получили . Функция type получающая в качестве параметра некоторое значение определяет название типа данных этой переменной. Вообще-то tuple - это частный случай списка. Список – это просто множество каких-то элементов, чисел, строк, чего угодно. У списка, равно как и у tuple, можно узнать его длину, а также получить по порядковому номеру его элемент. Список можно изменять, а вот tuple менять нельзя. В примере ниже я не сразу распечатываю результат вызова calcRoots а сохраняю в переменной tu:

```
tu = calcRoots(1, 6 ,3)
```

print tu # печатаем всю tuple сразу

print 'tuple size = ' , len(tu) # печатаем количество элементов списка tuple

print 'element of tuple # 0 = ' , tu [0] # печатаем первый элемент списка, нумерация идет от нуля

tu [0] = 'hello' # попытка присвоить новое значение – изменить элемент tuple

print tu # распечатаем что же там изменилось в tuple

В результате мы получим ошибку, именно при попытке изменить содержимое tuple.

Так же как и при работе со строками в части 7, мы не можем модифицировать существующую tuple или строку, а только создать новую tuple|строку.

```
Traceback (most recent call last):
```
```
  File "a5.py", line 29, in ?
```
```
    tu [0] = 'hello'
```

TypeError: object does not support item assignment

Для того чтобы создать tuple нужно всего лишь написать в круглых (именно в круглых скобках) скобках список значений. Например, (1,2,3,4) – вот пример tuple из четырех чисел, или так: (1,2,3, “hello world”).

Как вывод: tuple это список значений, любых типов данных, который не может быть изменен, но позволяет получить его длину и любой элемент с помощью порядкового номера.

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

Однако предположим, что эта функция может быть использована для рисования и квадратов, ведь это частный случай прямоугольника, только стороны в нем равны. Может, проще было бы иметь такую функцию, которая получала бы центр прямоугольника, его высоту, а параметр широты был бы не обязателен. Тогда бы функция, проверив сколько параметров было реально передано ей при вызове, рисовала бы либо квадрат, либо прямоугольник. Вот пример функции находящей максимальное значение из трех чисел, или из двух.

```
def find_max (a, b, c = False): 
```

# аргумент функции c необязателен и имеет значение по-умолчанию False – ложь.

Какое значение вы выберете не важно, главное в том,

чтобы вы всегда могли бы определить, было ли значение этой переменной передано

при ее вызове или же нет, брать на роль значения по-умолчанию любое число,

в именно этой задаче, несколько рискованно

```
    if a < b:
```
```
        d = b
```
```
    else:
```
```
        d = a
```
```
    if c != False:
```
```
        if c > d:
```
```
            return c
```
```
        else:
```
```
            return d
```
```
    else:
```
```
        return d
```
```
 
```

print find_max (20, 6) # вызываем поиск максимального числа среди двух чисел

print find_max (20, 6, 30) # вызываем поиск максимального числа уже среди всех трех аргументов

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

def find_anything (kind = 'max', *values):

```
    if len(values) == 0:
```

        return # нет возвращаемого значения

```
    found = values [0]
```
```
    i = 1
```
```
    while i < len(values):
```
```
        if (kind == 'max'):
```
```
            if (found < values[i]):
```
```
                found = values [i]
```
```
        else:
```
```
            if found > values [i]:
```
```
                found = values[i]
```
```
        i = 1 + i
```
```
    return found
```
```
 
```

print find_anything('max', 4, 7, 2 , 4 , 9 , 7 , 6   )

# ищем максимальное значение в списке

print find_anything('min', 4, 7, 2 , 4 , 9 , 7 , 6   )

 # а теперь ищем минимальное

В этом примере первый параметр функции имеет значение по-умолчанию слово “max”, количество же остальных параметров не определено и все они помещаются в список с именем values, перед именем такой переменной обязательно нужно ставить символ *. Также очевидно, что такие переменные накопители всего, должны идти самыми последними в списке аргументов функции.

Развивающее задание № 6. Наша программа “угадай число” растет, так что, несмотря на свою простоту, дает нам уже необходимость задуматься над таким понятием как оптимизация кода. Очевидно, что одна и та же задача может иметь разное количество решений. Например, мой прием с вычислением x^y через последовательные умножения x*x*..x - не лучший и тем более не единственный. Известно, что x^y = exp(y * ln(x)), попробуйте например такой код (должны получиться одинаковые числа):

>>> print math.pow(6, 7.3) , ‘ --- ’, math.exp (7.3 *math.log(6))

```
479186.007364 --- 479186.007364
```

Следовательно, нам нужен механизм позволяющий оценить насколько качественен выбранный нами алгоритм от других. Понятие качества алгоритма очень сложное, оно состоит из ряда компонент и эти компоненты не равнозначны, и в разных ситуациях эти доли важности могут меняться. Например, в простейшем случае качество тем выше, чем меньше время выполнения и количество затраченных ресурсов, скажем, оперативной памяти. Но если у Васи в компьютере быстрый процессор и мало памяти, то ему гораздо важнее чтобы наша программа потребляла меньше памяти. Для Пети, у которого слабый процессор, но много памяти, все наоборот.

Начнем с того, что оценим время выполнения некоторого алгоритма. В простейшем случае, вы можете узнать текущее системное время (с максимальной точностью до миллисекунд). Затем сохранить эту величину в переменной, например start. После выполнить тестируемый алгоритм, и снова замерить системное время. Разница между этими двумя замерами и будет искомой величиной.

```
import time
```
```
>>> time.time()
```
```
1165770365.921
```

Здесь используется функция time в модуле time, которая возвращает число равное, количеству секунд от сотворения мира. Это целая часть числа, и возможно возвращается дробная часть, в зависимости от операционной системы.

В качестве задания для игры “угадай число” введите учет времени затраченного на угадывание секретного числа, как во время очередного тура, так и всей игры (серии туров). После окончания очередного тура следует сообщить не только количество попыток угадать число, но и время, в течение которого шел этот тур игры.

Другой прием оценки времени выполнения алгоритма – использование модуля profile, например, так:

```
import profile
```

# --- весь код, который был в задаче расчета экспоненты ранее в части 5 ---

```
profile.run ("exponenta (2, 0.001)")
```

В качестве параметра функции run из модуля profile задается вычисляемое выражение. А результатом вызова функции run будет распечатанная таблица, в которой перечисляются то, какие функции были вызваны, сколько раз они были вызваны, а также, сколько времени было затрачено в среднем на вычисление кода этих функций.

Здесь

 ncalls - количество вызовов функции, 
 tottime - полное время выполнения кода функции 
 (без времени нахождения во вложенных функциях), 
 percall - тоже, в пересчете на один вызов,
 cumtime - аккумулированное время нахождения в функции, 
 вместе с вложенными вызовами других функций из этой функции. 
 Последний столбец содержит имя файла, номер строки с функцией и имя функции.

Развивающее задание № 7. Продолжаем совершенствовать нашу программу “Угадай число”. Теперь я хочу, чтобы вы добавили возможность сохранения истории вводившихся чисел в ходе очередного тура. И по завершению игры программа не только сообщала количество попыток и затраченное на тур время, но и предлагала пользователю получить перечисление всех ответов (чисел) которые он давал. Для того чтобы вы могли решить эту задачу нужно ответить на вопрос: где хранить данные об вводимых числах. До этого момента времени если мы создавали какую-то переменную, то в ней хранилось только одно значение: строка или число не важно, но только одно. Теперь в переменной надо хранить произвольное количество элементов, и мы ведь в общем случае незнаем даже сколько раз игрок будет пытаться угадать число, а, следовательно, сколько значений будет храниться внутри одной переменной. Правда, мы уже сталкивались с таким понятием как tuple.

Tuple – представляет собой список элементов произвольной длины любого типа, но я ведь говорил, что tuple – представляет собой неизменяемый список. Как же мы будем в него добавлять новые элементы? Tuple – это частный случай общего типа данных списка, и, именно, список может быть изменен. Создать список можно также как и tuple, просто перечислив элементы списка друг за другом через запятую, но элементы должны находиться не внутри круглых скобок, а именно внутри квадратных.

Список может содержать элементы любого типа, в том числе еще один список, который в свою очередь может содержать, почему бы, не еще один список. Список создается помимо перечисления его элементов также с помощью функции range (A,B), которая получает два параметра: A – начальный элемент списка, B – конечный, список будет заполнен числами от A до B. Возможен еще третий необязательный аргумент функции – задающий размер шага приращения.

```
>>> range(1,10)
```
```
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```
```
>>> range(1,10,2)
```
```
[1, 3, 5, 7, 9]
```

Для доступа к элементам списка используются порядковые номера, или индексы, отсчет начинается от нуля, если же вы указываете отрицательный индекс, то отсчет начинается от конца списка.

```
>>> print range (1,10)[0]
```
```
1
```
```
>>> print range (1,10)[2]
```
```
3
```
```
>>> print range (1,10)[-2]
```
```
8
```

Элементы списка можно изменять. Для этого в квадратных скобках вы должны указать индекс элемента, который будет изменен. Возможно, также указать индекс не одного элемента, а целого отрезка от и до, разделив их символом “:”.

```
>>> li = range(1,10)
```
```
>>> print li
```
```
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

>>> li [4] = 100 # изменяем пятый элемент списка на 100

>>> print li # проверяем – элемент действительно изменился

```
[1, 2, 3, 4, 100, 6, 7, 8, 9]
```

>>> li [7:]=["apple", "orange", "grapes"]

 # все элементы, начиная с восьмого до конца списка будут заменены на новый список из названий фруктов

```
>>> print li
```

[1, 2, 3, 4, 100, 6, 7, 'apple', 'orange', 'grapes']

```
>>> li [7:9]=["red", "green", "blue"] 
```

# теперь замене подлежат элементы списка от восьмого до десятого

```
>>> print li
```

[1, 2, 3, 4, 100, 6, 7, 'red', 'green', 'blue', 'grapes']

```
>>> li [:2]=[-1, -2, -3] 
```

# снова заменяем, но уже от начала списка до третьего элемента

```
>>> print li
```

[-1, -2, -3, 3, 4, 100, 6, 7, 'red', 'green', 'blue', 'grapes']

Часто ставится задача определения того, содержит ли список некоторый элемент.

Для этого служит оператор in, вот пример:

```
>>> print 3 in range(1,10)
```

True # истина – действительно число 3 находится в списке чисел от 1 до 10

```
>>> print "apple" in range(1,10)
```

False # ложь яблок в этом списке отсутствует

Для работы со списками можно использовать цикл while, мы его уже применяли для работы со списком argv в задании работы с параметрами командной строки, только тогда термин список явно не прозвучал. Теперь я покажу еще один прием с организацией цикла for.

```
import sys
```
```
import math
```
```
 
```
```
li = [] 
```

# вначале я создаю пустой список куда будут помещаться вводимые пользователем числа

```
 
```

while 1: # бесконечный цикл будет продолжаться до тех пор,

пока пользователь не введет число равное нулю,

остальные же числа будут добавляться в конец списка

    print 'Введите число, число 0 для завершения ввода набора чисел'

```
    num = float(sys.stdin.readline())
```
```
    if (num == 0):
```

        break # надо прервать выполнение цикла

```
    li = li + [ num ]; 
```

# для того чтобы добавить новый элемент в конец существующего списка

используется прием с конкатенацией или объединением списков,

важно что если бы я не поместил бы число num внутрь квадратных скобок,

то машина python сказала бы что мол ошибка,

нельзя к списку добавить число. А вот к списку добавить другой список,

пусть даже из одного элемента можно вполне.

```
 
```
```
if len(li) > 0 : 
```

# если количество введенных элементов больше нуля

то ищем среди них максимальный элемент,

алгоритм поиска максимального или минимального элемента очень прост,

надо предположить что искомый элемент например первый,

а затем перебрать все оставшиеся элементы списка и проверить

действительно ли очередной элемент списка больше или меньше

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

то переменной max хранящей в себе предполагаемое максимальное значение

нужно присвоить новое значение, аналогично при поиске минимального элемента списка

```
    max = li [0]
```
```
    for item in li: 
```

# цикл for говорит что надо с помощью переменной item перебрать все элементы в (in) списке li

```
        print "li [] = " , item
```
```
        if max < item:
```
```
            max = item
```

    print 'максимальный элемент списка = ', max

```
else:
```

    print 'список пуст в нем невозможно найти максимальный элемент'

В следующий раз продолжим работу с irrlicht и рассмотрим как создать приложение реагирующее на действия пользователя: ввод с клавиатуры и мышь. Для этого нам придется изучить такую возможность python|jython как классы.

Categories: Gamedev. Все об разработке игр

Study & DevО программировании и не только

Программируем трехмерную графику с Irrlicht . Часть 8

Эффективное программирование 3d-приложений с помощью Irrlicht и jython. Часть 8

Поиск

Недавнее

Архив

Разделы