Answer in one line:

''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(N))

or even shorter starting with Python 3.6 using random.choices():

''.join(random.choices(string.ascii_uppercase + string.digits, k=N))

A cryptographically more secure version: see this post

''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(N))

In details, with a clean function for further reuse:

>>> import string
>>> import random
>>> def id_generator(size=6, chars=string.ascii_uppercase + string.digits):
...    return ''.join(random.choice(chars) for _ in range(size))
...
>>> id_generator()
'G5G74W'
>>> id_generator(3, "6793YUIO")
'Y3U'

How does it work ?

We import string, a module that contains sequences of common ASCII characters, and random, a module that deals with random generation.

string.ascii_uppercase + string.digits just concatenates the list of characters representing uppercase ASCII chars and digits:

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.digits
'0123456789'
>>> string.ascii_uppercase + string.digits
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'

Then we use a list comprehension to create a list of 'n' elements:

>>> range(4) # range create a list of 'n' numbers
[0, 1, 2, 3]
>>> ['elem' for _ in range(4)] # we use range to create 4 times 'elem'
['elem', 'elem', 'elem', 'elem']

In the example above, we use [ to create the list, but we don't in the id_generator function so Python doesn't create the list in memory, but generates the elements on the fly, one by one (more about this here).

Instead of asking to create 'n' times the string elem, we will ask Python to create 'n' times a random character, picked from a sequence of characters:

>>> random.choice("abcde")
'a'
>>> random.choice("abcde")
'd'
>>> random.choice("abcde")
'b'

Therefore random.choice(chars) for _ in range(size) really is creating a sequence of size characters. Characters that are randomly picked from chars:

>>> [random.choice('abcde') for _ in range(3)]
['a', 'b', 'b']
>>> [random.choice('abcde') for _ in range(3)]
['e', 'b', 'e']
>>> [random.choice('abcde') for _ in range(3)]
['d', 'a', 'c']

Then we just join them with an empty string so the sequence becomes a string:

>>> ''.join(['a', 'b', 'b'])
'abb'
>>> [random.choice('abcde') for _ in range(3)]
['d', 'c', 'b']
>>> ''.join(random.choice('abcde') for _ in range(3))
'dac'

def roll_stats():
    a = random.randint(1, 6)
    b = random.randint(1, 6) 
    c = random.randint(1, 6)
    d = random.randint(1, 6)
    list = [a, b, c, d]

Call it dice or something more descriptive then list. You can also use list = [random.randint(1,6) for x in xrange(4)] rather then creating the variables separately.

    list.sort()
    add = sum(list[1:4])

Instead of sorting it and slicing it use: list.remove(min(list))

    return add

Don't assign variables just to return them on the next line, use return sum(list[1:4])

def pow_mod():
    a = "|+1 to hit on mele attack rolls| "
    b = "|+1 damage on mele attack rolls|"

    if pow >= 15 and pow < 17:

Don't take input to a function from global variables, pass it as a parameter

        return a
    if pow >= 17:
        return a + b
    else: 
        return " ~no modifiers~"

You return strings, but conceptually you are returning a list of modifiers. I suggest returning the list. You can then format the list anyway you like in the caller.

You've got a number of functions very similiar to this, it suggests moving some of the details into data structures. I'd do it like this:

POW_MODIFIERS = [
# specify minimum and maximum stat the modifier applies to
    (15, 9999, "+1 to hit on mele attack rolls"),
    (17, 9999, "+1 damage on mele attack rolls")
]

def calc_modifiers(stat, modifiers):
    return [modifier for minimum, maximum, modifier in modifiers if minimum <= state <= maximum]

def format_modifiers(modifiers):
    if modifiers:
       return ' '.join('|%s|' % modifier for modifier in modifiers) 
    else:
       return ' ~no modifiers~ '

By creating lists like POW_MODIFIERS for all your stats, you can reuse the functions for all the different stats. You should be able to apply similiar techniques to your other decisions. I'd also look at storing the data in a seperate file, perhaps using JSON.

Simple:

>>> import string
>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> import random
>>> random.choice(string.ascii_letters)
'j'

string.ascii_letters returns a string containing the lower case and upper case letters according to the current locale.

random.choice returns a single, random element from a sequence.

Very cool, I'm working on something similar!

Some suggestions:

• I'm not sure if you mean to use randrange or randint. Based on how you use it I think you mean randint as the max stat roll in D&D is 18 but randrange(8, 18) means that the max value you'll get is 17.

• You might want to add some comments or more descriptive function names. While I understand what ls does, I'm not sure what it stands for.

• I would include the Open Game License to make sure your project is on the up and up. Also review the license and basically, if it is from D&D but it isn't on SRD20 then take it down.

• In the README I would include examples of how to use your program, as well as list the dependencies which in your case is requirements.txt. For example, you can input the class on the first line to skip the second input, but that isn't ever document.

• You only use console for its clear command. Instead of forcing your users to install another library to use your tool I would write a small clear function. Something like:

  import os
  
    def clear():
        if os.name == 'nt':
            os.system('cls') # Windows
        else: 
            os.system('clear') # POSIX

• My final suggestions would just be formatting. Function names should be cased_like_this rather than likeThis. I would also lowercase Data.py.

EDITS:

• Forgot to mention that you might want to get the stat values in a way more accurately depicting the distribution you would get when rolling dice. So rather than a single 8-18 random value you might want something like:

  sum(randint(1, 6) for _ in range(3))

  That way you don't get 18's as often as you get 10's, which is the case when actually rolling dice.

• Okay so I've been playing with it more, actually I made a fork to mess with, and you should probably include a way to save the output into a file.

• I would also include error checking. If someone puts in bad input the program crashes.

• getRace also gets the class. I would separate these into two functions.

• This project could heavily benefit from using some classes. In particular, a class that creates the character.

I really like this project. Feel free to DM me if you have any questions.