Comment vérifier si une chaîne en Python est en ASCII?

Je veux vérifier si une chaîne est en ASCII ou non.

Je suis au courant ord(), cependant quand j'essaye ord('é'), je l'ai TypeError: ord() expected a character, but string of length 2 found. J'ai compris que cela est dû à la façon dont j'ai construit Python (comme expliqué dans ord()la documentation de ).

Existe-t-il un autre moyen de vérifier?

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

Je pense que vous ne posez pas la bonne question ...

Une chaîne en python n'a pas de propriété correspondant à 'ascii', utf-8 ou tout autre encodage. La source de votre chaîne (que vous la lisiez à partir d'un fichier, entrée à partir d'un clavier, etc.) peut avoir codé une chaîne unicode en ascii pour produire votre chaîne, mais c'est là que vous devez rechercher une réponse.

Peut-être la question que vous pouvez poser est: "Cette chaîne est-elle le résultat du codage d'une chaîne unicode en ascii?" - Vous pouvez y répondre en essayant:

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"

Python 3 voies:

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

Pour vérifier, passez la chaîne de test:

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

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

Nouveau dans Python 3.7 ( bpo32677 )

Plus de contrôles ascii fastidieux / inefficaces sur les chaînes, nouvelle méthode / str/ intégrée - vérifiera si les chaînes sont ascii.bytesbytearray.isascii()

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

Ran dans quelque chose comme ça récemment - pour référence future

import chardet

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

que vous pourriez utiliser avec:

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

Vincent Marchetti a la bonne idée, mais str.decodea été déprécié en Python 3. En Python 3, vous pouvez faire le même test avec str.encode:

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

Notez que l'exception que vous souhaitez intercepter est également passée de UnicodeDecodeErrorà UnicodeEncodeError.

Votre question est incorrecte; l'erreur que vous voyez n'est pas le résultat de la façon dont vous avez construit python, mais d'une confusion entre les chaînes d'octets et les chaînes unicode.

Les chaînes d'octets (par exemple "foo", ou "bar", en syntaxe python) sont des séquences d'octets; nombres de 0 à 255. Les chaînes Unicode (par exemple u "foo" ou u'bar ') sont des séquences de points de code Unicode; numéros de 0-1112064. Mais vous semblez intéressé par le caractère é, qui (dans votre terminal) est une séquence multi-octets qui représente un seul caractère.

Au lieu de cela ord(u'é'), essayez ceci:

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

Cela vous indique quelle séquence de points de code "é" représente. Cela peut vous donner [233], ou cela peut vous donner [101, 770].

Au lieu d' chr()inverser cela, il y aunichr() :

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

Ce caractère peut en fait être représenté soit par un ou plusieurs "points de code" unicode, qui eux-mêmes représentent soit des graphèmes soit des caractères. Il s'agit soit de "e avec un accent aigu (c'est-à-dire, point de code 233)", soit de "e" (point de code 101), suivi de "un accent aigu sur le caractère précédent" (point de code 770). Donc, ce même caractère exact peut être présenté comme la structure de données Python u'e\u0301'ou u'\u00e9'.

La plupart du temps, vous ne devriez pas vous soucier de cela, mais cela peut devenir un problème si vous itérez sur une chaîne unicode, car l'itération fonctionne par point de code, et non par caractère décomposable. En d'autres termes, len(u'e\u0301') == 2et len(u'\u00e9') == 1. Si cela vous intéresse, vous pouvez convertir entre les formes composées et décomposées à l'aide de unicodedata.normalize.

Le glossaire Unicode peut être un guide utile pour comprendre certains de ces problèmes, en montrant comment chaque terme spécifique fait référence à une partie différente de la représentation du texte, ce qui est beaucoup plus compliqué que ne le pensent de nombreux programmeurs.

Et si on faisait ça?

import string

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

J'ai trouvé cette question en essayant de déterminer comment utiliser / encoder / décoder une chaîne dont je n'étais pas sûr de l'encodage (et comment échapper / convertir des caractères spéciaux dans cette chaîne).

Ma première étape aurait dû être de vérifier le type de la chaîne - je ne savais pas que je pouvais obtenir de bonnes données sur sa mise en forme à partir des types. Cette réponse a été très utile et est arrivée à la véritable racine de mes problèmes.

Si vous obtenez un grossier et persistant

UnicodeDecodeError: le codec 'ascii' ne peut pas décoder l'octet 0xc3 en position 263: l'ordinal n'est pas dans la plage (128)

en particulier lorsque vous ENCODEZ, assurez-vous que vous n'essayez pas d'Unicode () une chaîne qui EST déjà UNICODE - pour une raison terrible, vous obtenez des erreurs de codec ascii. (Voir aussi la recette Python Kitchen et les documents Python didacticiels pour mieux comprendre à quel point cela peut être terrible.)

Finalement, j'ai déterminé que ce que je voulais faire était le suivant:

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

Le débogage a également été utile en définissant le codage par défaut de mon fichier sur utf-8 (mettez cela au début de votre fichier python):

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

Cela vous permet de tester des caractères spéciaux ('àéç') sans avoir à utiliser leurs échappements Unicode (u '\ xe0 \ xe9 \ xe7').

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

Pour améliorer la solution d'Alexander à partir de Python 2.6 (et dans Python 3.x), vous pouvez utiliser le module d'assistance curses.ascii et utiliser la fonction curses.ascii.isascii () ou diverses autres: https://docs.python.org/2.6/ bibliothèque / curses.ascii.html

from curses import ascii

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

Vous pouvez utiliser la bibliothèque d'expressions régulières qui accepte la définition standard de Posix [[: ASCII:]].

Une piqûre ( str-type) en Python est une série d'octets. Il n'y a aucun moyen de dire simplement en regardant la chaîne si cette série d'octets représente une chaîne ascii, une chaîne dans un jeu de caractères 8 bits comme ISO-8859-1 ou une chaîne codée avec UTF-8 ou UTF-16 ou autre .

Cependant, si vous connaissez l'encodage utilisé, vous pouvez decodetransformer la chaîne en chaîne unicode, puis utiliser une expression régulière (ou une boucle) pour vérifier si elle contient des caractères en dehors de la plage qui vous préoccupe.

Comme la réponse de @ RogerDahl, mais il est plus efficace de court-circuiter en annulant la classe de caractères et en utilisant la recherche au lieu de find_alloumatch .

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

J'imagine qu'une expression régulière est bien optimisée pour cela.

import re

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

Pour inclure une chaîne vide au format ASCII, remplacez +par *.

Pour éviter que votre code ne plante, vous souhaiterez peut-être utiliser un try-exceptpour intercepterTypeErrors

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

Par exemple

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

J'utilise ce qui suit pour déterminer si la chaîne est ascii ou unicode:

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

Utilisez ensuite un bloc conditionnel pour définir la fonction:

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