I'm using python 3 and I am creating an algorithm to find the sum square difference for the first 100 (or 1 to x) natural numbers. This happens to be project euler problem 6 if anyone is wondering.

I've written it two ways and I am looking for criticism on my writing style to further guide me in how I code algorithms. I am aware there is probably a better "optimized" solution in terms of big(o) but my math skills just haven't reached there yet.

Algorithm 1

def sum_square_difference(max_range):
 #Finds the sum square difference for the first x(max range) natural numbers
 numbers = range(1,max_range+1)
 sum_squares = sum([x**2 for x in numbers])
 square_sum = sum(numbers) ** 2
 return square_sum - sum_squares

I find this algorithm to be the most readable, but something tells me it may be more verbose in terms of lines of code than necessary so I wrote the following algorithm.

Algorithm 2

def sum_square_difference2(max_range):
 numbers = range(1,max_range+1)
 return (sum(numbers) ** 2) - (sum([x**2 for x in numbers]))

This one seems much cleaner, but I find myself struggling more to understand and read what is going on, especially when considering the perspective of an outside observer.

I appreciate any insight.

I would do something like:

def sum_of_squares(n):
 return sum(i ** 2 for i in range(1, n+1))

def square_of_sum(n):
 return sum(range(1, n+1)) ** 2

def sum_square_difference(n):
 return sum_of_squares(n) - square_of_sum(n)

Notice the use of a generator expression in sum, where I have omitted the square brackets.

I find myself struggling more to understand and read what is going on

This is the key insight. A chunk of code is likely to be read more times than it was written. So write your code to be read. Use comments, docstrings, whitespace, type hints, etc. to make it easier for someone unfamiliar with the code (including your future self) to read and understand it.

An alternative not discussed in the other answers: use numpy. As soon as you want to do anything serious with numbers, it's going to be useful. The downside is that numpy uses fixed-size integers, which can lead to overflow. It also allocates the array, which uses more memory than necessary.

import numpy as np

def sum_square_difference(n):
 nums = np.arange(1, n+1, dtype=int)
 return nums.sum()**2 - (nums**2).sum()

If you want to input very large numbers, or have access to very little memory, just use the analytical formulas for the sums:

def sum_square_analytical(n):
 sum_squares = n*(n+1)*(2*n+1)//6
 square_sum = (n*(n+1)//2)**2
 return square_sum - sum_squares

Of course, you can add docstrings and comments, as suggested in other answers.

Docstrings:

def sum_square_difference(max_range):
 #Finds the sum square difference for the first x(max range) natural numbers
 numbers = range(1,max_range+1)
 sum_squares = sum([x**2 for x in numbers])
 square_sum = sum(numbers) ** 2
 return square_sum - sum_squares 

When you define a function and include a docstring, it should be contained within triple quotes instead of # that is used for comments.

Like this:

def sum_square_difference(max_range):
""" Explanation goes here """

Regarding the syntax or how you write the code, you might do it in one line instead of the use of many unnecessary variables.

Like this:

def square_difference(upper_bound):
 """Return sum numbers squared - sum of squares in range upper_bound inclusive."""
 return sum(range(1, upper_bound + 1)) ** 2 - sum(x ** 2 for x in range(1, upper_bound + 1))

You might want to check pep8 https://www.python.org/dev/peps/pep-0008/ - the official Python style guide.