Principle of Computing (Python)學習筆記(5) BFS Searching + Zombie Apocalypse

標籤：

1 Generators  
Generator和list comprehension非常類似
Generators are a kind of iterator that are defined like functions. 

http://www.codeskulptor.org/#examples_generators.py

https://wiki.python.org/moin/Generators

generater function的函數體中必須寫上yield, 能夠寫或者不寫return。

Generators functions allow you to declare a function that behaves like an iterator, i.e. it can be used in a for loop.
Each time the next(), method is applied to the resulting generator, the code is run until the next yield expression, and the yield expression‘s value is returned from that method call. Thus, the creation of the generator does not wait for all of its elements to be generator, and the generator could even represent an infinite number of elements.

# A list comprehensionprint "max in list:", max([num * 2 - 3 for num in range(7)])# A generator expressionprint "max in gen:", max(num * 2 - 3 for num in range(7))# A generator functiondef genfunc(limit):    num = 0    while num < limit:        yield num  #generator function一般和iteration搭配使用。yield說明這個值產生了。放在一邊。如今迴圈繼續進行，等迴圈結束了，再回來處理之前yield產生的值。        num = num + 1print genfunc(7)# Iteration using a generator functionprint "Iterate over generator:"for number in genfunc(7):    print number

2 stack and queue

stack http://www.codeskulptor.org/#user36_ZHLkI0d7kb_2.py

queue  http://www.codeskulptor.org/#user35_AtoP6ttM6w_0.py

3 inheritance
http://www.codeskulptor.org/#examples_inheritance.py
http://www.codeskulptor.org/#examples_inheritance2.py


4 grid collision
http://www.codeskulptor.org/#poc_physics_quadratic.py
https://class.coursera.org/principlescomputing-001/wiki/view?

page=fun_growth

https://class.coursera.org/principlescomputing-001/wiki/view?

page=grids

5 grid類的實現  
http://www.codeskulptor.org/#poc_grid.py 
注意當中的”def get_index(self, point, cell_size):”的轉化方法，把實際的screen position轉化為了index

6 Conway’s game of life 類比
game of life 簡單介紹 http://en.wikipedia.org/wiki/Conway‘s_Game_of_Life
game of life 進行grid操作的練習 http://www.codeskulptor.org/#poc_gol_student.py

7 BFS
BFS動畫 野火燒不盡 春風吹又生 
http://www.codeskulptor.org/#poc_wildfire_student.py
http://www.codeskulptor.org/#poc_wildfire_gui.py
http://www.codeskulptor.org/#poc_grid.py
BFS原理 https://class.coursera.org/principlescomputing-001/wiki/view?page=bfs

8 grid的用途 使用bucket sorting進行string sorting
https://class.coursera.org/principlescomputing-001/wiki/view?page=strings
http://www.codeskulptor.org/#poc_string_sort.py
# 產生26個字母組成的list
list= [ chr(ord("a") + char_num) for char_num in range(26)]
print list


9 stack and queue
老師實現的queue http://www.codeskulptor.org/#poc_queue.py
自己實現的stackhttp://www.codeskulptor.org/#user36_ZHLkI0d7kb_2.py

10 Zombie Apocalypse
http://www.codeskulptor.org/#poc_zombie_template.py
1)  Passable cells in the grid correspond to EMPTY cells while FULL cells are impassable
2)  However, several humans and zombies may inhabit the same grid cell. 

3) 注意用for each in list1僅僅能讀取list1中的元素，不能改動list1中的元素，假設要改動的話。要使用下標操作。如

4) zombie和human移動的原理是這種。
首先對zombie計算一個distance_grid。這個distance_grid中的每一個cell都表達從當前cell到距離近期的一個zombie的距離，接下來，move_human的時候，就從human周圍的cell中選一個distance_grid相應值最大的cell,這樣human 就移動到了一個human最安全的點。

類似，對human計算一個distance_grid。中的每一個cell都表達從當前cell到距離近期的一個human的距離，接下來，move_zombie的時候。就從zombie周圍的cell中選一個distance_grid相應值最小的cell,這樣human 就移動到了一個最接近human的點。

5) 題目做了非常多簡化。

比方計算distance_grid的時候，無論是zombie還是human，都假定當前cell的相鄰cell僅僅有4個。而不是8個。

當zombie追上human的時候，僅僅是grid改變了顏色，假設下一步繼續human move，human還是活著的。

for idx in range(len(list1)):     list1[idx] += 1 

我的作業

"""Student portion of Zombie Apocalypse mini-project"""import randomimport poc_gridimport poc_queueimport poc_zombie_gui# global constantsEMPTY = 0 FULL = 1FOUR_WAY = 0EIGHT_WAY = 1OBSTACLE = "obstacle"HUMAN = "human"ZOMBIE = "zombie"class Zombie(poc_grid.Grid):    """    Class for simulating zombie pursuit of human on grid with    obstacles    """    def __init__(self, grid_height, grid_width, obstacle_list = None,                  zombie_list = None, human_list = None):        """        Create a simulation of given size with given obstacles,        humans, and zombies        """        poc_grid.Grid.__init__(self, grid_height, grid_width)        if obstacle_list != None:            for cell in obstacle_list:                self.set_full(cell[0], cell[1])        if zombie_list != None:            self._zombie_list = list(zombie_list)        else:            self._zombie_list = []        if human_list != None:            self._human_list = list(human_list)          else:            self._human_list = []            def clear(self):        """        Set cells in obstacle grid to be empty        Reset zombie and human lists to be empty        """        poc_grid.Grid.clear(self)        self._zombie_list = []        self._human_list = []            def add_zombie(self, row, col):        """        Add zombie to the zombie list        """        self._zombie_list.append((row,col))                    def num_zombies(self):        """        Return number of zombies        """        return len(self._zombie_list)              def zombies(self):        """        Generator that yields the zombies in the order they were        added.        """        num = 0        while num < self.num_zombies():            yield self._zombie_list[num]            num += 1         return    def add_human(self, row, col):        """        Add human to the human list        """        self._human_list.append((row,col))            def num_humans(self):        """        Return number of humans        """        return len(self._human_list)        def humans(self):        """        Generator that yields the humans in the order they were added.        """        num = 0        while num<self.num_humans():            yield self._human_list[num]            num += 1        return            def compute_distance_field(self, entity_type):        """        Function computes a 2D distance field        Distance at member of entity_queue is zero        Shortest paths avoid obstacles and use distance_type distances        """        visited = poc_grid.Grid(self._grid_height, self._grid_width)        distance_field = [[ self._grid_width * self._grid_height for dummy_col in range(self._grid_width)]                       for dummy_row in range(self._grid_height)]        if entity_type == HUMAN:              boundary = poc_queue.Queue()                          for each in self._human_list:                visited.set_full(each[0],each[1])                distance_field[each[0]][each[1]] = 0                boundary.enqueue(each)            while len(boundary)>0:                cur_cell = boundary.dequeue()                four_neighbors = poc_grid.Grid.four_neighbors(self,cur_cell[0],cur_cell[1])                for each_neighbor in four_neighbors:                    if  visited.is_empty(each_neighbor[0],each_neighbor[1]) and poc_grid.Grid.is_empty(self, each_neighbor[0], each_neighbor[1]) :                        visited.set_full(each_neighbor[0],each_neighbor[1])                        if distance_field[cur_cell[0]][cur_cell[1]]+1 < distance_field[each_neighbor[0]][ each_neighbor[1]]:                            distance_field[each_neighbor[0]][ each_neighbor[1]] = distance_field[cur_cell[0]][cur_cell[1]]+1                        boundary.enqueue(each_neighbor)                        elif  entity_type == ZOMBIE:            boundary = poc_queue.Queue()                                      for each in self._zombie_list:                visited.set_full(each[0],each[1])                distance_field[each[0]][each[1]] = 0                boundary.enqueue(each)            while len(boundary)>0:                               cur_cell = boundary.dequeue()                four_neighbors = poc_grid.Grid.four_neighbors(self,cur_cell[0],cur_cell[1])                                for each_neighbor in four_neighbors:                    if  visited.is_empty(each_neighbor[0],each_neighbor[1]) and poc_grid.Grid.is_empty(self, each_neighbor[0], each_neighbor[1]):                        visited.set_full(each_neighbor[0],each_neighbor[1])                                                if distance_field[cur_cell[0]][cur_cell[1]]+1 < distance_field[each_neighbor[0]][ each_neighbor[1]]:                            distance_field[each_neighbor[0]][ each_neighbor[1]] = distance_field[cur_cell[0]][cur_cell[1]]+1                        boundary.enqueue(each_neighbor)                        return   distance_field                                  def move_humans(self, zombie_distance):        """        Function that moves humans away from zombies, diagonal moves        are allowed        """        for idx in range(len(self._human_list)):            eight_neighbor_human = poc_grid.Grid.eight_neighbors(self, self._human_list[idx][0],self._human_list[idx][1])                max_distance = zombie_distance[self._human_list[idx][0]][self._human_list[idx][1]]            max_pos =(self._human_list[idx][0],self._human_list[idx][1])             for eight_neighbor in eight_neighbor_human:                if zombie_distance[eight_neighbor[0]][eight_neighbor[1]]> max_distance:                    max_distance = zombie_distance[eight_neighbor[0]][eight_neighbor[1]]                    max_pos =(eight_neighbor[0],eight_neighbor[1])            self._human_list[idx]=(max_pos[0],max_pos[1])        def move_zombies(self, human_distance):        """        Function that moves zombies towards humans, no diagonal moves        are allowed        """        for idx in range(len(self._zombie_list)):            four_neighbor_zombie = poc_grid.Grid.four_neighbors(self, self._zombie_list[idx][0],self._zombie_list[idx][1])                min_distance = human_distance[self._zombie_list[idx][0]][self._zombie_list[idx][1]]            min_pos =(self._zombie_list[idx][0],self._zombie_list[idx][1])             for four_neighbor in four_neighbor_zombie:                if human_distance[four_neighbor[0]][four_neighbor[1]]< min_distance:                    min_distance = human_distance[four_neighbor[0]][four_neighbor[1]]                    min_pos =(four_neighbor[0],four_neighbor[1])            self._zombie_list[idx]=(min_pos[0],min_pos[1])# Start up gui for simulation - You will need to write some code above# before this will work without errors#test_zombie =  Zombie(3, 3, [], [], [(2, 2)])#print test_zombie.compute_distance_field('human')poc_zombie_gui.run_gui(Zombie(20, 15))

Principle of Computing (Python)學習筆記(5) BFS Searching + Zombie Apocalypse