Comment puis-je analyser les variables Javascript à l'aide de python?

Le problème: Un site que je suis en train de rassembler des données provenant utilise Javascript pour produire un graphique. Je voudrais être en mesure de tirer les données utilisées dans le graphique, mais je ne suis pas sûr où commencer. Par exemple, les données pourraient être comme suit:

var line1=
[["Wed, 12 Jun 2013 01:00:00 +0000",22.4916114807,"2 sold"],
["Fri, 14 Jun 2013 01:00:00 +0000",27.4950008392,"2 sold"],
["Sun, 16 Jun 2013 01:00:00 +0000",19.5499992371,"1 sold"],
["Tue, 18 Jun 2013 01:00:00 +0000",17.25,"1 sold"],
["Sun, 23 Jun 2013 01:00:00 +0000",15.5420341492,"2 sold"],
["Thu, 27 Jun 2013 01:00:00 +0000",8.79045295715,"3 sold"],
["Fri, 28 Jun 2013 01:00:00 +0000",10,"1 sold"]];

C'est la tarification des données (Date, Prix, Volume). J'ai trouvé une autre question ici - L'analyse des données de la variable d'un js balise à l'aide de python - ce qui suggère que j'utilise JSON et BeautifulSoup, mais je suis pas sûr de la façon de l'appliquer à ce problème particulier, car la mise en forme est légèrement différente. En fait, dans ce problème, le code ressemble plus à python que tout autre type de JSON format du dictionnaire.

Je suppose que j'ai pu lire comme une chaîne de caractères, et ensuite utiliser XPATH et funk de la chaîne de montage afin de le convertir, mais cela semble trop de travail pour quelque chose qui est déjà formaté comme une variable Javascript.

Alors, que puis-je faire ici à tirer de ce type de données organisées de cette variable lors de l'utilisation de python? (Je suis plus familier avec python et BS4)

sauf le saut de ligne après = et la var mot-clé, le reste est valable en python
C'est que le code réel? ou est-il une variable appelée line1 qui est une liste de listes? Si c'est le cas, vous pourriez for list in line1: do_something_with(list[0], list[1], list2])
C'est une variable appelée line1, qui fait partie du contenu de la page sur la charge, et est une liste de listes.
Donc, fondamentalement, c'est une chaîne de caractères d'une variable javascript? Non d'une variable python. Je crains que vous aurez à utiliser une sorte d'analyse de module ou de la bande de la chaîne de tous les textes inutiles et exec(). Après l'utilisation de exec() vous pouvez faire toutes sortes de choses avec elle.
Il n'y a aucun moyen que je peux juste dire quelques analyseur de saisir le contenu de la ligne 1? Cela semble comme il devrait être si simple...

OriginalL'auteur Alex Ketay | 2013-08-21

7

Si votre format est vraiment juste un ou de plusieurs var foo = [JSON array or object literal];, vous pouvez simplement écrire un dotall regex extraire, ensuite d'analyser chacun de JSON. Par exemple:
```
>>> j = '''var line1=
[["Wed, 12 Jun 2013 01:00:00 +0000",22.4916114807,"2 sold"],
["Fri, 14 Jun 2013 01:00:00 +0000",27.4950008392,"2 sold"],
["Sun, 16 Jun 2013 01:00:00 +0000",19.5499992371,"1 sold"],
["Tue, 18 Jun 2013 01:00:00 +0000",17.25,"1 sold"],
["Sun, 23 Jun 2013 01:00:00 +0000",15.5420341492,"2 sold"],
["Thu, 27 Jun 2013 01:00:00 +0000",8.79045295715,"3 sold"],
["Fri, 28 Jun 2013 01:00:00 +0000",10,"1 sold"]];\s*$'''
>>> values = re.findall(r'var.*?=\s*(.*?);', j, re.DOTALL | re.MULTILINE)
>>> for value in values:
...     print(json.loads(value))
[[['Wed, 12 Jun 2013 01:00:00 +0000', 22.4916114807, '2 sold'],
  ['Fri, 14 Jun 2013 01:00:00 +0000', 27.4950008392, '2 sold'],
  ['Sun, 16 Jun 2013 01:00:00 +0000', 19.5499992371, '1 sold'],
  ['Tue, 18 Jun 2013 01:00:00 +0000', 17.25, '1 sold'],
  ['Sun, 23 Jun 2013 01:00:00 +0000', 15.5420341492, '2 sold'],
  ['Thu, 27 Jun 2013 01:00:00 +0000', 8.79045295715, '3 sold'],
  ['Fri, 28 Jun 2013 01:00:00 +0000', 10, '1 sold']]]
```
Bien sûr, cela fait quelques hypothèses:
- Un point-virgule à la fin de la ligne doit être une véritable déclaration de séparateur, pas au milieu d'une chaîne. Ce devrait être à l'abri parce que JS n'a pas de Python-style multiligne chaînes.
- Le code en réalité des points-virgules à la fin de chaque instruction, même si elles sont en option en JS. La plupart du code JS a ces points-virgules, mais il n'est évidemment pas garanti.
- Le tableau et l'objet des littéraux sont vraiment JSON-compatible. Ce n'est certainement pas garanti; par exemple, JS pouvez utiliser les chaînes entre guillemets, mais JSON ne le peuvent pas. Mais il fonctionne pour votre exemple.
- Votre format est vraiment bien défini. Par exemple, si il pourrait y avoir un énoncé comme var line2 = [[1]] + line1; au moyen de votre code, ça va causer des problèmes.
Noter que si les données peuvent contenir des JavaScript littéraux qui ne sont pas tous JSON valide, mais sont tous valides Python littéraux (ce qui n'est pas probable, mais n'est pas impossible non plus), vous pouvez utiliser ast.literal_eval sur eux au lieu de json.loads. Mais je ne le ferais pas, sauf si vous savez ce qui est le cas.

La droite. Je pense que les pages que je suis de grattage sont assez bien formaté, mais avoir un autre line1= quelque part serait vraiment vis les choses.
Vous voulez dire avoir un chien errant line1= quelque part, ou que vous voulez dire avoir line1= sans var avant? L'ancien serait simplement de ne pas correspondre, et être ignorées, ce qui est bien. Ce dernier serait également ne pas correspondre, et être ignorées, mais peut pas bien. Si c'est un problème, vous avez besoin d'un autre regex. Vraiment, la regex n'est pas approprié, sauf si vous pouvez définir clairement votre format d'entrée; si vous êtes juste faire des suppositions sur le format, vous voulez probablement quelque chose de plus souple et plus détaillé, peut-être un véritable analyseur construit en pyparsing.
Il semble que ce projet est assez clairement défini, qui est pourquoi regex travaillé. Cependant, je ne sais pas pour les autres pages que j'ai l'intention de le gratter. Je vais probablement juste utiliser les regex jusqu'à ce que quelque chose se brise et aller de là.
Tant qu'il est approprié de s'exécuter sur un tas de pages, puis de débogage de la regex sur le premier qui échoue, et de répéter ad nauseam, c'est raisonnable.

OriginalL'auteur abarnert
4

D'accord, alors il ya quelques façons de le faire, mais j'ai fini par tout simplement à l'aide d'une expression régulière pour trouver tout ce qui est entre line1= et ;
```
#Read page data as a string
pageData = sock.read()
#set p as regular expression
p = re.compile('(?<=line1=)(.*)(?=;)')
#find all instances of regular expression in pageData
parsed = p.findall(pageData)
#evaluate list as python code => turn into list in python
newParsed = eval(parsed[0])
```
Regex est agréable quand vous avez un bon codage, mais cette méthode est mieux (EDIT: ou pour le pire!) que toutes les autres réponses ici?

EDIT: j'ai finalement utilisé les suivantes:
```
#Read page data as a string
pageData = sock.read()
#set p as regular expression
p = re.compile('(?<=line1=)(.*)(?=;)')
#find all instances of regular expression in pageData
parsed = p.findall(pageData)
#load as JSON instead of using evaluate to prevent risky execution of unknown code
newParsed = json.loads(parsed[0])
```
eval est mauvais pour de nombreuses raisons, il est presque toujours préférable d'utiliser quelque chose de plus restrictive comme json.loads ou ast.literal_eval. Bien sûr, il pourrait être tout à fait sûr et valable tant que le code Python qui arrive à travailler, même si elle n'est pas littérale (comme 'abc' + 'def'), mais vous êtes au moins autant de chances d'une expression qui signifie quelque chose de différent, comme Python ou même fait quelque chose de dangereux. (Imaginez ce qui arriverait si quelqu'un vous donne var line1=__import__('os').system('rm -rf ~/')...)

OriginalL'auteur Alex Ketay

La suite rend quelques hypothèses telles que de savoir comment la page est mis en forme, mais une façon d'obtenir votre exemple en mémoire sur Python est comme ça

# example data
data = 'foo bar foo bar foo bar foo bar\r\nfoo bar foo bar foo bar foo bar \r\nvar line1=\r\n[["Wed, 12 Jun 2013 01:00:00 +0000",22.4916114807,"2 sold"],\r\n["Fri, 14 Jun 2013 01:00:00 +0000",27.4950008392,"2 sold"],\r\n["Sun, 16 Jun 2013 01:00:00 +0000",19.5499992371,"1 sold"],\r\n["Tue, 18 Jun 2013 01:00:00 +0000",17.25,"1 sold"],\r\n["Sun, 23 Jun 2013 01:00:00 +0000",15.5420341492,"2 sold"],\r\n["Thu, 27 Jun 2013 01:00:00 +0000",8.79045295715,"3 sold"],\r\n["Fri, 28 Jun 2013 01:00:00 +0000",10,"1 sold"]];\r\nfoo bar foo bar foo bar foo bar\r\nfoo bar foo bar foo bar foo bar'
# find your variable's start and end
x = data.find('line1=') + 6
y = data.find(';', x)
# so you can get just the relevant bit
interesting = data[x:y].strip()
# most dangerous step! don't do this on unknown sources
parsed = eval(interesting)
# maybe you'd want to use JSON instead, if the data has the right syntax
from json import loads as JSON
parsed = JSON(interesting)
# now parsed is your data

Je serais certainement pas utiliser eval ici. Si vous souhaitez gérer tout ce qui est un Python littéral, l'utilisation ast.literal_eval. Mais vous probaly ne veux pas même que.
En gros, vous avez eu la même chose que j'avais en tête, mais j'ai juste utilisé une expression régulière de la place. Bien que j'ai fini en utilisant eval...

OriginalL'auteur Paul S.

-1

En supposant que vous avez une variable python avec une ligne de javascript/bloc comme une chaîne de caractères comme"var line1 = [[a,b,c], [d,e,f]];", vous pouvez utiliser les éléments suivants, en quelques lignes de code.
```
>>> code = """var line1 = [['a','b','c'], ['d','e','f'], ['g','h','i']];"""
>>> python_readable_code = code.strip("var ;")
>>> exec(python_readable_code)
>>> print(line1)
[['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]
```
exec() Va exécuter le code qui est formaté comme une chaîne de caractères. Dans ce cas, il sera de définir la variable line1 à une liste de listes.

Et que vous pouvez utiliser quelque chose comme ceci:
```
for list in line1:
    print(list[0], list[1], list[2])
    # Or do something else with those values, like save them to a file
```
Vous n'avez pas vraiment besoin de dépouiller les points-virgules; ils sont valides séparateurs en Python, même si ce n'est que la séparation d'un énoncé à partir de rien. Mais plus important encore, strip("var ;") va être dangereux si les noms de variable pourrait être, disons, a_line...
Et plus important encore, en essayant de transformer le JS de Python et de l'exécuter est vraiment, vraiment hacky et dangereux. Il permettra de travailler en toute sécurité dans le même cas que juste le fractionnement et l'appel ast.literal_eval sur le côté droit serait, mais ce serait beaucoup plus sûr, et vous permettra de stocker les variables où vous le souhaitez (par exemple, dans un dict) au lieu de les pousser à habitants (qui n'est presque jamais ce que vous voulez).

OriginalL'auteur IPDGino

Vous devez vous connecter pour publier un commentaire.