Bir nesnenin bir liste veya grup olup olmadığını nasıl kontrol edebilirim (ancak dize değil)?

Girişin a list/ tuple- olduğunu değil, ancak a olduğunu belirlemek için normalde yaptığım budur str. Çünkü çoğu zaman bir fonksiyonun bir strnesneyi yanlışlıkla geçtiği hatalara rastladım ve hedef fonksiyon bunun aslında bir ya da for x in lstolduğunu varsayar .lstlisttuple

assert isinstance(lst, (list, tuple))

Sorum şu: Bunu başarmanın daha iyi bir yolu var mı?

Yalnızca python 2'de (python 3 değil):

assert not isinstance(lst, basestring)

Eğer istediğiniz aksi takdirde listeleri gibi hareket bir çok şey kaçırmış olacak, fakat alt sınıfları değil aslında ne listya tuple.

Python'da "ördek yazmayı" kullanmak istediğimizi unutmayın. Dolayısıyla liste gibi davranan her şey liste olarak kabul edilebilir. Bu nedenle, bir listenin türünü kontrol etmeyin, liste olarak davranıp davranmadığına bakın.

Ancak dizeler de bir liste gibi davranır ve genellikle istediğimiz bu değildir. Hatta bir sorun olduğu zamanlar var! Bu nedenle, açıkça bir dize olup olmadığını kontrol edin, ancak ördek yazmayı kullanın.

İşte eğlence için yazdığım bir fonksiyon. repr()Köşeli parantez içindeki herhangi bir diziyi ('<', '>') basan özel bir sürümüdür .

def srepr(arg):
    if isinstance(arg, basestring): # Python 3: isinstance(arg, str)
        return repr(arg)
    try:
        return '<' + ", ".join(srepr(x) for x in arg) + '>'
    except TypeError: # catch when for loop fails
        return repr(arg) # not a sequence so just return repr

Bu genel olarak temiz ve zarif. Ama bu isinstance()çek orada ne yapıyor? Bu bir tür hack. Ancak bu çok önemlidir.

Bu işlev, liste gibi davranan her şeyi özyinelemeli olarak çağırır. Dizeyi özel olarak ele almazsak, bir liste gibi ele alınır ve her seferinde bir karakter bölünür. Ama sonra özyinelemeli çağrı her karaktere bir liste gibi davranmaya çalışır - ve işe yarar! Tek karakterli bir dize bile liste olarak çalışır! Yığın taşana kadar işlev özyinelemeli olarak çağrılmaya devam eder.

Yapılacak olan işi parçalayan her özyinelemeli çağrıya bağlı olan bu gibi işlevler, özel durum dizeleri gerektirir - çünkü tek karakterli bir dize ve hatta bir dizenin seviyesinin altındaki bir dizeyi parçalayamazsınız. -character string bir liste gibi davranır.

Not: try/ except, niyetlerimizi ifade etmenin en temiz yoludur. Ancak bu kod bir şekilde zaman açısından kritikse, argbir dizi olup olmadığını görmek için bir tür testle değiştirmek isteyebiliriz . Türü test etmek yerine, muhtemelen davranışları test etmeliyiz. Bir .strip()yöntemi varsa, bir dizedir, bu yüzden bunu bir dizi olarak düşünmeyin; aksi takdirde, dizine eklenebilir veya yinelenebilirse, bu bir sekanstır:

def is_sequence(arg):
    return (not hasattr(arg, "strip") and
            hasattr(arg, "__getitem__") or
            hasattr(arg, "__iter__"))

def srepr(arg):
    if is_sequence(arg):
        return '<' + ", ".join(srepr(x) for x in arg) + '>'
    return repr(arg)

EDIT: Başlangıçta yukarıda bir çek ile yazdım __getslice__()ama collectionsmodül belgelerinde ilginç yöntemin olduğunu fark ettim __getitem__(); bu mantıklıdır, bir nesneyi bu şekilde endekslersiniz. __getslice__()Yukarıdakileri değiştirdiğimden daha temel görünüyor .

H = "Hello"

if type(H) is list or type(H) is tuple:
    ## Do Something.
else
    ## Do Something.

Python 3 için:

import collections.abc

if isinstance(obj, collections.abc.Sequence) and not isinstance(obj, str):
    print("obj is a sequence (list, tuple, etc) but not a string")

3.3 sürümünde değiştirildi: Koleksiyonlar Özet Temel Sınıflar collections.abc modülüne taşındı. Geriye dönük uyumluluk için, çalışmayı durduracağı 3.8 sürümüne kadar bu modülde de görünmeye devam edecektir.

Python 2 için:

import collections

if isinstance(obj, collections.Sequence) and not isinstance(obj, basestring):
    print "obj is a sequence (list, tuple, etc) but not a string or unicode"

PHP tadında Python:

def is_array(var):
    return isinstance(var, (list, tuple))

Genel olarak konuşursak, bir nesne üzerinde yinelenen bir fonksiyonun, dizeler, tuples ve listeler üzerinde çalışması, hatadan daha fazla özelliktir. Kesinlikle edebilirsiniz kullanmak isinstanceveya yazarak ördek bir tartışma kontrol etmek, ama neden olmasın?

Bu retorik bir soru gibi geliyor, ama değil. "Neden argümanın türünü kontrol etmeliyim?" muhtemelen algılanan soruna değil, gerçek soruna bir çözüm önerecektir. Bir dize işleve iletildiğinde neden bir hata oluştu? Ayrıca: bu işleve bir dize geçirildiğinde bir hata ise, başka bir liste dışı / tuple yinelenebilir geçirilmesi de bir hata mıdır? Neden ya da neden olmasın?

Sorunun en yaygın cevabının, muhtemelen yazan geliştiricilerin f("abc")işlevin yazmış gibi davranmasını bekledikleri olduğunu düşünüyorum f(["abc"]). Muhtemelen geliştiricileri kendilerinden korumanın, bir karakter dizisindeki karakterler arasında yineleme kullanma durumunu desteklemekten daha mantıklı olduğu durumlar vardır. Ama önce uzun ve sert düşünürdüm.

Okunabilirlik ve en iyi uygulamalar için bunu deneyin:

Python2

import types
if isinstance(lst, types.ListType) or isinstance(lst, types.TupleType):
    # Do something

Python3

import typing
if isinstance(lst, typing.List) or isinstance(lst, typing.Tuple):
    # Do something

Umarım yardımcı olur.

strNesne bir yok __iter__niteliği

>>> hasattr('', '__iter__')
False 

böylece bir çek yapabilirsin

assert hasattr(x, '__iter__')

ve bu aynı zamanda AssertionErrortekrarlanamayan diğer nesneler için de hoş bir artış sağlayacaktır .

Düzenleme: Tim yorumlarda bahsedildiği gibi, bu sadece python 2.x, 3.x çalışır

Bu doğrudan OP'ye cevap vermek amaçlı değil, ancak ilgili bazı fikirleri paylaşmak istedim.

Ördek yazmanın kırıldığı bir örnek vermiş gibi görünen yukarıdaki @steveha cevabı çok ilgimi çekti. Düşündüm de, ancak, onun örnek o ördek yazarak uygun zordur önerir, ancak bu gelmez değil önermek strherhangi özel işlem hak ediyor.

Sonuçta, strtür olmayan (örneğin, bazı karmaşık özyinelemeli yapıları koruyan kullanıcı tanımlı bir tür) @steveha sreprişlevinin sonsuz özyinelemeye neden olmasına neden olabilir. Kuşkusuz bu pek olası olmasa da, bu olasılığı görmezden gelemeyiz. Bu nedenle, özel Kılıf yerine strde srepr, ne istediğimizi açıklamak gerekir sreprzaman sonsuz tekrarlama sonuçları yapmak.

Makul bir yaklaşımın şu sreprandaki özyinelemeyi kırmak olduğu anlaşılabilir list(arg) == [arg]. Bu, aslında, problemi str, hiç olmadan , tamamen çözecektir isinstance.

Bununla birlikte, gerçekten karmaşık bir özyinelemeli yapı, list(arg) == [arg]asla gerçekleşmeyen yerlerde sonsuz bir döngüye neden olabilir . Bu nedenle, yukarıdaki kontrol yararlı olsa da, yeterli değildir. Özyineleme derinliğinde zor bir sınır gibi bir şeye ihtiyacımız var.

Demek istediğim, rastgele argüman türlerini ele almayı planlıyorsanız, strördek yazarak işlem yapmak (teorik olarak) karşılaşabileceğiniz daha genel türlerden çok daha kolay. Dolayısıyla str, örnekleri dışlama gereksinimi duyuyorsanız, bunun yerine bağımsız değişkenin açıkça belirttiğiniz birkaç türden birinin örneği olmasını talep etmelisiniz.

Tensorflow'da is_sequence adlı böyle bir işlev buluyorum .

def is_sequence(seq):
  """Returns a true if its input is a collections.Sequence (except strings).
  Args:
    seq: an input sequence.
  Returns:
    True if the sequence is a not a string and is a collections.Sequence.
  """
  return (isinstance(seq, collections.Sequence)
and not isinstance(seq, six.string_types))

Ve ihtiyaçlarınızı karşıladığını doğruladım.

Bunu testcaslarımda yapıyorum.

def assertIsIterable(self, item):
    #add types here you don't want to mistake as iterables
    if isinstance(item, basestring): 
        raise AssertionError("type %s is not iterable" % type(item))

    #Fake an iteration.
    try:
        for x in item:
            break;
    except TypeError:
        raise AssertionError("type %s is not iterable" % type(item))

Jeneratörlerde test edilmediğinde, bir jeneratöre aktarılırsa bir sonraki 'verimde' kaldığınızı düşünüyorum, bu da işleri aşağı doğru vidalayabilir. Ama sonra tekrar, bu bir 'unittest'

"Ördek yazarak" şekilde, nasıl olur

try:
    lst = lst + []
except TypeError:
    #it's not a list

veya

try:
    lst = lst + ()
except TypeError:
    #it's not a tuple

sırasıyla. Bu, isinstance/ hasattrintrospection öğelerini önler .

Bunun tersini de kontrol edebilirsiniz:

try:
    lst = lst + ''
except TypeError:
    #it's not (base)string

Tüm varyantlar aslında değişkenin içeriğini değiştirmez, ancak yeniden atama anlamına gelir. Bazı durumlarda bunun istenmeyen olup olmayacağından emin değilim.

İlginçtir ki, "yerinde" atama ile +=hiçbir TypeErroreğer her durumda zam yapılacak lstbir olan liste (bir tanımlama grubu ). Bu yüzden görev bu şekilde yapılır. Belki birisi bunun nedenine ışık tutabilir.

en basit yol ... kullanarak anyveisinstance

>>> console_routers = 'x'
>>> any([isinstance(console_routers, list), isinstance(console_routers, tuple)])
False
>>>
>>> console_routers = ('x',)
>>> any([isinstance(console_routers, list), isinstance(console_routers, tuple)])
True
>>> console_routers = list('x',)
>>> any([isinstance(console_routers, list), isinstance(console_routers, tuple)])
True

Dizgi benzeri nesneleri diğer dizi benzeri nesnelerden ayırmaya yardımcı olan ördek yazmanın başka bir sürümü.

Dize benzeri nesnelerin dize temsili dizenin kendisidir, böylece stryapıcıdan eşit bir nesne alıp almadığınızı kontrol edebilirsiniz :

# If a string was passed, convert it to a single-element sequence
if var == str(var):
    my_list = [var]

# All other iterables
else: 
    my_list = list(var)

Bu, strher tür yinelenebilir nesne ile uyumlu ve tüm nesneler için çalışmalıdır .

Python 3'de şunlar bulunur:

from typing import List

def isit(value):
    return isinstance(value, List)

isit([1, 2, 3])  # True
isit("test")  # False
isit({"Hello": "Mars"})  # False
isit((1, 2))  # False

Hem Listeleri hem de Tuples'ı kontrol etmek için:

from typing import List, Tuple

def isit(value):
    return isinstance(value, List) or isinstance(value, Tuple)

assert (type(lst) == list) | (type(lst) == tuple), "Not a valid lst type, cannot be string"

Sadece bunu yap

if type(lst) in (list, tuple):
    # Do stuff

pitonda> 3.6

import collections
isinstance(set(),collections.abc.Container)
True
isinstance([],collections.abc.Container)
True
isinstance({},collections.abc.Container)
True
isinstance((),collections.abc.Container)
True
isinstance(str,collections.abc.Container)
False

Bunu yapma eğilimindeyim (gerçekten, gerçekten yapmam gerekiyorsa):

for i in some_var:
   if type(i) == type(list()):
       #do something with a list
   elif type(i) == type(tuple()):
       #do something with a tuple
   elif type(i) == type(str()):
       #here's your string