@@ -115,7 +115,7 @@ def support_pruning(self):
         """Make sure we can prune values from domains. (We want to pay
         for this only if we use it.)"""
         if self.curr_domains is None:
-            self.curr_domains = dict((v, list(self.domains[v])) for v in self.variables)
+            self.curr_domains = {v: list(self.domains[v]) for v in self.variables}
 
     def suppose(self, var, value):
         "Start accumulating inferences from assuming var=value."
@@ -137,8 +137,8 @@ def choices(self, var):
     def infer_assignment(self):
         "Return the partial assignment implied by the current inferences."
         self.support_pruning()
-        return dict((v, self.curr_domains[v][0])
-                    for v in self.variables if 1 == len(self.curr_domains[v]))
+        return {v: self.curr_domains[v][0]
+                for v in self.variables if 1 == len(self.curr_domains[v])}
 
     def restore(self, removals):
         "Undo a supposition and all inferences from it."
@@ -512,7 +512,7 @@ def flatten(seqs): return sum(seqs, [])
 _ROWS = flatten([list(map(flatten, list(zip(*brow)))) for brow in _BGRID])
 _COLS = list(zip(*_ROWS))
 
-_NEIGHBORS = dict([(v, set()) for v in flatten(_ROWS)])
+_NEIGHBORS = {v: set() for v in flatten(_ROWS)}
 for unit in map(set, _BOXES + _ROWS + _COLS):
     for v in unit:
         _NEIGHBORS[v].update(unit - set([v]))
@@ -567,8 +567,8 @@ def __init__(self, grid):
         the digits 1-9 denote a filled cell, '.' or '0' an empty one;
         other characters are ignored."""
         squares = iter(re.findall(r'\d|\.', grid))
-        domains = dict((var, ([ch] if ch in '123456789' else '123456789'))
-                       for var, ch in zip(flatten(self.rows), squares))
+        domains = {var: [ch] if ch in '123456789' else '123456789'
+                   for var, ch in zip(flatten(self.rows), squares)}
         for _ in squares:
             raise ValueError("Not a Sudoku grid", grid)  # Too many squares
         CSP.__init__(self, None, domains, self.neighbors, different_values_constraint)
 
@@ -241,9 +241,9 @@ def NaiveBayesLearner(dataset):
 
     targetvals = dataset.values[dataset.target]
     target_dist = CountingProbDist(targetvals)
-    attr_dists = dict(((gv, attr), CountingProbDist(dataset.values[attr]))
-                      for gv in targetvals
-                      for attr in dataset.inputs)
+    attr_dists = {(gv, attr): CountingProbDist(dataset.values[attr])
+                  for gv in targetvals
+                  for attr in dataset.inputs}
     for example in dataset.examples:
         targetval = example[dataset.target]
         target_dist.add(targetval)
@@ -882,9 +882,9 @@ def RestaurantDataSet(examples=None):
 
 
 def T(attrname, branches):
-    branches = dict((value, (child if isinstance(child, DecisionFork)
-                             else DecisionLeaf(child)))
-                    for value, child in branches.items())
+    branches = {value: (child if isinstance(child, DecisionFork)
+                        else DecisionLeaf(child))
+                for value, child in branches.items()}
     return DecisionFork(restaurant.attrnum(attrname), attrname, branches)
 
 """ [Figure 18.2]
 
@@ -497,8 +497,9 @@ def pl_fc_entails(KB, q):
     >>> pl_fc_entails(horn_clauses_KB, expr('Q'))
     True
     """
-    count = dict([(c, len(conjuncts(c.args[0]))) for c in KB.clauses
-                  if c.op == '==>'])
+    count = {c: len(conjuncts(c.args[0]))
+             for c in KB.clauses
+             if c.op == '==>'}
     inferred = defaultdict(bool)
     agenda = [s for s in KB.clauses if is_prop_symbol(s.op)]
     while agenda:
@@ -642,7 +643,7 @@ def WalkSAT(clauses, p=0.5, max_flips=10000):
     # set of all symbols in all clauses
     symbols = set(sym for clause in clauses for sym in prop_symbols(clause))
     # model is a random assignment of true/false to the symbols in clauses
-    model = dict([(s, random.choice([True, False])) for s in symbols])
+    model = {s: random.choice([True, False]) for s in symbols}
     for i in range(max_flips):
         satisfied, unsatisfied = [], []
         for clause in clauses:
 
@@ -93,13 +93,14 @@ def to_grid(self, mapping):
     def to_arrows(self, policy):
         chars = {
             (1, 0): '>', (0, 1): '^', (-1, 0): '<', (0, -1): 'v', None: '.'}
-        return self.to_grid(
-                dict([(s, chars[a]) for (s, a) in policy.items()]))
+        return self.to_grid({s: chars[a] for (s, a) in policy.items()})
 
 # ______________________________________________________________________________
+
 """ [Figure 17.1]
 A 4x3 grid environment that presents the agent with a sequential decision problem.
 """
+
 sequential_decision_environment = GridMDP([[-0.04, -0.04, -0.04, +1],
                       [-0.04, None,  -0.04, -1],
                       [-0.04, -0.04, -0.04, -0.04]],
@@ -110,7 +111,7 @@ def to_arrows(self, policy):
 
 def value_iteration(mdp, epsilon=0.001):
     "Solving an MDP by value iteration. [Figure 17.4]"
-    U1 = dict([(s, 0) for s in mdp.states])
+    U1 = {s: 0 for s in mdp.states}
     R, T, gamma = mdp.R, mdp.T, mdp.gamma
     while True:
         U = U1.copy()
@@ -141,8 +142,8 @@ def expected_utility(a, s, U, mdp):
 
 def policy_iteration(mdp):
     "Solve an MDP by policy iteration [Figure 17.7]"
-    U = dict([(s, 0) for s in mdp.states])
-    pi = dict([(s, random.choice(mdp.actions(s))) for s in mdp.states])
+    U = {s: 0 for s in mdp.states}
+    pi = {s: random.choice(mdp.actions(s)) for s in mdp.states}
     while True:
         U = policy_evaluation(pi, U, mdp)
         unchanged = True
 
@@ -237,7 +237,7 @@ def __init__(self, X, parents, cpt):
         elif isinstance(cpt, dict):
             # one parent, 1-tuple
             if cpt and isinstance(list(cpt.keys())[0], bool):
-                cpt = dict(((v,), p) for v, p in cpt.items())
+                cpt = {(v,): p for v, p in cpt.items()}
 
         assert isinstance(cpt, dict)
         for vs, p in cpt.items():
@@ -344,8 +344,8 @@ def make_factor(var, e, bn):
     is the pointwise product of these factors for bn's variables."""
     node = bn.variable_node(var)
     variables = [X for X in [var] + node.parents if X not in e]
-    cpt = dict((event_values(e1, variables), node.p(e1[var], e1))
-               for e1 in all_events(variables, bn, e))
+    cpt = {event_values(e1, variables): node.p(e1[var], e1)
+           for e1 in all_events(variables, bn, e)}
     return Factor(variables, cpt)
 
 
@@ -373,24 +373,23 @@ def __init__(self, variables, cpt):
     def pointwise_product(self, other, bn):
         "Multiply two factors, combining their variables."
         variables = list(set(self.variables) | set(other.variables))
-        cpt = dict((event_values(e, variables), self.p(e) * other.p(e))
-                   for e in all_events(variables, bn, {}))
+        cpt = {event_values(e, variables): self.p(e) * other.p(e)
+               for e in all_events(variables, bn, {})}
         return Factor(variables, cpt)
 
     def sum_out(self, var, bn):
         "Make a factor eliminating var by summing over its values."
         variables = [X for X in self.variables if X != var]
-        cpt = dict((event_values(e, variables),
-                    sum(self.p(extend(e, var, val))
-                        for val in bn.variable_values(var)))
-                   for e in all_events(variables, bn, {}))
+        cpt = {event_values(e, variables): sum(self.p(extend(e, var, val))
+                                               for val in bn.variable_values(var))
+               for e in all_events(variables, bn, {})}
         return Factor(variables, cpt)
 
     def normalize(self):
         "Return my probabilities; must be down to one variable."
         assert len(self.variables) == 1
         return ProbDist(self.variables[0],
-                        dict((k, v) for ((k,), v) in self.cpt.items()))
+                        {k: v for ((k,), v) in self.cpt.items()})
 
     def p(self, e):
         "Look up my value tabulated for e."
@@ -442,8 +441,7 @@ def rejection_sampling(X, e, bn, N):
     ...   burglary, 10000).show_approx()
     'False: 0.7, True: 0.3'
     """
-    counts = dict((x, 0)
-                  for x in bn.variable_values(X))  # bold N in [Figure 14.14]
+    counts = {x: 0 for x in bn.variable_values(X)}  # bold N in [Figure 14.14]
     for j in range(N):
         sample = prior_sample(bn)  # boldface x in [Figure 14.14]
         if consistent_with(sample, e):
@@ -467,7 +465,7 @@ def likelihood_weighting(X, e, bn, N):
     ...   burglary, 10000).show_approx()
     'False: 0.702, True: 0.298'
     """
-    W = dict((x, 0) for x in bn.variable_values(X))
+    W = {x: 0 for x in bn.variable_values(X)}
     for j in range(N):
         sample, weight = weighted_sample(bn, e)  # boldface x, w in [Figure 14.15]
         W[sample[X]] += weight