Existe uma maneira de verificar se o tipo de uma variável em python é a string
, como:
isinstance(x,int);
para valores inteiros?
isinstance(True, int) is True
.
isinstance(x,str)
está correto no Python 3 (str é um tipo básico).
Existe uma maneira de verificar se o tipo de uma variável em python é a string
, como:
isinstance(x,int);
para valores inteiros?
isinstance(True, int) is True
.
isinstance(x,str)
está correto no Python 3 (str é um tipo básico).
Respostas:
No Python 2.x, você faria
isinstance(s, basestring)
basestring
é a superclasse abstrata de str
e unicode
. Pode ser usado para testar se um objeto é uma instância de str
ou unicode
.
No Python 3.x, o teste correto é
isinstance(s, str)
A bytes
classe não é considerada um tipo de string no Python 3.
unicode
objetos, que também devem ser considerados strings. Tanto o tipo str
quanto o tipo unicode
têm a classe base comum basestring
, e é isso que você deseja verificar.
basestring = str
.
unicode
no Python 3. Minha recomendação de compatibilidade entre o Python 2 e 3 é usar a biblioteca "six". (Especificamente isintance(s, six.string_types)
neste caso)
Sei que esse é um tópico antigo, mas sendo o primeiro mostrado no google e como não encontro nenhuma resposta satisfatória, deixarei aqui para referência futura:
six é uma biblioteca de compatibilidade Python 2 e 3 que já cobre esse problema. Você pode fazer algo assim:
import six
if isinstance(value, six.string_types):
pass # It's a string !!
Inspecionando o código, é isso que você encontra:
import sys
PY3 = sys.version_info[0] == 3
if PY3:
string_types = str,
else:
string_types = basestring,
value_is_string = isinstance(value, str if sys.version_info[0] >= 3 else basestring)
onde >=
assume que qualquer Python 4+ eventual mantém a str
classe raiz para strings.
No Python 3.x ou Python 2.7.6
if type(x) == str:
==
é explicitamente desencorajada pelo PEP8 e possui várias desvantagens além de ser considerada "unidiomatic", por exemplo, não detecta instâncias de subclasses de str
, que também devem ser consideradas seqüências de caracteres. Se você realmente deseja verificar exatamente o tipo str
e excluir subclasses explicitamente, use type(x) is str
.
O módulo de tipo também existe se você estiver verificando mais do que ints e strings. http://docs.python.org/library/types.html
types.StringTypes
,.
Edite com base na melhor resposta abaixo. Desça cerca de 3 respostas e descubra a frescura da base.
Resposta antiga: Cuidado com as strings unicode, que você pode obter de vários lugares, incluindo todas as chamadas COM no Windows.
if isinstance(target, str) or isinstance(target, unicode):
isinstance()
também usa uma tupla como segundo argumento. Então, mesmo basestring
que não existisse, você poderia apenas usar isinstance(target, (str, unicode))
.
unicode
não parece estar definido:NameError: name 'unicode' is not defined
Como basestring
não está definido no Python3, esse pequeno truque pode ajudar a tornar o código compatível:
try: # check whether python knows about 'basestring'
basestring
except NameError: # no, it doesn't (it's Python3); use 'str' instead
basestring=str
Depois disso, você pode executar o seguinte teste no Python2 e Python3
isinstance(myvar, basestring)
basestring = (str, bytes)
Python 2/3, incluindo unicode
from __future__ import unicode_literals
from builtins import str # pip install future
isinstance('asdf', str) # True
isinstance(u'asdf', str) # True
type('foo')
ser unicode
por padrão no python 2, e a segunda faz str
ser instância de unicode
. Thoses torna o código válido no Python 2 e 3. Obrigado novamente!
Também quero observar que, se você quiser verificar se o tipo de uma variável é um tipo específico, você pode comparar o tipo da variável com o tipo de um objeto conhecido.
Para string, você pode usar este
type(s) == type('')
str
? E as strings unicode, que nem herdam da str
2.x? Use isinstance(s, basestring)
no 2.x ou isinstance(s, str)
no 3.x.
isinstance()
permite subclasses (que também são strings, apenas especializadas), a type('')
chamada extra é redundante quando você pode simplesmente usar str
e os tipos são singletons, por isso type(s) is str
será um teste mais eficiente.
Muitas boas sugestões são fornecidas por outras pessoas aqui, mas não vejo um bom resumo entre plataformas. A seguir, deve ser uma boa introdução para qualquer programa Python:
def isstring(s):
# if we use Python 3
if (sys.version_info[0] >= 3):
return isinstance(s, str)
# we use Python 2
return isinstance(s, basestring)
Nesta função, usamos isinstance(object, classinfo)
para ver se nossa entrada é a str
em Python 3 ou a basestring
em Python 2.
>=
pelo menos.
a = '1000' # also tested for 'abc100', 'a100bc', '100abc'
isinstance(a, str) or isinstance(a, unicode)
retorna True
type(a) in [str, unicode]
retorna True
Aqui está minha resposta para oferecer suporte ao Python 2 e Python 3, juntamente com estes requisitos:
six
ou um módulo compatível semelhante, pois eles tendem a esconder o que está tentando ser alcançado.import sys
PY2 = sys.version_info.major == 2
# Check if string (lenient for byte-strings on Py2):
isinstance('abc', basestring if PY2 else str)
# Check if strictly a string (unicode-string):
isinstance('abc', unicode if PY2 else str)
# Check if either string (unicode-string) or byte-string:
isinstance('abc', basestring if PY2 else (str, bytes))
# Check for byte-string (Py3 and Py2.7):
isinstance('abc', bytes)
Se você não deseja depender de bibliotecas externas, isso funciona tanto para o Python 2.7+ quanto para o Python 3 ( http://ideone.com/uB4Kdc ):
# your code goes here
s = ["test"];
#s = "test";
isString = False;
if(isinstance(s, str)):
isString = True;
try:
if(isinstance(s, basestring)):
isString = True;
except NameError:
pass;
if(isString):
print("String");
else:
print("Not String");
Você pode simplesmente usar a função isinstance para garantir que os dados de entrada sejam de formato string ou unicode . Os exemplos abaixo ajudarão você a entender facilmente.
>>> isinstance('my string', str)
True
>>> isinstance(12, str)
False
>>> isinstance('my string', unicode)
False
>>> isinstance(u'my string', unicode)
True
s = '123'
issubclass(s.__class__, str)
É assim que eu faço:
if type(x) == type(str()):
type(str())
é uma maneira muito indireta de dizer str
. Os tipos são singletons, portanto, type(x) is str
é mais eficiente. isinstance()
deve ser usado, a menos que você tenha boas razões para ignorar subclasses de str
.
Eu tenho visto:
hasattr(s, 'endswith')
>>> thing = 'foo'
>>> type(thing).__name__ == 'str' or type(thing).__name__ == 'unicode'
True
type(thing).__name__ == 'str'
mais type(thing) == str
ou isinstance(thing, str)
? Também unicode
não existe nas versões modernas do Python.