fix Markdown in README

README.md

@@ -145,7 +145,7 @@ which is automatically converted to a Julia type, you will have override this
 via `@pywith EXPR::PyObject ...`.
 
 If you are already familiar with Python, it perhaps is easier to use
-``py`...``` and ````py```...``````` which are equivalent to Python's
+``py`...` `` and ````py```...``` ```` which are equivalent to Python's
 [`eval`](https://docs.python.org/3/library/functions.html#eval) and
 [`exec`](https://docs.python.org/3/library/functions.html#exec),
 respectively:
@@ -162,7 +162,7 @@ py`sinpi`(1)
 
 When creating a Julia module, it is a useful pattern to define Python
 functions or classes in Julia's `__init__` and then use it in Julia
-function with ``py`...```.
+function with ``py`...` ``.
 
 ````julia
 module MyModule
@@ -183,7 +183,7 @@ two(x) = py`one`(x) + py`one`(x)
 end
 ````
 
-Note that Python code in ``py`...``` of above example is evaluated in a
+Note that Python code in ``py`...` `` of above example is evaluated in a
 Python namespace dedicated to `MyModule`.  Thus, Python function `one`
 cannot be accessed outside `MyModule`.
 
@@ -355,38 +355,38 @@ and also by providing more type information to the Julia compiler.
   `@pycall function(args...)::returntype` into
   `pycall(function,returntype,args...)`.
 
-* ``py`...``` evaluates `"..."` as Python code, equivalent to
+* ``py`...` `` evaluates `"..."` as Python code, equivalent to
   Python's [`eval`](https://docs.python.org/3/library/functions.html#eval) function, and returns the result
   converted to `PyAny`.  Alternatively, ``py`...`o`` returns the raw `PyObject`
   (which can then be manually converted if desired).   You can interpolate
   Julia variables and other expressions into the Python code with `$`,
   which interpolates the *value* (converted to `PyObject`) of the given
   expression---data is not passed as a string, so this is different from
-  ordinary Julia string interpolation.  e.g. ``py`sum($([1,2,3]))``` calls the
+  ordinary Julia string interpolation.  e.g. ``py`sum($([1,2,3]))` `` calls the
   Python `sum` function on the Julia array `[1,2,3]`, returning `6`.
   In contrast, if you use `$$` before the interpolated expression, then
   the value of the expression is inserted as a string into the Python code,
   allowing you to generate Python code itself via Julia expressions.
-  For example, if `x="1+1"` in Julia, then ``py`$x``` returns the string `"1+1"`,
-  but ``py`$$x``` returns `2`.
-  If you use ````py```...``````` to pass a *multi-line* string, the string can
+  For example, if `x="1+1"` in Julia, then ``py`$x` `` returns the string `"1+1"`,
+  but ``py`$$x` `` returns `2`.
+  If you use ````py```...``` ```` to pass a *multi-line* string, the string can
   contain arbitrary Python code (not just a single expression) to be evaluated,
   but the return value is `nothing`; this is useful e.g. to define pure-Python
   functions, and is equivalent to Python's
   [`exec`](https://docs.python.org/3/library/functions.html#exec) function.
-  (If you define a Python global `g` in a multiline ````py```...```````
-  string, you can retrieve it in Julia by subsequently evaluating ``py`g```.)
+  (If you define a Python global `g` in a multiline ````py```...``` ````
+  string, you can retrieve it in Julia by subsequently evaluating ``py`g` ``.)
 
-  When ``py`...``` is used inside a Julia module, it uses a Python namespace
+  When ``py`...` `` is used inside a Julia module, it uses a Python namespace
   dedicated to this Julia module.  Thus, you can define Python function
-  using ````py```....``````` in your module without worrying about name clash
+  using ````py```....``` ```` in your module without worrying about name clash
   with other Python code.  Note that Python functions _must_ be defined in
   `__init__`.  Side-effect in Python occurred at top-level Julia scope
   cannot be used at run-time for precompiled modules.
 
 * `pybuiltin(s)`: Look up `s` (a string or symbol) among the global Python
   builtins.  If `s` is a string it returns a `PyObject`, while if `s` is a
-  symbol it returns the builtin converted to `PyAny`.  (You can also use ``py`s```
+  symbol it returns the builtin converted to `PyAny`.  (You can also use ``py`s` ``
   to look up builtins or other Python globas.)
 
 Occasionally, you may need to pass a keyword argument to Python that