Calculate Levenshtein distance between two strings in PythonEdit Distance Between Two StringsString Matching...

Does the average primeness of natural numbers tend to zero?

Typesetting a double Over Dot on top of a symbol

How did the USSR manage to innovate in an environment characterized by government censorship and high bureaucracy?

How to make payment on the internet without leaving a money trail?

Why do we use polarized capacitors?

Can I find out the caloric content of bread by dehydrating it?

Information to fellow intern about hiring?

Is Social Media Science Fiction?

What are the advantages and disadvantages of running one shots compared to campaigns?

Need help identifying/translating a plaque in Tangier, Morocco

Does a dangling wire really electrocute me if I'm standing in water?

Are cabin dividers used to "hide" the flex of the airplane?

I’m planning on buying a laser printer but concerned about the life cycle of toner in the machine

Why do UK politicians seemingly ignore opinion polls on Brexit?

Why doesn't a const reference extend the life of a temporary object passed via a function?

How to answer pointed "are you quitting" questioning when I don't want them to suspect

Is this food a bread or a loaf?

Could a US political party gain complete control over the government by removing checks & balances?

Why was the "bread communication" in the arena of Catching Fire left out in the movie?

Can the Produce Flame cantrip be used to grapple, or as an unarmed strike, in the right circumstances?

Email Account under attack (really) - anything I can do?

Doomsday-clock for my fantasy planet

What causes the sudden spool-up sound from an F-16 when enabling afterburner?

COUNT(*) or MAX(id) - which is faster?



Calculate Levenshtein distance between two strings in Python


Edit Distance Between Two StringsString Matching and ClusteringSorting movie search results by similarityEdit distance between 2 stringsMaking the Levenshtein distance code cleanerEdit distance (Optimal Alignment) - follow upGet Levenshtein DistanceMessage classification with Levenshtein DistanceCode to implement the Jaro similarity for fuzzy matching stringsFinding differences in strings with Levenshtein distance and soundex






.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty{ margin-bottom:0;
}







9












$begingroup$


I need a function that checks how different are two different strings. I chose the Levenshtein distance as a quick approach, and implemented this function:



from difflib import ndiff

def calculate_levenshtein_distance(str_1, str_2):
"""
The Levenshtein distance is a string metric for measuring the difference between two sequences.
It is calculated as the minimum number of single-character edits necessary to transform one string into another
"""
distance = 0
buffer_removed = buffer_added = 0
for x in ndiff(str_1, str_2):
code = x[0]
# Code ? is ignored as it does not translate to any modification
if code == ' ':
distance += max(buffer_removed, buffer_added)
buffer_removed = buffer_added = 0
elif code == '-':
buffer_removed += 1
elif code == '+':
buffer_added += 1
distance += max(buffer_removed, buffer_added)
return distance


Then calling it as:



similarity = 1 - calculate_levenshtein_distance(str_1, str_2) / max(len(str_1), len(str_2))


How sloppy/prone to errors is this code? How can it be improved?










share|improve this question









New contributor




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







$endgroup$



















    9












    $begingroup$


    I need a function that checks how different are two different strings. I chose the Levenshtein distance as a quick approach, and implemented this function:



    from difflib import ndiff

    def calculate_levenshtein_distance(str_1, str_2):
    """
    The Levenshtein distance is a string metric for measuring the difference between two sequences.
    It is calculated as the minimum number of single-character edits necessary to transform one string into another
    """
    distance = 0
    buffer_removed = buffer_added = 0
    for x in ndiff(str_1, str_2):
    code = x[0]
    # Code ? is ignored as it does not translate to any modification
    if code == ' ':
    distance += max(buffer_removed, buffer_added)
    buffer_removed = buffer_added = 0
    elif code == '-':
    buffer_removed += 1
    elif code == '+':
    buffer_added += 1
    distance += max(buffer_removed, buffer_added)
    return distance


    Then calling it as:



    similarity = 1 - calculate_levenshtein_distance(str_1, str_2) / max(len(str_1), len(str_2))


    How sloppy/prone to errors is this code? How can it be improved?










    share|improve this question









    New contributor




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







    $endgroup$















      9












      9








      9


      1



      $begingroup$


      I need a function that checks how different are two different strings. I chose the Levenshtein distance as a quick approach, and implemented this function:



      from difflib import ndiff

      def calculate_levenshtein_distance(str_1, str_2):
      """
      The Levenshtein distance is a string metric for measuring the difference between two sequences.
      It is calculated as the minimum number of single-character edits necessary to transform one string into another
      """
      distance = 0
      buffer_removed = buffer_added = 0
      for x in ndiff(str_1, str_2):
      code = x[0]
      # Code ? is ignored as it does not translate to any modification
      if code == ' ':
      distance += max(buffer_removed, buffer_added)
      buffer_removed = buffer_added = 0
      elif code == '-':
      buffer_removed += 1
      elif code == '+':
      buffer_added += 1
      distance += max(buffer_removed, buffer_added)
      return distance


      Then calling it as:



      similarity = 1 - calculate_levenshtein_distance(str_1, str_2) / max(len(str_1), len(str_2))


      How sloppy/prone to errors is this code? How can it be improved?










      share|improve this question









      New contributor




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







      $endgroup$




      I need a function that checks how different are two different strings. I chose the Levenshtein distance as a quick approach, and implemented this function:



      from difflib import ndiff

      def calculate_levenshtein_distance(str_1, str_2):
      """
      The Levenshtein distance is a string metric for measuring the difference between two sequences.
      It is calculated as the minimum number of single-character edits necessary to transform one string into another
      """
      distance = 0
      buffer_removed = buffer_added = 0
      for x in ndiff(str_1, str_2):
      code = x[0]
      # Code ? is ignored as it does not translate to any modification
      if code == ' ':
      distance += max(buffer_removed, buffer_added)
      buffer_removed = buffer_added = 0
      elif code == '-':
      buffer_removed += 1
      elif code == '+':
      buffer_added += 1
      distance += max(buffer_removed, buffer_added)
      return distance


      Then calling it as:



      similarity = 1 - calculate_levenshtein_distance(str_1, str_2) / max(len(str_1), len(str_2))


      How sloppy/prone to errors is this code? How can it be improved?







      python edit-distance






      share|improve this question









      New contributor




      Kyra_W 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




      Kyra_W 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








      edited 10 hours ago









      Reinderien

      5,340927




      5,340927






      New contributor




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









      asked 19 hours ago









      Kyra_WKyra_W

      462




      462




      New contributor




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





      New contributor





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






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






















          2 Answers
          2






          active

          oldest

          votes


















          10












          $begingroup$

          There is a module available for exactly that calculation, python-Levenshtein. You can install it with pip install python-Levenshtein.



          It is implemented in C, so is probably faster than anything you can come up with yourself.



          from Levenshtein import distance as levenshtein_distance




          According to the docstring conventions, your docstring should look like this, i.e. with the indentation aligned to the """ and the line length curtailed to 80 characters.



          def calculate_levenshtein_distance(str_1, str_2):
          """
          The Levenshtein distance is a string metric for measuring the difference
          between two sequences.
          It is calculated as the minimum number of single-character edits necessary to
          transform one string into another.
          """
          ...





          share|improve this answer











          $endgroup$









          • 7




            $begingroup$
            Just to note the module is licensed under GPL 2.0 so watch out if you're using it for work.
            $endgroup$
            – lucasgcb
            16 hours ago










          • $begingroup$
            Just to point out a small nitpick to other people who may stumble upon this answer, as per help center: "Every answer must make at least one insightful observation about the code in the question. Answers that merely provide an alternate solution with no explanation or justification do not constitute valid Code Review answers and may be deleted." While this answer does provide alternative and existing module suggestion, it also goes into some suggestions about improving code quality. So it's an example of a decent answer
            $endgroup$
            – Sergiy Kolodyazhnyy
            5 hours ago



















          5












          $begingroup$

          The code itself is rather clear. There are some smaller changes I would make



          tuple unpacking



          You can use tuple unpacking to do:



          for code, *_ in ndiff(str1, str2):


          instead of:



          for x in ndiff(str_1, str_2):
          code = x[0]


          dict results:



          Instead of a counter for the additions and removals, I would keep it in 1 dict: counter = ({"+": 0, "-": 0})



          def levenshtein_distance(str1, str2, ):
          counter = {"+": 0, "-": 0}
          distance = 0
          for edit_code, *_ in ndiff(str1, str2):
          if edit_code == " ":
          distance += max(counter.values())
          counter = {"+": 0, "-": 0}
          else:
          counter[edit_code] += 1
          distance += max(counter.values())
          return distance


          generators



          A smaller, less useful variation, is to let this method be a generator, and use the builtin sum to do the summary. this saves 1 variable inside the function:



          def levenshtein_distance_gen(str1, str2, ):
          counter = {"+": 0, "-": 0}
          for edit_code, *_ in ndiff(str1, str2):
          if edit_code == " ":
          yield max(counter.values())
          counter = {"+": 0, "-": 0}
          else:
          counter[edit_code] += 1
          yield max(counter.values())

          sum(levenshtein_distance_gen(str1, str2))




          timings



          The differences in timings between the original and both these variations are minimal, and within the variation of results. This is rather logical, since for simple strings (aaabbbc and abcabcabc) 90% of the time is spent in ndiff






          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
            });


            }
            });






            Kyra_W 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%2f217065%2fcalculate-levenshtein-distance-between-two-strings-in-python%23new-answer', 'question_page');
            }
            );

            Post as a guest















            Required, but never shown

























            2 Answers
            2






            active

            oldest

            votes








            2 Answers
            2






            active

            oldest

            votes









            active

            oldest

            votes






            active

            oldest

            votes









            10












            $begingroup$

            There is a module available for exactly that calculation, python-Levenshtein. You can install it with pip install python-Levenshtein.



            It is implemented in C, so is probably faster than anything you can come up with yourself.



            from Levenshtein import distance as levenshtein_distance




            According to the docstring conventions, your docstring should look like this, i.e. with the indentation aligned to the """ and the line length curtailed to 80 characters.



            def calculate_levenshtein_distance(str_1, str_2):
            """
            The Levenshtein distance is a string metric for measuring the difference
            between two sequences.
            It is calculated as the minimum number of single-character edits necessary to
            transform one string into another.
            """
            ...





            share|improve this answer











            $endgroup$









            • 7




              $begingroup$
              Just to note the module is licensed under GPL 2.0 so watch out if you're using it for work.
              $endgroup$
              – lucasgcb
              16 hours ago










            • $begingroup$
              Just to point out a small nitpick to other people who may stumble upon this answer, as per help center: "Every answer must make at least one insightful observation about the code in the question. Answers that merely provide an alternate solution with no explanation or justification do not constitute valid Code Review answers and may be deleted." While this answer does provide alternative and existing module suggestion, it also goes into some suggestions about improving code quality. So it's an example of a decent answer
              $endgroup$
              – Sergiy Kolodyazhnyy
              5 hours ago
















            10












            $begingroup$

            There is a module available for exactly that calculation, python-Levenshtein. You can install it with pip install python-Levenshtein.



            It is implemented in C, so is probably faster than anything you can come up with yourself.



            from Levenshtein import distance as levenshtein_distance




            According to the docstring conventions, your docstring should look like this, i.e. with the indentation aligned to the """ and the line length curtailed to 80 characters.



            def calculate_levenshtein_distance(str_1, str_2):
            """
            The Levenshtein distance is a string metric for measuring the difference
            between two sequences.
            It is calculated as the minimum number of single-character edits necessary to
            transform one string into another.
            """
            ...





            share|improve this answer











            $endgroup$









            • 7




              $begingroup$
              Just to note the module is licensed under GPL 2.0 so watch out if you're using it for work.
              $endgroup$
              – lucasgcb
              16 hours ago










            • $begingroup$
              Just to point out a small nitpick to other people who may stumble upon this answer, as per help center: "Every answer must make at least one insightful observation about the code in the question. Answers that merely provide an alternate solution with no explanation or justification do not constitute valid Code Review answers and may be deleted." While this answer does provide alternative and existing module suggestion, it also goes into some suggestions about improving code quality. So it's an example of a decent answer
              $endgroup$
              – Sergiy Kolodyazhnyy
              5 hours ago














            10












            10








            10





            $begingroup$

            There is a module available for exactly that calculation, python-Levenshtein. You can install it with pip install python-Levenshtein.



            It is implemented in C, so is probably faster than anything you can come up with yourself.



            from Levenshtein import distance as levenshtein_distance




            According to the docstring conventions, your docstring should look like this, i.e. with the indentation aligned to the """ and the line length curtailed to 80 characters.



            def calculate_levenshtein_distance(str_1, str_2):
            """
            The Levenshtein distance is a string metric for measuring the difference
            between two sequences.
            It is calculated as the minimum number of single-character edits necessary to
            transform one string into another.
            """
            ...





            share|improve this answer











            $endgroup$



            There is a module available for exactly that calculation, python-Levenshtein. You can install it with pip install python-Levenshtein.



            It is implemented in C, so is probably faster than anything you can come up with yourself.



            from Levenshtein import distance as levenshtein_distance




            According to the docstring conventions, your docstring should look like this, i.e. with the indentation aligned to the """ and the line length curtailed to 80 characters.



            def calculate_levenshtein_distance(str_1, str_2):
            """
            The Levenshtein distance is a string metric for measuring the difference
            between two sequences.
            It is calculated as the minimum number of single-character edits necessary to
            transform one string into another.
            """
            ...






            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited 18 hours ago

























            answered 19 hours ago









            GraipherGraipher

            26.9k54397




            26.9k54397








            • 7




              $begingroup$
              Just to note the module is licensed under GPL 2.0 so watch out if you're using it for work.
              $endgroup$
              – lucasgcb
              16 hours ago










            • $begingroup$
              Just to point out a small nitpick to other people who may stumble upon this answer, as per help center: "Every answer must make at least one insightful observation about the code in the question. Answers that merely provide an alternate solution with no explanation or justification do not constitute valid Code Review answers and may be deleted." While this answer does provide alternative and existing module suggestion, it also goes into some suggestions about improving code quality. So it's an example of a decent answer
              $endgroup$
              – Sergiy Kolodyazhnyy
              5 hours ago














            • 7




              $begingroup$
              Just to note the module is licensed under GPL 2.0 so watch out if you're using it for work.
              $endgroup$
              – lucasgcb
              16 hours ago










            • $begingroup$
              Just to point out a small nitpick to other people who may stumble upon this answer, as per help center: "Every answer must make at least one insightful observation about the code in the question. Answers that merely provide an alternate solution with no explanation or justification do not constitute valid Code Review answers and may be deleted." While this answer does provide alternative and existing module suggestion, it also goes into some suggestions about improving code quality. So it's an example of a decent answer
              $endgroup$
              – Sergiy Kolodyazhnyy
              5 hours ago








            7




            7




            $begingroup$
            Just to note the module is licensed under GPL 2.0 so watch out if you're using it for work.
            $endgroup$
            – lucasgcb
            16 hours ago




            $begingroup$
            Just to note the module is licensed under GPL 2.0 so watch out if you're using it for work.
            $endgroup$
            – lucasgcb
            16 hours ago












            $begingroup$
            Just to point out a small nitpick to other people who may stumble upon this answer, as per help center: "Every answer must make at least one insightful observation about the code in the question. Answers that merely provide an alternate solution with no explanation or justification do not constitute valid Code Review answers and may be deleted." While this answer does provide alternative and existing module suggestion, it also goes into some suggestions about improving code quality. So it's an example of a decent answer
            $endgroup$
            – Sergiy Kolodyazhnyy
            5 hours ago




            $begingroup$
            Just to point out a small nitpick to other people who may stumble upon this answer, as per help center: "Every answer must make at least one insightful observation about the code in the question. Answers that merely provide an alternate solution with no explanation or justification do not constitute valid Code Review answers and may be deleted." While this answer does provide alternative and existing module suggestion, it also goes into some suggestions about improving code quality. So it's an example of a decent answer
            $endgroup$
            – Sergiy Kolodyazhnyy
            5 hours ago













            5












            $begingroup$

            The code itself is rather clear. There are some smaller changes I would make



            tuple unpacking



            You can use tuple unpacking to do:



            for code, *_ in ndiff(str1, str2):


            instead of:



            for x in ndiff(str_1, str_2):
            code = x[0]


            dict results:



            Instead of a counter for the additions and removals, I would keep it in 1 dict: counter = ({"+": 0, "-": 0})



            def levenshtein_distance(str1, str2, ):
            counter = {"+": 0, "-": 0}
            distance = 0
            for edit_code, *_ in ndiff(str1, str2):
            if edit_code == " ":
            distance += max(counter.values())
            counter = {"+": 0, "-": 0}
            else:
            counter[edit_code] += 1
            distance += max(counter.values())
            return distance


            generators



            A smaller, less useful variation, is to let this method be a generator, and use the builtin sum to do the summary. this saves 1 variable inside the function:



            def levenshtein_distance_gen(str1, str2, ):
            counter = {"+": 0, "-": 0}
            for edit_code, *_ in ndiff(str1, str2):
            if edit_code == " ":
            yield max(counter.values())
            counter = {"+": 0, "-": 0}
            else:
            counter[edit_code] += 1
            yield max(counter.values())

            sum(levenshtein_distance_gen(str1, str2))




            timings



            The differences in timings between the original and both these variations are minimal, and within the variation of results. This is rather logical, since for simple strings (aaabbbc and abcabcabc) 90% of the time is spent in ndiff






            share|improve this answer









            $endgroup$


















              5












              $begingroup$

              The code itself is rather clear. There are some smaller changes I would make



              tuple unpacking



              You can use tuple unpacking to do:



              for code, *_ in ndiff(str1, str2):


              instead of:



              for x in ndiff(str_1, str_2):
              code = x[0]


              dict results:



              Instead of a counter for the additions and removals, I would keep it in 1 dict: counter = ({"+": 0, "-": 0})



              def levenshtein_distance(str1, str2, ):
              counter = {"+": 0, "-": 0}
              distance = 0
              for edit_code, *_ in ndiff(str1, str2):
              if edit_code == " ":
              distance += max(counter.values())
              counter = {"+": 0, "-": 0}
              else:
              counter[edit_code] += 1
              distance += max(counter.values())
              return distance


              generators



              A smaller, less useful variation, is to let this method be a generator, and use the builtin sum to do the summary. this saves 1 variable inside the function:



              def levenshtein_distance_gen(str1, str2, ):
              counter = {"+": 0, "-": 0}
              for edit_code, *_ in ndiff(str1, str2):
              if edit_code == " ":
              yield max(counter.values())
              counter = {"+": 0, "-": 0}
              else:
              counter[edit_code] += 1
              yield max(counter.values())

              sum(levenshtein_distance_gen(str1, str2))




              timings



              The differences in timings between the original and both these variations are minimal, and within the variation of results. This is rather logical, since for simple strings (aaabbbc and abcabcabc) 90% of the time is spent in ndiff






              share|improve this answer









              $endgroup$
















                5












                5








                5





                $begingroup$

                The code itself is rather clear. There are some smaller changes I would make



                tuple unpacking



                You can use tuple unpacking to do:



                for code, *_ in ndiff(str1, str2):


                instead of:



                for x in ndiff(str_1, str_2):
                code = x[0]


                dict results:



                Instead of a counter for the additions and removals, I would keep it in 1 dict: counter = ({"+": 0, "-": 0})



                def levenshtein_distance(str1, str2, ):
                counter = {"+": 0, "-": 0}
                distance = 0
                for edit_code, *_ in ndiff(str1, str2):
                if edit_code == " ":
                distance += max(counter.values())
                counter = {"+": 0, "-": 0}
                else:
                counter[edit_code] += 1
                distance += max(counter.values())
                return distance


                generators



                A smaller, less useful variation, is to let this method be a generator, and use the builtin sum to do the summary. this saves 1 variable inside the function:



                def levenshtein_distance_gen(str1, str2, ):
                counter = {"+": 0, "-": 0}
                for edit_code, *_ in ndiff(str1, str2):
                if edit_code == " ":
                yield max(counter.values())
                counter = {"+": 0, "-": 0}
                else:
                counter[edit_code] += 1
                yield max(counter.values())

                sum(levenshtein_distance_gen(str1, str2))




                timings



                The differences in timings between the original and both these variations are minimal, and within the variation of results. This is rather logical, since for simple strings (aaabbbc and abcabcabc) 90% of the time is spent in ndiff






                share|improve this answer









                $endgroup$



                The code itself is rather clear. There are some smaller changes I would make



                tuple unpacking



                You can use tuple unpacking to do:



                for code, *_ in ndiff(str1, str2):


                instead of:



                for x in ndiff(str_1, str_2):
                code = x[0]


                dict results:



                Instead of a counter for the additions and removals, I would keep it in 1 dict: counter = ({"+": 0, "-": 0})



                def levenshtein_distance(str1, str2, ):
                counter = {"+": 0, "-": 0}
                distance = 0
                for edit_code, *_ in ndiff(str1, str2):
                if edit_code == " ":
                distance += max(counter.values())
                counter = {"+": 0, "-": 0}
                else:
                counter[edit_code] += 1
                distance += max(counter.values())
                return distance


                generators



                A smaller, less useful variation, is to let this method be a generator, and use the builtin sum to do the summary. this saves 1 variable inside the function:



                def levenshtein_distance_gen(str1, str2, ):
                counter = {"+": 0, "-": 0}
                for edit_code, *_ in ndiff(str1, str2):
                if edit_code == " ":
                yield max(counter.values())
                counter = {"+": 0, "-": 0}
                else:
                counter[edit_code] += 1
                yield max(counter.values())

                sum(levenshtein_distance_gen(str1, str2))




                timings



                The differences in timings between the original and both these variations are minimal, and within the variation of results. This is rather logical, since for simple strings (aaabbbc and abcabcabc) 90% of the time is spent in ndiff







                share|improve this answer












                share|improve this answer



                share|improve this answer










                answered 15 hours ago









                Maarten FabréMaarten Fabré

                5,139517




                5,139517






















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










                    draft saved

                    draft discarded


















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













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












                    Kyra_W 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%2f217065%2fcalculate-levenshtein-distance-between-two-strings-in-python%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

                    El tren de la libertad Índice Antecedentes "Porque yo decido" Desarrollo de la...

                    Castillo d'Acher Características Menú de navegación

                    Puerta de Hutt Referencias Enlaces externos Menú de navegación15°58′00″S 5°42′00″O /...