语法中的空格会影响 Python 的性能吗？

Question

When I'm writing code for a personal project, or if I'm just testing things out, I tend to code like this, just because it makes me happy:

def importcontacts(request):
  context                       = initialize_context(request)
  context['form']               = UploadedFileForm()
  token                         = get_token(request)

  if request.method == 'POST':
    form                        = UploadFileForm(request.POST, request.FILES)

    if form.is_valid():
      contacts                  = request.FILES['file']
      fs                        = FileSystemStorage()
      filename                  = fs.save('import_data.json', contacts)
      uploaded_file_url         = fs.url(filename)
      context['fails']          = ct.import_contacts(uploaded_file_url,
                                                     token,
                                                     context['user']['email'],
                                                     context['user']['name'])
      messages.success(request, 'Contacts imported successfully.')

      return render(request, 'contactsdb/importresult.html', context)

  return render(request, 'contactsdb/import.html', context)

Obviously this isn't in any way PEP8 compliant and I would never put something like this into production but at the same time I don't truly know why and I also don't truly understand why the code even still works when set out like this. I assume all the space makes for slower code?

Googling has not helped me find my answer. I'm not looking for someone to tell me "you should never do that, blah blah", I'm well aware. I'd just like to know the reasons as to why this isn't OK.

Answer 1

Spacing shouldn't slow down code. Much like any other language, your python scripts get compiled to bytecode and then get interpreted by a virtual machine. The parser usually strips comments and whitespace that isn't indentation or a newline. This link further explains how logical lines are treated:

The end of a logical line is represented by the token NEWLINE. Statements cannot cross logical line boundaries except where NEWLINE is allowed by the syntax (eg, between statements in compound statements). A logical line is constructed from one or more physical lines by following the explicit or implicit line joining rules.

and this one explains how physical ones are treated:

A physical line ends in whatever the current platform's convention is for terminating lines. On Unix, this is the ASCII LF (linefeed) character. On DOS/Windows, it is the ASCII sequence CR LF (return followed by linefeed). On Macintosh, it is the ASCII CR (return) character.

This link further explains how indentation is treated:

Leading whitespace (spaces and tabs) at the beginning of a logical line is used to compute the indentation level of the line, which in turn is used to determine the grouping of statements.

And also gives an example of code that is correctly, but strangely indented:

def perm(l):
        # Compute the list of all permutations of l
    if len(l) <= 1:
                  return [l]
    r = []
    for i in range(len(l)):
             s = l[:i] + l[i+1:]
             p = perm(s)
             for x in p:
              r.append(l[i:i+1] + x)
    return r

Answer 2

This was an interesting question. Basically the use of white spaces between the operands and the operator is to increase readability. It's just a matter of personal choice to add one white space or add ten. The interpreter/compiler doesn't care about white spaces. It's just about readability.

Now when you do something like this-

a = 10
b = 100
c = a + b 

And when you do something like this-

a       =          10
b       =          100     
c       =          a + b

You'll notice that the first one is more readable than the second one, but this doesn't mean that the second one is wrong. It is just a matter of personal choice. Basically the convention says to follow the first method but we would get the same output with or without white spaces.

So you may use one or ten white spaces in your program, nobody can question you!!