我创建了一个实现BFS搜索的通用版本的类：
from collections import deque
class NodeSolver:
'''Class for modeling problems that can be modeled as a directed graph with goal nodes'''
def __init__(self, namer, detector, expander, follower):
'''
Whatever decides to use this gets to define what structure info is.
namer: takes info representing a node and returns a hashable object (the name);
names must be equal if and only if the nodes are equal
detector: takes info and returns True if the node represented by the info is the goal node,
...False otherwise.
expander: takes info and returns an iterable of moves that can be made from the node
...that the info represents. (a.k.a. paths leading out of that node)
follower: takes info and a move that can be made from the node that the info represents,
...and returns the info that represents the node that the move leads to
'''
self.get_name = namer
self.is_goal = detector
self.get_moves = expander
self.follow_move = follower
class BFSSolver(NodeSolver):
'''Class for solving node problems with breadth-first-search to reach the goal node'''
def solve(self, start_info):
'''
Returns the list of moves needed to reach the goal node
...from the node represented by the parameter.
Uses Breadth-first Search to go through the node tree
'''
if self.is_goal(start_info):
return []
start_name = self.get_name(start_info)
# data is in the form (info, path)
name_to_data = {start_name: (start_info, [])}
queue = deque()
queue.appendleft(start_name)
while queue:
current_name = queue.pop()
current_info, current_path = name_to_data[current_name]
expanded_moves = self.get_moves(current_info)
# print("possible moves from {} is {}".format(current_info, expanded_moves))
for move in expanded_moves:
child_info = self.follow_move(current_info, move)
child_path = current_path[:]
child_path.append(move)
if self.is_goal(child_info):
return child_path
child_name = self.get_name(child_info)
if child_name not in name_to_data:
# new, needs to be expanded
name_to_data[child_name] = (child_info, child_path)
queue.appendleft(child_name)
return None
算作info，move或name的实现完全取决于使用该类的人。
但是，一旦确定了这些定义，则它们应保持一致。例如，info可以是用户创建的Info对象类型。 move可能只是整数。 name可能只是一个字符串。
选择了这些定义之后，我希望类型检查器能够确保用户坚持使用这些定义。
我如何使用类型检查来完成类似的事情？
到目前为止，我已经完成：
from collections import deque
from typing import Callable, Any, Iterable, List, Deque, Tuple, Dict, Optional, Hashable
# pylint: disable=invalid-name
# Type definitions
# Can be literally anything
Info = Any
Name = Hashable
# Can be literally anything
Move = Any
# pylint: enable=invalid-name
class NodeSolver:
'''Class for modeling problems that can be modeled as a directed graph with goal nodes'''
def __init__(self, namer: Callable[[Info], Name],
detector: Callable[[Info], bool],
expander: Callable[[Info], Iterable[Move]],
follower: Callable[[Info, Move], Info]):
'''
Whatever decides to use this gets to define what structure info is.
namer: takes info representing a node and returns a hashable object (the name);
names must be equal if and only if the nodes are equal
detector: takes info and returns True if the node represented by the info is the goal node,
...False otherwise.
expander: takes info and returns an iterable of moves that can be made from the node
...that the info represents. (a.k.a. paths leading out of that node)
follower: takes info and a move that can be made from the node that the info represents,
...and returns the info that represents the node that the move leads to
'''
self.get_name = namer
self.is_goal = detector
self.get_moves = expander
self.follow_move = follower
class BFSSolver(NodeSolver):
'''Class for solving node problems with breadth-first-search to reach the goal node'''
def solve(self, start_info: Info) -> Optional[List[Move]]:
'''
Returns the list of moves needed to reach the goal node
...from the node represented by the parameter.
Uses Breadth-first Search to go through the node tree
'''
if self.is_goal(start_info):
return []
start_name = self.get_name(start_info)
# data is in the form (info, path)
name_to_data: Dict[Name, Tuple[Info, List[Move]]] = {start_name: (start_info, [])}
queue: Deque[Name] = deque()
queue.appendleft(start_name)
while queue:
current_name = queue.pop()
current_info, current_path = name_to_data[current_name]
expanded_moves = self.get_moves(current_info)
# print("possible moves from {} is {}".format(current_info, expanded_moves))
for move in expanded_moves:
child_info = self.follow_move(current_info, move)
child_path = current_path[:]
child_path.append(move)
if self.is_goal(child_info):
return child_path
child_name = self.get_name(child_info)
if child_name not in name_to_data:
# new, needs to be expanded
name_to_data[child_name] = (child_info, child_path)
queue.appendleft(child_name)
return None
但是，我不确定使用该类的类将如何设置这些变量以进行类型检查，并且我也不确定如果多个类对{{1 }}，Info和Move。
另外，到处都是Name时，我会出错。
答案 0 :(得分：2)
from collections import deque
from typing import Callable, Any, Iterable, List, Deque, Tuple, Dict, Optional, Hashable, TypeVar, Generic
TInfo = TypeVar('TInfo')
TName = TypeVar('TName', bound=Hashable)
TMove = TypeVar('TMove')
class NodeSolver(Generic[TInfo, TName, TMove]):
'''Class for modeling problems that can be modeled as a directed graph with goal nodes'''
def __init__(self,
namer: Callable[[TInfo], TName],
detector: Callable[[TInfo], bool],
expander: Callable[[TInfo], Iterable[TMove]],
follower: Callable[[TInfo, TMove], TInfo]):
self.get_name = namer
self.is_goal = detector
self.get_moves = expander
self.follow_move = follower
def namer1(info: int) -> str: ...
def detector1(info: int) -> bool: ...
def expander1(info: int) -> Iterable[bool]: ...
def follower1(info: int, move: bool) -> int: ...
def namer2(info: str) -> int: ...
def detector2(info: str) -> bool: ...
def expander2(info: str) -> Iterable[float]: ...
def follower2(info: str, move: float) -> str: ...
solver1 = NodeSolver(namer1, detector1, expander1, follower1)
solver2 = NodeSolver(namer2, detector2, expander2, follower2)
reveal_type(solver1) # Revealed type is 'test.NodeSolver[builtins.int*, builtins.str*, builtins.bool*]'
reveal_type(solver2) # Revealed type is 'test.NodeSolver[builtins.str*, builtins.int*, builtins.float*]'
gibberish = NodeSolver(namer1, detector2, expander1, follower2) # Cannot infer type argument 1 of "NodeSolver"
reveal_type(gibberish) # Revealed type is 'test.NodeSolver[Any, Any, Any]'
TypeVar本质上充当推断类型的占位符，并将参数化您的NodeSolver类型。