Un bon moyen d'obtenir le jeu de caractères/de codage d'une réponse HTTP en Python

La recherche d'un moyen facile d'obtenir le jeu de caractères/de codage de l'information d'une réponse HTTP à l'aide de Python urllib2, ou de toute autre bibliothèque Python.

>>> url = 'http://some.url.value'
>>> request = urllib2.Request(url)
>>> conn = urllib2.urlopen(request)
>>> response_encoding = ?

Je sais que c'est parfois présent dans le "Content-Type" de la tête, mais que la tête a d'autres informations, et il est intégré dans une chaîne que j'aurais besoin de l'analyser. Par exemple, le Contenu de l'en-tête de Type retourné par Google est

>>> conn.headers.getheader('content-type')
'text/html; charset=utf-8'

Je pouvais travailler avec cela, mais je ne suis pas sûr de la façon cohérente le format sera. Je suis sûr que c'est possible pour le jeu de caractères à être totalement absente, alors j'aimerais avoir à gérer ce cas de bord. Une sorte de chaîne de l'opération de fractionnement pour obtenir le 'utf-8' de l', il semble comme il est à la mauvaise manière de faire ce genre de chose.

>>> content_type_header = conn.headers.getheader('content-type')
>>> if '=' in content_type_header:
>>>  charset = content_type_header.split('=')[1]

C'est le genre de code qui se sent comme il fait trop de travail. Je suis également pas sûr si cela ne fonctionne pas dans tous les cas. Quelqu'un aurait-il une meilleure façon de le faire?

InformationsquelleAutor Clay Wardell | 2013-01-29

22

Pour analyser l'en-tête http, vous pourriez utiliser cgi.parse_header():
```
_, params = cgi.parse_header('text/html; charset=utf-8')
print params['charset'] # -> utf-8
```
Ou à l'aide de l'objet de réponse:
```
response = urllib2.urlopen('http://example.com')
response_encoding = response.headers.getparam('charset')
# or in Python 3: response.headers.get_content_charset(default)
```
En général, le serveur peut mentir au sujet de l'encodage ou ne pas signaler à tous (valeur par défaut dépend du type de contenu) ou le codage peut être spécifié à l'intérieur du corps de la réponse par exemple, <meta> élément dans les documents html ou en xml de la déclaration pour les documents xml. En dernier recours, le codage peut être deviné à partir du contenu lui-même.

Vous pouvez utiliser demande pour obtenir le texte Unicode:
```
import requests # pip install requests

r = requests.get(url)
unicode_str = r.text # may use `chardet` to auto-detect encoding
```
Ou BeautifulSoup pour parser le html (et de les convertir au format Unicode comme un effet secondaire):
```
from bs4 import BeautifulSoup # pip install beautifulsoup4

soup = BeautifulSoup(urllib2.urlopen(url)) # may use `cchardet` for speed
# ...
```
Ou bs4.UnicodeDammit directement de contenu arbitraire (pas nécessairement html):
```
from bs4 import UnicodeDammit

dammit = UnicodeDammit(b"Sacr\xc3\xa9 bleu!")
print(dammit.unicode_markup)
# -> Sacré bleu!
print(dammit.original_encoding)
# -> utf-8
```
InformationsquelleAutor jfs

Si vous arrive d'être familier avec la Flacon/Werkzeug de développement web de la pile, vous serez heureux de savoir que les Werkzeug bibliothèque a une réponse pour exactement ce genre d'en-tête HTTP de l'analyse, et les comptes pour le cas où le contenu-type n'est pas spécifié à tous, comme vous l'aviez voulu.

 >>> from werkzeug.http import parse_options_header
 >>> import requests
 >>> url = 'http://some.url.value'
 >>> resp = requests.get(url)
 >>> if resp.status_code is requests.codes.ok:
 ...     content_type_header = resp.headers.get('content_type')
 ...     print content_type_header
 'text/html; charset=utf-8'
 >>> parse_options_header(content_type_header) 
 ('text/html', {'charset': 'utf-8'})

Alors que vous pouvez faire:

 >>> content_type_header[1].get('charset')
 'utf-8'

Noter que si charset n'est pas fourni, ceci produira plutôt:

 >>> parse_options_header('text/html')
 ('text/html', {})

Il fonctionne même si vous ne fournissez pas rien, mais une chaîne vide ou dict:

 >>> parse_options_header({})
 ('', {})
 >>> parse_options_header('')
 ('', {})

Ainsi, il semble être EXACTEMENT ce que vous cherchiez! Si vous regardez le code source, vous verrez qu'ils avaient à votre but à l'esprit: https://github.com/mitsuhiko/werkzeug/blob/master/werkzeug/http.py#L320-329

def parse_options_header(value):
    """Parse a ``Content-Type`` like header into a tuple with the content
    type and the options:
    >>> parse_options_header('text/html; charset=utf8')
    ('text/html', {'charset': 'utf8'})
    This should not be used to parse ``Cache-Control`` like headers that use
    a slightly different format.  For these headers use the
    :func:`parse_dict_header` function.
    ...

Espère que cela aide quelqu'un un jour! 🙂

InformationsquelleAutor Brian Peterson

5

La demande bibliothèque rend cela facile:
```
>>> import requests
>>> r = requests.get('http://some.url.value')
>>> r.encoding
'utf-8' # e.g.
```
- À l'exception de codage de détection de demandes est incorrect (balises meta ne sont pas prises en compte), et ils ne sont pas prêts à le corriger (github.com/kennethreitz/requests/issues/1087).
- Veuillez voir ma réponse ici stackoverflow.com/a/52615216/520637, vous pouvez simplement utiliser requests.Response.apparent_encoding.
InformationsquelleAutor dnozay
3

Les jeux de caractères peuvent être spécifiés dans de nombreuses façons, mais c'est souvent fait dans les en-têtes.
```
>>> urlopen('http://www.python.org/').info().get_content_charset()
'utf-8'
>>> urlopen('http://www.google.com/').info().get_content_charset()
'iso-8859-1'
>>> urlopen('http://www.python.com/').info().get_content_charset()
>>> 
```
Que le dernier n'est pas en mesure de spécifier un jeu de caractères de n'importe où, donc get_content_charset() retourné None.
- Il semble que dans les en-têtes http qui peut mentir. <meta charset=..> à l'intérieur d'un document html est plus susceptible d'être sous le contrôle de la personne qui a créé le document de du serveur les en-têtes. Il n'est pas get_content_charset() en Python 2. cgi.parse_header() fonctionne de la même façon sur Python 2 et 3.
- cela fonctionne très bien en python 3 comme une vérification initiale pour le jeu de caractères à partir de l'en-tête d'infos, vous pouvez consulter cette première et si le champ est vide, puis de réaliser les BeautifulSoup contrôle sur le contenu lui-même.
InformationsquelleAutor Cees Timmerman
1

Correctement (c'est à dire dans un navigateur-comme - on ne peut pas faire mieux) le décodage de code html que vous devez prendre en compte:
1. HTTP Content-Type valeur d'en-tête;
2. NOMENCLATURE des marques;
3. <meta> balises dans la page de corps;
4. Différences entre le codage des noms définis utilisés dans le web de codage des noms disponibles en Python stdlib;
5. Comme un dernier recours, si tout le reste échoue, deviner sur la base des statistiques est une option.
Tous les ci-dessus est mise en œuvre dans w3lib.l'encodage.html_to_unicode fonction: il a html_to_unicode(content_type_header, html_body_str, default_encoding='utf8', auto_detect_fun=None) signature et retourne (detected_encoding, unicode_html_content) tuple.

demandes, BeautifulSoup, UnicodeDamnnit, chardet ou flacon de parse_options_header ne sont pas correctes des solutions qu'ils ont tous échoué à certains de ces points.
- Je cherchais une solution qui scanne simplement octets et récupère le codage des balises meta-tags. Vraiment joli!
InformationsquelleAutor Mikhail Korobov
0

C'est ce qui fonctionne parfaitement pour moi.
J'utilise python 2.7 et 3.4
```
print (text.encode('cp850','replace'))
```
InformationsquelleAutor Usama Tahir

Vous devez vous connecter pour publier un commentaire.