• Recursion here is unnatural (especially since Python does not eliminate tail recursion). However, a tail recursion elimination is a purely mechanical procedure (sorry for the shameless self-promotion). Consider an iterative reimplementation.

  A purely iterative approach would also avoid repeated exponentiation in base26LetterToBase10, which also feels very uncomfortable.

• Magic numbers (26, 96, 97) better have meaningful symbolic names.

• base26LetterToBase10 does not validate its input, and will happily convert any string. I am not sure it is a desirable behavior.

Theory

• The goal of recursion is to only consider 1 base case, and modify your input until you reach this base case. That's why you shouldn't check if num <= 26 or len(string) == 1. Just wait one more recursive call until num is 0 or string is empty.

• You should write tests, even if they are simple and use ==.

• You could replace magic numbers with a single definition, e.g. ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. If you need them, 26, 96, 97 can be calculated from ALPHABET.

• Use a // b instead of int(a/b).

• Recursion doesn't really fit base26LetterToBase10.

• You could run autopep8 on your script.

• Python function names should be written in snake_case.

• column_id_to_int should probably raise an error if the input string is incorrect.

• There's no reason the code shouldn't work with more than 11 chars. Below is an example with 26 chars.

Code

Here's a way to integrate those tips. I'd say the code became a bit clearer, more flexible and more robust:

ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'  # or string.ascii_uppercase
N = len(ALPHABET)
ALPHABET_INDEX = {d: i for i, d in enumerate(ALPHABET, 1)}


def int_to_column_id(num):
    ''' Converts any positive integer to Base26(letters only) with no 0th 
    case. Useful for applications such as spreadsheet columns to determine which 
    Letterset goes with a positive integer.
    '''
    if num < 0:
        raise ValueError("Input should be a non-negative integer.")
    elif num == 0:
        return ""
    else:
        q, r = divmod(num - 1, N)
        return int_to_column_id(q) + ALPHABET[r]


def column_id_to_int(string):
    ''' Converts a string from Base26(letters only) with no 0th case to a positive
    integer. Useful for figuring out column numbers from letters so that they can
    be called from a list. Raises a ValueError unless every character is a letter.
    '''
    result = 0
    try:
        for char in string.upper():
            result = result * N + ALPHABET_INDEX[char]
        return result
    except KeyError:
        raise ValueError("Input string should only contain letters.")

Tests

Here are the tests you mentioned and some more for large or incorrect inputs:

import unittest


class TestColumnIdToInt(unittest.TestCase):

    def test_large_input(self):
        self.assertEqual(int_to_column_id(
            256094574536617744129141650397448476), ALPHABET)

    def test_every_int(self):
        for i in range(100000):
            self.assertEqual(column_id_to_int(int_to_column_id(i)), i)

    def test_lower_case_input(self):
        self.assertEqual(column_id_to_int("abc"), column_id_to_int("ABC"))

    def test_incorrect_input(self):
        with self.assertRaises(ValueError):
            column_id_to_int("T3ST")
        with self.assertRaises(Exception):
            column_id_to_int(1234)


class TestIntToColumnId(unittest.TestCase):

    def test_common_ints(self):
        self.assertEqual(int_to_column_id(0), "")
        self.assertEqual(int_to_column_id(1), "A")
        self.assertEqual(int_to_column_id(26), "Z")
        self.assertEqual(int_to_column_id(27), "AA")
        self.assertEqual(int_to_column_id(702), "ZZ")
        self.assertEqual(int_to_column_id(18252), "ZYZ")

    def test_large_input(self):
        self.assertEqual(column_id_to_int(ALPHABET),
                         256094574536617744129141650397448476)

    def test_incorrect_input(self):
        with self.assertRaises(ValueError):
            int_to_column_id(-1234)
        with self.assertRaises(TypeError):
            int_to_column_id("Wrong")

if __name__ == '__main__':
    unittest.main()

All tests pass:

.......
----------------------------------------------------------------------
Ran 7 tests in 0.600s

OK

You can easily adjust the number 97 to 96 to make the code work for 1-based situation. Answering the op's question, with 'a' = 1, 'b' = 2 ... and so on...

def base26LetterToBase10_A_is_ONE(string):  ### 1-based
    ''' Converts a string from Base26(letters only) with no 0th case to a positive
    integer. Useful for figuring out column numbers from letters so that they can
    be called from a list.
    '''
    string = string.lower()

    a = [ ord(x) - 96  for x in string if x.isalpha()]
    if len(a) == 0:
        return 0
    return reduce(lambda x, y : 26 * x + y, a)

and the reverse convert is

def base10ToBase26Letter_A_is_ONE(num):  ### 1-based
    ''' Converts any positive integer to Base26(letters only) with no 0th 
    case. Useful for applications such as spreadsheet columns to determine which 
    Letterset goes with a positive integer.
    '''
    if num <= 0:
        return ""
    s = ""
    while (num > 0):
        s+=(chr(97+(num-1)%26))
        num -= 1
        num//=26
    return s[::-1]

Now this below is for normal Base26 conversion, with 'a' = 0, 'b' = 1 and so on .

def base26LetterToBase10_A_is_ZERO(string):  ### 0-based
    ''' Converts a string from Base26(letters only) with 0th case to a positive
    integer. Useful for figuring out column numbers from letters so that they can
    be called from a list.
    '''
    string = string.lower()

    a = [ ord(x) - 97  for x in string if x.isalpha()]
    if len(a) == 0:
        return 0
    return reduce(lambda x, y : 26 * x + y, a)

and the reverse converter is

def base10ToBase26Letter_A_is_ZERO(num):  ### 0-based
    ''' Converts any positive integer to Base26(letters only) with  0th 
    case. Useful for applications such as spreadsheet columns to determine which 
    Letterset goes with a positive integer.
    '''
    if num < 0:
        return ""
    if num == 0:
        return "a"

    s = ""
    while (num > 0):
        s+=(chr(97+num%26))
        num//=26
    return s[::-1]

How big difference they could be.

There is a lot of sound advice in other answers, so I will only touch on aspects that I think are worth considering, but are not yet addressed (or that I misunderstood).

Recursion

I like recursion. But when I find myself trying to use it in Python I stop and reconsider. Using recursion in Python is possible, but doing so is usually an exercise in snake wrestling more than it is productive programming.

while_stmt ::=  "while" expression ":" suite
                ["else" ":" suite]

On the other hand, the while statement is very similar conceptually. The syntactical differences from recursion are:

1. The test is true when the inductive base case is false.
2. The action on the base case comes at the end.

Other answers show examples of how to use while and it might be worth looking at them and trying "to see" them as recursive. It is probably worth using while instead of recursion if you plan to share Python code with other people because in the context of Python's community, recursive code is harder to understand.

Magic Numbers

The Danish alphabet has 29 letters. Icelandic has 32. Russian, 33. The length of the Latin alphabet, 26, is hard coded into the functions. These languages use characters that are not directly representable in ASCII. The code assumes that they are and hard codes the offset 97.

It may be the case that the Latin 26 character alphabet is hard coded into Google Sheets, now. If it is, that assumption should be made explicitly in one place so that maintenance will be easier if Google changes (or if there already is localization). Magic numbers are a "code smell". Sprinkling the same numbers throughout the code is another.

A => 1

Python is zero indexed. Indexing the Latin alphabet from 1 is fighting against the language. I can follow your rationales for wrestling the snake. But I have to think too much about your rationales in order to understand your code. If you had created a Domain Specific Language in Python and then were writing your functions in that, 1-indexing would make sense. But your code is in Python. The biggest advantage of Python is that people know what to expect. They don't expect 1-indexing.

Data Architecture

Zero-indexing versus one-indexing is mostly a matter of not conceptually separating the internal data representation of your application from the external interface of the Google API. The architecture of your application is:

Deserialize from API -> Manipulate -> Serialize to API

The decision to use One-indexing is due to letting the data abstractions of Google's API leak into your Python code. It makes your code brittle and harder to reason about. Nobody should have to think about Google's API when looking at the internals of the Manipulateportion of the architecture. It is probably better if all your wrestling with Google's API happens in Deserialize and Serialize and Manipulate just works and make sense with zero knowledge of Google (or any other) API's.

Naming

Consider deserialize_column_name and serialize_column_name as the names of your functions because those are your functions' functions. Base 26 is not really the important part of how someone uses it. That the output is a letter is not really the important part. Those are implementation details of Google's API protocol that can be described in the DocStrings. People will have to read the DocString with the current names, anyway.

The column_name_to_column_number function would be a good match for using functools.reduce. It operates on any sequence type (including str, the type of strings) and allows you to build up a result piece by piece while parsing through the sequence. You need to write a 2-param lambda expression or function to process each piece and update the intermediate value. There's even a way to specify a special case creating the starting value (i.e. what's in the intermediate storage before the first element of the sequence is applied).

Or, this also works (though it's ugly and unreadable)

transtable=str.maketrans(string.ascii_uppercase,"0123456789ABCDEFGHIJKLMNOP")
return int((chr(1+ord(s[0]))+s[1:]).translate(transtable),26)+1