Проверить тип объекта python

Question

У меня есть метод утилиты для печати списков элементов, который также обрабатывает несколько других вещей (например, удаление символов новой строки и т. Д.). Я хотел бы расширить мою функцию, чтобы я мог передавать строки, и она будет печатать строку так же, как и список. В настоящее время он будет перебирать и печатать каждую строку строки отдельно. Вот пример:

#The function 
def print_content(content): 
#do some modification of the list 
    for i in content: 
     print(i) 
#if I pass in a list, I will get output like: 
>Item 1 
>Item 2 
>Item 3 
#if I pass in a string, I will get output like: 
>I 
>t 
>e 
>m 
> 
>1 
#But I would like it to read: 
>Item 1 

Так что моя идея состояла в том, чтобы проверить, если переменная была строкой, и это было, включить его в список. Однако, если переменная является списком, оставьте ее в покое. Как я могу выполнить это или какие другие способы достичь этой задачи?

Answer 1

Вместо того, чтобы проверять определенные типы (типы), которые многие считают очень «бессовестными», вот общий способ сделать это, который использует метакласс на основе абстрактных базовых классов. Это позволяет вам выборочно определять, какие типы вы хотите считать атомом (без повторения), просто зарегистрировав их независимо от того, находятся ли они в смысле Python или нет. Как показано, он может применяться к существующим классам, а также работает как в Python 2 & 3. Это может показаться большим количеством кода, но может быть добавлено в модуль для простого повторного использования.

на основе ответа на вопрос Correct way to detect sequence parameter?

# metaclass of types to be considered indivisible rather than iterable 
# usage: isinstance(<obj>, Atomic) 
# from https://stackoverflow.com/a/306222/355230 
# to make metaclasses work in both py 2 & 3 see 
#  http://pythonhosted.org/six/#six.with_metaclass 
# (essentially the method used by the decorator is being done manually here) 

import abc # requires Py 2.6+ 
import collections 

class _AtomicBase(object): 
    @classmethod 
    def __subclasshook__(cls, other): 
     return not issubclass(other, collections.Sequence) or NotImplemented 

class Atomic(abc.ABCMeta("NewMeta", (_AtomicBase,), {})): 
    pass 

# use the abstract base class to make strings be considered atomic 
try: 
    basestring 
except NameError: # 'basestring' is undefined, assume Python >= 3 
    Atomic.register(str) # str includes unicode in Py 3, make both Atomic 
    Atomic.register(bytes) # bytes should also be considered Atomic 
else: 
    # basestring is the abstract superclass of both str and unicode types 
    Atomic.register(basestring) # will make both types Atomic 

if __name__ == '__main__': 
    print('[] Atomic? -> {}'.format(isinstance([], Atomic)))  # -> False 
    print('"abc" Atomic? -> {}'.format(isinstance("abc", Atomic))) # -> True 

Answer 2

Хотя ответ Мартино является излишним, на мой взгляд, он делает твердую точку относительно избежать проверки типов. Я бы предложил определить класс, для которого вы четко указываете, как вы хотите сохранить свой список.

#!/usr/bin/python 

class Content(object): 
    def __init__(self): 
     self.content_list = [] 

    def add_string_to_content(self, a_string): 
     self.content_list.append(a_string) 

    def print_content(self): 
     for i in self.content_list: 
      print(i) 

    def append_list_to_content(self, a_list): 
     self.content_list += a_list 

def main(): 
    content_list = ['item 1', 'item 2'] 
    content_string = "item 3" 
    some_content = Content() 
    some_content.append_list_to_content(content_list) 
    some_content.add_string_to_content(content_string) 
    some_content.print_content() 

if __name__ == "__main__": 
    main() 

Выход из которых:

brock@brock-desktop:~/testing$ python test.py 
item 1 
item 2 
item 3 

Можно даже написать небольшой метод синтаксического анализа, который будет принимать строку «пункт 1 пункт 2» и превратить его в [ «пункт 1», " пункт 2 "]. Дело в том, что метод будет содержаться в классе и явно указан, чтобы избежать путаницы.