Como verificar se uma string em Python está em ASCII?

Quero verificar se uma string está em ASCII ou não.

Estou ciente ord(), no entanto, quando tento ord('é'), tenho TypeError: ord() expected a character, but string of length 2 found. Eu entendi que isso é causado pela maneira como construí o Python (como explicado na ord()documentação de ).

Existe outra maneira de verificar?

def is_ascii(s):
    return all(ord(c) < 128 for c in s)

Eu acho que você não está fazendo a pergunta certa--

Uma cadeia de caracteres em python não possui propriedades correspondentes a 'ascii', utf-8 ou qualquer outra codificação. A fonte da sua string (se você a lê em um arquivo, entrada em um teclado etc.) pode ter codificado uma string unicode em ascii para produzir sua string, mas é aí que você precisa obter uma resposta.

Talvez a pergunta que você possa fazer seja: "Essa string é o resultado da codificação de uma string unicode em ascii?" - Isso você pode responder tentando:

try:
    mystring.decode('ascii')
except UnicodeDecodeError:
    print "it was not a ascii-encoded unicode string"
else:
    print "It may have been an ascii-encoded unicode string"

Maneira Python 3:

isascii = lambda s: len(s) == len(s.encode())

Para verificar, passe na sequência de teste:

str1 = "♥O◘♦♥O◘♦"
str2 = "Python"

print(isascii(str1)) -> will return False
print(isascii(str2)) -> will return True

Novo no Python 3.7 ( bpo32677 )

Chega de verificações ascii cansativas / ineficientes nas strings, novo método str/ bytes/ bytearrayinterno - .isascii()verificará se as strings são ascii.

print("is this ascii?".isascii())
# True

Encontrei algo assim recentemente - para referência futura

import chardet

encoding = chardet.detect(string)
if encoding['encoding'] == 'ascii':
    print 'string is in ascii'

com o qual você pode usar:

string_ascii = string.decode(encoding['encoding']).encode('ascii')

Vincent Marchetti tem a idéia certa, mas str.decodefoi preterido no Python 3. No Python 3, você pode fazer o mesmo teste com str.encode:

try:
    mystring.encode('ascii')
except UnicodeEncodeError:
    pass  # string is not ascii
else:
    pass  # string is ascii

Observe que a exceção que você deseja capturar também mudou de UnicodeDecodeErrorpara UnicodeEncodeError.

Sua pergunta está incorreta; o erro que você vê não é resultado de como você criou python, mas de uma confusão entre cadeias de bytes e cadeias unicode.

Cadeias de bytes (por exemplo, "foo", ou 'bar', na sintaxe python) são sequências de octetos; números de 0 a 255. Strings Unicode (por exemplo, u "foo" ou u'bar ') são sequências de pontos de código unicode; números de 0 a 11202064. Mas você parece estar interessado no caractere é, que (em seu terminal) é uma sequência de vários bytes que representa um único caractere.

Em vez de ord(u'é'), tente o seguinte:

>>> [ord(x) for x in u'é']

Isso indica qual sequência de pontos de código "é" representa. Pode dar a você [233], ou pode dar a você [101, 770].

Em vez de chr()reverter isso, existe unichr():

>>> unichr(233)
u'\xe9'

Na verdade, esse caractere pode ser representado como um ou vários "pontos de código" unicode, que representam grafos ou caracteres. É "e com um sotaque agudo (isto é, ponto de código 233)" ou "e" (ponto de código 101), seguido por "um sotaque agudo do caractere anterior" (ponto de código 770). Portanto, esse mesmo caractere exato pode ser apresentado como a estrutura de dados Python u'e\u0301'ouu'\u00e9' .

Na maioria das vezes, você não precisa se preocupar com isso, mas isso pode se tornar um problema se você estiver iterando sobre uma cadeia unicode, pois a iteração funciona por ponto de código, não por caractere decomponível. Em outras palavras, len(u'e\u0301') == 2e len(u'\u00e9') == 1. Se isso lhe interessa, você pode converter entre formulários compostos e decompostos usando unicodedata.normalize.

O Glossário Unicode pode ser um guia útil para entender alguns desses problemas, apontando como cada termo específico se refere a uma parte diferente da representação do texto, o que é muito mais complicado do que muitos programadores imaginam.

Que tal fazer isso?

import string

def isAscii(s):
    for c in s:
        if c not in string.ascii_letters:
            return False
    return True

Encontrei essa pergunta ao tentar determinar como usar / codificar / decodificar uma string cuja codificação eu não tinha certeza (e como escapar / converter caracteres especiais nessa string).

Meu primeiro passo deveria ter sido verificar o tipo da string - eu não sabia que podia obter bons dados sobre a formatação dos tipos. Esta resposta foi muito útil e chegou à raiz real dos meus problemas.

Se você está sendo grosseiro e persistente

UnicodeDecodeError: o codec 'ascii' não pode decodificar o byte 0xc3 na posição 263: ordinal fora do intervalo (128)

particularmente quando você está codificando, verifique se não está tentando unicode () uma string que já é unicode - por algum motivo terrível, você recebe erros de codec ascii. (Veja também a receita do Python Kitchen e os documentos do Python tutoriais de para entender melhor o quão terrível isso pode ser.)

Eventualmente, eu determinei que o que eu queria fazer era o seguinte:

escaped_string = unicode(original_string.encode('ascii','xmlcharrefreplace'))

Também útil na depuração foi definir a codificação padrão no meu arquivo para utf-8 (coloque isso no início do seu arquivo python):

# -*- coding: utf-8 -*-

Isso permite que você teste caracteres especiais ('àéç') sem precisar usar seus escapes unicode (u '\ xe0 \ xe9 \ xe7').

>>> specials='àéç'
>>> specials.decode('latin-1').encode('ascii','xmlcharrefreplace')
'àéç'

Para melhorar a solução de Alexander do Python 2.6 (e no Python 3.x), você pode usar o módulo auxiliar curses.ascii e a função curses.ascii.isascii () ou várias outras funções: https://docs.python.org/2.6/ library / curses.ascii.html

from curses import ascii

def isascii(s):
    return all(ascii.isascii(c) for c in s)

Você pode usar a biblioteca de expressões regulares que aceita a definição padrão [[: ASCII:]] do Posix.

Uma picada ( str-tipo) no Python é uma série de bytes. Não tem como dizer, apenas olhando para a string, se essa série de bytes representa uma string ascii, uma string em um conjunto de caracteres de 8 bits como ISO-8859-1 ou uma string codificada com UTF-8 ou UTF-16 ou qualquer outra coisa. .

No entanto, se você souber a codificação usada, poderá decodecolocar a string em uma string unicode e, em seguida, usar uma expressão regular (ou um loop) para verificar se ela contém caracteres fora do intervalo que você está preocupado.

Como a resposta de @ RogerDahl, mas é mais eficiente dar um curto-circuito negando a classe de personagem e usando a pesquisa em vez de find_allou match.

>>> import re
>>> re.search('[^\x00-\x7F]', 'Did you catch that \x00?') is not None
False
>>> re.search('[^\x00-\x7F]', 'Did you catch that \xFF?') is not None
True

Imagino que uma expressão regular seja bem otimizada para isso.

import re

def is_ascii(s):
    return bool(re.match(r'[\x00-\x7F]+$', s))

Para incluir uma sequência vazia como ASCII, altere +para *.

Para evitar falhas no código, talvez você queira usar um try-exceptpara capturarTypeErrors

>>> ord("¶")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: ord() expected a character, but string of length 2 found

Por exemplo

def is_ascii(s):
    try:
        return all(ord(c) < 128 for c in s)
    except TypeError:
        return False

Eu uso o seguinte para determinar se a seqüência de caracteres é ascii ou unicode:

>> print 'test string'.__class__.__name__
str
>>> print u'test string'.__class__.__name__
unicode
>>> 

Em seguida, basta usar um bloco condicional para definir a função:

def is_ascii(input):
    if input.__class__.__name__ == "str":
        return True
    return False