Apart from 2d_dict being an invalid variable name (it starts with a digit), your existing solution already works:

>>> from collections import defaultdict
>>> d2_dict = defaultdict(dict)
>>> d2_dict[('canned_food', 'food')]['spam'] = 'delicious'
>>> d2_dict
defaultdict(<type 'dict'>, {('canned_food', 'food'): {'spam': 'delicious'}})

In fact, you don't even need the parentheses - Python will still recognise your key as a tuple:

>>> d2_dict['fresh_food', 'food']['eggs'] = 'delicious'
>>> d2_dict
defaultdict(<type 'dict'>, {('canned_food', 'food'): {'spam': 'delicious'},
('fresh_food', 'food'): {'eggs': 'delicious'}})

... and, yes, it's a perfectly reasonable way to build a 2D+1D lookup table.

If you want to build a 3D lookup table using nested dicts instead of tuple keys, this works:

>>> d3_dict = defaultdict(lambda: defaultdict(dict))
>>> d3_dict['dried_food']['food']['jerky'] = 'chewy'
>>> d3_dict
defaultdict(<function <lambda> at 0x7f20af38a2a8>, 
{'dried_food': defaultdict(<type 'dict'>, {'food': {'jerky': 'chewy'}})})

1. Comments on your code

1. No docstrings! What does your code do and how am I supposed to use it?

2. No test cases. This ought to be a good opportunity to use doctests.

3. Given that your purpose here is to implement RPG lookup tables, your design seems a bit hard to use. The printed RPG table probably says something like this:

   1-8     giant spider
   9-12    skeleton
   13-18   brass dragon
   ...
   

   but you have to input it like this (adding one to the limit of each range):

   range_dict((range(1, 9), "giant spider"),
              (range(9, 13), "skeleton"),
              (range(13, 18), "brass dragon"),
              ...)
   

   which would be easy to get wrong.

4. The design also seems fragile, because it doesn't ensure that the ranges are contiguous. If you made a data entry mistake:

   d = range_dict((range(1, 8), "giant spider"),
                  (range(9, 13), "skeleton"),
                  (range(13, 18), "brass dragon"),
                  ...)
   

   then the missing key would later result in an error:

   >>> d[8]
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   KeyError: 8
   

2. An alternative approach

Here's how I'd implement this lookup table:

from bisect import bisect_left
from collections.abc import Mapping

class LookupTable(Mapping):
    """A lookup table with contiguous ranges of small positive integers as
    keys. Initialize a table by passing pairs (max, value) as
    arguments. The first range starts at 1, and second and subsequent
    ranges start at the end of the previous range.

    >>> t = LookupTable((10, '1-10'), (35, '11-35'), (100, '36-100'))
    >>> t[10], t[11], t[100]
    ('1-10', '11-35', '36-100')
    >>> t[0]
    Traceback (most recent call last):
      ...
    KeyError: 0
    >>> next(iter(t.items()))
    (1, '1-10')

    """
    def __init__(self, *table):
        self.table = sorted(table)
        self.max = self.table[-1][0]

    def __getitem__(self, key):
        key = int(key)
        if not 1 <= key <= self.max:
            raise KeyError(key)
        return self.table[bisect_left(self.table, (key,))][1]

    def __iter__(self):
        return iter(range(1, self.max + 1))

    def __len__(self):
        return self.max

Notes on this implementation:

1. The constructor takes the maximum for each range (not the maximum plus one), making data entry less error-prone.

2. The minimum of each range is taken from the end of the previous range, thus ensuring that there are no gaps between ranges.

3. The collections.abc.Mapping abstract base class provides much of the functionality of a read-only dictionary. The idea is that you supply the __getitem__, __iter__ and __len__ methods, and the Mapping class supplies implementations of __contains__, keys, items, values, get, __eq__, and __ne__ methods for you. (Which you can override if you need to, but that's not necessary here.)

4. I've used bisect.bisect_left to efficiently look up keys in the sorted table.

You have two straightforward choices. One is the standard look-up list, as in Evan's comment:

{'guiseppe': 'Joseph', 'joe': 'Joseph', 'joey': 'Joseph', 'joseph': 'Joseph',
 'Samuel': 'Samuel', 'sam': 'Samuel', 'samuel': 'Samuel', 'shmuel': 'Samuel'}

Now, adapt this to return the full object, rather than the name. Since you didn't specify an object, I'll assume a Person class:

joseph = Person(name = "Joseph", gender = "m", xro = "xy")
samuel = Person(name = "Samuel", gender = "m", xro = "xy")

Now, just insert the objects into your look-up table:

{'guiseppe': joseph, 'joe': joseph, 'joey': joseph, 'joseph': 'Joseph',
 'Samuel': samuel, 'sam': samuel, 'samuel': samuel, 'shmuel': 'Samuel'}

The other look-up method is to remove the extra loop from your existing code; use the in operator:

for canon in name_forms:
    for variant in name_forms[canon]:
        if txt.lower() in variant:
            return canon

You will still need a string-to-object table, but now it's shorter:

{"Joseph": jospeh, "Samuel": samuel}

Assuming data is a country code (like "PL" for example):

def get_path(data):
    return countries.get(data)

The get() method checks if the dictionary has the key, and if so returns the corresponding value, otherwise it returns None.

If you want a default value other than None when the key is not present you can specify it as second argument, like this:

def get_path(data):
    return countries.get(data, "default/path/x/y/z")

Since we are not given any further information about what ranges should be associated with which values, I assume you will transfer my answer to your own problem.

Look-up-Tables are called dictionary in python. They are indicated by curly brackets.

Easy example:

myDict = {1: [1, 2, 3, 4, 5],
          2: [2, 3, 4, 5, 6],
          3: [3, 4, 5, 6, 7]}

Here you create a dictionary with three entries: 1, 2, 3. Each of these entries has a range associated with it. In the example it is of logic range(i, i+5).

You inquire your "Look-Up-Table" just like a list:

print(myDict[2])
>>> [2, 3, 4, 5, 6]

(Note how [2] is not index #2, but actually the value 2 you were looking for)

Often you do not want to create a dictionary by hand, but rather want to construct it automatically. You can e.g. combine two lists of the same length to a dictionary, by using dict with zip:

indices = range(15, 76) # your values from 15 to 75
i_ranges = [range(i, i+5) for i in indices] # this constructs your ranges
myDict = dict(zip(indices, i_ranges)) # zip together the lists and make a dict from it
print(myDict[20])
>>> [20, 21, 22, 23, 24]

By the way, you are not restricted to integers and lists. You can also go like:

myFruits = {'apples': 20, 'cherries': 50, 'bananas': 23}
print(myFruits['cherries'])
>>> 50

Let's go through it line by line.

ops1 = {
        "1": print("1"), # this value is actually the value returned by print
        "2": print("2"),
        "4": print("4")
} # when the dictionary is created, everything in it is evaluated,
# so it executes those print calls
# that's why you see all three printed

lis = [1, 2, 3]

for x in range(0, len(lis)-1): # this includes 0 and 1
    if (lis[x] in ops1.keys()): # lis[0] is 1 and lis[1] is 2
        ops1.get(x) # look for 0 and then 1 in the dictionary

Now let's fix it.

ops1 = {
        "1": lambda: print("1"), # this value is now a FUNCTION, which you can call later
        "2": lambda: print("2"),
        "4": lambda: print("4")
} # when the dictionary is created, everything in it is evaluated, but the functions are not called

lis = [1, 2, 3]

for x in range(len(lis)): # goes through 0, 1, and 2
    if lis[x] in ops1: # lis[0] is 1, lis[1] is 2, lis[2] is 3
        ops1.get(str(lis[x]), print)() # look for '1', '2', and '3',
                                       # then call their values

You could improve that last loop like this:

for x in lis:
    ops1.get(str(x), print)()

So, first we look up the key '1'. That corresponds to a function. Then we call the function. This prints the string '1\n'. Then we look up the key '2'. That corresponds to a function. Then we call the function. This prints the string '2\n'. Then we look up the key '3'. This is not present in the dictionary, so it returns a default function. Then we call this default function. This prints the string '\n'.