Python'da türü kontrol etmenin standart yolu nedir?

Belirli bir nesnenin belirli bir türde olup olmadığını kontrol etmenin en iyi yolu nedir? Nesnenin belirli bir türden miras alıp almadığını kontrol etmeye ne dersiniz?

Diyelim ki bir nesnem var o. Bunun olup olmadığını nasıl kontrol edebilirim str?

Alt sınıfının obir örneği mi, stryoksa herhangi bir alt sınıfı mı olduğunu kontrol etmek striçin isinstance işlevini kullanın (bu "standart" yol olacaktır):

if isinstance(o, str):

Türünün otam olarak olup olmadığını kontrol etmek için str(alt sınıfları hariç tutun):

if type(o) is str:

Aşağıdakiler de çalışır ve bazı durumlarda yararlı olabilir:

if issubclass(type(o), str):

İlgili bilgiler için Python Kütüphanesi Referansındaki Yerleşik İşlevler konusuna bakın .

Bir not daha: bu durumda, Python 2 kullanıyorsanız, aslında aşağıdakileri kullanmak isteyebilirsiniz:

if isinstance(o, basestring):

Bu da Unicode dizeleri yakalayacak (çünkü unicodebir alt sınıfı değildir str; hem strve unicodealt sınıflarıdır basestring). Dizelerin ( ) ve ikili verilerin ( ) sıkı bir şekilde ayrıldığıbasestring Python 3'te artık mevcut olmadığını unutmayın .strbytes

Alternatif olarak, isinstancebir grup dersi kabul eder. Bu dönecektir Trueeğer oherhangi herhangi alt sınıfının bir örneğidir (str, unicode):

if isinstance(o, (str, unicode)):

En nesnenin türünü kontrol etmek Pythonictir yolu bunu kontrol etmek değil ... olduğunu.

Python Ördek Yazmayı teşvik ettiğinden , yalnızca try...exceptnesnenin yöntemlerini kullanmak istediğiniz şekilde kullanmalısınız. Bu nedenle, işleviniz yazılabilir bir dosya nesnesi arıyorsa , bunun bir alt sınıfı olup olmadığını kontrol etmeyinfile , sadece .write()yöntemini kullanmayı deneyin !

Tabii ki, bazen bu güzel soyutlamalar yıkılır ve isinstance(obj, cls)ihtiyacınız olan şeydir. Ancak idareli kullanın.

isinstance(o, str)dönecektir Trueeğer obir olduğunu strya da devralır bir tiptedir str.

type(o) is strTrueyalnızca ostr ise geri döner . Bu dönecektir Falseeğer oo devralır bir tiptedir str.

Soru sorulup cevaplandıktan sonra, Python'a tip ipuçları eklendi . Python'daki tip ipuçları tiplerin kontrol edilmesine izin verir, ancak statik olarak yazılan dillerden çok farklı bir şekilde. Python dilinde yaz ipuçları fonksiyonları ile ilişkili çalışma zamanı erişilebilir veri olarak fonksiyonları ile argümanlar beklenen türlerini ilişkilendirmek ve bu izin verir tipleri kontrol edilecek için. Tip ipucu sözdizimi örneği:

def foo(i: int):
    return i

foo(5)
foo('oops')

Bu durumda foo('oops'), argümanın açıklamalı türü olduğundan bir hatanın tetiklenmesini istiyoruz int. Eklenen tür ipucu , komut dosyası normal olarak çalıştırıldığında bir hata oluşmasına neden olmaz . Ancak, diğer programların sorgulayabileceği ve tür hatalarını denetlemek için kullanabileceği beklenen türleri açıklayan işleve öznitelikler ekler.

Tür hatasını bulmak için kullanılabilecek bu diğer programlardan biri mypy:

mypy script.py
script.py:12: error: Argument 1 to "foo" has incompatible type "str"; expected "int"

( mypyPaket yöneticinizden yüklemeniz gerekebilir . CPython ile geldiğini düşünmüyorum, ancak bir miktar "resmiyet" var gibi görünüyor.)

Bu yolla yazım denetimi, statik olarak yazılan derlenmiş dillerde yazım denetiminden farklıdır. Python'da türler dinamik olduğu için, tür denetlemesi çalışma zamanında yapılmalıdır, bu da her fırsatta ısrar edersek - doğru programlarda bile - bir maliyet oluşturur. Açık tür denetimleri de gerekenden daha kısıtlayıcı olabilir ve gereksiz hatalara neden olabilir (örneğin, argümanın gerçekten tam olarak olması gerekiyor listmu veya yeterli bir şey var mı?).

Açık tip denetiminin tersi, hataları daha erken yakalayabilmesi ve ördek yazımından daha net hata mesajları verebilmesidir. Ördek tipinin kesin gereklilikleri sadece harici belgelerle (umarım eksiksiz ve doğrudur) ifade edilebilir ve uyumsuz tiplerden kaynaklanan hatalar kaynaklandıkları yerden uzakta meydana gelebilir.

Python'un tip ipuçları, tiplerin belirtilebileceği ve kontrol edilebileceği bir uzlaşma sunmak içindir, ancak normal kod yürütme sırasında ek bir maliyet yoktur.

typingTipi ipuçları kullanılabilecek paket teklifler tip değişkenler belirli türleri gerektirmeden gerekli davranışları ifade etmek. Örneğin, bu davranışlara sahip herhangi bir türe duyulan ihtiyacı belirtmek için Iterableve gibi Callableipuçları içeren değişkenler içerir .

Tür ipuçları türleri kontrol etmenin en Pythonic yolu olsa da, türleri hiç kontrol etmemek ve ördek yazımına güvenmek genellikle daha da Pythonic'tir. Tip ipuçları nispeten yenidir ve jüri en Pythonic çözümü olduklarında hala açıktır. Nispeten tartışmalı fakat çok genel bir karşılaştırma: Tür ipuçları, uygulanabilecek, kodun daha erken ve daha kolay anlaşılabilecek hatalar üretmesine izin veren, ördek yazmanın yapamayacağı hataları yakalayabilen ve statik olarak (olağandışı bir şekilde) kontrol edilebilen bir belge biçimi sağlar ama yine de çalışma zamanının dışında). Öte yandan, ördek yazmak uzun zamandır Pythonic yoludur, statik yazmanın bilişsel yükünü dayatmaz, daha az ayrıntılıdır ve tüm uygulanabilir türleri ve sonra bazılarını kabul eder.

Ördek yazmanın neden tehlikeli olduğunu bilmeden kötü olduğu bir örnek. Örneğin: İşte Python kodu (muhtemelen uygun girintiyi atlayan), gerçekten bir ördeğe ihtiyaç duyduğunuzda bomba alamadığınızdan emin olmak için isinstance ve issubclassof işlevlerine dikkat ederek bu durumun önlenebileceğini unutmayın.

class Bomb:
    def __init__(self):
        ""

    def talk(self):
        self.explode()

    def explode(self):
        print "BOOM!, The bomb explodes."

class Duck:
    def __init__(self):
        ""
    def talk(self):
        print "I am a duck, I will not blow up if you ask me to talk."    

class Kid:
    kids_duck = None

    def __init__(self):
        print "Kid comes around a corner and asks you for money so he could buy a duck."

    def takeDuck(self, duck):
        self.kids_duck = duck
        print "The kid accepts the duck, and happily skips along"

    def doYourThing(self):
        print "The kid tries to get the duck to talk"
        self.kids_duck.talk()

myKid = Kid()
myBomb = Bomb()
myKid.takeDuck(myBomb)
myKid.doYourThing()

isinstance(o, str)

Dokümanlara bağlantı

Bence Python gibi dinamik bir dil kullanmanın en güzel yanı, gerçekten böyle bir şeyi kontrol etmek zorunda olmamanızdır.

Sadece nesne üzerinde gerekli yöntemleri çağırmak ve bir yakalamak AttributeError. Daha sonra bu, test etmek için bir nesneyle alay etmek gibi farklı görevleri yerine getirmek için yöntemlerinizi diğer (görünüşte ilgisiz) nesnelerle çağırmanıza izin verecektir.

Bunu web gibi veri alırken urllib2.urlopen()hangi nesneyi dosya gibi döndürür çok kullandım . Bu, read()gerçek bir dosyayla aynı yöntemi uyguladığından, bir dosyadan okunan hemen hemen her yönteme geçirilebilir .

Ama eminim kullanmak için bir zaman ve yer var isinstance(), aksi takdirde muhtemelen orada olmaz :)

Daha karmaşık tür doğrulamaları için , python türü ipucu ek açıklamalarına dayanarak tipguard'ın doğrulama yaklaşımını seviyorum :

from typeguard import check_type
from typing import List

try:
    check_type('mylist', [1, 2], List[int])
except TypeError as e:
    print(e)

Çok temiz ve okunaklı bir şekilde çok karmaşık doğrulama işlemleri yapabilirsiniz.

check_type('foo', [1, 3.14], List[Union[int, float]])
# vs
isinstance(foo, list) and all(isinstance(a, (int, float)) for a in foo) 

Bir değişkenin __name__ işlevini kullanarak bir değişkenin türünü kontrol edebilirsiniz.

Ör:

>>> a = [1,2,3,4]  
>>> b = 1  
>>> type(a).__name__
'list'
>>> type(a).__name__ == 'list'
True
>>> type(b).__name__ == 'list'
False
>>> type(b).__name__
'int'

Hugo'ya:

Muhtemelen listbunun yerine demek istediniz array, ancak bu, tür kontrolüyle ilgili tüm soruna işaret ediyor - söz konusu nesnenin bir liste olup olmadığını bilmek istemiyorsunuz, bunun bir tür sekans mı yoksa tek bir nesne mi olduğunu bilmek istiyorsunuz. Yani bir dizi gibi kullanmaya çalışın.

Nesneyi mevcut bir diziye eklemek istediğinizi veya bir nesne dizisi varsa hepsini ekleyin

try:
   my_sequence.extend(o)
except TypeError:
  my_sequence.append(o)

Bununla ilgili bir hile, dizeler ve / veya diziler dizileriyle çalışıyorsanız - bu bir tizdir, çünkü bir dize genellikle tek bir nesne olarak düşünülür, ancak aynı zamanda bir karakter dizisidir. Bundan daha da kötüsü, gerçekten tek uzunlukta dizelerden oluşan bir dizi.

Genellikle API'mı yalnızca tek bir değeri veya bir diziyi kabul edecek şekilde tasarlamayı tercih ederim - işleri kolaylaştırır. [ ]Gerekirse onu geçtiğinizde tek değerinizin etrafına koymak zor değildir .

(Bu diziler gibi hatalara neden olabilir, ancak diziler gibi görünürler.)

Türü kontrol etmenin basit bir yolu, türünü bildiğiniz bir şeyle karşılaştırmaktır.

>>> a  = 1
>>> type(a) == type(1)
True
>>> b = 'abc'
>>> type(b) == type('')
True

Bence en iyi yol değişkenlerinizi iyi yazmaktır. Bunu "yazarak" kitaplığını kullanarak yapabilirsiniz.

Misal:

from typing import NewType UserId = NewType ('UserId', int) some_id = UserId (524313) '

Bkz. Https://docs.python.org/3/library/typing.html

Verilen değerin hangi karakter tipinde olduğunu kontrol etmek için aşağıdaki satırla kontrol edebilirsiniz:

def chr_type(chrx):
    if chrx.isalpha()==True:
        return 'alpha'
    elif chrx.isdigit()==True:
        return 'numeric'
    else:
        return 'nothing'

chr_type("12)