bir dize bir sayı (float) olup olmadığını nasıl kontrol edebilirim?

oy
1k

bir dize Python bir sayı olarak temsil edilebilir olmadığını kontrol etmek mümkün olan en iyi yolu nedir?

Şu anda elimizde olan işlevdir:

def is_number(s):
    try:
        float(s)
        return True
    except ValueError:
        return False

Hangi çirkin ve yavaş kalmaz, aksak görünüyor. Çağırmadan Ancak ben daha iyi bir yöntem bulamadı floatana işlevinde daha da kötü.

Oluştur 09/12/2008 saat 21:03
kaynak kullanıcı
Diğer dillerde...                            


34 cevaplar

oy
1k

Eğer yerine yüzen (pozitif, imzasız) tamsayılar ayrıştırma arıyoruz, kullanabileceğiniz isdigit()dize nesneler için işlevini.

>>> a = "03523"
>>> a.isdigit()
True
>>> b = "963spam"
>>> b.isdigit()
False

Dize Yöntemleri - isdigit()

Orada çok aşina değilim Unicode dizeleri, bir şey de var Unicode - ondalık / ondalık mı

Cevap 09/12/2008 saat 21:15
kaynak kullanıcı

oy
556

Ki, sadece çirkin ve yavaş

Her iki itiraz ediyorum.

Bir düzenli ifade ya da diğer dize ayrıştırma çirkin ve daha yavaş olacaktır.

Ben çok şey yukarıda daha hızlı olabilir emin değilim. Bu fonksiyon ve döner çağırır. En yaygın durum yığın çerçeveler geniş bir arama olmadan yakalanır çünkü Yakalama çok yükü getirmemektedir / deneyin.

Sorun herhangi bir sayısal dönüştürme fonksiyonu sonuçlarının iki çeşit olmasıdır

  • Bir dizi, sayı geçerli olup olmadığını
  • Bir durum (errno aracılığıyla örneğin) kodu veya istisna geçerli bir numara ayrıştırılır olabileceğini göstermek için.

C (örnek olarak) bu yolları etrafında kesmek. Python açık ve açıkça ortaya koymaktadır.

Bunu yaptığım için kod mükemmel olduğunu düşünüyorum.

Cevap 09/12/2008 saat 21:30
kaynak kullanıcı

oy
62

Eğer dikkate almak isteyebilirsiniz bir istisna vardır: string 'NaN'

Eğer is_number için YANLIŞ dönmek istiyorsanız Python gibi çalışmaz 'NaN' Bu kodu (kimlik sorunları hakkında konuşmak) bir sayı değil bir sayının onun temsil dönüştürür:

>>> float('NaN')
nan

Aksi takdirde, ben şimdi yoğun kullanmak kod parçası için teşekkür ederim aslında gerekir. :)

G.

Cevap 01/09/2010 saat 15:06
kaynak kullanıcı

oy
56

TL; DR en iyi çözümdürs.replace('.','',1).isdigit()

Bazı yaptım kriterler farklı yaklaşımlar karşılaştıran

def is_number_tryexcept(s):
    """ Returns True is string is a number. """
    try:
        float(s)
        return True
    except ValueError:
        return False

import re    
def is_number_regex(s):
    """ Returns True is string is a number. """
    if re.match("^\d+?\.\d+?$", s) is None:
        return s.isdigit()
    return True


def is_number_repl_isdigit(s):
    """ Returns True is string is a number. """
    return s.replace('.','',1).isdigit()

dize bir sayı değilse, hariç-blok oldukça yavaştır. Ama daha önemlisi, deneme-hariç yöntemle doğru bilimsel semboller kolları tek yaklaşımdır.

funcs = [
          is_number_tryexcept, 
          is_number_regex,
          is_number_repl_isdigit
          ]

a_float = '.1234'

print('Float notation ".1234" is not supported by:')
for f in funcs:
    if not f(a_float):
        print('\t -', f.__name__)

Float notasyonu" 0,1234" tarafından desteklenmez:
- is_number_regex

scientific1 = '1.000000e+50'
scientific2 = '1e50'


print('Scientific notation "1.000000e+50" is not supported by:')
for f in funcs:
    if not f(scientific1):
        print('\t -', f.__name__)




print('Scientific notation "1e50" is not supported by:')
for f in funcs:
    if not f(scientific2):
        print('\t -', f.__name__)

Bilimsel gösterim "1.000000e + 50" tarafından desteklenmez:
- is_number_regex
- is_number_repl_isdigit
: Bilimsel gösterimde "1e50" tarafından desteklenmemektedir
is_number_regex -
- is_number_repl_isdigit

DÜZENLEME: benchmark sonuçları

import timeit

test_cases = ['1.12345', '1.12.345', 'abc12345', '12345']
times_n = {f.__name__:[] for f in funcs}

for t in test_cases:
    for f in funcs:
        f = f.__name__
        times_n[f].append(min(timeit.Timer('%s(t)' %f, 
                      'from __main__ import %s, t' %f)
                              .repeat(repeat=3, number=1000000)))

Aşağıdaki fonksiyonlar test edildi nerede

from re import match as re_match
from re import compile as re_compile

def is_number_tryexcept(s):
    """ Returns True is string is a number. """
    try:
        float(s)
        return True
    except ValueError:
        return False

def is_number_regex(s):
    """ Returns True is string is a number. """
    if re_match("^\d+?\.\d+?$", s) is None:
        return s.isdigit()
    return True


comp = re_compile("^\d+?\.\d+?$")    

def compiled_regex(s):
    """ Returns True is string is a number. """
    if comp.match(s) is None:
        return s.isdigit()
    return True


def is_number_repl_isdigit(s):
    """ Returns True is string is a number. """
    return s.replace('.','',1).isdigit()

Burada görüntü açıklama girin

Cevap 13/05/2014 saat 20:28
kaynak kullanıcı

oy
51

buna ne dersin:

'3.14'.replace('.','',1).isdigit()

Bir veya hiç yoktur, sadece hangi gerçek dönecektir. '' basamak dizesinde.

'3.14.5'.replace('.','',1).isdigit()

return false olacak

düzenleme: Sadece bir ekleme ... Başka yorum gördüm .replace(badstuff,'',maxnum_badstuff)diğer durumlar için yapılabilir. Tuzu ve keyfi çeşniler (ref: geçiyoruz xkcd # 974 ) Bu yeterli olacaktır: P

Cevap 25/05/2012 saat 23:22
kaynak kullanıcı

oy
37

Alfe işaret Güncelleme sonrasında karmaşık hem kolları olarak ayrı ayrı şamandıra kontrol etmek gerekmez:

def is_number(s):
    try:
        complex(s) # for int, long, float and complex
    except ValueError:
        return False

    return True

Daha önce sözü: Ayrıca bir şamandıra ile temsil edilemez karmaşık sayılar (örneğin 1 + 2i), kontrol etmek gerekebilir bazı nadir durumlarda mı:

def is_number(s):
    try:
        float(s) # for int, long and float
    except ValueError:
        try:
            complex(s) # for complex
        except ValueError:
            return False

    return True
Cevap 26/07/2010 saat 14:10
kaynak kullanıcı

oy
37

Hangi çirkin ve yavaş kalmaz, aksak görünüyor.

Bu alışmak biraz zaman alabilir, ancak bu bunu yapmanın pythonic yoludur. Zaten belirtildiği gibi, alternatifler kötüdür. polimorfizmi: ama böylesi yapmanın bir diğer avantajı vardır.

ördek yazarak gerisindeki temel düşünce "o yürür ve ördek gibi konuşur, o zaman bir ördek" olmasıdır. Ne sen bir şey şamandıra dönüştürülebilir olmadığını belirlemenize nasıl değiştirebilir böylece dizeyi alt sınıfı için ihtiyacınız olduğuna karar olur? Ya da ne tamamen başka bir nesne test etmeye karar olur? Yukarıdaki kodunu değiştirmek zorunda kalmadan bu şeyler yapabilirsiniz.

Diğer diller arayüzlerini kullanarak bu sorunları çözmek. Ben çözüm başka bir iş parçacığı için daha iyi olduğu analizini kazanırsınız. nokta olsa da, piton denklemin ördek yazarak tarafında kesinlikle olmasıdır ve muhtemelen (Python çok programlama yapmayı planlıyorsanız böyle söz diziminde alışmak zorunda gidiyoruz ama anlamına gelmez siz) elbette hoşlanmak zorunda.

Bir başka şey dikkate almak isteyebilirsiniz: Python atma ve diğer birçok dille (30x örneğin Net daha hızlı) kıyasla durumları yakalamak oldukça hızlı. Heck, dil kendisi bile olmayan istisnai normal program koşulları (eğer döngü için kullanmak her zaman) iletişim kurmak için istisnalar atar. Eğer önemli bir sorun olduğunu fark kadar Dolayısıyla, bu kodun performans yönleri hakkında çok fazla endişe olmaz.

Cevap 11/12/2008 saat 05:56
kaynak kullanıcı

oy
17

Için intkullanılmak bu:

>>> "1221323".isdigit()
True

Ama için floatbazı hileler ihtiyacımız ;-). Her şamandıra numaralı noktası vardır ...

>>> "12.34".isdigit()
False
>>> "12.34".replace('.','',1).isdigit()
True
>>> "12.3.4".replace('.','',1).isdigit()
False

Ayrıca negatif sayılar için sadece eklemek lstrip():

>>> '-12'.lstrip('-')
'12'

Ve şimdi evrensel bir yol olsun:

>>> '-12.34'.lstrip('-').replace('.','',1).isdigit()
True
>>> '.-234'.lstrip('-').replace('.','',1).isdigit()
False
Cevap 08/09/2015 saat 08:42
kaynak kullanıcı

oy
14

Olmayan sayıların dizeleri için, try: except:düzenli ifadeler daha doğrusu yavaştır. Geçerli sayıların dizeleri, normal ifade yavaştır. Yani, uygun yöntem girişine bağlıdır.

Eğer bir performans gelmediğini fark ederseniz, yeni bir üçüncü taraf modülünü denilen kullanabilirsiniz fastnumbers adlı bir işlev sağlar isfloat . Tam açıklama, ben yazarım. Aşağıda zamanlamaları sonuçlarını dahil ettik.


from __future__ import print_function
import timeit

prep_base = '''\
x = 'invalid'
y = '5402'
z = '4.754e3'
'''

prep_try_method = '''\
def is_number_try(val):
    try:
        float(val)
        return True
    except ValueError:
        return False

'''

prep_re_method = '''\
import re
float_match = re.compile(r'[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$').match
def is_number_re(val):
    return bool(float_match(val))

'''

fn_method = '''\
from fastnumbers import isfloat

'''

print('Try with non-number strings', timeit.timeit('is_number_try(x)',
    prep_base + prep_try_method), 'seconds')
print('Try with integer strings', timeit.timeit('is_number_try(y)',
    prep_base + prep_try_method), 'seconds')
print('Try with float strings', timeit.timeit('is_number_try(z)',
    prep_base + prep_try_method), 'seconds')
print()
print('Regex with non-number strings', timeit.timeit('is_number_re(x)',
    prep_base + prep_re_method), 'seconds')
print('Regex with integer strings', timeit.timeit('is_number_re(y)',
    prep_base + prep_re_method), 'seconds')
print('Regex with float strings', timeit.timeit('is_number_re(z)',
    prep_base + prep_re_method), 'seconds')
print()
print('fastnumbers with non-number strings', timeit.timeit('isfloat(x)',
    prep_base + 'from fastnumbers import isfloat'), 'seconds')
print('fastnumbers with integer strings', timeit.timeit('isfloat(y)',
    prep_base + 'from fastnumbers import isfloat'), 'seconds')
print('fastnumbers with float strings', timeit.timeit('isfloat(z)',
    prep_base + 'from fastnumbers import isfloat'), 'seconds')
print()

Try with non-number strings 2.39108395576 seconds
Try with integer strings 0.375686168671 seconds
Try with float strings 0.369210958481 seconds

Regex with non-number strings 0.748660802841 seconds
Regex with integer strings 1.02021503448 seconds
Regex with float strings 1.08564686775 seconds

fastnumbers with non-number strings 0.174362897873 seconds
fastnumbers with integer strings 0.179651021957 seconds
fastnumbers with float strings 0.20222902298 seconds

Gördüğün gibi

  • try: except: Geçersiz bir girdi için sayısal girişi için hızlı ama çok yavaş
  • Giriş geçersiz olduğunda regex çok etkilidir
  • fastnumbers Her iki durumda da kazanır
Cevap 14/08/2014 saat 04:34
kaynak kullanıcı

oy
14

Sadece Taklit C #

C # 'sayısal değerin ayrıştırma işlemek iki farklı işlevleri vardır:

  • Float.Parse ()
  • Float.TryParse ()

) (Float.parse:

def parse(string):
    try:
        return float(string)
    except Exception:
        throw TypeError

Not: Bir TypeError istisna değişti neden merak ediyorsanız, burada dokümantasyon var .

) (Float.try_parse:

def try_parse(string, fail=None):
    try:
        return float(string)
    except Exception:
        return fail;

Not: Bunu hala bir değer tipi çünkü boolean 'Yanlış' dönmek istemiyorum. o başarısızlığını gösterir, çünkü hiçbiri daha iyidir. Eğer farklı bir şey istiyorsanız Tabii ki, ne istersen başarısız parametreyi değiştirebilirsiniz.

'Ayrıştırma ()' ve 'try_parse ()' içerecek şekilde şamandıra uzatmak için bu yöntemleri eklemek float sınıfı monkeypatch gerekir.

Eğer önceden varolan işlevlerini saygı istiyorsanız kod gibi bir şey olmalıdır:

def monkey_patch():
    if(!hasattr(float, 'parse')):
        float.parse = parse
    if(!hasattr(float, 'try_parse')):
        float.try_parse = try_parse

Sidenote: Ben YMMV ama bunu yaparken dil kötüye çıkardığımı hissediyorum çünkü ben şahsen Maymun Delme demeyi tercih.

Kullanımı:

float.parse('giggity') // throws TypeException
float.parse('54.3') // returns the scalar value 54.3
float.tryParse('twank') // returns None
float.tryParse('32.2') // returns the scalar value 32.2

Ve büyük Adaçayı Pythonas "her şey daha iyisini yapabilirim yapabilirim; ben senden daha iyi yapabiliriz.", Vatikan Sharpisus dedi

Cevap 18/02/2012 saat 02:35
kaynak kullanıcı

oy
13

Bu özellikle eski ama ben inanıyorum bir cevap en yüksek bulamayan kimsenin herhangi birine çok değerli olabilir cevap olarak eksik bilgileri kapsar eklersiniz biliyorum:

Eğer herhangi bir giriş gerekiyorsa aşağıdaki yöntemlerden her bir sayısı ile bağlamak için kabul edilecek. (Biz vb vokal tamsayılar tanımlarını yerine 0-255, kullandığınız varsayarak)

x.isdigit() x bir tamsayı olup olmadığını kontrol etmek için iyi çalışır.

x.replace('-','').isdigit() x negatifse kontrol için iyi çalışıyor (Çek - birinci konumda).

x.replace('.','').isdigit() x ondalık ise kontrol için iyi çalışır.

x.replace(':','').isdigit() x oran ise kontrol için iyi çalışır.

x.replace('/','',1).isdigit() x fraksiyon ise kontrol için iyi çalışır.

Cevap 05/01/2016 saat 15:21
kaynak kullanıcı

oy
10

Sen Unicode dizeleri kullanabilirsiniz, onlar ne istediğini sadece yapmak için bir yöntem vardır:

>>> s = u"345"
>>> s.isnumeric()
True

Veya:

>>> s = "345"
>>> u = unicode(s)
>>> u.isnumeric()
True

http://www.tutorialspoint.com/python/string_isnumeric.htm

http://docs.python.org/2/howto/unicode.html

Cevap 04/03/2013 saat 17:12
kaynak kullanıcı

oy
9

şamandıra () özel olarak sadece bu içindir beri yüzer Döküm ve ValueError alıcı, muhtemelen en hızlı yoludur. dizesini ayrıştırma (regex, vb) gerektirir başka bir şey olasılıkla nedeniyle bu işlem için ayarlanmış değil gerçeğine daha yavaş olacaktır. Benim $ 0.02.

Cevap 09/12/2008 saat 21:31
kaynak kullanıcı

oy
8

Lets Eğer dizede basamak olduğunu varsayalım. str = "100949" ve sadece numaraları vardır olmadığını kontrol etmek istiyorum

if str.isdigit():
returns TRUE or FALSE 

isdigit dokümanlar

aksi takdirde yöntem, bir dizede bir rakam oluşumunu bulmak için iyi çalışıyor.

Cevap 13/10/2014 saat 10:17
kaynak kullanıcı

oy
7

Ben en hızlı hangi yöntemin görmek istedi. Genel iyi ve en tutarlı sonuçlar verdiği edildi check_replacefonksiyonu. En hızlı sonuçlar tarafından verildi check_exceptionfonksiyonu, ama sadece ateş istisna vardı - kodunu anlam en verimli olmakla istisna atma havai oldukça büyüktür.

Başarılı bir döküm denetleme örneğin, bu çalışır, doğru tek yöntem olduğuna dikkat edin check_exceptionancak diğer iki test fonksiyonu geçerli bir şamandıra için yanlış döndürür:

huge_number = float('1e+100')

İşte kriter kodudur:

import time, re, random, string

ITERATIONS = 10000000

class Timer:    
    def __enter__(self):
        self.start = time.clock()
        return self
    def __exit__(self, *args):
        self.end = time.clock()
        self.interval = self.end - self.start

def check_regexp(x):
    return re.compile("^\d*\.?\d*$").match(x) is not None

def check_replace(x):
    return x.replace('.','',1).isdigit()

def check_exception(s):
    try:
        float(s)
        return True
    except ValueError:
        return False

to_check = [check_regexp, check_replace, check_exception]

print('preparing data...')
good_numbers = [
    str(random.random() / random.random()) 
    for x in range(ITERATIONS)]

bad_numbers = ['.' + x for x in good_numbers]

strings = [
    ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(random.randint(1,10)))
    for x in range(ITERATIONS)]

print('running test...')
for func in to_check:
    with Timer() as t:
        for x in good_numbers:
            res = func(x)
    print('%s with good floats: %s' % (func.__name__, t.interval))
    with Timer() as t:
        for x in bad_numbers:
            res = func(x)
    print('%s with bad floats: %s' % (func.__name__, t.interval))
    with Timer() as t:
        for x in strings:
            res = func(x)
    print('%s with strings: %s' % (func.__name__, t.interval))

İşte 2017 MacBook Pro 13 Python 2.7.10 ile sonuçlar şöyle:

check_regexp with good floats: 12.688639
check_regexp with bad floats: 11.624862
check_regexp with strings: 11.349414
check_replace with good floats: 4.419841
check_replace with bad floats: 4.294909
check_replace with strings: 4.086358
check_exception with good floats: 3.276668
check_exception with bad floats: 13.843092
check_exception with strings: 15.786169

İşte 2017 MacBook Pro 13 Python 3.6.5 ile sonuçlar şöyle:

check_regexp with good floats: 13.472906000000009
check_regexp with bad floats: 12.977665000000016
check_regexp with strings: 12.417542999999995
check_replace with good floats: 6.011045999999993
check_replace with bad floats: 4.849356
check_replace with strings: 4.282754000000011
check_exception with good floats: 6.039081999999979
check_exception with bad floats: 9.322753000000006
check_exception with strings: 9.952595000000002

İşte 2017 MacBook Pro 13 PYPY 2.7.13 ile sonuçlar şöyle:

check_regexp with good floats: 2.693217
check_regexp with bad floats: 2.744819
check_regexp with strings: 2.532414
check_replace with good floats: 0.604367
check_replace with bad floats: 0.538169
check_replace with strings: 0.598664
check_exception with good floats: 1.944103
check_exception with bad floats: 2.449182
check_exception with strings: 2.200056
Cevap 16/01/2013 saat 07:09
kaynak kullanıcı

oy
6

Yani Nan, sonsuzluğa ve karmaşık sayılar için kontrol hep birlikte koymak için o sonuçlanır (onlar değil ben, yani 1 + 2j, j ile belirtilir görünüyor):

def is_number(s):
    try:
        n=str(float(s))
        if n == "nan" or n=="inf" or n=="-inf" : return False
    except ValueError:
        try:
            complex(s) # for complex
        except ValueError:
            return False
    return True
Cevap 23/03/2012 saat 17:10
kaynak kullanıcı

oy
5

Kodunuz bana iyi göründü.

Belki kod çünkü istisnalar kullanmanın "aksak" olduğunu düşünüyorum? Python programcıları onun düşük performans cezası kod okunabilirliği sayesinde geliştirir zaman özgürce istisnalar kullanma eğiliminde olduğunu unutmayın.

Cevap 11/12/2008 saat 05:03
kaynak kullanıcı

oy
4

Bu cevap dizedir bulmak için örneklerle adım kılavuz olan fonksiyonu adım sağlamaktadır:

  • Pozitif tamsayı
  • Pozitif / Negatif - tamsayı / şamandıra
  • numara için kontrol ederken nasıl "NaN" (sayı değil) dizeleri atmak için?

Dize olup olmadığını kontrol edin pozitif tamsayı

Sen kullanabilir str.isdigit()verilen dize olup olmadığını kontrol etmek pozitif tam sayı.

Numune Sonuçlar:

# For digit
>>> '1'.isdigit()
True
>>> '1'.isalpha()
False

tamsayı / şamandıra - pozitif / negatif olarak dize olup olmadığını kontrol edin

str.isdigit()döndüren Falsedizesi ise negatif sayı veya şamandıra numarası. Örneğin:

# returns `False` for float
>>> '123.3'.isdigit()
False
# returns `False` for negative number
>>> '-123'.isdigit()
False

İsterseniz de kontrol negatif tamsayılar vefloat , o zaman bunu kontrol için özel bir işlevi yazabilirsiniz:

def is_number(n):
    try:
        float(n)   # Type-casting the string to `float`.
                   # If string is not a valid `float`, 
                   # it'll raise `ValueError` exception
    except ValueError:
        return False
    return True

Çalıştır Örnek:

>>> is_number('123')    # positive integer number
True

>>> is_number('123.4')  # positive float number
True

>>> is_number('-123')   # negative integer number
True

>>> is_number('-123.4') # negative `float` number
True

>>> is_number('abc')    # `False` for "some random" string
False

numara için kontrol ederken "NaN" (sayı değil) dizeleri atın

Yukarıdaki fonksiyonları dönecektir Trueonu temsil eden geçerli şamandıra bir sayı değildir "NAN" (Bir sayı değil) çünkü Python için dizesi için. Örneğin:

>>> is_number('NaN')
True

Numarası "NaN" olup olmadığını kontrol etmek için, kullanabileceğiniz math.isnan()gibidir:

>>> import math
>>> nan_num = float('nan')

>>> math.isnan(nan_num)
True

Bunu kontrol için ek kütüphane ithal etmek istemiyorsanız Veya, o zaman sadece kendisi kullanarak karşılaştırarak yoluyla kontrol edebilir ==. Python döndürür Falsezaman nanşamandıra kendisi ile karşılaştırılır. Örneğin:

# `nan_num` variable is taken from above example
>>> nan_num == nan_num
False

Dolayısıyla, yukarıdaki fonksiyon is_numberdöndürmek için güncellenebilir Falseiçin"NaN" gibidir:

def is_number(n):
    is_number = True
    try:
        num = float(n)
        # check for "nan" floats
        is_number = num == num   # or use `math.isnan(num)`
    except ValueError:
        is_number = False
    return is_number

Çalıştır Örnek:

>>> is_number('Nan')   # not a number "Nan" string
False

>>> is_number('nan')   # not a number string "nan" with all lower cased
False

>>> is_number('123')   # positive integer
True

>>> is_number('-123')  # negative integer
True

>>> is_number('-1.12') # negative `float`
True

>>> is_number('abc')   # "some random" string
False

Not: sayı türüne bağlı her kontrol için her operasyon ek yükü ile birlikte gelir. Sürümünü seçin is_numberKendi ihtiyaçlarınıza uygun fonksiyonu.

Cevap 11/02/2018 saat 08:34
kaynak kullanıcı

oy
4

Ben bir dize temel tipleri (şamandıra, int, str, bool) içine dökme olmadığını belirlemek gerekiyordu. Bu oluşturulan internette hiçbir şey bulamıyor sonra:

def str_to_type (s):
    """ Get possible cast type for a string

    Parameters
    ----------
    s : string

    Returns
    -------
    float,int,str,bool : type
        Depending on what it can be cast to

    """    
    try:                
        f = float(s)        
        if "." not in s:
            return int
        return float
    except ValueError:
        value = s.upper()
        if value == "TRUE" or value == "FALSE":
            return bool
        return type(s)

Örnek

str_to_type("true") # bool
str_to_type("6.0") # float
str_to_type("6") # int
str_to_type("6abc") # str
str_to_type(u"6abc") # unicode       

Sen türünü yakalamak ve bunu kullanabilirsiniz

s = "6.0"
type_ = str_to_type(s) # float
f = type_(s) 
Cevap 03/07/2014 saat 18:12
kaynak kullanıcı

oy
4

Bazı hız testi yaptı. Dize ise Diyelim ki muhtemel sayı olması haricinde / deneyin strateji dizedir hızlı possible.If olan olası değildir bir numara olmak ve ilgilendiğiniz Tamsayı çek, bazı testi (isdigit artı başlığı yapmak worths '-'). Eğer şamandıra numarasını kontrol etmek istiyorsanız, kullanmak zorunda hariç / denemek whitout kaçış kodu.

Cevap 12/10/2010 saat 08:43
kaynak kullanıcı

oy
3

aşağıdaki gibi, giriş çekebilir:

a="50" b=50 c=50.1 d="50.1"


1 Genel girişi:

Bu fonksiyonun girdi her şey olabilir!

Verilen değişken sayısal olup olmadığını bulur. Sayısal dizeleri isteğe bağlı bir işaret herhangi bir rakam, isteğe bağlı ondalık kısmı ve opsiyonel üstel kısımdan oluşur. Böylece + 0123.45e6 geçerli bir sayısal değerdir. Onaltılık (örn 0xf4c3b00c) ve ikili (örneğin 0b10100111001) notasyonu izin verilmez.

is_numeric işlevi

import ast
import numbers              
def is_numeric(obj):
    if isinstance(obj, numbers.Number):
        return True
    elif isinstance(obj, str):
        nodes = list(ast.walk(ast.parse(obj)))[1:]
        if not isinstance(nodes[0], ast.Expr):
            return False
        if not isinstance(nodes[-1], ast.Num):
            return False
        nodes = nodes[1:-1]
        for i in range(len(nodes)):
            #if used + or - in digit :
            if i % 2 == 0:
                if not isinstance(nodes[i], ast.UnaryOp):
                    return False
            else:
                if not isinstance(nodes[i], (ast.USub, ast.UAdd)):
                    return False
        return True
    else:
        return False

Ölçek:

>>> is_numeric("54")
True
>>> is_numeric("54.545")
True
>>> is_numeric("0x45")
True

is_float işlevi

Verilen değişken şamandıra olup olmadığını bulur. dizeleri opsiyonel işareti oluşur yüzer, numaraların herhangi ...

import ast

def is_float(obj):
    if isinstance(obj, float):
        return True
    if isinstance(obj, int):
        return False
    elif isinstance(obj, str):
        nodes = list(ast.walk(ast.parse(obj)))[1:]
        if not isinstance(nodes[0], ast.Expr):
            return False
        if not isinstance(nodes[-1], ast.Num):
            return False
        if not isinstance(nodes[-1].n, float):
            return False
        nodes = nodes[1:-1]
        for i in range(len(nodes)):
            if i % 2 == 0:
                if not isinstance(nodes[i], ast.UnaryOp):
                    return False
            else:
                if not isinstance(nodes[i], (ast.USub, ast.UAdd)):
                    return False
        return True
    else:
        return False

Ölçek:

>>> is_float("5.4")
True
>>> is_float("5")
False
>>> is_float(5)
False
>>> is_float("5")
False
>>> is_float("+5.4")
True

nedir ast ?


Eğer değişken içeriği eminseniz 2- Dize :

Kullanım str.isdigit () metodu

>>> a=454
>>> a.isdigit()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'isdigit'
>>> a="454"
>>> a.isdigit()
True

3-sayısal giriş:

int değerini tespit:

>>> isinstance("54", int)
False
>>> isinstance(54, int)
True
>>> 

şamandıra algılamak:

>>> isinstance("45.1", float)
False
>>> isinstance(45.1, float)
True
Cevap 06/10/2018 saat 07:23
kaynak kullanıcı

oy
3

Ryann anlaşılacağı

Eğer bir NaN ve Inf x = şamandıra (ler) için değişiklik hattı için yanlış dönmek istiyorsanız; Dönüş (x == x) ve (x -! 1 = x). Bu Inf ve NaN hariç tüm yüzen için doğru dönmelidir

Yeterince büyük yüzen için, çünkü Ama bu, oldukça işe yaramazsa x-1 == xtrue döndürür. Örneğin,2.0**54 - 1 == 2.0**54

Cevap 29/07/2013 saat 15:08
kaynak kullanıcı

oy
1

Ben de söz fonksiyonu kullanılır, ama yakında "Nan", "Inf" gibi dizeler fark ve sayı olarak kabul edilir varyasyonu bulunuyor. Bu yüzden Girilecek bu tip yanlış dönecek ve "1E3" varyantları başarısız olmayacak senin fonksiyonu, gelişmiş bir versiyonudur teklif:

def is_float(text):
    try:
        float(text)
        # check for nan/infinity etc.
        if text.isalpha():
            return False
        return True
    except ValueError:
        return False
Cevap 15/10/2016 saat 21:11
kaynak kullanıcı

oy
1

Sen normal ifade kullanabilir.

number = raw_input("Enter a number: ")
if re.match(r'^\d+$', number):
    print "It's integer"
    print int(number)
elif re.match(r'^\d+\.\d+$', number):
    print "It's float"
    print float(number)
else:
    print("Please enter a number")
Cevap 23/08/2015 saat 13:22
kaynak kullanıcı

oy
1

Bunu dene.

 def is_number(var):
    try:
       if var == int(var):
            return True
    except Exception:
        return False
Cevap 30/05/2015 saat 17:12
kaynak kullanıcı

oy
1

Ben en çok sezgisel bir şekilde dizeleri ve numaralara verilerin bir koleksiyon dönüştürmek için yani nasıl, bu konuya götürdü bir problem üzerinde çalışıyordu. Elimden gerekli iki şekilde farklı olduğunu orijinal kodu okuduktan sonra fark etti:

1 - dize bir tamsayı temsil eğer bir tamsayı sonucunu istedi

2 - Bir veri yapısı içine sopa bir sayı veya bir dize sonucunu istedi

bu yüzden bu türevi üretmek için orijinal kodu uyarlanmış

def string_or_number(s):
    try:
        z = int(s)
        return z
    except ValueError:
        try:
            z = float(s)
            return z
        except ValueError:
            return s
Cevap 09/11/2014 saat 14:06
kaynak kullanıcı

oy
1

İşte bunu yapmanın benim basit bir yoludur. en Bazı dizeleri arasında döngü ediyorum ve onlar sayılar haline gelmek durumunda bir diziye eklemek istediğiniz diyelim.

try:
    myvar.append( float(string_to_check) )
except:
    continue

Bir numara olarak çıkıyor eğer dize ile yapmak istiyorsan onu operasyonu ile myvar.apppend değiştirin. Fikir şamandıra () işlemini kullanmak ve dize bir sayı olup olmadığını belirlemek için döndürülen hata kullanmaya çalışmaktır.

Cevap 16/07/2009 saat 18:45
kaynak kullanıcı

oy
1

Eğer varsa bilmek istiyorsanız tüm dize bir sayı olarak temsil edilebilir bir Regexp'i kullanmak (ya da belki bir dizeye geri şamandırayı dönüştürmek ve kaynak dizeye karşılaştırmak istersiniz, ama ben tahmin ediyorum çok hızlı değil ).

Cevap 10/12/2008 saat 10:15
kaynak kullanıcı

oy
0

Bu kod regex kullanarak wihtout, üsler, yüzen ve tamsayılar işler.

return True if str1.lstrip('-').replace('.','',1).isdigit() or float(str1) else False
Cevap 16/12/2018 saat 07:12
kaynak kullanıcı

oy
0
import re
def is_number(num):
    pattern = re.compile(r'^[-+]?[-0-9]\d*\.\d*|[-+]?\.?[0-9]\d*$')
    result = pattern.match(num)
    if result:
        return True
    else:
        return False


​>>>: is_number('1')
True

>>>: is_number('111')
True

>>>: is_number('11.1')
True

>>>: is_number('-11.1')
True

>>>: is_number('inf')
False

>>>: is_number('-inf')
False
Cevap 02/08/2018 saat 11:06
kaynak kullanıcı

oy
0

tüm davalarına bakan şu kullanın: -

import re
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.3') 
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '.3')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.3sd')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.3')
Cevap 24/02/2017 saat 11:11
kaynak kullanıcı

oy
0

Giriş değeri bir olup olmadığını kontrol etmek float, bir girdi türünü karşılaştırabilirsinizfloat

def isFloat(s):
    realFloat = 0.1

    if type(s) == type(realFloat):
        return True
    else:
        return False

İade:

False     # s = 5
True      # s = 1.2345

Orijinal yayını aslında döneceğini Trueiçin s = 5bir sayı (tam sayı) olduğu ve bir yayınlayabileceğim intbir karşı floatbir olmadan ValueError. Eğer gerçek bir olduğunu doğrulamak çalışıyorsanız floatbunun yerine sadece bir sayı, bu durumda hesaba gerekir.

Cevap 16/09/2016 saat 05:00
kaynak kullanıcı

oy
0

Sen True ve False daha yararlı değerleri dönerek yararlı bir şekilde istisna tekniğini genelleme yapabiliriz. Örneğin bu fonksiyon dizeleri yuvarlak tırnak koyar ama tek başına numaralarını bırakır. Bu yüzden R. için bazı değişken tanımları yapmak için hızlı ve kirli filtre için sadece ne ihtiyaç vardır

import sys

def fix_quotes(s):
    try:
        float(s)
        return s
    except ValueError:
        return '"{0}"'.format(s)

for line in sys.stdin:
    input = line.split()
    print input[0], '<- c(', ','.join(fix_quotes(c) for c in input[1:]), ')'
Cevap 24/05/2013 saat 22:36
kaynak kullanıcı

oy
-1

Ben de benzer bir sorun var. Bunun yerine bir ISNUMBER fonksiyonunu tanımlamanın, ben yüzer için dizgi listesi, üst düzey açısından olacağını şey dönüştürmek istiyorum:

[ float(s) for s in list if isFloat(s)]

Gerçekten isFloat (ler) işlevlerden şamandıra (ler) ayıramam verilir: Bu iki sonuç aynı işlevi tarafından döndürülen edilmelidir. şamandıra (ler) başarısız olursa, ayrıca, tüm işlem sadece hatalı elemanı göz ardı yerine, başarısız olur. Artı, "0" geçerli bir sayıdır ve listeye dahil edilmelidir. Kötü unsurları dışarı filtre uygularken, 0 dışlamak değil emin olun.

Bu nedenle, yukarıdaki anlama nasılsa şekilde değiştirilmesi gerekir:

  • Listedeki herhangi eleman dönüştürülemez ise, bunu görmezden ve bir özel durum yoktur
  • her eleman için şamandıra (ler) bir defadan fazla arama önlemek (dönüşüm için bir test için başka)
  • Dönüştürülen değeri 0 ise, yine de son listede mevcut olmalıdır

Ben C # 'ın null sayısal türlerinde ilham bir çözüm öneriyoruz. Bu tür dahili sayısal değere sahip ve değer geçerli olup olmadığını gösteren bir boolean ekleyen bir yapı ile temsil edilmektedir:

def tryParseFloat(s):
    try:
        return(float(s), True)
    except:
        return(None, False)

tupleList = [tryParseFloat(x) for x in list]
floats = [v for v,b in tupleList if b]
Cevap 18/03/2018 saat 00:18
kaynak kullanıcı

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more