> LISP doesn't really have syntax - you write parse trees directly.

Lisp has plenty of syntax, it's just extensible and largely defined in operators. Commonly used macros like DEFUN, WITH-OPEN-FILE, and LOOP all add their own syntax to the language; that's what macros are for. When you put them together, typical Lisp code ends up looking like

    (defun count-words (filespec)
      (with-open-file (f filespec)
        (loop with counts = (make-hash-table :test 'equal)
              for line = (read-line f nil)
              while line do
                (loop for word in (cl-ppcre:split "\\s+" line) do
                  (incf (gethash word counts 0)))
              finally (return counts))))

Which I don't think is that alien. It translates pretty cleanly into Python:

    def count_words(filespec):
        with open(filespec) as f:
            counts = collections.defaultdict(int)
            for line in f:
                for word in line.split():
                    counts[word] += 1
            return counts

Do you find the former significantly harder to understand? I don't see how it's any more like "writing a parse tree directly."

> Why should I write (+ p 2) when most people think (p+2)? This difference gets worse with more complex expressions.

As mentioned in other comments, there are infix packages available for when you're writing math-heavy code (or if you just need infix operators), but I also think that a lot of people don't write very much code with complicated inline arithmetic in it, and overstate how much the awkward math syntax would affect them (there are of course plenty of projects that are math-heavy and where it does make a large difference). When you're defining variables/functions/classes/etc or calling functions or looping or whatever, there's not much difference between Lisp and most other languages aside from whether the bracket is { or ( and which side of the keyword it goes on; in my experience, that sort of code tends to make up the large bulk of most codebases in most languages.

edit: Another place where Lisp's default syntax is significantly different from a lot of languages is something like object.f(x).g(y).h(z), which in Lisp looks like (h (g (f object x) y) z). This can be remedied with common macros like -> that let you write (-> object (f x) (g y) (h z)).