专门开一个帖分享cs61a的答案

lab04

1. """ Lab 04: Lists and Data Abstraction """
   
2. 
   
3. # Q2
   
4. def if_this_not_that(i_list, this):
   
5.     """Define a function which takes a list of integers `i_list` and an integer
   
6.     `this`. For each element in `i_list`, print the element if it is larger
   
7.     than `this`; otherwise, print the word "that".
   
8. 
   
9.     >>> original_list = [1, 2, 3, 4, 5]
   
10.     >>> if_this_not_that(original_list, 3)
    
11.     that
    
12.     that
    
13.     that
    
14.     4
    
15.     5
    
16.     """
    
17.     "*** YOUR CODE HERE ***"
    
18.     for i in i_list:
    
19.         if i<= this:
    
20.             print('that')
    
21.         else:
    
22.             print(i)
    
23. 
    
24. # City ADT
    
25. def make_city(name, lat, lon):
    
26.     """
    
27.     >>> city = make_city('Berkeley', 0, 1)
    
28.     >>> get_name(city)
    
29.     'Berkeley'
    
30.     >>> get_lat(city)
    
31.     0
    
32.     >>> get_lon(city)
    
33.     1
    
34.     """
    
35.     return [name, lat, lon]
    
36. 
    
37. def get_name(city):
    
38.     """
    
39.     >>> city = make_city('Berkeley', 0, 1)
    
40.     >>> get_name(city)
    
41.     'Berkeley'
    
42.     """
    
43.     return city[0]
    
44. 
    
45. def get_lat(city):
    
46.     """
    
47.     >>> city = make_city('Berkeley', 0, 1)
    
48.     >>> get_lat(city)
    
49.     0
    
50.     """
    
51.     return city[1]
    
52. 
    
53. def get_lon(city):
    
54.     """
    
55.     >>> city = make_city('Berkeley', 0, 1)
    
56.     >>> get_lon(city)
    
57.     1
    
58.     """
    
59.     return city[2]
    
60. 
    
61. # Q4
    
62. from math import sqrt
    
63. def distance(city1, city2):
    
64.     """
    
65.     >>> city1 = make_city('city1', 0, 1)
    
66.     >>> city2 = make_city('city2', 0, 2)
    
67.     >>> distance(city1, city2)
    
68.     1.0
    
69.     >>> city3 = make_city('city3', 6.5, 12)
    
70.     >>> city4 = make_city('city4', 2.5, 15)
    
71.     >>> distance(city3, city4)
    
72.     5.0
    
73.     """
    
74.     "*** YOUR CODE HERE ***"
    
75.     return sqrt((get_lat(city1)-get_lat(city2))**2+(get_lon(city1)-get_lon(city2))**2)
    
76. 
    
77. # Q5
    
78. def closer_city(lat, lon, city1, city2):
    
79.     """
    
80.     Returns the name of either city1 or city2, whichever is closest to
    
81.     coordinate (lat, lon).
    
82. 
    
83.     >>> berkeley = make_city('Berkeley', 37.87, 112.26)
    
84.     >>> stanford = make_city('Stanford', 34.05, 118.25)
    
85.     >>> closer_city(38.33, 121.44, berkeley, stanford)
    
86.     'Stanford'
    
87.     >>> bucharest = make_city('Bucharest', 44.43, 26.10)
    
88.     >>> vienna = make_city('Vienna', 48.20, 16.37)
    
89.     >>> closer_city(41.29, 174.78, bucharest, vienna)
    
90.     'Bucharest'
    
91.     """
    
92.     "*** YOUR CODE HERE ***"
    
93.     distance_12 = distance(city1,city2)
    
94.     city3 = make_city('city3',lat,lon)
    
95.     if distance(city1,city3)>= distance(city2,city3):
    
96.         return get_name(city2)
    
97.     else:
    
98.         return get_name(city1)
    
99. # Q6
    
100. # This is another implementation of the City ADT. Make sure
     
101. # your code works for both the previous and the following versions
     
102. # of the constructor and selectors!
     
103. #
     
104. make_city = lambda name, lat, lon: [lon, [lat], name]
     
105. get_name = lambda city: city[2]
     
106. get_lat = lambda city: city[1][0]
     
107. get_lon = lambda city: city[0]
     

复制代码

lab04_extra

1. """ Lab 04 Optional Questions """
   
2. 
   
3. from lab04 import *
   
4. 
   
5. # Q6
   
6. def flatten(lst):
   
7.     """Returns a flattened version of lst.
   
8. 
   
9.     >>> flatten([1, 2, 3])     # normal list
   
10.     [1, 2, 3]
    
11.     >>> x = [1, [2, 3], 4]      # deep list
    
12.     >>> flatten(x)
    
13.     [1, 2, 3, 4]
    
14.     >>> x = [[1, [1, 1]], 1, [1, 1]] # deep list
    
15.     >>> flatten(x)
    
16.     [1, 1, 1, 1, 1, 1]
    
17.     """
    
18.     "*** YOUR CODE HERE ***"
    
19.     def unlst(lst):#因为要循环调用这个功能， 所以用HOF
    
20.         flt_ls = []
    
21.         for i in lst:
    
22.             if type(i) == list:
    
23.                 flt_ls += unlst(i)
    
24.             else:
    
25.                 flt_ls += [i]
    
26.         return flt_ls
    
27.     return unlst(lst)
    
28. 
    
29. # Q7
    
30. def merge(lst1, lst2):
    
31.     """Merges two sorted lists.
    
32. 
    
33.     >>> merge([1, 3, 5], [2, 4, 6])
    
34.     [1, 2, 3, 4, 5, 6]
    
35.     >>> merge([], [2, 4, 6])
    
36.     [2, 4, 6]
    
37.     >>> merge([1, 2, 3], [])
    
38.     [1, 2, 3]
    
39.     >>> merge([5, 7], [2, 4, 6])
    
40.     [2, 4, 5, 6, 7]
    
41.     """
    
42.     "*** YOUR CODE HERE ***"
    
43.     #用序列号做对调
    
44.     ls = lst1 + lst2
    
45.     od = 0 #第一个i的序列号
    
46.     for i in ls:
    
47.         for m in range(0,len(ls)):
    
48.             if i < ls[m]:
    
49.                 ls[od], ls[m] = ls[m], ls[od]
    
50.         od += 1
    
51.     return ls
    
52.   
    
53. ######################
    
54. ### Connect N Game ###
    
55. ######################
    
56. 
    
57. def create_row(size):
    
58.     """Returns a single, empty row with the given size. Each empty spot is
    
59.     represented by the string '-'.
    
60. 
    
61.     >>> create_row(5)
    
62.     ['-', '-', '-', '-', '-']
    
63.     """
    
64.     "*** YOUR CODE HERE ***"
    
65.     return ['-' for i in range(0,size)]
    
66. 
    
67. def create_board(rows, columns):
    
68.     """Returns a board with the given dimensions.
    
69. 
    
70.     >>> create_board(3, 5)
    
71.     [['-', '-', '-', '-', '-'], ['-', '-', '-', '-', '-'], ['-', '-', '-', '-', '-']]
    
72.     """
    
73.     "*** YOUR CODE HERE ***"
    
74.     return [create_row(columns) for i in range(0,rows)]
    
75. 
    
76. def replace_elem(lst, index, elem):
    
77.     """Create and return a new list whose elements are the same as those in
    
78.     LST except at index INDEX, which should contain element ELEM instead.
    
79. 
    
80.     >>> old = [1, 2, 3, 4, 5, 6, 7]
    
81.     >>> new = replace_elem(old, 2, 8)
    
82.     >>> new
    
83.     [1, 2, 8, 4, 5, 6, 7]
    
84.     >>> new is old   # check that replace_elem outputs a new list
    
85.     False
    
86.     """
    
87.     assert index >= 0 and index < len(lst), 'Index is out of bounds'
    
88.     "*** YOUR CODE HERE ***"
    
89.     return [lst[i] for i in range(0,index)]+[elem] +[lst[i] for i in range(index+1,len(lst))]
    
90. 
    
91. def get_piece(board, row, column):
    
92.     """Returns the piece at location (row, column) in the board.
    
93.     >>> rows, columns = 2, 2
    
94.     >>> board = create_board(rows, columns)
    
95.     >>> board = put_piece(board, rows, 0, 'X')[1] # Puts piece "X" in column 0 of board and updates board
    
96.     >>> board = put_piece(board, rows, 0, 'O')[1] # Puts piece "O" in column 0 of board and updates board
    
97.     >>> get_piece(board, 1, 0)
    
98.     'X'
    
99.     >>> get_piece(board, 1, 1)
    
100.     '-'
     
101.     """
     
102.     "*** YOUR CODE HERE ***"
     
103.     return board[row][column]
     
104. 
     
105. def put_piece(board, max_rows, column, player):
     
106.     """Puts PLAYER's piece in the bottommost empty spot in the given column of
     
107.     the board. Returns a tuple of two elements:
     
108. 
     
109.         1. The index of the row the piece ends up in, or -1 if the column
     
110.            is full.
     
111.         2. The new board
     
112. 
     
113.     >>> rows, columns = 2, 2
     
114.     >>> board = create_board(rows, columns)
     
115.     >>> row, new_board = put_piece(board, rows, 0, 'X')
     
116.     >>> row
     
117.     1
     
118.     >>> row, new_board = put_piece(new_board, rows, 0, 'O')
     
119.     >>> row
     
120.     0
     
121.     >>> row, new_board = put_piece(new_board, rows, 0, 'X')
     
122.     >>> row
     
123.     -1
     
124.     """
     
125.     "*** YOUR CODE HERE ***"
     
126.     for i in range(max_rows-1,-1,-1):
     
127.         if board[i][column] == '-':
     
128.             new_row = replace_elem(board[i],column,player)
     
129.             new_bd = replace_elem(board,i,new_row)
     
130.             return(i,new_bd)
     
131.     return (-1,board)
     
132. 
     
133. def make_move(board, max_rows, max_cols, col, player):
     
134.     """Put player's piece in column COL of the board, if it is a valid move.
     
135.     Return a tuple of two values:
     
136. 
     
137.         1. If the move is valid, make_move returns the index of the row the
     
138.            piece is placed in. Otherwise, it returns -1.
     
139.         2. The updated board
     
140. 
     
141.     >>> rows, columns = 2, 2
     
142.     >>> board = create_board(rows, columns)
     
143.     >>> row, board = make_move(board, rows, columns, 0, 'X')
     
144.     >>> row
     
145.     1
     
146.     >>> get_piece(board, 1, 0)
     
147.     'X'
     
148.     >>> row, board = make_move(board, rows, columns, 0, 'O')
     
149.     >>> row
     
150.     0
     
151.     >>> row, board = make_move(board, rows, columns, 0, 'X')
     
152.     >>> row
     
153.     -1
     
154.     >>> row, board = make_move(board, rows, columns, -4, '0')
     
155.     >>> row
     
156.     -1
     
157.     """
     
158.     "*** YOUR CODE HERE ***"
     
159.     if col in range(0,max_cols):
     
160.         row, new_board = put_piece(board,max_rows,col,player)
     
161.         return(row, new_board)
     
162.     else:
     
163.         return(-1,board)
     
164.         
     
165. 
     
166. def print_board(board, max_rows, max_cols):
     
167.     """Prints the board. Row 0 is at the top, and column 0 at the far left.
     
168. 
     
169.     >>> rows, columns = 2, 2
     
170.     >>> board = create_board(rows, columns)
     
171.     >>> print_board(board, rows, columns)
     
172.     - -
     
173.     - -
     
174.     >>> new_board = make_move(board, rows, columns, 0, 'X')[1]
     
175.     >>> print_board(new_board, rows, columns)
     
176.     - -
     
177.     X -
     
178.     """
     
179.     "*** YOUR CODE HERE ***"
     
180.     st = ''
     
181.     for i in range(0,max_rows):
     
182.         if i != max_rows -1: #不加这个最后一行会有一个空格，可以试着把空格替换成其他的更直观看到区别
     
183.             for ii in range(0,max_cols):
     
184.                 if ii != max_cols -1:
     
185.                     st = st + get_piece(board,i,ii) + ' '
     
186.                 else:
     
187.                     st = st + get_piece(board,i,ii)
     
188.             st = st + '\n'
     
189.         else:#不加这个else最后一行会有一个\n
     
190.             for ii in range(0,max_cols):
     
191.                 if ii != max_cols -1:
     
192.                     st = st + get_piece(board,i,ii) + ' '
     
193.                 else:
     
194.                     st = st + get_piece(board,i,ii)
     
195.     print(st.strip())
     
196. #字符串的打印虽然打出来可能显示一样但机制不同也会报错
     
197. 
     
198. def check_win_row(board, max_rows, max_cols, num_connect, row, player):
     
199.     """ Returns True if the given player has a horizontal win
     
200.     in the given row, and otherwise False.
     
201. 
     
202.     >>> rows, columns, num_connect = 4, 4, 2
     
203.     >>> board = create_board(rows, columns)
     
204.     >>> board = make_move(board, rows, columns, 0, 'X')[1]
     
205.     >>> board = make_move(board, rows, columns, 0, 'O')[1]
     
206.     >>> check_win_row(board, rows, columns, num_connect, 3, 'O')
     
207.     False
     
208.     >>> board = make_move(board, rows, columns, 2, 'X')[1]
     
209.     >>> board = make_move(board, rows, columns, 0, 'O')[1]
     
210.     >>> check_win_row(board, rows, columns, num_connect, 3, 'X')
     
211.     False
     
212.     >>> board = make_move(board, rows, columns, 1, 'X')[1]
     
213.     >>> check_win_row(board, rows, columns, num_connect, 3, 'X')
     
214.     True
     
215.     >>> check_win_row(board, rows, columns, 4, 3, 'X')    # A win depends on the value of num_connect
     
216.     False
     
217.     >>> check_win_row(board, rows, columns, num_connect, 3, 'O')   # We only detect wins for the given player
     
218.     False
     
219.     """
     
220.     "*** YOUR CODE HERE ***"
     
221.     count = 0
     
222.     player_st = ''
     
223.     row_st = ''
     
224.     for i in board[row]:
     
225.         row_st += str(i) + ' '
     
226.         if i == player:
     
227.             count += 1
     
228.     if count >= num_connect:
     
229.         m = 0
     
230.         while m < num_connect:
     
231.             player_st += player + ' '
     
232.             m += 1
     
233.         if player_st in row_st:
     
234.             return True
     
235.         else:
     
236.             
     
237.             return False
     
238.     else:
     
239.         return False
     
240.         
     
241. 
     
242. def check_win_column(board, max_rows, max_cols, num_connect, col, player):
     
243.     """ Returns True if the given player has a vertical win in the given column,
     
244.     and otherwise False.
     
245. 
     
246.     >>> rows, columns, num_connect = 5, 5, 2
     
247.     >>> board = create_board(rows, columns)
     
248.     >>> board = make_move(board, rows, columns, 0, 'X')[1]
     
249.     >>> board = make_move(board, rows, columns, 1, 'O')[1]
     
250.     >>> check_win_column(board, rows, columns, num_connect, 0, 'X')
     
251.     False
     
252.     >>> board = make_move(board, rows, columns, 1, 'X')[1]
     
253.     >>> board = make_move(board, rows, columns, 1, 'O')[1]
     
254.     >>> check_win_column(board, rows, columns, num_connect, 1, 'O')
     
255.     False
     
256.     >>> board = make_move(board, rows, columns, 2, 'X')[1]
     
257.     >>> board = make_move(board, rows, columns, 1, 'O')[1]
     
258.     >>> check_win_column(board, rows, columns, num_connect, 1, 'O')
     
259.     True
     
260.     >>> check_win_column(board, rows, columns, 4, 1, 'O')
     
261.     False
     
262.     >>> check_win_column(board, rows, columns, num_connect, 1, 'X')
     
263.     False
     
264.     """
     
265.     "*** YOUR CODE HERE ***"
     
266.     count = 0
     
267.     player_st = ''
     
268.     col_st = ''
     
269.     for i in range(0,max_rows):
     
270.         col_st += str(board[i][col]) + ' '
     
271.         if board[i][col] == player:
     
272.             count += 1
     
273.     if count >= num_connect:
     
274.         m = 0
     
275.         while m < num_connect:
     
276.             player_st += player + ' '
     
277.             m += 1
     
278.         if player_st in col_st:
     
279.             return True
     
280.         else:
     
281.             
     
282.             return False
     
283.     else:
     
284.         return False
     
285. 
     
286. def check_win(board, max_rows, max_cols, num_connect, row, col, player):
     
287.     """Returns True if the given player has any kind of win after placing a
     
288.     piece at (row, col), and False otherwise.
     
289. 
     
290.     >>> rows, columns, num_connect = 2, 2, 2
     
291.     >>> board = create_board(rows, columns)
     
292.     >>> board = make_move(board, rows, columns, 0, 'X')[1]
     
293.     >>> board = make_move(board, rows, columns, 1, 'O')[1]
     
294.     >>> board = make_move(board, rows, columns, 0, 'X')[1]
     
295.     >>> check_win(board, rows, columns, num_connect, 0, 0, 'O')
     
296.     False
     
297.     >>> check_win(board, rows, columns, num_connect, 0, 0, 'X')
     
298.     True
     
299. 
     
300.     >>> board = create_board(rows, columns)
     
301.     >>> board = make_move(board, rows, columns, 0, 'X')[1]
     
302.     >>> board = make_move(board, rows, columns, 0, 'O')[1]
     
303.     >>> board = make_move(board, rows, columns, 1, 'X')[1]
     
304.     >>> check_win(board, rows, columns, num_connect, 1, 0, 'X')
     
305.     True
     
306.     >>> check_win(board, rows, columns, num_connect, 0, 0, 'X')
     
307.     False
     
308. 
     
309.     >>> board = create_board(rows, columns)
     
310.     >>> board = make_move(board, rows, columns, 0, 'X')[1]
     
311.     >>> board = make_move(board, rows, columns, 1, 'O')[1]
     
312.     >>> board = make_move(board, rows, columns, 1, 'X')[1]
     
313.     >>> check_win(board, rows, columns, num_connect, 0, 0, 'X')
     
314.     False
     
315.     >>> check_win(board, rows, columns, num_connect, 1, 0, 'X')
     
316.     True
     
317.     """
     
318.     diagonal_win = check_win_diagonal(board, max_rows, max_cols, num_connect,
     
319.                                       row, col, player)
     
320.     "*** YOUR CODE HERE ***"
     
321.     if check_win_column(board, max_rows, max_cols, num_connect, col, player):
     
322.         return True
     
323.     elif check_win_row(board, max_rows, max_cols, num_connect, row, player):
     
324.         return True
     
325.     elif check_win_diagonal(board, max_rows, max_cols, num_connect, row, col, player):
     
326.         return True
     
327.     else:
     
328.         return False
     
329. 
     
330. ###############################################################
     
331. ### Functions for reference when solving the other problems ###
     
332. ###############################################################
     
333. 
     
334. def check_win_diagonal(board, max_rows, max_cols, num_connect, row, col, player):
     
335.     """ Returns True if the given player has a diagonal win passing the spot
     
336.     (row, column), and False otherwise.
     
337.     """
     
338.     # Find top left of diagonal passing through the newly placed piece.
     
339.     adjacent = 0
     
340.     row_top_left, col_top_left = row, col
     
341.     while row_top_left > 0 and col_top_left > 0:
     
342.         row_top_left -= 1
     
343.         col_top_left -= 1
     
344. 
     
345.     # Loop through top left to bottom right diagonal and check for win.
     
346.     while row_top_left < max_rows and col_top_left < max_cols:
     
347.         piece = get_piece(board, row_top_left, col_top_left)
     
348.         if piece == player:
     
349.             adjacent += 1
     
350.         else:
     
351.             adjacent = 0
     
352.         if adjacent >= num_connect:
     
353.             return True
     
354.         row_top_left += 1
     
355.         col_top_left += 1
     
356. 
     
357.     # Find top right of diagonal passing through the newly placed piece.
     
358.     adjacent = 0
     
359.     row_top_right, col_top_right = row, col
     
360.     while row_top_right > 0 and col_top_right < max_cols - 1:
     
361.         row_top_right -= 1
     
362.         col_top_right += 1
     
363. 
     
364.     # Loop through top right to bottom left diagonal and check for win.
     
365.     while row_top_right < max_rows and col_top_right >= 0:
     
366.         piece = get_piece(board, row_top_right, col_top_right)
     
367.         if piece == player:
     
368.             adjacent += 1
     
369.         else:
     
370.             adjacent = 0
     
371.         if adjacent >= num_connect:
     
372.             return True
     
373.         row_top_right += 1
     
374.         col_top_right -= 1
     
375. 
     
376.     return False
     
377. 
     
378. #####################################################################################
     
379. ### You do not need to read or understand the following code for this assignment. ###
     
380. #####################################################################################
     
381. 
     
382. import sys
     
383. 
     
384. def other(player):
     
385.     """ Returns the given player's opponent.
     
386.     """
     
387.     if player == 'X':
     
388.         return 'O'
     
389.     return 'X'
     
390. 
     
391. def play(board, max_rows, max_cols, num_connect):
     
392.     max_turns = max_rows * max_cols
     
393.     playing = True
     
394.     print("Player 'X' starts")
     
395.     who = 'X'
     
396.     turns = 0
     
397. 
     
398.     while True:
     
399.         turns += 1
     
400.         if turns > max_turns:
     
401.             print("No more moves. It's a tie!")
     
402.             sys.exit()
     
403. 
     
404.         while True:
     
405.             try:
     
406.                 col_index = int(input('Which column, player {}? '.format(who)))
     
407.             except ValueError as e:
     
408.                 print('Invalid input. Please try again.')
     
409.                 continue
     
410. 
     
411.             row_index, board = make_move(board, max_rows, max_cols, col_index, who)
     
412. 
     
413.             if row_index != -1:
     
414.                 break
     
415. 
     
416.             print("Oops, you can't put a piece there")
     
417. 
     
418.         print_board(board, max_rows, max_cols)
     
419. 
     
420.         if check_win(board, max_rows, max_cols, num_connect, row_index, col_index, who):
     
421.             print("Player {} wins!".format(who))
     
422.             sys.exit()
     
423. 
     
424.         who = other(who)
     
425. 
     
426. def start_game():
     
427.     # Get all parameters for the game from user.
     
428.     while True:
     
429.         # Get num_connect from user.
     
430.         while True:
     
431.             try:
     
432.                 num_connect = int(input('How many to connect (e.g. 4 for Connect 4)? '))
     
433.             except ValueError as e:
     
434.                 print('Invalid input. Please try again.')
     
435.                 continue
     
436.             break
     
437. 
     
438.         # Get number of rows for board from user.
     
439.         while True:
     
440.             try:
     
441.                  max_rows = int(input('How many rows? '))
     
442.             except ValueError as e:
     
443.                 print('Invalid input. Please try again.')
     
444.                 continue
     
445.             break
     
446. 
     
447.         # Get number of columns for board from user.
     
448.         while True:
     
449.             try:
     
450.                 max_cols = int(input('How many columns? '))
     
451.             except ValueError as e:
     
452.                 print('Invalid input. Please try again.')
     
453.                 continue
     
454.             break
     
455. 
     
456.         if max_rows >= num_connect or max_cols >= num_connect:
     
457.             break
     
458.         print("Invalid dimensions for connect {0}. Please try again.".format(num_connect))
     
459. 
     
460.     board = create_board(max_rows, max_cols)
     
461.     play(board, max_rows, max_cols, num_connect)
     

复制代码

project02: yelp maps

abstraction:

1. """Data Abstractions"""
   
2. 
   
3. from utils import mean
   
4. 
   
5. #############################
   
6. # Phase 1: Data Abstraction #
   
7. #############################
   
8. 
   
9. 
   
10. # Reviews
    
11. 
    
12. def make_review(restaurant_name, rating):
    
13.     """Return a review data abstraction."""
    
14.     return [restaurant_name, rating]
    
15. 
    
16. def review_restaurant_name(review):
    
17.     """Return the restaurant name of the review, which is a string."""
    
18.     return review[0]
    
19. 
    
20. def review_rating(review):
    
21.     """Return the number of stars given by the review, which is a
    
22.     floating point number between 1 and 5."""
    
23.     return review[1]   
    
24. 
    
25. 
    
26. # Users
    
27. 
    
28. def make_user(name, reviews):
    
29.     """Return a user data abstraction."""
    
30.     return [name, {review_restaurant_name(r): r for r in reviews}]
    
31. 
    
32. def user_name(user):
    
33.     """Return the name of the user, which is a string."""
    
34.     return user[0]
    
35. 
    
36. def user_reviews(user):
    
37.     """Return a dictionary from restaurant names to reviews by the user."""
    
38.     return user[1]
    
39. 
    
40. 
    
41. ### === +++ USER ABSTRACTION BARRIER +++ === ###
    
42. 
    
43. def user_reviewed_restaurants(user, restaurants):
    
44.     """Return the subset of restaurants reviewed by user.
    
45. 
    
46.     Arguments:
    
47.     user -- a user
    
48.     restaurants -- a list of restaurant data abstractions
    
49.     """
    
50.     names = list(user_reviews(user))
    
51.     return [r for r in restaurants if restaurant_name(r) in names]
    
52. 
    
53. def user_rating(user, restaurant_name):
    
54.     """Return the rating given for restaurant_name by user."""
    
55.     reviewed_by_user = user_reviews(user)
    
56.     user_review = reviewed_by_user[restaurant_name]
    
57.     return review_rating(user_review)
    
58. 
    
59. 
    
60. # Restaurants
    
61. 
    
62. def make_restaurant(name, location, categories, price, reviews):
    
63.     """Return a restaurant data abstraction containing the name, location,
    
64.     categories, price, and reviews for that restaurant."""
    
65.     # BEGIN Question 2
    
66.     "*** YOUR CODE HERE ***"
    
67.     res = {'resnm':name,'resloc':location,'rescate':categories,'respri':price,'resrev':reviews}
    
68.     return res
    
69.     # END Question 2
    
70. 
    
71. def restaurant_name(restaurant):
    
72.     """Return the name of the restaurant, which is a string."""
    
73.     # BEGIN Question 2
    
74.     "*** YOUR CODE HERE ***"
    
75.     return restaurant['resnm']
    
76.     # END Question 2
    
77. 
    
78. def restaurant_location(restaurant):
    
79.     """Return the location of the restaurant, which is a list containing
    
80.     latitude and longitude."""
    
81.     # BEGIN Question 2
    
82.     "*** YOUR CODE HERE ***"
    
83.     return restaurant['resloc']
    
84.     # END Question 2
    
85. 
    
86. def restaurant_categories(restaurant):
    
87.     """Return the categories of the restaurant, which is a list of strings."""
    
88.     # BEGIN Question 2
    
89.     "*** YOUR CODE HERE ***"
    
90.     return restaurant['rescate']
    
91.     # END Question 2
    
92. 
    
93. def restaurant_price(restaurant):
    
94.     """Return the price of the restaurant, which is a number."""
    
95.     # BEGIN Question 2
    
96.     "*** YOUR CODE HERE ***"
    
97.     return restaurant['respri']
    
98.     # END Question 2
    
99. 
    
100. def restaurant_ratings(restaurant):
     
101.     """Return a list of ratings, which are numbers from 1 to 5, of the
     
102.     restaurant based on the reviews of the restaurant."""
     
103.     # BEGIN Question 2
     
104.     "*** YOUR CODE HERE ***"
     
105.     rt = []
     
106.     for i in restaurant['resrev']:
     
107.         rt += [review_rating(i)] #i就是['name',4]这种review
     
108.     return rt
     
109.     # END Question 2
     

复制代码

recommend

1. """A Yelp-powered Restaurant Recommendation Program"""
   
2. 
   
3. from abstractions import *
   
4. from data import ALL_RESTAURANTS, CATEGORIES, USER_FILES, load_user_file
   
5. from ucb import main, trace, interact
   
6. from utils import distance, mean, zip, enumerate, sample
   
7. from visualize import draw_map
   
8. 
   
9. ##################################
   
10. # Phase 2: Unsupervised Learning #
    
11. ##################################
    
12. 
    
13. 
    
14. def find_closest(location, centroids):
    
15.     """Return the centroid in centroids that is closest to location.
    
16.     If multiple centroids are equally close, return the first one.
    
17. 
    
18.     >>> find_closest([3.0, 4.0], [[0.0, 0.0], [2.0, 3.0], [4.0, 3.0], [5.0, 5.0]])
    
19.     [2.0, 3.0]
    
20.     """
    
21.     # BEGIN Question 3
    
22.     "*** YOUR CODE HERE ***"
    
23.     return min(centroids, key = lambda x :distance(location,x))
    
24.     #一个疑问，下面的代码哪里错了？
    
25.     #之前的代码是return [min(center, key = lambda x :distance(location,x)) for center in centroids]            
    
26.     # END Question 3
    
27. 
    
28. 
    
29. def group_by_first(pairs):
    
30.     """Return a list of pairs that relates each unique key in the [key, value]
    
31.     pairs to a list of all values that appear paired with that key.
    
32. 
    
33.     Arguments:
    
34.     pairs -- a sequence of pairs
    
35. 
    
36.     >>> example = [ [1, 2], [3, 2], [2, 4], [1, 3], [3, 1], [1, 2] ]
    
37.     >>> group_by_first(example)
    
38.     [[2, 3, 2], [2, 1], [4]]
    
39.     """
    
40.     keys = []
    
41.     for key, _ in pairs:
    
42.         if key not in keys:
    
43.             keys.append(key)
    
44.     return [[y for x, y in pairs if x == key] for key in keys]
    
45. 
    
46. 
    
47. def group_by_centroid(restaurants, centroids):
    
48.     """Return a list of clusters, where each cluster contains all restaurants
    
49.     nearest to a corresponding centroid in centroids. Each item in
    
50.     restaurants should appear once in the result, along with the other
    
51.     restaurants closest to the same centroid.
    
52.     """
    
53.     # BEGIN Question 4
    
54.     "*** YOUR CODE HERE ***"
    
55.     ls = []
    
56.     for restaurant in restaurants:
    
57.         location = restaurant_location(restaurant)
    
58.         #min里面的东西应该是一个序列，我差点又犯错了 = =
    
59.         ls.append([min(centroids, key = lambda x :distance(x,location)),restaurant])
    
60.     return group_by_first(ls)#返回的是同一centroid的restaurant的集合的集合
    
61.     # END Question 4
    
62. 
    
63. 
    
64. def find_centroid(cluster):
    
65.     """Return the centroid of the locations of the restaurants in cluster."""
    
66.     # BEGIN Question 5
    
67.     "*** YOUR CODE HERE ***"
    
68.     lat,lon = [],[]
    
69.     for restaurant in cluster:
    
70.         lat += [restaurant_location(restaurant)[0]]
    
71.         lon += [restaurant_location(restaurant)[1]]
    
72.     return [mean(lat),mean(lon)]
    
73.     # END Question 5
    
74. 
    
75. 
    
76. def k_means(restaurants, k, max_updates=100):
    
77.     """Use k-means to group restaurants by location into k clusters."""
    
78.     assert len(restaurants) >= k, 'Not enough restaurants to cluster'
    
79.     old_centroids, n = [], 0
    
80.     # Select initial centroids randomly by choosing k different restaurants
    
81.     centroids = [restaurant_location(r) for r in sample(restaurants, k)]
    
82.     while old_centroids != centroids and n < max_updates:
    
83.         old_centroids = centroids
    
84.         # BEGIN Question 6
    
85.         "*** YOUR CODE HERE ***"
    
86.         cluster = group_by_centroid(restaurants,centroids)
    
87.         centroids = [find_centroid(single_cluster) for single_cluster in cluster]
    
88.         '''
    
89.         1.随机选取中心点
    
90.         2.先用已有的中心点把每个餐馆聚类
    
91.         3.更新每个聚类的中心点
    
92.         '''
    
93.         #一定要注意边界！ 否则会做重复工作
    
94.         # END Question 6
    
95.         n += 1
    
96.     return centroids
    
97. 
    
98. 
    
99. ################################
    
100. # Phase 3: Supervised Learning #
     
101. ################################
     
102. 
     
103. 
     
104. def find_predictor(user, restaurants, feature_fn):
     
105.     """Return a rating predictor (a function from restaurants to ratings),
     
106.     for a user by performing least-squares linear regression using feature_fn
     
107.     on the items in restaurants. Also, return the R^2 value of this model.
     
108. 
     
109.     Arguments:
     
110.     user -- A user
     
111.     restaurants -- A sequence of restaurants
     
112.     feature_fn -- A function that takes a restaurant and returns a number
     
113.     """
     
114.     reviews_by_user = {review_restaurant_name(review): review_rating(review)
     
115.                        for review in user_reviews(user).values()}
     
116. 
     
117.     xs = [feature_fn(r) for r in restaurants]
     
118.     ys = [reviews_by_user[restaurant_name(r)] for r in restaurants]
     
119.    
     
120.     # BEGIN Question 7
     
121.     Sxx,Syy,Sxy = 0,0,0
     
122.     pairs = zip(xs, ys)
     
123.     s_xx, s_yy, s_xy = 0, 0, 0
     
124.     for x, y in pairs:
     
125.         s_xx += (x - mean(xs)) ** 2
     
126.         s_yy += (y - mean(ys)) ** 2
     
127.         s_xy += (x - mean(xs)) * (y - mean(ys))
     
128.     b = s_xy / s_xx
     
129.     a = mean(ys) - b * mean(xs)
     
130.     r_squared = (s_xy ** 2) / (s_xx * s_yy)
     
131.    
     
132.     def predictor(restaurant):
     
133.         return a+b*feature_fn(restaurant)
     
134.    
     
135.     return predictor, r_squared
     
136.     #为什么下面这个代码是错的？
     
137.    
     
138.     '''Sxx,Syy,Sxy = 0,0,0
     
139.     for i in range(len(xs)):
     
140.         Sxx += (xs[i]-mean(xs))**2
     
141.         Syy += (ys[i]-mean(ys))**2
     
142.         Sxy += (xs[i]-mean(xs))*(ys[i]-mean(ys))
     
143.     b = Sxy/Sxx,
     
144.     a = mean(ys) - b*mean(xs)
     
145.     r_squared = Sxy**2/(Sxx*Syy)
     
146.     def predictor(restaurant):
     
147.         return a+b*feature_fn(restaurant)
     
148.    
     
149.     return predictor, r_squared'''
     
150.    
     
151.     # END Question 7
     
152.    
     
153.     def predictor(restaurant):
     
154.         return b * feature_fn(restaurant) + a
     
155. 
     
156.     return predictor, r_squared
     
157. 
     
158. 
     
159. def best_predictor(user, restaurants, feature_fns):
     
160.     """Find the feature within feature_fns that gives the highest R^2 value
     
161.     for predicting ratings by the user; return a predictor using that feature.
     
162. 
     
163.     Arguments:
     
164.     user -- A user
     
165.     restaurants -- A list of restaurants
     
166.     feature_fns -- A sequence of functions that each takes a restaurant
     
167.     """
     
168.     reviewed = user_reviewed_restaurants(user, restaurants)
     
169.     # BEGIN Question 8
     
170.     "*** YOUR CODE HERE ***"
     
171.    
     
172.     pred_rat = {find_predictor(user, reviewed, feature_fn)[0]: find_predictor(user, reviewed, feature_fn)[1]
     
173.                 for feature_fn in feature_fns}
     
174.     return max(pred_rat, key = lambda keys: pred_rat[keys])
     
175.     #区分字典单独出现和字典有selector的区别
     
176.     # END Question 8
     
177. 
     
178. 
     
179. def rate_all(user, restaurants, feature_fns):
     
180.     """Return the predicted ratings of restaurants by user using the best
     
181.     predictor based on a function from feature_fns.
     
182. 
     
183.     Arguments:
     
184.     user -- A user
     
185.     restaurants -- A list of restaurants
     
186.     feature_fns -- A sequence of feature functions
     
187.     """
     
188.     predictor = best_predictor(user, ALL_RESTAURANTS, feature_fns)
     
189.     reviewed = user_reviewed_restaurants(user, restaurants)
     
190.     # BEGIN Question 9
     
191.     "*** YOUR CODE HERE ***"
     
192.     rate_dic = []
     
193.     for restaurant in restaurants:
     
194.         if restaurant not in reviewed:
     
195.             rate_dic.append([restaurant_name(restaurant),predictor(restaurant)])
     
196.         else:
     
197.             rate_dic.append([restaurant_name(restaurant),user_rating(user, restaurant_name(restaurant))])
     
198.     return dict(rate_dic)
     
199.     # END Question 9
     
200. 
     
201. 
     
202. def search(query, restaurants):
     
203.     """Return each restaurant in restaurants that has query as a category.
     
204. 
     
205.     Arguments:
     
206.     query -- A string
     
207.     restaurants -- A sequence of restaurants
     
208.     """
     
209.     # BEGIN Question 10
     
210.     "*** YOUR CODE HERE ***"
     
211.     return [restaurant for restaurant in restaurants if (query in restaurant_categories(restaurant))]
     
212.     # END Question 10
     
213. 
     
214. 
     
215. def feature_set():
     
216.     """Return a sequence of feature functions."""
     
217.     return [lambda r: mean(restaurant_ratings(r)),
     
218.             restaurant_price,
     
219.             lambda r: len(restaurant_ratings(r)),
     
220.             lambda r: restaurant_location(r)[0],
     
221.             lambda r: restaurant_location(r)[1]]
     
222. 
     
223. 
     
224. @main
     
225. def main(*args):
     
226.     import argparse
     
227.     parser = argparse.ArgumentParser(
     
228.         description='Run Recommendations',
     
229.         formatter_class=argparse.RawTextHelpFormatter
     
230.     )
     
231.     parser.add_argument('-u', '--user', type=str, choices=USER_FILES,
     
232.                         default='test_user',
     
233.                         metavar='USER',
     
234.                         help='user file, e.g.\n' +
     
235.                         '{{{}}}'.format(','.join(sample(USER_FILES, 3))))
     
236.     parser.add_argument('-k', '--k', type=int, help='for k-means')
     
237.     parser.add_argument('-q', '--query', choices=CATEGORIES,
     
238.                         metavar='QUERY',
     
239.                         help='search for restaurants by category e.g.\n'
     
240.                         '{{{}}}'.format(','.join(sample(CATEGORIES, 3))))
     
241.     parser.add_argument('-p', '--predict', action='store_true',
     
242.                         help='predict ratings for all restaurants')
     
243.     parser.add_argument('-r', '--restaurants', action='store_true',
     
244.                         help='outputs a list of restaurant names')
     
245.     args = parser.parse_args()
     
246. 
     
247.     # Output a list of restaurant names
     
248.     if args.restaurants:
     
249.         print('Restaurant names:')
     
250.         for restaurant in sorted(ALL_RESTAURANTS, key=restaurant_name):
     
251.             print(repr(restaurant_name(restaurant)))
     
252.         exit(0)
     
253. 
     
254.     # Select restaurants using a category query
     
255.     if args.query:
     
256.         restaurants = search(args.query, ALL_RESTAURANTS)
     
257.     else:
     
258.         restaurants = ALL_RESTAURANTS
     
259. 
     
260.     # Load a user
     
261.     assert args.user, 'A --user is required to draw a map'
     
262.     user = load_user_file('{}.dat'.format(args.user))
     
263. 
     
264.     # Collect ratings
     
265.     if args.predict:
     
266.         ratings = rate_all(user, restaurants, feature_set())
     
267.     else:
     
268.         restaurants = user_reviewed_restaurants(user, restaurants)
     
269.         names = [restaurant_name(r) for r in restaurants]
     
270.         ratings = {name: user_rating(user, name) for name in names}
     
271. 
     
272.     # Draw the visualization
     
273.     if args.k:
     
274.         centroids = k_means(restaurants, min(args.k, len(restaurants)))
     
275.     else:
     
276.         centroids = [restaurant_location(r) for r in restaurants]
     
277.     draw_map(centroids, restaurants, ratings)
     

复制代码

utils

1. """Utilities for Maps"""
   
2. 
   
3. from math import sqrt
   
4. from random import sample
   
5. 
   
6. # Rename the built-in zip ([url]http://docs.python.org/3/library/functions.html#zip[/url])
   
7. _zip = zip
   
8. 
   
9. def map_and_filter(s, map_fn, filter_fn):
   
10.     """Returns a new list containing the results of calling map_fn on each
    
11.     element of sequence s for which filter_fn returns a true value.
    
12. 
    
13.     >>> square = lambda x: x * x
    
14.     >>> is_odd = lambda x: x % 2 == 1
    
15.     >>> map_and_filter([1, 2, 3, 4, 5], square, is_odd)
    
16.     [1, 9, 25]
    
17.     """
    
18.     # BEGIN Question 0
    
19.     return [map_fn(i) for i in s if filter_fn(i)]
    
20.     # END Question 0
    
21. 
    
22. def key_of_min_value(d):
    
23.     """Returns the key in a dict d that corresponds to the minimum value of d.
    
24. 
    
25.     >>> letters = {'a': 6, 'b': 5, 'c': 4, 'd': 5}
    
26.     >>> min(letters)
    
27.     'a'
    
28.     >>> key_of_min_value(letters)
    
29.     'c'
    
30.     """
    
31.     # BEGIN Question 0
    
32.     return min(d,key = lambda x : d[x]) #d[x]中的x是d中的元素，所以d[x]就是values
    
33.     # END Question 0
    
34. 
    
35. def zip(*sequences):
    
36.     """Returns a list of lists, where the i-th list contains the i-th
    
37.     element from each of the argument sequences.
    
38. 
    
39.     >>> zip(range(0, 3), range(3, 6))
    
40.     [[0, 3], [1, 4], [2, 5]]
    
41.     >>> for a, b in zip([1, 2, 3], [4, 5, 6]):
    
42.     ...     print(a, b)
    
43.     1 4
    
44.     2 5
    
45.     3 6
    
46.     >>> for triple in zip(['a', 'b', 'c'], [1, 2, 3], ['do', 're', 'mi']):
    
47.     ...     print(triple)
    
48.     ['a', 1, 'do']
    
49.     ['b', 2, 're']
    
50.     ['c', 3, 'mi']
    
51.     """
    
52.     return list(map(list, _zip(*sequences)))
    
53. 
    
54. def enumerate(s, start=0):
    
55.     """Returns a list of lists, where the i-th list contains i+start and
    
56.     the i-th element of s.
    
57. 
    
58.     >>> enumerate([6, 1, 'a'])
    
59.     [[0, 6], [1, 1], [2, 'a']]
    
60.     >>> enumerate('five', 5)
    
61.     [[5, 'f'], [6, 'i'], [7, 'v'], [8, 'e']]
    
62.     """
    
63.     # BEGIN Question 0
    
64.     "*** YOUR CODE HERE ***"
    
65.     return zip([i+start for i in range(0,len(s))],s)
    
66.     # END Question 0
    
67. 
    
68. def distance(pos1, pos2):
    
69.     """Returns the Euclidean distance between pos1 and pos2, which are pairs.
    
70. 
    
71.     >>> distance([1, 2], [4, 6])
    
72.     5.0
    
73.     """
    
74.     return sqrt((pos1[0] - pos2[0]) ** 2 + (pos1[1] - pos2[1]) ** 2)
    
75. 
    
76. def mean(s):
    
77.     """Returns the arithmetic mean of a sequence of numbers s.
    
78. 
    
79.     >>> mean([-1, 3])
    
80.     1.0
    
81.     >>> mean([0, -3, 2, -1])
    
82.     -0.5
    
83.     """
    
84.     # BEGIN Question 1
    
85.     "*** YOUR CODE HERE ***"
    
86.     assert s != []
    
87.     total = 0
    
88.     for i in s:
    
89.         total += i
    
90.     return total/len(s)
    
91.     # END Question 1
    

复制代码

lilirr 发表于 2019-7-27 10:55
在github上找，每一个都有答案
一个参考

哈哈哈这是我的仓库 = =

表扬楼主积极学习分享的精神！
不过不知道楼主看没看过https://www.1point3acres.com/bbs/thread-37823-1-1.html关于Honor Code的帖子

hw05（不包括extra，因为我在赶进度所以extra先略过了）

1. def tree(label, branches=[]):
   
2.     """Construct a tree with the given label value and a list of branches."""
   
3.     for branch in branches:
   
4.         assert is_tree(branch), 'branches must be trees'
   
5.     return [label] + list(branches)
   
6. 
   
7. def label(tree):
   
8.     """Return the label value of a tree."""
   
9.     return tree[0]
   
10. 
    
11. def branches(tree):
    
12.     """Return the list of branches of the given tree."""
    
13.     return tree[1:]
    
14. 
    
15. def is_tree(tree):
    
16.     """Returns True if the given tree is a tree, and False otherwise."""
    
17.     if type(tree) != list or len(tree) < 1:
    
18.         return False
    
19.     for branch in branches(tree):
    
20.         if not is_tree(branch):
    
21.             return False
    
22.     return True
    
23. 
    
24. def is_leaf(tree):
    
25.     """Returns True if the given tree's list of branches is empty, and False
    
26.     otherwise.
    
27.     """
    
28.     return not branches(tree)
    
29. 
    
30. def print_tree(t, indent=0):
    
31.     """Print a representation of this tree in which each node is
    
32.     indented by two spaces times its depth from the root.
    
33. 
    
34.     >>> print_tree(tree(1))
    
35.     1
    
36.     >>> print_tree(tree(1, [tree(2)]))
    
37.     1
    
38.       2
    
39.     >>> numbers = tree(1, [tree(2), tree(3, [tree(4), tree(5)]), tree(6, [tree(7)])])
    
40.     >>> print_tree(numbers)
    
41.     1
    
42.       2
    
43.       3
    
44.         4
    
45.         5
    
46.       6
    
47.         7
    
48.     """
    
49.     print('  ' * indent + str(label(t)))
    
50.     for b in branches(t):
    
51.         print_tree(b, indent + 1)
    
52. 
    
53. def copy_tree(t):
    
54.     """Returns a copy of t. Only for testing purposes.
    
55. 
    
56.     >>> t = tree(5)
    
57.     >>> copy = copy_tree(t)
    
58.     >>> t = tree(6)
    
59.     >>> print_tree(copy)
    
60.     5
    
61.     """
    
62.     return tree(label(t), [copy_tree(b) for b in branches(t)])
    
63. 
    
64. #############
    
65. # Questions #
    
66. #############
    
67. 
    
68. def replace_leaf(t, old, new):
    
69.     """Returns a new tree where every leaf value equal to old has
    
70.     been replaced with new.
    
71. 
    
72.     >>> yggdrasil = tree('odin',
    
73.     ...                  [tree('balder',
    
74.     ...                        [tree('thor'),
    
75.     ...                         tree('loki')]),
    
76.     ...                   tree('frigg',
    
77.     ...                        [tree('thor')]),
    
78.     ...                   tree('thor',
    
79.     ...                        [tree('sif'),
    
80.     ...                         tree('thor')]),
    
81.     ...                   tree('thor')])
    
82.     >>> laerad = copy_tree(yggdrasil) # copy yggdrasil for testing purposes
    
83.     >>> print_tree(replace_leaf(yggdrasil, 'thor', 'freya'))
    
84.     odin
    
85.       balder
    
86.         freya
    
87.         loki
    
88.       frigg
    
89.         freya
    
90.       thor
    
91.         sif
    
92.         freya
    
93.       freya
    
94.     >>> laerad == yggdrasil # Make sure original tree is unmodified
    
95.     True
    
96.     """
    
97.     "*** YOUR CODE HERE ***"
    
98.     if is_leaf(t):
    
99.         if label(t) == old:
    
100.             return tree(new)
     
101.         return t #这一步很关键啊
     
102.     else:
     
103.         return tree(label(t),[replace_leaf(branch,old,new)for branch in branches(t)])
     
104.             
     
105. def print_move(origin, destination):
     
106.     """Print instructions to move a disk."""
     
107.     print("Move the top disk from rod", origin, "to rod", destination)
     
108. 
     
109. def move_stack(n, start, end):
     
110.     """Print the moves required to move n disks on the start pole to the end
     
111.     pole without violating the rules of Towers of Hanoi.
     
112. 
     
113.     n -- number of disks
     
114.     start -- a pole position, either 1, 2, or 3
     
115.     end -- a pole position, either 1, 2, or 3
     
116. 
     
117.     There are exactly three poles, and start and end must be different. Assume
     
118.     that the start pole has at least n disks of increasing size, and the end
     
119.     pole is either empty or has a top disk larger than the top n start disks.
     
120. 
     
121.     >>> move_stack(1, 1, 3)
     
122.     Move the top disk from rod 1 to rod 3
     
123.     >>> move_stack(2, 1, 3)
     
124.     Move the top disk from rod 1 to rod 2
     
125.     Move the top disk from rod 1 to rod 3
     
126.     Move the top disk from rod 2 to rod 3
     
127.     >>> move_stack(3, 1, 3)
     
128.     Move the top disk from rod 1 to rod 3
     
129.     Move the top disk from rod 1 to rod 2
     
130.     Move the top disk from rod 3 to rod 2
     
131.     Move the top disk from rod 1 to rod 3
     
132.     Move the top disk from rod 2 to rod 1
     
133.     Move the top disk from rod 2 to rod 3
     
134.     Move the top disk from rod 1 to rod 3
     
135.     """
     
136.     assert 1 <= start <= 3 and 1 <= end <= 3 and start != end, "Bad start/end"
     
137.     "*** YOUR CODE HERE ***"
     
138.     #核心思想是把start上面n-1个移到auxiliary pole上，再把start上剩余的第n个移到end上。重复进行
     
139.     auxiliary = 6-start-end
     
140.     if n ==1:
     
141.         print_move(start,end)
     
142.     else:
     
143.         move_stack(n-1,start,auxiliary)
     
144.         print_move(start,end)
     
145.         move_stack(n-1,auxiliary,end)
     
146. ###########
     
147. # Mobiles #
     
148. ###########
     
149. 
     
150. def mobile(left, right):
     
151.     """Construct a mobile from a left side and a right side."""
     
152.     return tree('mobile', [left, right])
     
153. 
     
154. def is_mobile(m):
     
155.     return is_tree(m) and label(m) == 'mobile'
     
156. 
     
157. def sides(m):
     
158.     """Select the sides of a mobile."""
     
159.     assert is_mobile(m), "must call sides on a mobile"
     
160.     return branches(m)
     
161. 
     
162. def is_side(m):
     
163.     return not is_mobile(m) and not is_weight(m) and type(label(m)) == int
     
164. 
     
165. def side(length, mobile_or_weight):
     
166.     """Construct a side: a length of rod with a mobile or weight at the end."""
     
167.     return tree(length, [mobile_or_weight])
     
168. 
     
169. def length(s):
     
170.     """Select the length of a side."""
     
171.     assert is_side(s), "must call length on a side"
     
172.     return label(s)
     
173. 
     
174. def end(s):
     
175.     """Select the mobile or weight hanging at the end of a side."""
     
176.     assert is_side(s), "must call end on a side"
     
177.     return branches(s)[0]
     
178. 
     
179. def weight(size):
     
180.     """Construct a weight of some size."""
     
181.     assert size > 0
     
182.     "*** YOUR CODE HERE ***"
     
183.     #tree的branch也必须是tree类型,注意label不一定是str类型
     
184.     return tree(size,[])
     
185. 
     
186. def size(w):
     
187.     """Select the size of a weight."""
     
188.     "*** YOUR CODE HERE ***"
     
189.     assert is_weight(w)
     
190.     return label(w)
     
191. 
     
192. def is_weight(w):
     
193.     """Whether w is a weight, not a mobile."""
     
194.     "*** YOUR CODE HERE ***"
     
195.     return not is_mobile(w) and type(label(w))==int and branches(w)==[]
     
196. 
     
197. def examples():
     
198.     t = mobile(side(1, weight(2)),
     
199.                side(2, weight(1)))
     
200.     u = mobile(side(5, weight(1)),
     
201.                side(1, mobile(side(2, weight(3)),
     
202.                               side(3, weight(2)))))
     
203.     v = mobile(side(4, t), side(2, u))
     
204.     return (t, u, v)
     
205. 
     
206. 
     
207. def total_weight(m):
     
208.     """Return the total weight of m, a weight or mobile.
     
209. 
     
210.     >>> t, u, v = examples()
     
211.     >>> total_weight(t)
     
212.     3
     
213.     >>> total_weight(u)
     
214.     6
     
215.     >>> total_weight(v)
     
216.     9
     
217.     """
     
218.     if is_weight(m):
     
219.         return size(m)
     
220.     else:
     
221.         assert is_mobile(m), "must get total weight of a mobile or a weight"
     
222.         return sum([total_weight(end(s)) for s in sides(m)])
     
223. 
     
224. def balanced(m):
     
225.     """Return whether m is balanced.
     
226. 
     
227.     >>> t, u, v = examples()
     
228.     >>> balanced(t)
     
229.     True
     
230.     >>> balanced(v)
     
231.     True
     
232.     >>> w = mobile(side(3, t), side(2, u))
     
233.     >>> balanced(w)
     
234.     False
     
235.     >>> balanced(mobile(side(1, v), side(1, w)))
     
236.     False
     
237.     >>> balanced(mobile(side(1, w), side(1, v)))
     
238.     False
     
239.     """
     
240.     "*** YOUR CODE HERE ***"
     
241.     for side in sides(m):
     
242.         #sides(m)返回的m的branches[left,right]，所以side是个tree
     
243.         if is_mobile(end(side)) and not balanced(end(side)):#这一步容易错，对照balanced(mobile(side(1, v), side(1, w)))，submobile v,w也必须是平衡的
     
244.             return False
     
245.     weight0,weight1 = total_weight(end(sides(m)[0])),total_weight(end(sides(m)[1]))
     
246.     return weight0*length(sides(m)[0]) == weight1*length(sides(m)[1])
     
247.             
     
248. 
     
249. #######
     
250. # OOP #
     
251. #######
     
252. 
     
253. class Account:
     
254.     """An account has a balance and a holder.
     
255. 
     
256.     >>> a = Account('John')
     
257.     >>> a.deposit(10)
     
258.     10
     
259.     >>> a.balance
     
260.     10
     
261.     >>> a.interest
     
262.     0.02
     
263. 
     
264.     >>> a.time_to_retire(10.25) # 10 -> 10.2 -> 10.404
     
265.     2
     
266.     >>> a.balance               # balance should not change
     
267.     10
     
268.     >>> a.time_to_retire(11)    # 10 -> 10.2 -> ... -> 11.040808032
     
269.     5
     
270.     >>> a.time_to_retire(100)
     
271.     117
     
272.     """
     
273. 
     
274.     interest = 0.02  # A class attribute
     
275. 
     
276.     def __init__(self, account_holder):
     
277.         self.holder = account_holder
     
278.         self.balance = 0
     
279. 
     
280.     def deposit(self, amount):
     
281.         """Add amount to balance."""
     
282.         self.balance = self.balance + amount
     
283.         return self.balance
     
284. 
     
285.     def withdraw(self, amount):
     
286.         """Subtract amount from balance if funds are available."""
     
287.         if amount > self.balance:
     
288.             return 'Insufficient funds'
     
289.         self.balance = self.balance - amount
     
290.         return self.balance
     
291. 
     
292.     def time_to_retire(self, amount):
     
293.         """Return the number of years until balance would grow to amount."""
     
294.         assert self.balance > 0 and amount > 0 and self.interest > 0
     
295.         "*** YOUR CODE HERE ***"
     
296.         future_salary = self.balance
     
297.         year = 0
     
298.         while future_salary < amount:
     
299.             future_salary = future_salary * (1+self.interest)
     
300.             year += 1
     
301.         return year
     
302. 
     
303. class FreeChecking(Account):
     
304.     """A bank account that charges for withdrawals, but the first two are free!
     
305. 
     
306.     >>> ch = FreeChecking('Jack')
     
307.     >>> ch.balance = 20
     
308.     >>> ch.withdraw(100)  # First one's free
     
309.     'Insufficient funds'
     
310.     >>> ch.withdraw(3)    # And the second
     
311.     17
     
312.     >>> ch.balance
     
313.     17
     
314.     >>> ch.withdraw(3)    # Ok, two free withdrawals is enough
     
315.     13
     
316.     >>> ch.withdraw(3)
     
317.     9
     
318.     >>> ch2 = FreeChecking('John')
     
319.     >>> ch2.balance = 10
     
320.     >>> ch2.withdraw(3) # No fee
     
321.     7
     
322.     >>> ch.withdraw(3)  # ch still charges a fee
     
323.     5
     
324.     >>> ch.withdraw(5)  # Not enough to cover fee + withdraw
     
325.     'Insufficient funds'
     
326.     """
     
327.     withdraw_fee = 1
     
328.     free_withdrawals = 2
     
329. 
     
330.     "*** YOUR CODE HERE ***"
     
331.     def withdraw(self, amount):
     
332.         self.free_withdrawals -= 1
     
333.         if self.free_withdrawals >= 0:
     
334.             return Account.withdraw(self,amount)
     
335.         else:
     
336.             if amount+self.withdraw_fee > self.balance:
     
337.                 return 'Insufficient funds'
     
338.             self.balance = self.balance - amount - self.withdraw_fee
     
339.             return self.balance
     
340. 
     
341. ############
     
342. # Mutation #
     
343. ############
     
344. 
     
345. def make_counter():
     
346.     """Return a counter function.
     
347. 
     
348.     >>> c = make_counter()
     
349.     >>> c('a')
     
350.     1
     
351.     >>> c('a')
     
352.     2
     
353.     >>> c('b')
     
354.     1
     
355.     >>> c('a')
     
356.     3
     
357.     >>> c2 = make_counter()
     
358.     >>> c2('b')
     
359.     1
     
360.     >>> c2('b')
     
361.     2
     
362.     >>> c('b') + c2('b')
     
363.     5
     
364.     """
     
365.     "*** YOUR CODE HERE ***"
     
366.     memory = []
     
367.     appear_times = []
     
368.     def counter(string):
     
369.         nonlocal memory
     
370.         nonlocal appear_times
     
371.         if string not in memory:
     
372.             memory.append(string)
     
373.             appear_times.append(1)
     
374.             indx = memory.index(string)
     
375.         else:
     
376.             indx = memory.index(string)
     
377.             appear_times[indx] += 1
     
378.         return appear_times[indx]
     
379.     return counter
     
380. 
     
381. def make_fib():
     
382.     """Returns a function that returns the next Fibonacci number
     
383.     every time it is called.
     
384. 
     
385.     >>> fib = make_fib()
     
386.     >>> fib()
     
387.     0
     
388.     >>> fib()
     
389.     1
     
390.     >>> fib()
     
391.     1
     
392.     >>> fib()
     
393.     2
     
394.     >>> fib()
     
395.     3
     
396.     >>> fib2 = make_fib()
     
397.     >>> fib() + sum([fib2() for _ in range(5)])
     
398.     12
     
399.     """
     
400.     "*** YOUR CODE HERE ***"
     
401.     call_times_m1 = 0
     
402.     last_two = 0
     
403.     last = 0
     
404.     def fib_num():
     
405.         nonlocal call_times_m1
     
406.         nonlocal last_two
     
407.         nonlocal last
     
408.         if call_times_m1 == 0:
     
409.             call_times_m1 +=1
     
410.             return 0
     
411.         elif call_times_m1 ==1:
     
412.             last_two,last = 0, 1
     
413.             call_times_m1 +=1
     
414.             return 1
     
415.         else:
     
416.             last,last_two = last+last_two,last
     
417.             call_times_m1 +=1
     
418.         return last
     
419.     return fib_num
     
420. 
     
421. def make_withdraw(balance, password):
     
422.     """Return a password-protected withdraw function.
     
423.     >>> w = make_withdraw(100, 'hax0r')
     
424.     >>> w(25, 'hax0r')
     
425.     75
     
426.     >>> error = w(90, 'hax0r')
     
427.     >>> error
     
428.     'Insufficient funds'
     
429.     >>> error = w(25, 'hwat')
     
430.     >>> error
     
431.     'Incorrect password'
     
432.     >>> new_bal = w(25, 'hax0r')
     
433.     >>> new_bal
     
434.     50
     
435.     >>> w(75, 'a')
     
436.     'Incorrect password'
     
437.     >>> w(10, 'hax0r')
     
438.     40
     
439.     >>> w(20, 'n00b')
     
440.     'Incorrect password'
     
441.     >>> w(10, 'hax0r')
     
442.     "Your account is locked. Attempts: ['hwat', 'a', 'n00b']"
     
443.     >>> w(10, 'l33t')
     
444.     "Your account is locked. Attempts: ['hwat', 'a', 'n00b']"
     
445.     >>> type(w(10, 'l33t')) == str
     
446.     True
     
447.     """
     
448.     "*** YOUR CODE HERE ***"
     
449.     incorrect_pw = []
     
450.     def withdraw(amount,input_pw):
     
451.         nonlocal balance,incorrect_pw
     
452.         if len(incorrect_pw) >= 3:
     
453.             return "Your account is locked. Attempts: " + str(incorrect_pw)
     
454.         elif input_pw != password and input_pw not in incorrect_pw:
     
455.             incorrect_pw.append(input_pw)
     
456.             return "Incorrect password"
     
457.         elif input_pw != password and input_pw in incorrect_pw:
     
458.             return "Incorrect password"
     
459.         else:
     
460.             if amount > balance:
     
461.                 return "Insufficient funds"
     
462.             balance = balance - amount
     
463.         return balance
     
464.     return withdraw
     
465. 
     
466. #好好复习这道题，难，并且陷阱很多，不敢相信我居然卡了三个小时  = = ...
     
467. def make_joint(withdraw, old_password, new_password):
     
468.     """Return a password-protected withdraw function that has joint access to
     
469.     the balance of withdraw.
     
470. 
     
471.     >>> w = make_withdraw(100, 'hax0r')
     
472.     >>> w(25, 'hax0r')
     
473.     75
     
474.     >>> make_joint(w, 'my', 'secret')
     
475.     'Incorrect password'
     
476.     >>> j = make_joint(w, 'hax0r', 'secret')
     
477.     >>> w(25, 'secret')
     
478.     'Incorrect password'
     
479.     >>> j(25, 'secret')
     
480.     50
     
481.     >>> j(25, 'hax0r')
     
482.     25
     
483.     >>> j(100, 'secret')
     
484.     'Insufficient funds'
     
485. 
     
486.     >>> j2 = make_joint(j, 'secret', 'code')
     
487.     >>> j2(5, 'code')
     
488.     20
     
489.     >>> j2(5, 'secret')
     
490.     15
     
491.     >>> j2(5, 'hax0r')
     
492.     10
     
493. 
     
494.     >>> j2(25, 'password')
     
495.     'Incorrect password'
     
496.     >>> j2(5, 'secret')
     
497.     "Your account is locked. Attempts: ['my', 'secret', 'password']"
     
498.     >>> j(5, 'secret')
     
499.     "Your account is locked. Attempts: ['my', 'secret', 'password']"
     
500.     >>> w(5, 'hax0r')
     
501.     "Your account is locked. Attempts: ['my', 'secret', 'password']"
     
502.     >>> make_joint(w, 'hax0r', 'hello')
     
503.     "Your account is locked. Attempts: ['my', 'secret', 'password']"
     
504.     """
     
505.     "*** YOUR CODE HERE ***"
     
506. 
     
507.    
     
508.     correct_passwords = [old_password,new_password]
     
509.     def jointed(amount,user_password):#这个user_password这里卡了
     
510.         if user_password in correct_passwords:
     
511.             return withdraw(amount,old_password)
     
512.         else:
     
513.             return withdraw(amount,user_password)
     
514.     if type(withdraw(0,old_password)) != str: #密码对上了
     
515.              return jointed #直接返回密码正确的withdraw，功能同上
     
516.     else:
     
517.         return withdraw(0,old_password) #密码错误的功能用已定义的实现（很巧妙！！）'''
     
518.    
     
519. 
     
520. ###################
     
521. # Extra Questions #
     
522. ###################
     
523. 
     
524. def interval(a, b):
     
525.     """Construct an interval from a to b."""
     
526.     return [a, b]
     
527. 
     
528. def lower_bound(x):
     
529.     """Return the lower bound of interval x."""
     
530.     "*** YOUR CODE HERE ***"
     
531. 
     
532. def upper_bound(x):
     
533.     """Return the upper bound of interval x."""
     
534.     "*** YOUR CODE HERE ***"
     
535. 
     
536. def str_interval(x):
     
537.     """Return a string representation of interval x."""
     
538.     return '{0} to {1}'.format(lower_bound(x), upper_bound(x))
     
539. 
     
540. def add_interval(x, y):
     
541.     """Return an interval that contains the sum of any value in interval x and
     
542.     any value in interval y."""
     
543.     lower = lower_bound(x) + lower_bound(y)
     
544.     upper = upper_bound(x) + upper_bound(y)
     
545.     return interval(lower, upper)
     
546. 
     
547. def mul_interval(x, y):
     
548.     """Return the interval that contains the product of any value in x and any
     
549.     value in y."""
     
550.     p1 = x[0] * y[0]
     
551.     p2 = x[0] * y[1]
     
552.     p3 = x[1] * y[0]
     
553.     p4 = x[1] * y[1]
     
554.     return [min(p1, p2, p3, p4), max(p1, p2, p3, p4)]
     
555. 
     
556. def sub_interval(x, y):
     
557.     """Return the interval that contains the difference between any value in x
     
558.     and any value in y."""
     
559.     "*** YOUR CODE HERE ***"
     
560. 
     
561. def div_interval(x, y):
     
562.     """Return the interval that contains the quotient of any value in x divided by
     
563.     any value in y. Division is implemented as the multiplication of x by the
     
564.     reciprocal of y."""
     
565.     "*** YOUR CODE HERE ***"
     
566.     reciprocal_y = interval(1/upper_bound(y), 1/lower_bound(y))
     
567.     return mul_interval(x, reciprocal_y)
     
568. 
     
569. def par1(r1, r2):
     
570.     return div_interval(mul_interval(r1, r2), add_interval(r1, r2))
     
571. 
     
572. def par2(r1, r2):
     
573.     one = interval(1, 1)
     
574.     rep_r1 = div_interval(one, r1)
     
575.     rep_r2 = div_interval(one, r2)
     
576.     return div_interval(one, add_interval(rep_r1, rep_r2))
     
577. 
     
578. def check_par():
     
579.     """Return two intervals that give different results for parallel resistors.
     
580. 
     
581.     >>> r1, r2 = check_par()
     
582.     >>> x = par1(r1, r2)
     
583.     >>> y = par2(r1, r2)
     
584.     >>> lower_bound(x) != lower_bound(y) or upper_bound(x) != upper_bound(y)
     
585.     True
     
586.     """
     
587.     r1 = interval(1, 1) # Replace this line!
     
588.     r2 = interval(1, 1) # Replace this line!
     
589.     return r1, r2
     
590. 
     
591. def multiple_references_explanation():
     
592.     return """The multiple reference problem..."""
     
593. 
     
594. def quadratic(x, a, b, c):
     
595.     """Return the interval that is the range of the quadratic defined by
     
596.     coefficients a, b, and c, for domain interval x.
     
597. 
     
598.     >>> str_interval(quadratic(interval(0, 2), -2, 3, -1))
     
599.     '-3 to 0.125'
     
600.     >>> str_interval(quadratic(interval(1, 3), 2, -3, 1))
     
601.     '0 to 10'
     
602.     """
     
603.     "*** YOUR CODE HERE ***"
     
604. 
     
605. def polynomial(x, c):
     
606.     """Return the interval that is the range of the polynomial defined by
     
607.     coefficients c, for domain interval x.
     
608. 
     
609.     >>> str_interval(polynomial(interval(0, 2), [-1, 3, -2]))
     
610.     '-3 to 0.125'
     
611.     >>> str_interval(polynomial(interval(1, 3), [1, -3, 2]))
     
612.     '0 to 10'
     
613.     >>> str_interval(polynomial(interval(0.5, 2.25), [10, 24, -6, -8, 3]))
     
614.     '18.0 to 23.0'
     
615.     """
     
616.     "*** YOUR CODE HERE ***"
     
617. 
     

复制代码

lab05和hw05重复太多了，我就没写 直接上的lab06 which is really fun

lab06

1. # A "simple" adventure game.
   
2. 
   
3. class Player(object):
   
4.     def __init__(self, name, place):
   
5.         """Create a player object."""
   
6.         self.name = name
   
7.         self.place = place
   
8.         self.backpack = []
   
9. 
   
10.     def look(self):
    
11.         self.place.look()
    
12. 
    
13.     def go_to(self, location):
    
14.         """Go to a location if it's among the exits of player's current place.
    
15.         >>> sather_gate = Place('Sather Gate', 'Sather Gate', [], [])
    
16.         >>> gbc = Place('GBC', 'Golden Bear Cafe', [], [])
    
17.         >>> sather_gate.add_exits([gbc])
    
18.         >>> sather_gate.locked = True
    
19.         >>> gbc.add_exits([sather_gate])
    
20.         >>> me = Player('player', sather_gate)
    
21.         >>> me.go_to('GBC')
    
22.         You are at GBC
    
23.         >>> me.place is gbc
    
24.         True
    
25.         >>> me.place.name
    
26.         'GBC'
    
27.         >>> me.go_to('GBC')
    
28.         Can't go to GBC from GBC.
    
29.         Try looking around to see where to go.
    
30.         You are at GBC
    
31.         >>> me.go_to('Sather Gate')
    
32.         Sather Gate is locked! Go look for a key to unlock it
    
33.         You are at GBC
    
34.         """
    
35.         destination_place = self.place.get_neighbor(location)
    
36.         if destination_place.locked:
    
37.             print(destination_place.name, 'is locked! Go look for a key to unlock it')
    
38.         else:
    
39.             self.place = destination_place
    
40.         print('You are at ' + self.place.name)
    
41. 
    
42. 
    
43.     def talk_to(self, person):
    
44.         """Talk to person if person is at player's current place.
    
45.         >>> jerry = Character('Jerry', 'I am not the Jerry you are looking for.')
    
46.         >>> wheeler = Place('Wheeler', 'You are at Wheeler', [jerry], [])
    
47.         >>> me = Player('player', wheeler)
    
48.         >>> me.talk_to(jerry)
    
49.         Person has to be a string.
    
50.         >>> me.talk_to('Jerry')
    
51.         Jerry says: I am not the Jerry you are looking for.
    
52.         >>> me.talk_to('Tiffany')
    
53.         Tiffany is not here.
    
54.         """
    
55.         if type(person) != str:
    
56.             print('Person has to be a string.')
    
57.         elif person not in self.place.characters:
    
58.             print(person + ' is not here.')
    
59.         else:
    
60.             print(person + ' says: ' + self.place.characters[person].talk())
    
61. 
    
62.     def take(self, thing):
    
63.         """Take a thing if thing is at player's current place
    
64.         >>> lemon = Thing('Lemon', 'A lemon-looking lemon')
    
65.         >>> gbc = Place('GBC', 'You are at Golden Bear Cafe', [], [lemon])
    
66.         >>> me = Player('Player', gbc)
    
67.         >>> me.backpack
    
68.         []
    
69.         >>> me.take(lemon)
    
70.         Thing should be a string.
    
71.         >>> me.take('orange')
    
72.         orange is not here.
    
73.         >>> me.take('Lemon')
    
74.         Player takes the Lemon
    
75.         >>> me.take('Lemon')
    
76.         Lemon is not here.
    
77.         >>> isinstance(me.backpack[0], Thing)
    
78.         True
    
79.         >>> len(me.backpack)
    
80.         1
    
81.         """
    
82.         if type(thing) != str:
    
83.             print('Thing should be a string.')
    
84.         elif thing not in self.place.things:
    
85.             print(thing + ' is not here.')
    
86.         else:
    
87.             print('Player takes the ' + self.place.things[thing].name)
    
88.             self.backpack.append(self.place.things[thing])
    
89.             self.place.take(thing)
    
90. 
    
91. 
    
92. 
    
93.     def check_backpack(self):
    
94.         """Print each item with its description and return a list of item names.
    
95.         >>> cookie = Thing('Cookie', 'A huge cookie')
    
96.         >>> donut = Thing('Donut', 'A huge donut')
    
97.         >>> cupcake = Thing('Cupcake', 'A huge cupcake')
    
98.         >>> gbc = Place('GBC', 'You are at Golden Bear Cafe',
    
99.         ...             [], [cookie, donut, cupcake])
    
100.         >>> me = Player('Player', gbc)
     
101.         >>> me.check_backpack()
     
102.         In your backpack:
     
103.             there is nothing.
     
104.         []
     
105.         >>> me.take('Cookie')
     
106.         Player takes the Cookie
     
107.         >>> me.check_backpack()
     
108.         In your backpack:
     
109.             Cookie - A huge cookie
     
110.         ['Cookie']
     
111.         >>> me.take('Donut')
     
112.         Player takes the Donut
     
113.         >>> food = me.check_backpack()
     
114.         In your backpack:
     
115.             Cookie - A huge cookie
     
116.             Donut - A huge donut
     
117.         >>> food
     
118.         ['Cookie', 'Donut']
     
119.         """
     
120.         print('In your backpack:')
     
121.         if not self.backpack:
     
122.             print('    there is nothing.')
     
123.         else:
     
124.             for item in self.backpack:
     
125.                 print('   ', item.name, '-', item.description)
     
126.         return [item.name for item in self.backpack]
     
127. 
     
128.     def unlock(self, place):
     
129.         """If player has a key, unlock a locked neighboring place.
     
130.         >>> key = Key('SkeletonKey', 'A Key to unlock all doors.')
     
131.         >>> gbc = Place('GBC', 'You are at Golden Bear Cafe', [], [key])
     
132.         >>> fsm = Place('FSM', 'Home of the nectar of the gods', [], [])
     
133.         >>> gbc.add_exits([fsm])
     
134.         >>> fsm.locked = True
     
135.         >>> me = Player('Player', gbc)
     
136.         >>> me.unlock(fsm)
     
137.         Place must be a string
     
138.         >>> me.go_to('FSM')
     
139.         FSM is locked! Go look for a key to unlock it
     
140.         You are at GBC
     
141.         >>> me.unlock(fsm)
     
142.         Place must be a string
     
143.         >>> me.unlock('FSM')
     
144.         FSM can't be unlocked without a key!
     
145.         >>> me.take('SkeletonKey')
     
146.         Player takes the SkeletonKey
     
147.         >>> me.unlock('FSM')
     
148.         FSM is now unlocked!
     
149.         >>> me.unlock('FSM')
     
150.         FSM is already unlocked!
     
151.         >>> me.go_to('FSM')
     
152.         You are at FSM
     
153.         """
     
154.         if type(place) != str:
     
155.             print("Place must be a string")
     
156.             return
     
157.         key = None
     
158.         for item in self.backpack:
     
159.             if type(item) == Key:
     
160.                 key = item
     
161.         
     
162.         place = self.place.get_neighbor(place)#变成了obj
     
163.         if not key and place.locked:
     
164.             print(place.name + ' can\'t be unlocked without a key!')
     
165.         elif not place.locked:
     
166.             print(place.name + ' is already unlocked!')
     
167.         else:   
     
168.             key.use(place)
     
169.             print(place.name + ' is now unlocked!')
     
170. 
     
171. class Character(object):
     
172.     def __init__(self, name, message):
     
173.         self.name = name
     
174.         self.message = message
     
175. 
     
176.     def talk(self):
     
177.         return self.message
     
178. 
     
179. 
     
180. class Thing(object):
     
181.     def __init__(self, name, description):
     
182.         self.name = name
     
183.         self.description = description
     
184. 
     
185.     def use(self, place):
     
186.         print("You can't use a {0} here".format(self.name))
     
187. 
     
188. """ Implement Key here! """
     
189. class Key(Thing):
     
190.     def use(self,place):
     
191.         place.locked = False
     
192. 
     
193. class Treasure(Thing):
     
194.     def __init__(self, name, description, value, weight):
     
195.         Thing.__init__(self, name, description)
     
196.         self.value = value
     
197.         self.weight = weight
     
198. 
     
199. class Place(object):
     
200.     def __init__(self, name, description, characters, things):
     
201.         self.name = name
     
202.         self.description = description
     
203.         self.characters = {character.name: character for character in characters}
     
204.         self.things = {thing.name: thing for thing in things}
     
205.         self.locked = False
     
206.         self.exits = {} # {'name': (exit, 'description')}
     
207. 
     
208.     def look(self):
     
209.         print('You are currently at ' + self.name + '. You take a look around and see:')
     
210.         print('Characters:')
     
211.         if not self.characters:
     
212.             print('    no one in particular')
     
213.         else:
     
214.             for character in self.characters:
     
215.                 print('   ', character)
     
216.         print('Things:')
     
217.         if not self.things:
     
218.             print('    nothing in particular')
     
219.         else:
     
220.             for thing in self.things.values():
     
221.                 print('   ', thing.name, '-', thing.description)
     
222.         self.check_exits()
     
223. 
     
224.     def get_neighbor(self, exit):
     
225.         """
     
226.         >>> sather_gate = Place('Sather Gate', 'You are at Sather Gate', [], [])
     
227.         >>> gbc = Place('GBC', 'You are at Golden Bear Cafe', [], [])
     
228.         >>> gbc.add_exits([sather_gate])
     
229.         >>> place = gbc.get_neighbor('Sather Gate')
     
230.         >>> place is sather_gate
     
231.         True
     
232.         >>> place = gbc.get_neighbor('FSM')
     
233.         Can't go to FSM from GBC.
     
234.         Try looking around to see where to go.
     
235.         >>> place is gbc
     
236.         True
     
237.         """
     
238.         if type(exit) != str:
     
239.             print('Exit has to be a string.')
     
240.             return self
     
241.         elif exit in self.exits:
     
242.             exit_place = self.exits[exit][0]
     
243.             return exit_place
     
244.         else:
     
245.             print("Can't go to {} from {}.".format(exit, self.name))
     
246.             print("Try looking around to see where to go.")
     
247.             return self
     
248. 
     
249.     def take(self, thing):
     
250.         return self.things.pop(thing)
     
251. 
     
252.     def check_exits(self):
     
253.         print('You can exit to:')
     
254.         for exit in self.exits:
     
255.             print('   ', exit)
     
256. 
     
257.     def add_exits(self, places):
     
258.         for place in places:
     
259.             self.exits[place.name] = (place, place.description)
     

复制代码

lab06 extra代码是单独的不知道为什么...

单独测试会报错 但其实代码没有问题
我觉得应该是lab06.zip文件没有更新...

lab06_extra

1. def vending_machine(snacks):
   
2.     """Cycles through sequence of snacks.
   
3. 
   
4.     >>> vender = vending_machine(('chips', 'chocolate', 'popcorn'))
   
5.     >>> vender()
   
6.     'chips'
   
7.     >>> vender()
   
8.     'chocolate'
   
9.     >>> vender()
   
10.     'popcorn'
    
11.     >>> vender()
    
12.     'chips'
    
13.     >>> other = vending_machine(('brownie',))
    
14.     >>> other()
    
15.     'brownie'
    
16.     >>> vender()
    
17.     'chocolate'
    
18.     """
    
19.     "*** YOUR CODE HERE ***"
    
20.     snacks = list(snacks)
    
21.     cyc_index = -1
    
22.     count = 0
    
23.     def cycling():
    
24.         nonlocal cyc_index,count
    
25.         if count >=3:
    
26.             cyc_index -= 3
    
27.             count -=3
    
28.         cyc_index +=1
    
29.         count +=1
    
30.         return snacks[cyc_index]        
    
31.     return cycling

复制代码