Improving a Medicare Beneficiary Identifier (MBI) generator
Instead of while 1: please just use while True. while 1: is a throwback from old versions of C that didn't have stdbool.h. while True: is much most explicit a about what your intent is.

At the top you have
letter = 'ACDEFGHJKMNPQRTUVWXY' # not = B, I, L, O, S, Z
digit = str('0123456789')
partdig = str('123456789')
dig_let = digit + letter

Python actually has built-ins for these:
from string import digits, ascii_uppercase

# letter is the set of ascii characters minus B, I, L. . .
letter = &quot;&quot;.join(set(ascii_uppercase) - {'B', 'I', 'L', 'O', 'S', 'Z'})
# Just use digits instead of digit
partdig = digits[1:]  # Remove the first digit
dig_let = digits + letter

That saves you from needing to type out each of the letters to include.
Also note, even if string.digits didn't exist, you could have also defined digit as:
&gt;&gt;&gt; digit = &quot;&quot;.join(str(n) for n in range(0, 10))
&gt;&gt;&gt; digit
'0123456789'


Also, all variable names here should be lowercase, separated by underscores. partdig should be part_dig, or part_digits, or even better: non_zero_digits.
I also think letter should be letters, since it's a collection of letters. It's a small change, but it lets your readers know that it's multiple letters, not just a single one.

Watch your indentation:
mbi_need = int(input(&quot;How many MBI numbers do you need to generate?: &quot;))
 for x in range(0,mbi_need):

Especially in Python that matters a lot. If that was just a pasting error, it's a good idea to look over the code before posting just to double check that errors weren't introduced accidentally.
You're using a odd 5-space indentation in the loop though, which is part of the problem. Please use 4-space indentation.

for x in range(0,mbi_need):
    mbi = &quot;&quot;
    for x in range(0, mbi_return):

Both loops define a x variable! Since you never use x in either loop though, use _ instead:
for _ in range(0,mbi_need):
    mbi = &quot;&quot;
    for _ in range(0, mbi_return):

_ is a convention that says &quot;I needed to create a name, but don't need the variable&quot;, which is the case here.

range(0, mbi_need)

0 is the implicit start; it's not necessary to specify it if you only otherwise need to specify the ending number. Just write:
range(mbi_need)


mbi_char0 = random.choice(partdig)
mbi_char1 = random.choice(letter)
mbi_char2 = random.choice(dig_let)
mbi_char3 = random.choice(digits)
. . .

Whenever you find yourself creating many similar variables, and you're differentiating them by putting numbers in the name, stop! You should likely be using a list instead. Because the make-up of the MBIs doesn't follow an easy pattern, fixing this isn't super straightforward, but it's still possible. First, I'd create a list holding the order of partdig, letter, dig_let, digits. . . which will define the order of the different character types:
mbi_pattern = [non_zero_digits, letters, digit_letters, digits,
               letters, digit_letters, digits, letters,
               letters, digits, digits]

This looks ugly, but it will clean up the code later. Sometimes all you can do is move the ugly bulk to the side. Once you've defined that list, creating a MBI is trivial and tiny:
mbi = &quot;&quot;.join(random.choice(part) for part in mbi_pattern)
print(mbi)

Get each of the part sets, generate a random character from each of them, then join them into a string.

Your inner
for _ in range(mbi_return):

loop doesn't appear to be doing anything. It seems like it's doing a similar job as the other loop, except it will always be range(1), which will only run once, which means it isn't really a loop. I got rid of it because it isn't doing anything except complicating the code.
The same can be said about the while True as well. You want to generate 10000 codes, repeatedly, forever? The while True loop will never end since you never break from it. I also got rid of it because it is also complicating the code without good reason.

 mbi = &quot;&quot;

This isn't necessary. Even if you needed mbi in the outer scope, loops in Python don't create scopes like they do in other languages. mbi &quot;defined&quot; inside the loop can be accessed from outside of the loop.

In your remaining loop, you're creating an mbi, then just printing it. That doesn't allow you to do anything with the data though, like save it to file. It would be much cleaner to store the generated MBIs in a list so that they can potentially be used later. If you do that, your loop can be made into a list comprehension:
mbis = [&quot;&quot;.join(random.choice(part) for part in mbi_pattern)
        for _ in range(mbi_need)]

Each MBI is generated using the same generator expression as before, but now it's wrapped in a list comprehension to generate multiple.

In the end, this is what I'm left with:
import random
from string import digits, ascii_uppercase

letters = &quot;&quot;.join(set(ascii_uppercase) - {'B', 'I', 'L', 'O', 'S', 'Z'})
non_zero_digits = digits[1:]
digit_letters = digits + letters

mbi_pattern = [non_zero_digits, letters, digit_letters, digits,
               letters, digit_letters, digits, letters,
               letters, digits, digits]

mbi_need = int(input(&quot;How many MBI numbers do you need to generate?: &quot;))

mbis = [&quot;&quot;.join(random.choice(part) for part in mbi_pattern)
        for _ in range(mbi_need)]

print(&quot;\n&quot;.join(mbis))

And its usage:
How many MBI numbers do you need to generate?: &gt;? 10
5V70VK4JP28
8Y12N77RC51
9JM2JN8RQ38
3X08DH7FH95
3MH6Y49KU87
6N70AC7MW75
9A67A62TU38
4A48C94QT38
2NP7TY0DC65
1GP8A57JQ27


As mentioned in the comment though, really, code should be tucked into functions. In larger programs, that eases testing and comprehension of your code.
Here, you could have a function that generates a single MBI, then use it to generate a list of them. I also always have a main function that ties the whole program together so I can control the execution of the code easier.
I also realized after I had my coffee that all the variables at the top are really constants, so they should be in UPPER_SNAKE_CASE.
After those changes, I'm left with:
import random
from string import digits, ascii_uppercase

LETTERS = &quot;&quot;.join(set(ascii_uppercase) - {'B', 'I', 'L', 'O', 'S', 'Z'})
NON_ZERO_DIGITS = digits[1:]
DIGIT_LETTERS = digits + LETTERS

MBI_PATTERN = [NON_ZERO_DIGITS, LETTERS, DIGIT_LETTERS, digits,
               LETTERS, DIGIT_LETTERS, digits, LETTERS,
               LETTERS, digits, digits]


def generate_mbi():
    return &quot;&quot;.join(random.choice(part) for part in MBI_PATTERN)


def main():
    mbi_need = int(input(&quot;How many MBI numbers do you need to generate?: &quot;))
    mbis = [generate_mbi() for _ in range(mbi_need)]
    print(&quot;\n&quot;.join(mbis))
    
if __name__ == '__main__':
    main()