Gibt es eine Möglichkeit, Zahlenwörter in Ganzzahlen umzuwandeln?


75

Ich muss konvertieren onein 1, twoin 2und so weiter.

Gibt es eine Möglichkeit, dies mit einer Bibliothek oder einer Klasse oder etwas anderem zu tun?



Vielleicht wäre dies hilfreich: pastebin.com/WwFCjYtt
alvas

2
Wenn noch jemand nach einer Antwort darauf sucht, habe ich mich von allen folgenden Antworten inspirieren lassen und ein Python-Paket erstellt: github.com/careless25/text2digits
stackErr

Ich habe die folgenden Beispiele verwendet, um diesen Prozess zu entwickeln und zu erweitern, aber auf Spanisch, um später darauf
zurückgreifen

Antworten:


118

Der Großteil dieses Codes besteht darin, das Nummernwort-Diktat einzurichten, das nur beim ersten Aufruf ausgeführt wird.

def text2int(textnum, numwords={}):
    if not numwords:
      units = [
        "zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
        "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
        "sixteen", "seventeen", "eighteen", "nineteen",
      ]

      tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]

      scales = ["hundred", "thousand", "million", "billion", "trillion"]

      numwords["and"] = (1, 0)
      for idx, word in enumerate(units):    numwords[word] = (1, idx)
      for idx, word in enumerate(tens):     numwords[word] = (1, idx * 10)
      for idx, word in enumerate(scales):   numwords[word] = (10 ** (idx * 3 or 2), 0)

    current = result = 0
    for word in textnum.split():
        if word not in numwords:
          raise Exception("Illegal word: " + word)

        scale, increment = numwords[word]
        current = current * scale + increment
        if scale > 100:
            result += current
            current = 0

    return result + current

print text2int("seven billion one hundred million thirty one thousand three hundred thirty seven")
#7100031337

Zu Ihrer Information, dies funktioniert nicht mit Daten. Versuchen Sie: print text2int("nineteen ninety six") # 115
Nick Ruiz

20
Die korrekte Schreibweise von 1996 als Zahl in Worten lautet "eintausendneunhundertsechsundneunzig". Wenn Sie Jahre unterstützen möchten, benötigen Sie einen anderen Code.
rekursiv

Es gibt ein Rubinjuwel von Marc Burns, das das macht. Ich habe es kürzlich gegabelt, um jahrelang Unterstützung hinzuzufügen. Sie können Ruby-Code von Python aus aufrufen .
Dimid

Es bricht für 'hundertsechs' Versuch. print (text2int ("hundert und sechs")) .. auch print (text2int ("tausend"))
Harish Kayarohanam

Die korrekte Schreibweise dieser Zahlen ist einhundertsechs und eintausend. Wenn Sie diese Fälle jedoch bearbeiten müssen, können Sie Unterstützung hinzufügen.
rekursiv

19

Ich habe gerade ein Python-Modul für PyPI namens word2number für den genauen Zweck veröffentlicht. https://github.com/akshaynagpal/w2n

Installieren Sie es mit:

pip install word2number

Stellen Sie sicher, dass Ihr Pip auf die neueste Version aktualisiert ist.

Verwendung:

from word2number import w2n

print w2n.word_to_num("two million three thousand nine hundred and eighty four")
2003984

1
Versuchte dein Paket. Würde vorschlagen, Zeichenfolgen wie: "1 million"oder zu behandeln "1M". w2n.word_to_num ("1 Million") gibt einen Fehler aus.
Ray

1
@ Ray Danke, dass du es ausprobiert hast. Können Sie bitte ein Problem bei erhöhen github.com/akshaynagpal/w2n/issues . Sie können auch einen Beitrag leisten, wenn Sie möchten. Andernfalls werde ich mich in der nächsten Version definitiv mit diesem Thema befassen. Danke noch einmal!
Akshaynagpal

11
Robert, bei Open Source-Software geht es darum, dass Menschen sie gemeinsam verbessern. Ich wollte eine Bibliothek und sah, dass die Leute auch eine wollten. So hat es gemacht. Es ist möglicherweise nicht bereit für Systeme auf Produktionsebene oder entspricht nicht den Schlagworten des Lehrbuchs. Aber es funktioniert für den Zweck. Es wäre auch großartig, wenn Sie eine PR einreichen könnten, damit diese für alle Benutzer weiter verbessert werden kann.
Akshaynagpal

macht es Berechnungen? Sagen Sie: neunzehn% siebenundfünfzig? oder ein anderer Betreiber, dh +, 6, * und /
S.Jackson,

Ab sofort nicht @ S.Jackson.
Akshaynagpal

14

Wenn jemand interessiert ist, habe ich eine Version gehackt, die den Rest der Zeichenfolge verwaltet (obwohl sie möglicherweise Fehler enthält, habe ich sie nicht zu oft getestet).

def text2int (textnum, numwords={}):
    if not numwords:
        units = [
        "zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
        "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
        "sixteen", "seventeen", "eighteen", "nineteen",
        ]

        tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]

        scales = ["hundred", "thousand", "million", "billion", "trillion"]

        numwords["and"] = (1, 0)
        for idx, word in enumerate(units):  numwords[word] = (1, idx)
        for idx, word in enumerate(tens):       numwords[word] = (1, idx * 10)
        for idx, word in enumerate(scales): numwords[word] = (10 ** (idx * 3 or 2), 0)

    ordinal_words = {'first':1, 'second':2, 'third':3, 'fifth':5, 'eighth':8, 'ninth':9, 'twelfth':12}
    ordinal_endings = [('ieth', 'y'), ('th', '')]

    textnum = textnum.replace('-', ' ')

    current = result = 0
    curstring = ""
    onnumber = False
    for word in textnum.split():
        if word in ordinal_words:
            scale, increment = (1, ordinal_words[word])
            current = current * scale + increment
            if scale > 100:
                result += current
                current = 0
            onnumber = True
        else:
            for ending, replacement in ordinal_endings:
                if word.endswith(ending):
                    word = "%s%s" % (word[:-len(ending)], replacement)

            if word not in numwords:
                if onnumber:
                    curstring += repr(result + current) + " "
                curstring += word + " "
                result = current = 0
                onnumber = False
            else:
                scale, increment = numwords[word]

                current = current * scale + increment
                if scale > 100:
                    result += current
                    current = 0
                onnumber = True

    if onnumber:
        curstring += repr(result + current)

    return curstring

Beispiel:

 >>> text2int("I want fifty five hot dogs for two hundred dollars.")
 I want 55 hot dogs for 200 dollars.

Es könnte Probleme geben, wenn Sie beispielsweise "200 US-Dollar" haben. Aber das war wirklich rau.


2
Ich nahm dieses und andere Codefragmente von hier und machte es in eine Python-Bibliothek: github.com/careless25/text2digits
stackErr

12

Ich brauchte etwas anderes, da meine Eingabe aus einer Sprach-Text-Konvertierung stammt und die Lösung nicht immer darin besteht, die Zahlen zu summieren. Beispiel: "Meine Postleitzahl ist eins, zwei, drei, vier, fünf" sollte nicht in "Meine Postleitzahl ist 15" konvertiert werden.

Ich nahm Andrews Antwort und optimierte sie, um einige andere Fälle zu behandeln, die als Fehler hervorgehoben wurden, und fügte Unterstützung für Beispiele wie die oben erwähnte Postleitzahl hinzu. Einige grundlegende Testfälle sind unten aufgeführt, aber ich bin sicher, dass noch Verbesserungspotenzial besteht.

def is_number(x):
    if type(x) == str:
        x = x.replace(',', '')
    try:
        float(x)
    except:
        return False
    return True

def text2int (textnum, numwords={}):
    units = [
        'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight',
        'nine', 'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen',
        'sixteen', 'seventeen', 'eighteen', 'nineteen',
    ]
    tens = ['', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety']
    scales = ['hundred', 'thousand', 'million', 'billion', 'trillion']
    ordinal_words = {'first':1, 'second':2, 'third':3, 'fifth':5, 'eighth':8, 'ninth':9, 'twelfth':12}
    ordinal_endings = [('ieth', 'y'), ('th', '')]

    if not numwords:
        numwords['and'] = (1, 0)
        for idx, word in enumerate(units): numwords[word] = (1, idx)
        for idx, word in enumerate(tens): numwords[word] = (1, idx * 10)
        for idx, word in enumerate(scales): numwords[word] = (10 ** (idx * 3 or 2), 0)

    textnum = textnum.replace('-', ' ')

    current = result = 0
    curstring = ''
    onnumber = False
    lastunit = False
    lastscale = False

    def is_numword(x):
        if is_number(x):
            return True
        if word in numwords:
            return True
        return False

    def from_numword(x):
        if is_number(x):
            scale = 0
            increment = int(x.replace(',', ''))
            return scale, increment
        return numwords[x]

    for word in textnum.split():
        if word in ordinal_words:
            scale, increment = (1, ordinal_words[word])
            current = current * scale + increment
            if scale > 100:
                result += current
                current = 0
            onnumber = True
            lastunit = False
            lastscale = False
        else:
            for ending, replacement in ordinal_endings:
                if word.endswith(ending):
                    word = "%s%s" % (word[:-len(ending)], replacement)

            if (not is_numword(word)) or (word == 'and' and not lastscale):
                if onnumber:
                    # Flush the current number we are building
                    curstring += repr(result + current) + " "
                curstring += word + " "
                result = current = 0
                onnumber = False
                lastunit = False
                lastscale = False
            else:
                scale, increment = from_numword(word)
                onnumber = True

                if lastunit and (word not in scales):                                                                                                                                                                                                                                         
                    # Assume this is part of a string of individual numbers to                                                                                                                                                                                                                
                    # be flushed, such as a zipcode "one two three four five"                                                                                                                                                                                                                 
                    curstring += repr(result + current)                                                                                                                                                                                                                                       
                    result = current = 0                                                                                                                                                                                                                                                      

                if scale > 1:                                                                                                                                                                                                                                                                 
                    current = max(1, current)                                                                                                                                                                                                                                                 

                current = current * scale + increment                                                                                                                                                                                                                                         
                if scale > 100:                                                                                                                                                                                                                                                               
                    result += current                                                                                                                                                                                                                                                         
                    current = 0                                                                                                                                                                                                                                                               

                lastscale = False                                                                                                                                                                                                              
                lastunit = False                                                                                                                                                
                if word in scales:                                                                                                                                                                                                             
                    lastscale = True                                                                                                                                                                                                         
                elif word in units:                                                                                                                                                                                                             
                    lastunit = True

    if onnumber:
        curstring += repr(result + current)

    return curstring

Einige Tests ...

one two three -> 123
three forty five -> 345
three and forty five -> 3 and 45
three hundred and forty five -> 345
three hundred -> 300
twenty five hundred -> 2500
three thousand and six -> 3006
three thousand six -> 3006
nineteenth -> 19
twentieth -> 20
first -> 1
my zip is one two three four five -> my zip is 12345
nineteen ninety six -> 1996
fifty-seventh -> 57
one million -> 1000000
first hundred -> 100
I will buy the first thousand -> I will buy the 1000  # probably should leave ordinal in the string
thousand -> 1000
hundred and six -> 106
1 million -> 1000000

2
Ich habe Ihre Antwort genommen und einige Fehler behoben. Unterstützung für "zehnundzwanzig" -> 2010 und alle zehn im Allgemeinen hinzugefügt. Sie finden es hier: github.com/careless25/text2digits
stackErr

Dies scheint am besten zu funktionieren! Danke @totalhack
user3480922

macht es Berechnungen? Sagen Sie: neunzehn% siebenundfünfzig? oder ein anderer Betreiber, dh +, 6, * und /
S.Jackson,

9

Danke für das Code-Snippet ... hat mir viel Zeit gespart!

Ich musste ein paar zusätzliche Parsing-Fälle behandeln, wie z. B. Ordnungswörter ("erste", "zweite"), getrennte Wörter ("einhundert") und getrennte ordinale Wörter wie ("siebenundfünfzigstes"), also fügte ich hinzu ein paar Zeilen:

def text2int(textnum, numwords={}):
    if not numwords:
        units = [
        "zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
        "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
        "sixteen", "seventeen", "eighteen", "nineteen",
        ]

        tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]

        scales = ["hundred", "thousand", "million", "billion", "trillion"]

        numwords["and"] = (1, 0)
        for idx, word in enumerate(units):  numwords[word] = (1, idx)
        for idx, word in enumerate(tens):       numwords[word] = (1, idx * 10)
        for idx, word in enumerate(scales): numwords[word] = (10 ** (idx * 3 or 2), 0)

    ordinal_words = {'first':1, 'second':2, 'third':3, 'fifth':5, 'eighth':8, 'ninth':9, 'twelfth':12}
    ordinal_endings = [('ieth', 'y'), ('th', '')]

    textnum = textnum.replace('-', ' ')

    current = result = 0
    for word in textnum.split():
        if word in ordinal_words:
            scale, increment = (1, ordinal_words[word])
        else:
            for ending, replacement in ordinal_endings:
                if word.endswith(ending):
                    word = "%s%s" % (word[:-len(ending)], replacement)

            if word not in numwords:
                raise Exception("Illegal word: " + word)

            scale, increment = numwords[word]

         current = current * scale + increment
         if scale > 100:
            result += current
            current = 0

    return result + current`

Hinweis: Gibt Null hundredth, thousandthetc. Einsatz one hundredthbekommen 100!
Rohithpr

4

Hier ist der triviale Fallansatz:

>>> number = {'one':1,
...           'two':2,
...           'three':3,}
>>> 
>>> number['two']
2

Oder suchen Sie etwas, das mit "zwölftausend, einhundertzweiundsiebzig" umgehen kann ?


4

Dies ist die c # -Implementierung des Codes in der ersten Antwort:

public static double ConvertTextToNumber(string text)
{
    string[] units = new string[] {
        "zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
        "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
        "sixteen", "seventeen", "eighteen", "nineteen",
    };

    string[] tens = new string[] {"", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};

    string[] scales = new string[] { "hundred", "thousand", "million", "billion", "trillion" };

    Dictionary<string, ScaleIncrementPair> numWord = new Dictionary<string, ScaleIncrementPair>();
    numWord.Add("and", new ScaleIncrementPair(1, 0));
    for (int i = 0; i < units.Length; i++)
    {
        numWord.Add(units[i], new ScaleIncrementPair(1, i));
    }

    for (int i = 1; i < tens.Length; i++)
    {
        numWord.Add(tens[i], new ScaleIncrementPair(1, i * 10));                
    }

    for (int i = 0; i < scales.Length; i++)
    {
        if(i == 0)
            numWord.Add(scales[i], new ScaleIncrementPair(100, 0));
        else
            numWord.Add(scales[i], new ScaleIncrementPair(Math.Pow(10, (i*3)), 0));
    }

    double current = 0;
    double result = 0;

    foreach (var word in text.Split(new char[] { ' ', '-', '—'}))
    {
        ScaleIncrementPair scaleIncrement = numWord[word];
        current = current * scaleIncrement.scale + scaleIncrement.increment;
        if (scaleIncrement.scale > 100)
        {
            result += current;
            current = 0;
        }
    }
    return result + current;
}


public struct ScaleIncrementPair
{
    public double scale;
    public int increment;
    public ScaleIncrementPair(double s, int i)
    {
        scale = s;
        increment = i;
    }
}

Dies ist, was mir gefällt - Erweiterungen von Antworten zu sehen, die sich auf verschiedene Arten erweitern, um dieselbe Antwort zu implementieren. Da die Frage bereits beantwortet wurde, würde es nicht schaden, sie in einer Sprache zu implementieren, die der Fragesteller nicht angegeben hat. Aber es tut Menschen helfen , die zusammen kommen , um zu versuchen und den Code zu implementieren. Um zukünftigen Lesern dieses Problems zu helfen, +1

3

Dies kann leicht in ein Wörterbuch fest codiert werden, wenn es eine begrenzte Anzahl von Zahlen gibt, die Sie analysieren möchten.

In etwas komplexeren Fällen möchten Sie dieses Wörterbuch wahrscheinlich automatisch basierend auf der relativ einfachen Zahlengrammatik generieren. Etwas in dieser Richtung (natürlich verallgemeinert ...)

for i in range(10):
   myDict[30 + i] = "thirty-" + singleDigitsDict[i]

Wenn Sie etwas umfangreicheres benötigen, benötigen Sie anscheinend Tools zur Verarbeitung natürlicher Sprache. Dieser Artikel könnte ein guter Ausgangspunkt sein.


2

Schneller und schmutziger Java-Port der C # -Implementierung von e_h (oben). Beachten Sie, dass beide double und nicht int zurückgeben.

public class Text2Double {

    public double Text2Double(String text) {

        String[] units = new String[]{
                "zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
                "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
                "sixteen", "seventeen", "eighteen", "nineteen",
        };

        String[] tens = new String[]{"", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};

        String[] scales = new String[]{"hundred", "thousand", "million", "billion", "trillion"};

        Map<String, ScaleIncrementPair> numWord = new LinkedHashMap<>();
        numWord.put("and", new ScaleIncrementPair(1, 0));


        for (int i = 0; i < units.length; i++) {
            numWord.put(units[i], new ScaleIncrementPair(1, i));
        }

        for (int i = 1; i < tens.length; i++) {
            numWord.put(tens[i], new ScaleIncrementPair(1, i * 10));
        }

        for (int i = 0; i < scales.length; i++) {
            if (i == 0)
                numWord.put(scales[i], new ScaleIncrementPair(100, 0));
            else
                numWord.put(scales[i], new ScaleIncrementPair(Math.pow(10, (i * 3)), 0));
        }

        double current = 0;
        double result = 0;

        for(String word : text.split("[ -]"))
        {
            ScaleIncrementPair scaleIncrement = numWord.get(word);
            current = current * scaleIncrement.scale + scaleIncrement.increment;
            if (scaleIncrement.scale > 100) {
                result += current;
                current = 0;
            }
        }
        return result + current;
    }
}

public class ScaleIncrementPair
{
    public double scale;
    public int increment;

    public ScaleIncrementPair(double s, int i)
    {
        scale = s;
        increment = i;
    }
}

1

Änderung vorgenommen, damit text2int (scale) die korrekte Konvertierung zurückgibt. ZB text2int ("hundert") => 100.

import re

numwords = {}


def text2int(textnum):

    if not numwords:

        units = [ "zero", "one", "two", "three", "four", "five", "six",
                "seven", "eight", "nine", "ten", "eleven", "twelve",
                "thirteen", "fourteen", "fifteen", "sixteen", "seventeen",
                "eighteen", "nineteen"]

        tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", 
                "seventy", "eighty", "ninety"]

        scales = ["hundred", "thousand", "million", "billion", "trillion", 
                'quadrillion', 'quintillion', 'sexillion', 'septillion', 
                'octillion', 'nonillion', 'decillion' ]

        numwords["and"] = (1, 0)
        for idx, word in enumerate(units): numwords[word] = (1, idx)
        for idx, word in enumerate(tens): numwords[word] = (1, idx * 10)
        for idx, word in enumerate(scales): numwords[word] = (10 ** (idx * 3 or 2), 0)

    ordinal_words = {'first':1, 'second':2, 'third':3, 'fifth':5, 
            'eighth':8, 'ninth':9, 'twelfth':12}
    ordinal_endings = [('ieth', 'y'), ('th', '')]
    current = result = 0
    tokens = re.split(r"[\s-]+", textnum)
    for word in tokens:
        if word in ordinal_words:
            scale, increment = (1, ordinal_words[word])
        else:
            for ending, replacement in ordinal_endings:
                if word.endswith(ending):
                    word = "%s%s" % (word[:-len(ending)], replacement)

            if word not in numwords:
                raise Exception("Illegal word: " + word)

            scale, increment = numwords[word]

        if scale > 1:
            current = max(1, current)

        current = current * scale + increment
        if scale > 100:
            result += current
            current = 0

    return result + current

Ich denke, die korrekte englische Schreibweise von 100 ist "einhundert".
rekursiv

@recursive Sie haben absolut Recht, aber der Vorteil dieses Codes ist, dass er "Hundertstel" verarbeitet (vielleicht war es das, was Dawa hervorheben wollte). Nach dem Klang der Beschreibung benötigte der andere ähnliche Code "ein Hundertstel" und das ist nicht immer der häufig verwendete Begriff (z. B. wie in "Sie hat den hundertsten zu verwerfenden Gegenstand ausgewählt")
Neil

1

Es gibt ein Rubinjuwel von Marc Burns, das das macht. Ich habe es kürzlich gegabelt, um jahrelang Unterstützung hinzuzufügen. Sie können Ruby-Code von Python aus aufrufen .

  require 'numbers_in_words'
  require 'numbers_in_words/duck_punch'

  nums = ["fifteen sixteen", "eighty five sixteen",  "nineteen ninety six",
          "one hundred and seventy nine", "thirteen hundred", "nine thousand two hundred and ninety seven"]
  nums.each {|n| p n; p n.in_numbers}

Ergebnisse:
"fifteen sixteen" 1516 "eighty five sixteen" 8516 "nineteen ninety six" 1996 "one hundred and seventy nine" 179 "thirteen hundred" 1300 "nine thousand two hundred and ninety seven" 9297


Bitte rufen Sie keinen Ruby-Code aus Python oder Python-Code aus Ruby auf. Sie sind nah genug, dass so etwas einfach portiert werden sollte.
Yekta

1
Einverstanden, aber bis es portiert ist, ist es besser als nichts, Ruby-Code aufzurufen.
Dimid

Es ist nicht sehr komplex, unter @recursive hat Logik (mit wenigen Codezeilen) bereitgestellt, die verwendet werden kann.
Yekta

Es scheint mir tatsächlich, dass "fünfzehn sechzehn" falsch ist?
PascalVKooten

@yekta Richtig, ich denke, die Antwort von rekursiv ist im Rahmen einer SO-Antwort gut. Das Juwel bietet jedoch ein Komplettpaket mit Tests und anderen Funktionen. Jedenfalls denke ich, dass beide ihren Platz haben.
Dimid

1

Verwenden Sie das Python-Paket: WordToDigits

pip installiere wordtodigits

Es kann Zahlen in Wortform in einem Satz finden und sie dann in das richtige numerische Format konvertieren. Kümmert sich auch um den Dezimalteil, falls vorhanden. Die Wortdarstellung von Zahlen könnte sich an einer beliebigen Stelle in der Passage befinden .

https://pypi.org/project/wordtodigits/


0

Eine schnelle Lösung besteht darin, mit der Datei inflect.py ein Wörterbuch für die Übersetzung zu erstellen .

inflect.py hat eine number_to_words()Funktion, die eine Zahl (z. B. 2) in ihre Wortform (z 'two'. B. ) umwandelt . Leider wird die Umkehrung (die es Ihnen ermöglichen würde, die Route des Übersetzungswörterbuchs zu vermeiden) nicht angeboten. Trotzdem können Sie diese Funktion verwenden, um das Übersetzungswörterbuch zu erstellen:

>>> import inflect
>>> p = inflect.engine()
>>> word_to_number_mapping = {}
>>>
>>> for i in range(1, 100):
...     word_form = p.number_to_words(i)  # 1 -> 'one'
...     word_to_number_mapping[word_form] = i
...
>>> print word_to_number_mapping['one']
1
>>> print word_to_number_mapping['eleven']
11
>>> print word_to_number_mapping['forty-three']
43

Wenn Sie bereit sind, etwas Zeit zu investieren, ist es möglicherweise möglich, die number_to_words()Funktionsweise der Funktion von inflect.py zu untersuchen und Ihren eigenen Code zu erstellen, um dies dynamisch zu tun (ich habe nicht versucht, dies zu tun).


0

Ich nahm die Logik von @ recursive und konvertierte zu Ruby. Ich habe auch die Nachschlagetabelle fest codiert, damit sie nicht so cool ist, aber einem Neuling helfen könnte, zu verstehen, was los ist.

WORDNUMS = {"zero"=> [1,0], "one"=> [1,1], "two"=> [1,2], "three"=> [1,3],
            "four"=> [1,4], "five"=> [1,5], "six"=> [1,6], "seven"=> [1,7], 
            "eight"=> [1,8], "nine"=> [1,9], "ten"=> [1,10], 
            "eleven"=> [1,11], "twelve"=> [1,12], "thirteen"=> [1,13], 
            "fourteen"=> [1,14], "fifteen"=> [1,15], "sixteen"=> [1,16], 
            "seventeen"=> [1,17], "eighteen"=> [1,18], "nineteen"=> [1,19], 
            "twenty"=> [1,20], "thirty" => [1,30], "forty" => [1,40], 
            "fifty" => [1,50], "sixty" => [1,60], "seventy" => [1,70], 
            "eighty" => [1,80], "ninety" => [1,90],
            "hundred" => [100,0], "thousand" => [1000,0], 
            "million" => [1000000, 0]}

def text_2_int(string)
  numberWords = string.gsub('-', ' ').split(/ /) - %w{and}
  current = result = 0
  numberWords.each do |word|
    scale, increment = WORDNUMS[word]
    current = current * scale + increment
    if scale > 100
      result += current
      current = 0
    end
  end
  return result + current
end

Ich wollte mit Saiten umgehen wie two thousand one hundred and forty-six


0

Dieser Code funktioniert für eine Reihe von Daten:

import pandas as pd
mylist = pd.Series(['one','two','three'])
mylist1 = []
for x in range(len(mylist)):
    mylist1.append(w2n.word_to_num(mylist[x]))
print(mylist1)

-3
This code works only for numbers below 99.
both word to Int and int to word.
(for rest need to implement 10-20 lines of code and simple logic. This is just simple code for beginners)


num=input("Enter the number you want to convert : ")
mydict={'1': 'One', '2': 'Two', '3': 'Three', '4': 'Four', '5': 'Five','6': 'Six', '7': 'Seven', '8': 'Eight', '9': 'Nine', '10': 'Ten','11': 'Eleven', '12': 'Twelve', '13': 'Thirteen', '14': 'Fourteen', '15': 'Fifteen', '16': 'Sixteen', '17': 'Seventeen', '18': 'Eighteen', '19': 'Nineteen'}
mydict2=['','','Twenty','Thirty','Fourty','fifty','sixty','Seventy','Eighty','Ninty']
if num.isdigit():
    if(int(num)<20):
        print(" :---> "+mydict[num])
    else:
            var1=int(num)%10
            var2=int(num)/10
            print(" :---> "+mydict2[int(var2)]+mydict[str(var1)])
else:
    num=num.lower();
    dict_w={'one':1,'two':2,'three':3,'four':4,'five':5,'six':6,'seven':7,'eight':8,'nine':9,'ten':10,'eleven':11,'twelve':12,'thirteen':13,'fourteen':14,'fifteen':15,'sixteen':16,'seventeen':'17','eighteen':'18','nineteen':'19'}
    mydict2=['','','twenty','thirty','fourty','fifty','sixty','seventy','eighty','ninty']
    divide=num[num.find("ty")+2:]
    if num:
        if(num in dict_w.keys()):
            print(" :---> "+str(dict_w[num]))
        elif divide=='' :
                for i in range(0, len(mydict2)-1):
                   if mydict2[i] == num:
                      print(" :---> "+str(i*10))
        else :
            str3=0
            str1=num[num.find("ty")+2:]
            str2=num[:-len(str1)]
            for i in range(0, len(mydict2) ):
                if mydict2[i] == str2:
                    str3=i;
            if str2 not in mydict2:
                print("----->Invalid Input<-----")                
            else:
                try:
                    print(" :---> "+str((str3*10)+dict_w[str1]))
                except:
                    print("----->Invalid Input<-----")
    else:
            print("----->Please Enter Input<-----")

1
Bitte erklären Sie, was dieser Code macht und wie er das macht. Auf diese Weise ist Ihre Antwort für diejenigen wertvoller, die das Codieren noch nicht so gut verstehen.
Luuklag

Wenn der Benutzer eine Ziffer als Eingabeprogramm angibt, wird diese in Worten zurückgegeben und umgekehrt, z. B. 5-> fünf und für Fünf-> 5. Das Programm funktioniert für Zahlen unter 100, kann jedoch durch Hinzufügen weniger Codezeilen auf einen beliebigen Bereich erweitert werden.
Shriram Jadhav
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.