dict1 = {'name':'張三'}
print(json.dumps(dict1,encoding='utf-8',ensure_ascii=False))

Exception in thread Thread-1:
Traceback (most recent call last):
  File "/usr/local/python3/lib/python3.9/threading.py", line 950, in _bootstrap_inner
 self.run()
  File "/usr/local/python3/lib/python3.9/threading.py", line 888, in run
 self._target(*self._args, **self._kwargs)
  File "/home/dapan_ext/project_table.py", line 91, in http_request
 self.get_data(project_response_data)
  File "/home/dapan_ext/project_table.py", line 115, in get_data
 json.dumps(dict_1, encoding='utf-8', ensure_ascii=False)
  File "/usr/local/python3/lib/python3.9/json/__init__.py", line 234, in dumps
 return cls(
TypeError: __init__() got an unexpected keyword argument 'encoding'

def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,
  allow_nan=True, cls=None, indent=None, separators=None,
  default=None, sort_keys=False, **kw):
 """Serialize ``obj`` to a JSON formatted ``str``.
 If ``skipkeys`` is true then ``dict`` keys that are not basic types
 (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
 instead of raising a ``TypeError``.
 If ``ensure_ascii`` is false, then the return value can contain non-ASCII
 characters if they appear in strings contained in ``obj``. Otherwise, all
 such characters are escaped in JSON strings.
 If ``check_circular`` is false, then the circular reference check
 for container types will be skipped and a circular reference will
 result in an ``OverflowError`` (or worse).
 If ``allow_nan`` is false, then it will be a ``ValueError`` to
 serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in
 strict compliance of the JSON specification, instead of using the
 JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
 If ``indent`` is a non-negative integer, then JSON array elements and
 object members will be pretty-printed with that indent level. An indent
 level of 0 will only insert newlines. ``None`` is the most compact
 representation.
 If specified, ``separators`` should be an ``(item_separator, key_separator)``
 tuple.  The default is ``(', ', ': ')`` if *indent* is ``None`` and
 ``(',', ': ')`` otherwise.  To get the most compact JSON representation,
 you should specify ``(',', ':')`` to eliminate whitespace.
 ``default(obj)`` is a function that should return a serializable version
 of obj or raise TypeError. The default simply raises TypeError.
 If *sort_keys* is true (default: ``False``), then the output of
 dictionaries will be sorted by key.
 To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
 ``.default()`` method to serialize additional types), specify it with
 the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.
 """
 # cached encoder
 if (not skipkeys and ensure_ascii and
  check_circular and allow_nan and
  cls is None and indent is None and separators is None and
  default is None and not sort_keys and not kw):
  return _default_encoder.encode(obj)
 if cls is None:
  cls = JSONEncoder
 return cls(
  skipkeys=skipkeys, ensure_ascii=ensure_ascii,
  check_circular=check_circular, allow_nan=allow_nan, indent=indent,
  separators=separators, default=default, sort_keys=sort_keys,
  **kw).encode(obj)

server_name = str(related['name'])
# print(server_name)
dict_1 = {'appKey': related['appKey'], 'client': related['client'], 'name': server_name}
crasheye.append(dict_1)
crasheyes = json.dumps(crasheye, ensure_ascii=False)