Method for adding error messages to a dictionary given a key The Next CEO of Stack Overflow“Multi-key” dictionaryOutputting all possible words which fit a string of lettersCheck value from two different dictionary with matched keyDictionary of key signatures for various major and minor scalesResolving MySQL 1215 errors in a declarative MySQL migration systemSmall Chatbot challengeSimple Python script seems to stop when N >> 1Make a given number by adding given numbersAdding values from DictReader to empty dictionaryDefine the scope of negation with the Dependency Parser of spaCy

Why didn't Khan get resurrected in the Genesis Explosion?

Why doesn't UK go for the same deal Japan has with EU to resolve Brexit?

Why don't programming languages automatically manage the synchronous/asynchronous problem?

Easy to read palindrome checker

Would a grinding machine be a simple and workable propulsion system for an interplanetary spacecraft?

Does soap repel water?

Won the lottery - how do I keep the money?

Is it okay to majorly distort historical facts while writing a fiction story?

Is it possible to replace duplicates of a character with one character using tr

RigExpert AA-35 - Interpreting The Information

Why is quantifier elimination desirable for a given theory?

Should I tutor a student who I know has cheated on their homework?

When you upcast Blindness/Deafness, do all targets suffer the same effect?

What did we know about the Kessel run before the prequels?

Writing differences on a blackboard

Why is my new battery behaving weirdly?

Rotate a column

Unclear about dynamic binding

Some questions about different axiomatic systems for neighbourhoods

0 rank tensor vs 1D vector

How to invert MapIndexed on a ragged structure? How to construct a tree from rules?

Powershell. How to parse gci Name?

Can a Bladesinger Wizard use Bladesong with a Hand Crossbow?

INSERT to a table from a database to other (same SQL Server) using Dynamic SQL



Method for adding error messages to a dictionary given a key



The Next CEO of Stack Overflow“Multi-key” dictionaryOutputting all possible words which fit a string of lettersCheck value from two different dictionary with matched keyDictionary of key signatures for various major and minor scalesResolving MySQL 1215 errors in a declarative MySQL migration systemSmall Chatbot challengeSimple Python script seems to stop when N >> 1Make a given number by adding given numbersAdding values from DictReader to empty dictionaryDefine the scope of negation with the Dependency Parser of spaCy










5












$begingroup$


I want this method to be completely understandable just from looking at the code and comments only.



def add_error(error_dict, key, err):
"""Given an error message, or a list of error messages, this method
adds it/them to a dictionary of errors.

Doctests:
>>> add_error(, 'key1', 'error1')
'key1': ['error1']
>>> add_error('key1': ['error1'], 'key1', 'error2')
'key1': ['error1', 'error2']
>>> add_error('key1': ['error1', 'error2'], 'key2', 'error1')
'key1': ['error1', 'error2'], 'key2': ['error1']
>>> add_error(, 'key1', ['error1', 'error2'])
'key1': ['error1', 'error2']
>>> add_error(, 'key1', [])

>>> add_error('key1': ['error1'], 'key2', ['error1', 'error2'])
'key1': ['error1'], 'key2': ['error1', 'error2']
>>> add_error(, 'key1', 23) # doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
TypeError: The error(s) must be a string, or a list of strings.
>>> add_error(, 'key1', [23]) # doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
TypeError: The error(s) must be a string, or a list of strings.
>>> add_error(, 'key1', ['error1', 23]) # doctest:
+IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
TypeError: The error(s) must be a string, or a list of strings.
"""
if not isinstance(err, list):
err = [err]

if not key in error_dict and len(err) > 0:
error_dict[key] = []

for e in err:
if not isinstance(e, string_types):
raise TypeError(
'The error(s) must be a string, or a list of strings.'
)
error_dict[key].append(e)
return error_dict


Hopefully, the code along with the comment does the job well, but I would still appreciate review(s) of this method. One thing I always keep on wondering is whether this is too many doc-tests for such a simple method. Thanks.










share|improve this question







New contributor




darkhorse is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.







$endgroup$
















    5












    $begingroup$


    I want this method to be completely understandable just from looking at the code and comments only.



    def add_error(error_dict, key, err):
    """Given an error message, or a list of error messages, this method
    adds it/them to a dictionary of errors.

    Doctests:
    >>> add_error(, 'key1', 'error1')
    'key1': ['error1']
    >>> add_error('key1': ['error1'], 'key1', 'error2')
    'key1': ['error1', 'error2']
    >>> add_error('key1': ['error1', 'error2'], 'key2', 'error1')
    'key1': ['error1', 'error2'], 'key2': ['error1']
    >>> add_error(, 'key1', ['error1', 'error2'])
    'key1': ['error1', 'error2']
    >>> add_error(, 'key1', [])

    >>> add_error('key1': ['error1'], 'key2', ['error1', 'error2'])
    'key1': ['error1'], 'key2': ['error1', 'error2']
    >>> add_error(, 'key1', 23) # doctest: +IGNORE_EXCEPTION_DETAIL
    Traceback (most recent call last):
    ...
    TypeError: The error(s) must be a string, or a list of strings.
    >>> add_error(, 'key1', [23]) # doctest: +IGNORE_EXCEPTION_DETAIL
    Traceback (most recent call last):
    ...
    TypeError: The error(s) must be a string, or a list of strings.
    >>> add_error(, 'key1', ['error1', 23]) # doctest:
    +IGNORE_EXCEPTION_DETAIL
    Traceback (most recent call last):
    ...
    TypeError: The error(s) must be a string, or a list of strings.
    """
    if not isinstance(err, list):
    err = [err]

    if not key in error_dict and len(err) > 0:
    error_dict[key] = []

    for e in err:
    if not isinstance(e, string_types):
    raise TypeError(
    'The error(s) must be a string, or a list of strings.'
    )
    error_dict[key].append(e)
    return error_dict


    Hopefully, the code along with the comment does the job well, but I would still appreciate review(s) of this method. One thing I always keep on wondering is whether this is too many doc-tests for such a simple method. Thanks.










    share|improve this question







    New contributor




    darkhorse is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.







    $endgroup$














      5












      5








      5





      $begingroup$


      I want this method to be completely understandable just from looking at the code and comments only.



      def add_error(error_dict, key, err):
      """Given an error message, or a list of error messages, this method
      adds it/them to a dictionary of errors.

      Doctests:
      >>> add_error(, 'key1', 'error1')
      'key1': ['error1']
      >>> add_error('key1': ['error1'], 'key1', 'error2')
      'key1': ['error1', 'error2']
      >>> add_error('key1': ['error1', 'error2'], 'key2', 'error1')
      'key1': ['error1', 'error2'], 'key2': ['error1']
      >>> add_error(, 'key1', ['error1', 'error2'])
      'key1': ['error1', 'error2']
      >>> add_error(, 'key1', [])

      >>> add_error('key1': ['error1'], 'key2', ['error1', 'error2'])
      'key1': ['error1'], 'key2': ['error1', 'error2']
      >>> add_error(, 'key1', 23) # doctest: +IGNORE_EXCEPTION_DETAIL
      Traceback (most recent call last):
      ...
      TypeError: The error(s) must be a string, or a list of strings.
      >>> add_error(, 'key1', [23]) # doctest: +IGNORE_EXCEPTION_DETAIL
      Traceback (most recent call last):
      ...
      TypeError: The error(s) must be a string, or a list of strings.
      >>> add_error(, 'key1', ['error1', 23]) # doctest:
      +IGNORE_EXCEPTION_DETAIL
      Traceback (most recent call last):
      ...
      TypeError: The error(s) must be a string, or a list of strings.
      """
      if not isinstance(err, list):
      err = [err]

      if not key in error_dict and len(err) > 0:
      error_dict[key] = []

      for e in err:
      if not isinstance(e, string_types):
      raise TypeError(
      'The error(s) must be a string, or a list of strings.'
      )
      error_dict[key].append(e)
      return error_dict


      Hopefully, the code along with the comment does the job well, but I would still appreciate review(s) of this method. One thing I always keep on wondering is whether this is too many doc-tests for such a simple method. Thanks.










      share|improve this question







      New contributor




      darkhorse is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.







      $endgroup$




      I want this method to be completely understandable just from looking at the code and comments only.



      def add_error(error_dict, key, err):
      """Given an error message, or a list of error messages, this method
      adds it/them to a dictionary of errors.

      Doctests:
      >>> add_error(, 'key1', 'error1')
      'key1': ['error1']
      >>> add_error('key1': ['error1'], 'key1', 'error2')
      'key1': ['error1', 'error2']
      >>> add_error('key1': ['error1', 'error2'], 'key2', 'error1')
      'key1': ['error1', 'error2'], 'key2': ['error1']
      >>> add_error(, 'key1', ['error1', 'error2'])
      'key1': ['error1', 'error2']
      >>> add_error(, 'key1', [])

      >>> add_error('key1': ['error1'], 'key2', ['error1', 'error2'])
      'key1': ['error1'], 'key2': ['error1', 'error2']
      >>> add_error(, 'key1', 23) # doctest: +IGNORE_EXCEPTION_DETAIL
      Traceback (most recent call last):
      ...
      TypeError: The error(s) must be a string, or a list of strings.
      >>> add_error(, 'key1', [23]) # doctest: +IGNORE_EXCEPTION_DETAIL
      Traceback (most recent call last):
      ...
      TypeError: The error(s) must be a string, or a list of strings.
      >>> add_error(, 'key1', ['error1', 23]) # doctest:
      +IGNORE_EXCEPTION_DETAIL
      Traceback (most recent call last):
      ...
      TypeError: The error(s) must be a string, or a list of strings.
      """
      if not isinstance(err, list):
      err = [err]

      if not key in error_dict and len(err) > 0:
      error_dict[key] = []

      for e in err:
      if not isinstance(e, string_types):
      raise TypeError(
      'The error(s) must be a string, or a list of strings.'
      )
      error_dict[key].append(e)
      return error_dict


      Hopefully, the code along with the comment does the job well, but I would still appreciate review(s) of this method. One thing I always keep on wondering is whether this is too many doc-tests for such a simple method. Thanks.







      python python-3.x






      share|improve this question







      New contributor




      darkhorse is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.











      share|improve this question







      New contributor




      darkhorse is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.









      share|improve this question




      share|improve this question






      New contributor




      darkhorse is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.









      asked 5 hours ago









      darkhorsedarkhorse

      1634




      1634




      New contributor




      darkhorse is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.





      New contributor





      darkhorse is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.






      darkhorse is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.




















          3 Answers
          3






          active

          oldest

          votes


















          4












          $begingroup$

          Consider narrowing accepted types



          This might not be possible based on the context of your code, but if it is: arguments sharing one of many different types hinders and complicates testability and maintainability. There are many different solutions to this that will help this situation; one is accepting variadic arguments - i.e.



          def add_error(error_dict, key, *errs):


          This is still easily invocable without needing to wrap a single error in a list.



          Use x not in instead of not x in



          i.e.



          if key not in error_dict


          Lose your loop



          and also lose your empty-list assignment, instead doing



          error_dict.setdefault(key, []).extend(err)


          If you use the variadic suggestion above, your entire function becomes that one line.



          Immutable or not?



          Currently you do two things - alter a dictionary and return it - when you should only pick one. Either make a copy of the dict and return an altered version, or modify the dict and don't return anything.






          share|improve this answer









          $endgroup$




















            3












            $begingroup$

            congratulations on writing a fairly clear, readable function! (And welcome!)



            What types do you take?



            You explicitly check for an instance of type list. I think you should invert your check, and look for a string type instead. The reason is that it would enable you to accept iterables other than list as your errors.



            For example, you would be able to do something like:



            add_error(edict, 'key', (str(e) for e in ...))


            That last parameter is not a list, but it is something you might want to do. Also, *args is not a list but a tuple - you might want to splat a tuple rather than converting it to a list first.



            What types do you take?



            Your key parameter is always tested as a string. But dicts can have other key-types than string, and you neither test those, nor do you appear to have coded any kind of rejection on that basis. I suggest you add some tests that demonstrate your intent: is it okay to use non-strings as keys, or not?



            What constraints exist on the errors?



            I don't see any indication of what happens when duplicate errors are added. Is this intended to be allowed, or not?



            What constraints exist on the keys?



            Is it okay to use None as a key? How about '' (empty string)? Tests, please.






            share|improve this answer









            $endgroup$




















              0












              $begingroup$

              Type Hints



              Based on your doctests, you must be using Python 3.6 or later (due to reliance on dictionary key order).



              Since Python 3.5+ includes support for type hints, you could declare you function as:



              def add_error(error_dict: dict, key: str, err: list) -> dict:


              Or



              from typing import List, Dict

              def add_error(error_dict: Dict[str, List[str]], key: str,
              err: List[str]) -> Dict[str]:


              Of course, modify the type hints if you take the argument changes suggested in other answers. In particular, as is, the type of err is actually a variant type. I’d prefer a variable list of strings, *err: str.



              Detect Errors before Modifying



              If an error is not a string, you will raise an exception. But first, if the key does not exist in the dictionary, you add an empty list for that key.



              If the error list contains strings before a non-string, you add those strings to the key’s list, then raise an exception part way through.



              Consider moving the checks up to the start of the function, before any changes have been made.



              if any(not isinstance(e, string_types) for e in err):
              raise TypeError("The error(s) must be a string, or list of strings")


              Duck Typing



              Why must the errors be a string? Any object can be converted to a string...






              share|improve this answer











              $endgroup$













                Your Answer





                StackExchange.ifUsing("editor", function ()
                return StackExchange.using("mathjaxEditing", function ()
                StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix)
                StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["\$", "\$"]]);
                );
                );
                , "mathjax-editing");

                StackExchange.ifUsing("editor", function ()
                StackExchange.using("externalEditor", function ()
                StackExchange.using("snippets", function ()
                StackExchange.snippets.init();
                );
                );
                , "code-snippets");

                StackExchange.ready(function()
                var channelOptions =
                tags: "".split(" "),
                id: "196"
                ;
                initTagRenderer("".split(" "), "".split(" "), channelOptions);

                StackExchange.using("externalEditor", function()
                // Have to fire editor after snippets, if snippets enabled
                if (StackExchange.settings.snippets.snippetsEnabled)
                StackExchange.using("snippets", function()
                createEditor();
                );

                else
                createEditor();

                );

                function createEditor()
                StackExchange.prepareEditor(
                heartbeatType: 'answer',
                autoActivateHeartbeat: false,
                convertImagesToLinks: false,
                noModals: true,
                showLowRepImageUploadWarning: true,
                reputationToPostImages: null,
                bindNavPrevention: true,
                postfix: "",
                imageUploader:
                brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
                contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
                allowUrls: true
                ,
                onDemand: true,
                discardSelector: ".discard-answer"
                ,immediatelyShowMarkdownHelp:true
                );



                );






                darkhorse is a new contributor. Be nice, and check out our Code of Conduct.









                draft saved

                draft discarded


















                StackExchange.ready(
                function ()
                StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f216535%2fmethod-for-adding-error-messages-to-a-dictionary-given-a-key%23new-answer', 'question_page');

                );

                Post as a guest















                Required, but never shown

























                3 Answers
                3






                active

                oldest

                votes








                3 Answers
                3






                active

                oldest

                votes









                active

                oldest

                votes






                active

                oldest

                votes









                4












                $begingroup$

                Consider narrowing accepted types



                This might not be possible based on the context of your code, but if it is: arguments sharing one of many different types hinders and complicates testability and maintainability. There are many different solutions to this that will help this situation; one is accepting variadic arguments - i.e.



                def add_error(error_dict, key, *errs):


                This is still easily invocable without needing to wrap a single error in a list.



                Use x not in instead of not x in



                i.e.



                if key not in error_dict


                Lose your loop



                and also lose your empty-list assignment, instead doing



                error_dict.setdefault(key, []).extend(err)


                If you use the variadic suggestion above, your entire function becomes that one line.



                Immutable or not?



                Currently you do two things - alter a dictionary and return it - when you should only pick one. Either make a copy of the dict and return an altered version, or modify the dict and don't return anything.






                share|improve this answer









                $endgroup$

















                  4












                  $begingroup$

                  Consider narrowing accepted types



                  This might not be possible based on the context of your code, but if it is: arguments sharing one of many different types hinders and complicates testability and maintainability. There are many different solutions to this that will help this situation; one is accepting variadic arguments - i.e.



                  def add_error(error_dict, key, *errs):


                  This is still easily invocable without needing to wrap a single error in a list.



                  Use x not in instead of not x in



                  i.e.



                  if key not in error_dict


                  Lose your loop



                  and also lose your empty-list assignment, instead doing



                  error_dict.setdefault(key, []).extend(err)


                  If you use the variadic suggestion above, your entire function becomes that one line.



                  Immutable or not?



                  Currently you do two things - alter a dictionary and return it - when you should only pick one. Either make a copy of the dict and return an altered version, or modify the dict and don't return anything.






                  share|improve this answer









                  $endgroup$















                    4












                    4








                    4





                    $begingroup$

                    Consider narrowing accepted types



                    This might not be possible based on the context of your code, but if it is: arguments sharing one of many different types hinders and complicates testability and maintainability. There are many different solutions to this that will help this situation; one is accepting variadic arguments - i.e.



                    def add_error(error_dict, key, *errs):


                    This is still easily invocable without needing to wrap a single error in a list.



                    Use x not in instead of not x in



                    i.e.



                    if key not in error_dict


                    Lose your loop



                    and also lose your empty-list assignment, instead doing



                    error_dict.setdefault(key, []).extend(err)


                    If you use the variadic suggestion above, your entire function becomes that one line.



                    Immutable or not?



                    Currently you do two things - alter a dictionary and return it - when you should only pick one. Either make a copy of the dict and return an altered version, or modify the dict and don't return anything.






                    share|improve this answer









                    $endgroup$



                    Consider narrowing accepted types



                    This might not be possible based on the context of your code, but if it is: arguments sharing one of many different types hinders and complicates testability and maintainability. There are many different solutions to this that will help this situation; one is accepting variadic arguments - i.e.



                    def add_error(error_dict, key, *errs):


                    This is still easily invocable without needing to wrap a single error in a list.



                    Use x not in instead of not x in



                    i.e.



                    if key not in error_dict


                    Lose your loop



                    and also lose your empty-list assignment, instead doing



                    error_dict.setdefault(key, []).extend(err)


                    If you use the variadic suggestion above, your entire function becomes that one line.



                    Immutable or not?



                    Currently you do two things - alter a dictionary and return it - when you should only pick one. Either make a copy of the dict and return an altered version, or modify the dict and don't return anything.







                    share|improve this answer












                    share|improve this answer



                    share|improve this answer










                    answered 3 hours ago









                    ReinderienReinderien

                    4,995925




                    4,995925























                        3












                        $begingroup$

                        congratulations on writing a fairly clear, readable function! (And welcome!)



                        What types do you take?



                        You explicitly check for an instance of type list. I think you should invert your check, and look for a string type instead. The reason is that it would enable you to accept iterables other than list as your errors.



                        For example, you would be able to do something like:



                        add_error(edict, 'key', (str(e) for e in ...))


                        That last parameter is not a list, but it is something you might want to do. Also, *args is not a list but a tuple - you might want to splat a tuple rather than converting it to a list first.



                        What types do you take?



                        Your key parameter is always tested as a string. But dicts can have other key-types than string, and you neither test those, nor do you appear to have coded any kind of rejection on that basis. I suggest you add some tests that demonstrate your intent: is it okay to use non-strings as keys, or not?



                        What constraints exist on the errors?



                        I don't see any indication of what happens when duplicate errors are added. Is this intended to be allowed, or not?



                        What constraints exist on the keys?



                        Is it okay to use None as a key? How about '' (empty string)? Tests, please.






                        share|improve this answer









                        $endgroup$

















                          3












                          $begingroup$

                          congratulations on writing a fairly clear, readable function! (And welcome!)



                          What types do you take?



                          You explicitly check for an instance of type list. I think you should invert your check, and look for a string type instead. The reason is that it would enable you to accept iterables other than list as your errors.



                          For example, you would be able to do something like:



                          add_error(edict, 'key', (str(e) for e in ...))


                          That last parameter is not a list, but it is something you might want to do. Also, *args is not a list but a tuple - you might want to splat a tuple rather than converting it to a list first.



                          What types do you take?



                          Your key parameter is always tested as a string. But dicts can have other key-types than string, and you neither test those, nor do you appear to have coded any kind of rejection on that basis. I suggest you add some tests that demonstrate your intent: is it okay to use non-strings as keys, or not?



                          What constraints exist on the errors?



                          I don't see any indication of what happens when duplicate errors are added. Is this intended to be allowed, or not?



                          What constraints exist on the keys?



                          Is it okay to use None as a key? How about '' (empty string)? Tests, please.






                          share|improve this answer









                          $endgroup$















                            3












                            3








                            3





                            $begingroup$

                            congratulations on writing a fairly clear, readable function! (And welcome!)



                            What types do you take?



                            You explicitly check for an instance of type list. I think you should invert your check, and look for a string type instead. The reason is that it would enable you to accept iterables other than list as your errors.



                            For example, you would be able to do something like:



                            add_error(edict, 'key', (str(e) for e in ...))


                            That last parameter is not a list, but it is something you might want to do. Also, *args is not a list but a tuple - you might want to splat a tuple rather than converting it to a list first.



                            What types do you take?



                            Your key parameter is always tested as a string. But dicts can have other key-types than string, and you neither test those, nor do you appear to have coded any kind of rejection on that basis. I suggest you add some tests that demonstrate your intent: is it okay to use non-strings as keys, or not?



                            What constraints exist on the errors?



                            I don't see any indication of what happens when duplicate errors are added. Is this intended to be allowed, or not?



                            What constraints exist on the keys?



                            Is it okay to use None as a key? How about '' (empty string)? Tests, please.






                            share|improve this answer









                            $endgroup$



                            congratulations on writing a fairly clear, readable function! (And welcome!)



                            What types do you take?



                            You explicitly check for an instance of type list. I think you should invert your check, and look for a string type instead. The reason is that it would enable you to accept iterables other than list as your errors.



                            For example, you would be able to do something like:



                            add_error(edict, 'key', (str(e) for e in ...))


                            That last parameter is not a list, but it is something you might want to do. Also, *args is not a list but a tuple - you might want to splat a tuple rather than converting it to a list first.



                            What types do you take?



                            Your key parameter is always tested as a string. But dicts can have other key-types than string, and you neither test those, nor do you appear to have coded any kind of rejection on that basis. I suggest you add some tests that demonstrate your intent: is it okay to use non-strings as keys, or not?



                            What constraints exist on the errors?



                            I don't see any indication of what happens when duplicate errors are added. Is this intended to be allowed, or not?



                            What constraints exist on the keys?



                            Is it okay to use None as a key? How about '' (empty string)? Tests, please.







                            share|improve this answer












                            share|improve this answer



                            share|improve this answer










                            answered 2 hours ago









                            Austin HastingsAustin Hastings

                            7,5771233




                            7,5771233





















                                0












                                $begingroup$

                                Type Hints



                                Based on your doctests, you must be using Python 3.6 or later (due to reliance on dictionary key order).



                                Since Python 3.5+ includes support for type hints, you could declare you function as:



                                def add_error(error_dict: dict, key: str, err: list) -> dict:


                                Or



                                from typing import List, Dict

                                def add_error(error_dict: Dict[str, List[str]], key: str,
                                err: List[str]) -> Dict[str]:


                                Of course, modify the type hints if you take the argument changes suggested in other answers. In particular, as is, the type of err is actually a variant type. I’d prefer a variable list of strings, *err: str.



                                Detect Errors before Modifying



                                If an error is not a string, you will raise an exception. But first, if the key does not exist in the dictionary, you add an empty list for that key.



                                If the error list contains strings before a non-string, you add those strings to the key’s list, then raise an exception part way through.



                                Consider moving the checks up to the start of the function, before any changes have been made.



                                if any(not isinstance(e, string_types) for e in err):
                                raise TypeError("The error(s) must be a string, or list of strings")


                                Duck Typing



                                Why must the errors be a string? Any object can be converted to a string...






                                share|improve this answer











                                $endgroup$

















                                  0












                                  $begingroup$

                                  Type Hints



                                  Based on your doctests, you must be using Python 3.6 or later (due to reliance on dictionary key order).



                                  Since Python 3.5+ includes support for type hints, you could declare you function as:



                                  def add_error(error_dict: dict, key: str, err: list) -> dict:


                                  Or



                                  from typing import List, Dict

                                  def add_error(error_dict: Dict[str, List[str]], key: str,
                                  err: List[str]) -> Dict[str]:


                                  Of course, modify the type hints if you take the argument changes suggested in other answers. In particular, as is, the type of err is actually a variant type. I’d prefer a variable list of strings, *err: str.



                                  Detect Errors before Modifying



                                  If an error is not a string, you will raise an exception. But first, if the key does not exist in the dictionary, you add an empty list for that key.



                                  If the error list contains strings before a non-string, you add those strings to the key’s list, then raise an exception part way through.



                                  Consider moving the checks up to the start of the function, before any changes have been made.



                                  if any(not isinstance(e, string_types) for e in err):
                                  raise TypeError("The error(s) must be a string, or list of strings")


                                  Duck Typing



                                  Why must the errors be a string? Any object can be converted to a string...






                                  share|improve this answer











                                  $endgroup$















                                    0












                                    0








                                    0





                                    $begingroup$

                                    Type Hints



                                    Based on your doctests, you must be using Python 3.6 or later (due to reliance on dictionary key order).



                                    Since Python 3.5+ includes support for type hints, you could declare you function as:



                                    def add_error(error_dict: dict, key: str, err: list) -> dict:


                                    Or



                                    from typing import List, Dict

                                    def add_error(error_dict: Dict[str, List[str]], key: str,
                                    err: List[str]) -> Dict[str]:


                                    Of course, modify the type hints if you take the argument changes suggested in other answers. In particular, as is, the type of err is actually a variant type. I’d prefer a variable list of strings, *err: str.



                                    Detect Errors before Modifying



                                    If an error is not a string, you will raise an exception. But first, if the key does not exist in the dictionary, you add an empty list for that key.



                                    If the error list contains strings before a non-string, you add those strings to the key’s list, then raise an exception part way through.



                                    Consider moving the checks up to the start of the function, before any changes have been made.



                                    if any(not isinstance(e, string_types) for e in err):
                                    raise TypeError("The error(s) must be a string, or list of strings")


                                    Duck Typing



                                    Why must the errors be a string? Any object can be converted to a string...






                                    share|improve this answer











                                    $endgroup$



                                    Type Hints



                                    Based on your doctests, you must be using Python 3.6 or later (due to reliance on dictionary key order).



                                    Since Python 3.5+ includes support for type hints, you could declare you function as:



                                    def add_error(error_dict: dict, key: str, err: list) -> dict:


                                    Or



                                    from typing import List, Dict

                                    def add_error(error_dict: Dict[str, List[str]], key: str,
                                    err: List[str]) -> Dict[str]:


                                    Of course, modify the type hints if you take the argument changes suggested in other answers. In particular, as is, the type of err is actually a variant type. I’d prefer a variable list of strings, *err: str.



                                    Detect Errors before Modifying



                                    If an error is not a string, you will raise an exception. But first, if the key does not exist in the dictionary, you add an empty list for that key.



                                    If the error list contains strings before a non-string, you add those strings to the key’s list, then raise an exception part way through.



                                    Consider moving the checks up to the start of the function, before any changes have been made.



                                    if any(not isinstance(e, string_types) for e in err):
                                    raise TypeError("The error(s) must be a string, or list of strings")


                                    Duck Typing



                                    Why must the errors be a string? Any object can be converted to a string...







                                    share|improve this answer














                                    share|improve this answer



                                    share|improve this answer








                                    edited 47 mins ago

























                                    answered 1 hour ago









                                    AJNeufeldAJNeufeld

                                    6,5101621




                                    6,5101621




















                                        darkhorse is a new contributor. Be nice, and check out our Code of Conduct.









                                        draft saved

                                        draft discarded


















                                        darkhorse is a new contributor. Be nice, and check out our Code of Conduct.












                                        darkhorse is a new contributor. Be nice, and check out our Code of Conduct.











                                        darkhorse is a new contributor. Be nice, and check out our Code of Conduct.














                                        Thanks for contributing an answer to Code Review Stack Exchange!


                                        • Please be sure to answer the question. Provide details and share your research!

                                        But avoid


                                        • Asking for help, clarification, or responding to other answers.

                                        • Making statements based on opinion; back them up with references or personal experience.

                                        Use MathJax to format equations. MathJax reference.


                                        To learn more, see our tips on writing great answers.




                                        draft saved


                                        draft discarded














                                        StackExchange.ready(
                                        function ()
                                        StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f216535%2fmethod-for-adding-error-messages-to-a-dictionary-given-a-key%23new-answer', 'question_page');

                                        );

                                        Post as a guest















                                        Required, but never shown





















































                                        Required, but never shown














                                        Required, but never shown












                                        Required, but never shown







                                        Required, but never shown

































                                        Required, but never shown














                                        Required, but never shown












                                        Required, but never shown







                                        Required, but never shown







                                        Popular posts from this blog

                                        Oświęcim Innehåll Historia | Källor | Externa länkar | Navigeringsmeny50°2′18″N 19°13′17″Ö / 50.03833°N 19.22139°Ö / 50.03833; 19.2213950°2′18″N 19°13′17″Ö / 50.03833°N 19.22139°Ö / 50.03833; 19.221393089658Nordisk familjebok, AuschwitzInsidan tro och existensJewish Community i OświęcimAuschwitz Jewish Center: MuseumAuschwitz Jewish Center

                                        Valle di Casies Indice Geografia fisica | Origini del nome | Storia | Società | Amministrazione | Sport | Note | Bibliografia | Voci correlate | Altri progetti | Collegamenti esterni | Menu di navigazione46°46′N 12°11′E / 46.766667°N 12.183333°E46.766667; 12.183333 (Valle di Casies)46°46′N 12°11′E / 46.766667°N 12.183333°E46.766667; 12.183333 (Valle di Casies)Sito istituzionaleAstat Censimento della popolazione 2011 - Determinazione della consistenza dei tre gruppi linguistici della Provincia Autonoma di Bolzano-Alto Adige - giugno 2012Numeri e fattiValle di CasiesDato IstatTabella dei gradi/giorno dei Comuni italiani raggruppati per Regione e Provincia26 agosto 1993, n. 412Heraldry of the World: GsiesStatistiche I.StatValCasies.comWikimedia CommonsWikimedia CommonsValle di CasiesSito ufficialeValle di CasiesMM14870458910042978-6

                                        Typsetting diagram chases (with TikZ?) Announcing the arrival of Valued Associate #679: Cesar Manara Planned maintenance scheduled April 17/18, 2019 at 00:00UTC (8:00pm US/Eastern)How to define the default vertical distance between nodes?Draw edge on arcNumerical conditional within tikz keys?TikZ: Drawing an arc from an intersection to an intersectionDrawing rectilinear curves in Tikz, aka an Etch-a-Sketch drawingLine up nested tikz enviroments or how to get rid of themHow to place nodes in an absolute coordinate system in tikzCommutative diagram with curve connecting between nodesTikz with standalone: pinning tikz coordinates to page cmDrawing a Decision Diagram with Tikz and layout manager