วิธีการตรวจสอบว่าวัตถุเป็นรายการหรือ tuple (แต่ไม่ใช่สตริง)?

นี่คือสิ่งที่ผมทำตามปกติในการสั่งซื้อเพื่อให้แน่ใจว่าการป้อนข้อมูลที่เป็นlist/ tuple- strแต่ไม่ได้เป็น เพราะหลายครั้งที่ผมเจอข้อบกพร่องที่ฟังก์ชั่นผ่านstrวัตถุโดยไม่ได้ตั้งใจและฟังก์ชั่นเป้าหมายไม่for x in lstสมมติว่าlstเป็นจริงหรือlisttuple

assert isinstance(lst, (list, tuple))

คำถามของฉันคือ: มีวิธีที่ดีกว่าในการบรรลุเป้าหมายนี้หรือไม่?

ในงูหลาม 2 เท่านั้น (ไม่ใช่งูหลาม 3):

assert not isinstance(lst, basestring)

เป็นจริงสิ่งที่คุณต้องการมิฉะนั้นคุณจะพลาดในสิ่งต่างๆมากมายซึ่งการกระทำเช่นรายการ แต่ไม่ได้เป็นคลาสย่อยหรือlisttuple

จำไว้ว่าใน Python เราต้องการใช้ "การพิมพ์เป็ด" ดังนั้นสิ่งใดก็ตามที่ทำหน้าที่เหมือนรายการจึงถือว่าเป็นรายการได้ ดังนั้นอย่าตรวจสอบประเภทของรายการเพียงดูว่ามันทำหน้าที่เหมือนกับรายการหรือไม่

แต่สายอักขระทำหน้าที่เหมือนรายการเช่นกันและบ่อยครั้งนั้นไม่ใช่สิ่งที่เราต้องการ มีบางครั้งที่มันเป็นปัญหา! ดังนั้นตรวจสอบสตริงอย่างชัดเจน แต่จากนั้นใช้การพิมพ์เป็ด

นี่คือฟังก์ชั่นที่ฉันเขียนเพื่อความสนุก มันเป็นรุ่นพิเศษrepr()ที่พิมพ์ลำดับใด ๆ ในวงเล็บมุม ('<', '>')

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

นี่คือสะอาดและสง่างามโดยรวม แต่สิ่งที่isinstance()ตรวจสอบทำที่นั่น? นั่นคือการแฮ็ค แต่มันเป็นสิ่งสำคัญ

ฟังก์ชั่นนี้เรียกตัวเองซ้ำในสิ่งที่ทำหน้าที่เหมือนรายการ หากเราไม่ได้จัดการกับสายอักขระโดยเฉพาะมันจะได้รับการปฏิบัติเหมือนเป็นรายการและแยกอักขระทีละตัว แต่แล้วการโทรซ้ำจะพยายามรักษาตัวละครแต่ละตัวเป็นรายการ - และมันก็ใช้ได้ แม้แต่สตริงตัวละครเดียวก็ใช้เป็นรายการได้! ฟังก์ชั่นจะยังคงเรียกตัวเองซ้ำ ๆ จนกว่าจะล้นสแต็ค

ฟังก์ชั่นเช่นนี้ที่ขึ้นอยู่กับการเรียกซ้ำแต่ละครั้งเพื่อแยกแยะงานที่ต้องทำต้องใช้สตริงตัวพิมพ์เล็ก - เพราะคุณไม่สามารถแยกสตริงที่ต่ำกว่าระดับของสตริงอักขระหนึ่งตัวและแม้แต่อันเดียว สตริงอักขระทำหน้าที่เหมือนรายการ

หมายเหตุ: try/ exceptเป็นวิธีที่สะอาดที่สุดในการแสดงเจตนาของเรา แต่ถ้ารหัสนี้มีความสำคัญต่อเวลาเราอาจต้องการแทนที่ด้วยการทดสอบบางประเภทเพื่อดูว่าargเป็นลำดับหรือไม่ แทนที่จะทดสอบประเภทเราควรทดสอบพฤติกรรม ถ้ามันมี.strip()เมธอดมันเป็นสตริงดังนั้นอย่าคิดว่ามันเป็นลำดับ มิฉะนั้นหากสามารถทำดัชนีได้หรือทำซ้ำได้ก็เป็นลำดับ:

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)

แก้ไข: เดิมฉันเขียนข้างต้นด้วยการตรวจสอบ__getslice__()แต่ฉันสังเกตเห็นว่าในcollectionsเอกสารประกอบโมดูลวิธีที่น่าสนใจคือ__getitem__(); มันสมเหตุสมผลแล้วนั่นคือวิธีที่คุณจัดทำดัชนีวัตถุ ที่ดูเหมือนพื้นฐานมากกว่า__getslice__()ดังนั้นฉันเปลี่ยนข้างต้น

H = "Hello"

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

สำหรับ Python 3:

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: ย้ายคอลเลกชั่นคลาสฐานบทคัดย่อไปยังโมดูล collection.abc สำหรับความเข้ากันได้ย้อนหลังพวกเขาจะยังคงมองเห็นได้ในโมดูลนี้เช่นกันจนกระทั่งรุ่น 3.8 ซึ่งจะหยุดทำงาน

สำหรับ Python 2:

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"

Python กับรสชาติของ PHP:

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

โดยทั่วไปแล้วความจริงที่ว่าฟังก์ชั่นที่วนซ้ำวัตถุทำงานกับสตริงเช่นเดียวกับ tuples และรายการมีคุณสมบัติมากกว่าข้อผิดพลาด แน่นอนคุณสามารถใช้isinstanceหรือพิมพ์เป็ดเพื่อตรวจสอบการโต้แย้ง แต่ทำไมคุณควร?

ฟังดูเหมือนเป็นคำถามเชิงโวหาร แต่ไม่ใช่ คำตอบของ "ทำไมฉันควรตรวจสอบประเภทของการโต้แย้ง" อาจจะแนะนำวิธีแก้ไขปัญหาจริงไม่ใช่ปัญหาที่รับรู้ ทำไมข้อผิดพลาดเมื่อส่งผ่านสตริงไปยังฟังก์ชัน นอกจากนี้ถ้ามันเป็นข้อผิดพลาดเมื่อสตริงถูกส่งผ่านไปยังฟังก์ชั่นนี้มันก็เป็นข้อผิดพลาดถ้าอื่น ๆ ที่ไม่ใช่รายการ / tuple iterable ถูกส่งผ่านไปยัง ทำไมหรือทำไมไม่?

ผมคิดว่าคำตอบที่พบบ่อยที่สุดคำถามที่มีแนวโน้มที่จะพัฒนาที่ผู้เขียนจะคาดหวังว่าฟังก์ชั่นการทำงานราวกับว่าพวกเขาต้องการเขียนf("abc") f(["abc"])อาจมีสถานการณ์ที่เหมาะสมกว่าในการปกป้องนักพัฒนาซอฟต์แวร์จากตัวเองมากกว่าที่จะรองรับกรณีการใช้งานการวนซ้ำข้ามอักขระในสตริง แต่ฉันจะคิดให้นานและหนักหน่วงก่อน

ลองใช้วิธีนี้ในการอ่านและแนวทางปฏิบัติที่ดีที่สุด:

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

หวังว่ามันจะช่วย

strวัตถุไม่ได้มี__iter__แอตทริบิวต์

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

เพื่อให้คุณสามารถตรวจสอบ

assert hasattr(x, '__iter__')

และสิ่งนี้จะเพิ่มสิ่งที่ดีAssertionErrorสำหรับวัตถุที่ไม่ทำซ้ำอื่น ๆ ด้วย

แก้ไข: เนื่องจาก Tim กล่าวถึงความคิดเห็นสิ่งนี้จะใช้ได้ใน python 2.x เท่านั้นไม่ใช่ 3.x

นี่ไม่ได้ตั้งใจจะตอบ OP โดยตรง แต่ฉันต้องการแบ่งปันแนวคิดที่เกี่ยวข้อง

ฉันสนใจคำตอบ @steveha ด้านบนมากซึ่งดูเหมือนจะยกตัวอย่างว่าการพิมพ์เป็ดดูเหมือนจะแตก ในความคิดที่สองอย่างไรก็ตามตัวอย่างของเขาแสดงให้เห็นว่าการพิมพ์เป็ดนั้นยากที่จะทำตาม แต่ก็ไม่แนะนำว่าstrควรมีการจัดการเป็นพิเศษ

strท้ายที่สุดแล้วชนิดที่ไม่ใช่(เช่นชนิดที่ผู้ใช้กำหนดเองที่รักษาโครงสร้างแบบเรียกซ้ำที่ซับซ้อน) อาจทำให้sreprฟังก์ชัน@steveha ทำให้เกิดการเรียกซ้ำแบบไม่สิ้นสุด แม้ว่าสิ่งนี้จะไม่น่ายอมรับ แต่เราก็ไม่สามารถเพิกเฉยต่อความเป็นไปได้นี้ได้ ดังนั้นแทนที่จะพิเศษปลอกstrในsreprเราควรจะชี้แจงสิ่งที่เราต้องการsreprจะทำอย่างไรเมื่อผลการเรียกซ้ำอนันต์

อาจดูเหมือนว่าวิธีการหนึ่งที่สมเหตุสมผลคือการทำลายการสอบถามซ้ำในsreprเวลาlist(arg) == [arg]นั้น นี้จะในความเป็นจริงอย่างสมบูรณ์แก้ปัญหาด้วยโดยไม่ต้องใด ๆstrisinstance

อย่างไรก็ตามโครงสร้างแบบเรียกซ้ำที่ซับซ้อนจริงๆอาจทำให้เกิดการวนซ้ำไม่สิ้นสุดที่list(arg) == [arg]ไม่เคยเกิดขึ้น ดังนั้นในขณะที่การตรวจสอบข้างต้นมีประโยชน์ แต่ก็ไม่เพียงพอ เราต้องการบางสิ่งที่เหมือนขีด จำกัด อย่างหนักต่อความลึกในการเรียกซ้ำ

ประเด็นของฉันคือถ้าคุณวางแผนที่จะจัดการกับชนิดของอาร์กิวเมนท์โดยพลการการจัดการstrผ่านการพิมพ์เป็ดนั้นไกลกว่าการจัดการประเภททั่วไปที่คุณอาจพบเจอ ดังนั้นหากคุณรู้สึกว่าจำเป็นต้องยกเว้นstrอินสแตนซ์คุณควรเรียกร้องให้อาร์กิวเมนต์เป็นตัวอย่างของหนึ่งในไม่กี่ประเภทที่คุณระบุไว้อย่างชัดเจน

ผมพบว่าฟังก์ชั่นที่มีชื่อเช่นis_sequence ใน tensorflow

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

และฉันได้ตรวจสอบแล้วว่ามันตรงกับความต้องการของคุณ

ฉันทำสิ่งนี้ในผลงานของฉัน

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

ฉันคิดว่าคุณถูกปล่อยให้อยู่ใน 'ผลผลิต' ถัดไปหากผ่านไปในเครื่องกำเนิดไฟฟ้า แต่แล้วอีกครั้งนี่คือ 'unittest'

ในลักษณะ "การพิมพ์เป็ด" วิธีการเกี่ยวกับ

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

หรือ

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

ตามลำดับ สิ่งนี้จะหลีกเลี่ยงสิ่งที่isinstance/ hasattrวิปัสสนา

คุณสามารถตรวจสอบในทางกลับกัน:

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

ตัวแปรทั้งหมดไม่ได้เปลี่ยนเนื้อหาของตัวแปร แต่เป็นการกำหนดใหม่ ฉันไม่แน่ใจว่าสิ่งนี้อาจไม่เป็นที่พึงปรารถนาในบางสถานการณ์

ที่น่าสนใจด้วยการมอบหมาย "ในสถานที่" จะ+=ไม่มีการTypeErrorยกในกรณีใด ๆ หากlstเป็นรายการ (ไม่ใช่tuple ) นั่นเป็นสาเหตุที่การบ้านทำแบบนี้ บางทีใครบางคนสามารถทำให้เข้าใจว่าทำไมถึงเป็นเช่นนั้น

วิธีที่ง่ายที่สุด ... ใช้anyและisinstance

>>> 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

รุ่นอื่นของการพิมพ์เป็ดเพื่อช่วยแยกแยะวัตถุที่มีลักษณะคล้ายสตริงออกจากวัตถุที่มีลำดับเหมือนกัน

การแทนค่าสตริงของวัตถุที่มีลักษณะคล้ายสตริงนั้นเป็นสตริงเองดังนั้นคุณสามารถตรวจสอบว่าคุณได้รับออบเจ็กต์ที่เท่ากันจากตัวstrสร้างหรือไม่:

# 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)

สิ่งนี้ควรจะใช้ได้กับทุกวัตถุที่เข้ากันได้strและสำหรับวัตถุที่ทำซ้ำได้ทุกชนิด

Python 3 มีสิ่งนี้:

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

ดังนั้นเพื่อตรวจสอบทั้งรายการและสิ่งอันดับมันจะเป็น:

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"

เพิ่งทำสิ่งนี้

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

ในหลาม> 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

ฉันมักจะทำสิ่งนี้ (ถ้าฉันต้องทำจริงๆ):

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