Come verificare se una stringa in Python è in ASCII?

Voglio verificare se una stringa è in ASCII o no.

Sono consapevole ord(), tuttavia, quando provo ord('é'), ho TypeError: ord() expected a character, but string of length 2 found. Ho capito che è causato dal modo in cui ho creato Python (come spiegato nella ord()documentazione di ).

C'è un altro modo per verificare?

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

Penso che non stai facendo la domanda giusta ...

Una stringa in Python non ha proprietà corrispondenti a 'ascii', utf-8 o qualsiasi altra codifica. La fonte della tua stringa (sia che tu la legga da un file, l'input da una tastiera, ecc.) Potrebbe aver codificato una stringa unicode in ascii per produrre la tua stringa, ma è lì che devi cercare una risposta.

Forse la domanda che puoi porre è: "Questa stringa è il risultato della codifica di una stringa unicode in ascii?" - A questo puoi rispondere provando:

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

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

Per verificare, passare la stringa di prova:

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

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

Nuovo in Python 3.7 ( bpo32677 )

Niente più controlli ascii noiosi / inefficienti sulle stringhe, nuovo metodo / str/ incorporato - controllerà se le stringhe sono ascii.bytesbytearray.isascii()

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

Mi sono imbattuto in qualcosa di simile di recente - per riferimento futuro

import chardet

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

che potresti usare con:

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

Vincent Marchetti ha l'idea giusta, ma str.decodeè stato deprecato in Python 3. In Python 3 puoi fare lo stesso test con str.encode:

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

Nota che anche l'eccezione che vuoi catturare è cambiata da UnicodeDecodeErrora UnicodeEncodeError.

La tua domanda non è corretta; l'errore che vedi non è il risultato di come hai creato Python, ma di una confusione tra stringhe di byte e stringhe unicode.

Le stringhe di byte (ad es. "Pippo", o "bar", nella sintassi di Python) sono sequenze di ottetti; numeri da 0 a 255. Le stringhe Unicode (ad es. U "foo" o u'bar ') sono sequenze di punti di codice unicode; numeri da 0-1112064. Ma sembra che tu sia interessato al carattere é, che (nel tuo terminale) è una sequenza multi-byte che rappresenta un singolo carattere.

Invece di ord(u'é'), prova questo:

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

Ciò indica quale sequenza di punti di codice "é" rappresenta. Potrebbe darti [233] o potrebbe darti [101, 770].

Invece di chr()invertire questo, c'è unichr():

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

Questo personaggio può effettivamente essere rappresentato da un singolo o multiplo "punti di codice" unicode, che rappresentano essi stessi grafi o caratteri. È "e con un accento acuto (cioè il punto di codice 233)" o "e" (punto di codice 101), seguito da "un accento acuto sul carattere precedente" (punto di codice 770). Quindi questo stesso identico personaggio può essere presentato come la struttura dati di Python u'e\u0301'o u'\u00e9'.

Il più delle volte non dovresti preoccuparti di questo, ma può diventare un problema se stai iterando su una stringa unicode, poiché l'iterazione funziona per punto di codice, non per carattere scomponibile. In altre parole, len(u'e\u0301') == 2e len(u'\u00e9') == 1. Se questo è importante per te, puoi convertire tra forme composte e decomposte utilizzando unicodedata.normalize.

Il Glossario Unicode può essere una guida utile per comprendere alcuni di questi problemi, indicando come ogni termine specifico si riferisce a una parte diversa della rappresentazione del testo, che è molto più complicata di quanto molti programmatori realizzino.

Che ne dici di fare questo?

import string

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

Ho trovato questa domanda mentre provavo a determinare come usare / codificare / decodificare una stringa di cui non ero sicuro della codifica (e come sfuggire / convertire caratteri speciali in quella stringa).

Il mio primo passo avrebbe dovuto essere quello di controllare il tipo di stringa: non mi ero reso conto che avrei potuto ottenere buoni dati sulla sua formattazione dai tipi. Questa risposta è stata molto utile e ha raggiunto la vera radice dei miei problemi.

Se stai diventando scortese e persistente

UnicodeDecodeError: il codec 'ascii' non può decodificare il byte 0xc3 in posizione 263: ordinale non compreso nell'intervallo (128)

in particolare quando stai ENCODING, assicurati di non provare a unicode () una stringa che è già unicode - per qualche motivo terribile, ricevi errori di codec ASCII. (Vedi anche la ricetta di Python Kitchen e i documenti di Python esercitazioni sui per una migliore comprensione di quanto possa essere terribile.)

Alla fine ho deciso che quello che volevo fare era questo:

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

Utile anche nel debug è stato impostare la codifica predefinita nel mio file su utf-8 (mettilo all'inizio del tuo file python):

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

Ciò ti consente di testare caratteri speciali ('àéç') senza dover usare le loro escape unicode (u '\ xe0 \ xe9 \ xe7').

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

Per migliorare la soluzione di Alexander da Python 2.6 (e in Python 3.x) puoi usare il modulo helper curses.ascii e usare la funzione curses.ascii.isascii () o altro: https://docs.python.org/2.6/ biblioteca / curses.ascii.html

from curses import ascii

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

È possibile utilizzare la libreria di espressioni regolari che accetta la definizione standard [[: ASCII:]] di Posix.

Una puntura ( strtipo) in Python è una serie di byte. Non c'è modo di dire semplicemente guardando la stringa se questa serie di byte rappresenta una stringa ASCII, una stringa in un set di caratteri a 8 bit come ISO-8859-1 o una stringa codificata con UTF-8 o UTF-16 o qualsiasi altra cosa .

Tuttavia, se si conosce la codifica utilizzata, è possibile inserire decodestr in una stringa unicode e quindi utilizzare un'espressione regolare (o un ciclo) per verificare se contiene caratteri al di fuori dell'intervallo di cui si è preoccupati.

Come la risposta di @ RogerDahl, ma è più efficiente cortocircuitare negando la classe di caratteri e usando la ricerca anziché find_allo 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

Immagino che un'espressione regolare sia ottimizzata per questo.

import re

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

Per includere una stringa vuota come ASCII, modificare +in *.

Per evitare arresti anomali del codice, potresti voler usare a try-exceptper catturareTypeErrors

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

Per esempio

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

Uso quanto segue per determinare se la stringa è ASCII o Unicode:

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

Quindi basta usare un blocco condizionale per definire la funzione:

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