docs: formatting

Author: lidatong

README.md

@@ -344,59 +344,60 @@ dump_dict = {"endpoint": "some_api_endpoint", "data": {"foo": 1, "bar": "2"}, "u
 1. You can enforce to always raise an error by setting the `undefined` keyword to `Undefined.RAISE`
  (`'RAISE'` as a case-insensitive string works as well). Of course it works normally if you don't pass any undefined parameters.
 
-    ```python
-    from dataclasses_json import Undefined
-    
-    @dataclass_json(undefined=Undefined.RAISE)
-    @dataclass()
-    class ExactAPIDump:
-        endpoint: str
-        data: Dict[str, Any]
-    
-    dump = ExactAPIDump.from_dict(dump_dict)  # raises UndefinedParameterError
-    ```
+```python
+from dataclasses_json import Undefined
+
+@dataclass_json(undefined=Undefined.RAISE)
+@dataclass()
+class ExactAPIDump:
+    endpoint: str
+    data: Dict[str, Any]
+
+dump = ExactAPIDump.from_dict(dump_dict)  # raises UndefinedParameterError
+```
 
 2. You can simply ignore any undefined parameters by setting the `undefined` keyword to `Undefined.EXCLUDE`
  (`'EXCLUDE'` as a case-insensitive string works as well). Note that you will not be able to retrieve them using `to_dict`:
 
-    ```python
-    from dataclasses_json import Undefined
-    
-    @dataclass_json(undefined=Undefined.EXCLUDE)
-    @dataclass()
-    class DontCareAPIDump:
-        endpoint: str
-        data: Dict[str, Any]
-    
-    dump = DontCareAPIDump.from_dict(dump_dict)  # DontCareAPIDump(endpoint='some_api_endpoint', data={'foo': 1, 'bar': '2'})
-    dump.to_dict()  # {"endpoint": "some_api_endpoint", "data": {"foo": 1, "bar": "2"}}
-    ```
+```python
+from dataclasses_json import Undefined
+
+@dataclass_json(undefined=Undefined.EXCLUDE)
+@dataclass()
+class DontCareAPIDump:
+    endpoint: str
+    data: Dict[str, Any]
+
+dump = DontCareAPIDump.from_dict(dump_dict)  # DontCareAPIDump(endpoint='some_api_endpoint', data={'foo': 1, 'bar': '2'})
+dump.to_dict()  # {"endpoint": "some_api_endpoint", "data": {"foo": 1, "bar": "2"}}
+```
 
 3. You can save them in a catch-all field and do whatever needs to be done later. Simply set the `undefined`
 keyword to `Undefined.INCLUDE` (`'INCLUDE'` as a case-insensitive string works as well) and define a field
 of type `CatchAll` where all unknown values will end up.
  This simply represents a dictionary that can hold anything. 
  If there are no undefined parameters, this will be an empty dictionary.
 
-    ```python
-    from dataclasses_json import Undefined, CatchAll
-    
-    @dataclass_json(undefined=Undefined.INCLUDE)
-    @dataclass()
-    class UnknownAPIDump:
-        endpoint: str
-        data: Dict[str, Any]
-        unknown_things: CatchAll
-    
-    dump = UnknownAPIDump.from_dict(dump_dict)  # UnknownAPIDump(endpoint='some_api_endpoint', data={'foo': 1, 'bar': '2'}, unknown_things={'undefined_field_name': [1, 2, 3]})
-    dump.to_dict()  # {'endpoint': 'some_api_endpoint', 'data': {'foo': 1, 'bar': '2'}, 'undefined_field_name': [1, 2, 3]}
-    ```
-
-    - When using `Undefined.INCLUDE`, an `UndefinedParameterError` will be raised if you don't specify
-    exactly one field of type `CatchAll`.
-    - Note that `LetterCase` does not affect values written into the `CatchAll` field, they will be as they are given.
-    - When specifying a default (or a default factory) for the the `CatchAll`-field, e.g. `unknown_things: CatchAll = None`, the default value will be used instead of an empty dict if there are no undefined parameters.
-    - Calling __init__ with non-keyword arguments resolves the arguments to the defined fields and writes everything else into the catch-all field.
+```python
+from dataclasses_json import Undefined, CatchAll
+
+@dataclass_json(undefined=Undefined.INCLUDE)
+@dataclass()
+class UnknownAPIDump:
+    endpoint: str
+    data: Dict[str, Any]
+    unknown_things: CatchAll
+
+dump = UnknownAPIDump.from_dict(dump_dict)  # UnknownAPIDump(endpoint='some_api_endpoint', data={'foo': 1, 'bar': '2'}, unknown_things={'undefined_field_name': [1, 2, 3]})
+dump.to_dict()  # {'endpoint': 'some_api_endpoint', 'data': {'foo': 1, 'bar': '2'}, 'undefined_field_name': [1, 2, 3]}
+```
+
+Notes:
+- When using `Undefined.INCLUDE`, an `UndefinedParameterError` will be raised if you don't specify
+exactly one field of type `CatchAll`.
+- Note that `LetterCase` does not affect values written into the `CatchAll` field, they will be as they are given.
+- When specifying a default (or a default factory) for the the `CatchAll`-field, e.g. `unknown_things: CatchAll = None`, the default value will be used instead of an empty dict if there are no undefined parameters.
+- Calling __init__ with non-keyword arguments resolves the arguments to the defined fields and writes everything else into the catch-all field.
 
 4. All 3 options work as well using `schema().loads` and `schema().dumps`, as long as you don't overwrite it by specifying `schema(unknown=<a marshmallow value>)`.
 marshmallow uses the same 3 keywords ['include', 'exclude', 'raise'](https://marshmallow.readthedocs.io/en/stable/quickstart.html#handling-unknown-fields).