Python填写问卷星

Python填写问卷星

有些无意义的问卷作业，真的没有必要。
但是作业既然有了，那就想办法解决它把。
关于IP限制的问题，可以使用X-Forwarded-For更换IP。
只会用印象笔记markdown的我，感觉markdown好复杂。
我想做个目录，但是[toc]没反应，...

1.分析接口

问卷星提交数据的url

url需要参数生成，submiitdata为提交的数据

1$2：表示选择第一问的第二个选项，这是单选题的数据格式

2.构造url

构造url需要submittype, curID, t, starttime, ktimes, rn, hlv, jqnonce, jqsign
经实验，必要的参数如下：

• submittype,curID,ktimes,rn,jqnonce,jqsign
  但是只传这些参数，会让你输入验证码，最后得出结果，除了hlv其他参数都是必要的

必要参数获取方式：

• submittype：我做的是调查类问卷，固定值为1，其他类型问卷没试过
• curlID：问卷网址中含有此数值，也可以从访问问卷网址获取的response中获取
• t：时间戳，后三位为随机数，推测为提交数据的时间，我们可以使用python生成
• starttime：字符串格式的时间，推测为打开网页的时间，我们可以使用python生成
• ktimes：做题的时间，但是不是秒数，根据做题时间变长而增大，用以生成jasign，我们可以用python生成
• rn：从访问问卷网址获取的response中获取
• jqnonce： 从访问问卷网址获取的response中获取，用以生成jqsign
• jqsign：使用ktimes和jqnonce
  • 经过查看js代码，找到了jqsign的生成函数
    其中a是jqnonce

    dataenc(a)
    {
    var b = ktimes % 10;
    b == 0 && (b = 1);
    for (var d = [], c = 0; c < a.length; c++) {
        var f = a.charCodeAt(c) ^ b;
        d.push(String.fromCharCode(f))
    }
    return d.join("")
    }
    
    

    转换为python:

        result = []
        b = ktimes % 10
        if b == 0:
            b = 1
        for char in list(jqnonce):
            f = ord(char) ^ b
            result.append(chr(f))
        return ''.join(result)
    

---

思路有了，可以开工了。
先定义一个问卷星的类：

• wj_url：要填写的问卷的url
• post_url：用来提交数据的url
• header：请求头
• cookie：请求使用的cookie，提交问卷cookie可设置可不设置
• data：需要提交的数据

import requests
import re
import time
import random

class WenJuanXing:
    def __init__(self, url):
        """
        :param url:要填写的问卷的url
        """
        self.wj_url = url
        self.post_url = None
        self.header = None
        self.cookie = None
        self.data = None

ktimes生成函数：

    def get_ktimes(self):
        """
        随机生成一个ktimes,ktimes是构造post_url需要的参数，为一个整数
        :return:
        """
        return random.randint(5, 18)

header设置函数：
随机生成IP,如果不换IP,提交多了会提示输入验证码
很少见到x-forwarded-for能有用的时候，问卷星刚好就可以

    def set_header(self):
        """
        随机生成ip，设置X-Forwarded-For
        ip需要控制ip段，不然生成的大部分是国外的
        :return:
        """
        ip = '{}.{}.{}.{}'.format(112, random.randint(64, 68), random.randint(0, 255), random.randint(0, 255))
        self.header = {
            'X-Forwarded-For': ip,
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko\
                        ) Chrome/71.0.3578.98 Safari/537.36',
        }

访问问卷网址，获取response：

    def get_response(self):
        """
        访问问卷网页，获取网页代码
        :return: get请求返回的response
        """
        response = requests.get(url=self.wj_url, headers=self.header)
        self.cookie = response.cookies
        return response

通过上面的response获取jqnonce:
由于jqnonce是script里面的一个变量，所以使用正则表达式提取
我更喜欢xpath，但是好像xpath提不出来

    def get_jqnonce(self, response):
        """
        通过正则表达式找出jqnonce,jqnonce是构造post_url需要的参数
        :param response: 访问问卷网页，返回的reaponse
        :return: 找到的jqnonce
        """
        jqnonce = re.search(r'.{8}-.{4}-.{4}-.{4}-.{12}', response.text)
        return jqnonce.group()

通过response获取rn：

    def get_rn(self, response):
        """
        通过正则表达式找出rn,rn是构造post_url需要的参数
        :param response: 访问问卷网页，返回的reaponse
        :return: 找到的rn
        """
        rn = re.search(r'\d{9,10}\.\d{8}', response.text)
        return rn.group()

通过response获取id

    def get_id(self, response):
        """
        通过正则表达式找出问卷id,问卷是构造post_url需要的参数
        :param response: 访问问卷网页，返回的reaponse
        :return: 找到的问卷id
        """
        id = re.search(r'\d{8}', response.text)
        return id.group()

通过jqnonce和ktimes生成jqsign：

    def get_jqsign(self, ktimes, jqnonce):
        """
        通过ktimes和jqnonce计算jqsign,jqsign是构造post_url需要的参数
        :param ktimes: ktimes
        :param jqnonce: jqnonce
        :return: 生成的jqsign
        """
        result = []
        b = ktimes % 10
        if b == 0:
            b = 1
        for char in list(jqnonce):
            f = ord(char) ^ b
            result.append(chr(f))
        return ''.join(result)

通过response获取starttime：
获取starttime的正则表达式我没有获取秒，因为获取秒后会弹验证码
我猜测：

• starttime，t， ktimes存在一定关系，但这些数据都是我们伪造的，忽略的秒数可能会消除我们伪造的虚假

    def get_start_time(self, response):
        """
        通过正则表达式找出问卷starttime,问卷是构造post_url需要的参数
        :param response: 访问问卷网页，返回的reaponse
        :return: 找到的starttime
        """
        start_time = re.search(r'\d+?/\d+?/\d+?\s\d+?:\d{2}', response.text)
        return start_time.group()

终于把各个参数获取的差不多了，可以生成url了：

    def set_post_url(self):
        """
        生成post_url
        :return:
        """
        self.set_header()  # 设置请求头，更换ip
        response = self.get_response()  # 访问问卷网页，获取response
        ktimes = self.get_ktimes()  # 获取ktimes
        jqnonce = self.get_jqnonce(response)  # 获取jqnonce
        rn = self.get_rn(response)  # 获取rn
        id = self.get_id(response)  # 获取问卷id
        jqsign = self.get_jqsign(ktimes, jqnonce)  # 生成jqsign
        start_time = self.get_start_time(response)  # 获取starttime
        time_stamp = '{}{}'.format(int(time.time()), random.randint(100, 200))  # 生成一个时间戳，最后三位为随机数
        url = 'https://www.wjx.cn/joinnew/processjq.ashx?submittype=1&curID={}&t={}&starttim' \
              'e={}&ktimes={}&rn={}&jqnonce={}&jqsign={}'.format(id, time_stamp, start_time, ktimes, rn, jqnonce, jqsign)
        self.post_url = url  # 设置url
        print(self.post_url)

3.生成数据

url生成好了，我们基本成功了，剩下的工作就比较轻松了
生成需要提交的数据：

• 之前提过了,1$1代表选择第一问的第一个选项
• 如果有更多的选项和不同的问题类型，需要浏览器抓包了解其结构
• 可以使用有限制的随机函数，是提交的结果不那么假
• 我这儿只有一道题作为测试，所以数据构造的很简答

    def set_data(self):
        """
        这个函数中生成问卷的结果，可根据问卷结果，随机生成答案
        :return:
        """
        self.data = {
            'submitdata': '1$1'
        }

4.提交数据

万事俱备，只欠东风。
如果response.text为22，则代表失败
会有少数的失败，不知道什么原因
post_data函数：

    def post_data(self):
        """
        发送数据给服务器
        :return: 服务器返回的结果
        """
        self.set_data()
        response = requests.post(url=self.post_url, data=self.data, headers=self.header, cookies=self.cookie)
        return response

run函数：
至此我们就可以全自动化的填问卷了，而且不受ip的限制

    def run(self):
        """
        填写一次问卷
        :return:
        """
        self.set_post_url()
        result = self.post_data()
        print(result.content.decode())

一次填写多个问卷：

    def mul_run(self, n):
        """
        填写多次问卷
        :return:
        """
        for i in range(n):
            self.run()

5.启动启动

运行一下：

if __name__ == '__main__':
    w = WenJuanXing('https://www.wjx.cn/jq/xxxxxxxx.aspx')
    w.mul_run(100)

结果：
红色圈出来的22代表失败，其他的代表成功

结果

问卷统计：

问卷统计

地理位置：

位置统计

6.完整代码

好了，该睡觉了
如果觉得速度不够快，可以用多线程

import requests
import re
import time
import random


class WenJuanXing:
    def __init__(self, url):
        """
        :param url:要填写的问卷的url
        """
        self.wj_url = url
        self.post_url = None
        self.header = None
        self.cookie = None
        self.data = None

    def set_data(self):
        """
        这个函数中生成问卷的结果，可根据问卷结果，随机生成答案
        :return:
        """
        self.data = {
            'submitdata': '1$1'
        }

    def set_header(self):
        """
        随机生成ip，设置X-Forwarded-For
        ip需要控制ip段，不然生成的大部分是国外的
        :return:
        """
        ip = '{}.{}.{}.{}'.format(112, random.randint(64, 68), random.randint(0, 255), random.randint(0, 255))
        self.header = {
            'X-Forwarded-For': ip,
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko\
                        ) Chrome/71.0.3578.98 Safari/537.36',
        }

    def get_ktimes(self):
        """
        随机生成一个ktimes,ktimes是构造post_url需要的参数，为一个整数
        :return:
        """
        return random.randint(15, 50)

    def get_response(self):
        """
        访问问卷网页，获取网页代码
        :return: get请求返回的response
        """
        response = requests.get(url=self.wj_url, headers=self.header)
        self.cookie = response.cookies
        return response

    def get_jqnonce(self, response):
        """
        通过正则表达式找出jqnonce,jqnonce是构造post_url需要的参数
        :param response: 访问问卷网页，返回的reaponse
        :return: 找到的jqnonce
        """
        jqnonce = re.search(r'.{8}-.{4}-.{4}-.{4}-.{12}', response.text)
        return jqnonce.group()

    def get_rn(self, response):
        """
        通过正则表达式找出rn,rn是构造post_url需要的参数
        :param response: 访问问卷网页，返回的reaponse
        :return: 找到的rn
        """
        rn = re.search(r'\d{9,10}\.\d{8}', response.text)
        return rn.group()

    def get_id(self, response):
        """
        通过正则表达式找出问卷id,问卷是构造post_url需要的参数
        :param response: 访问问卷网页，返回的reaponse
        :return: 找到的问卷id
        """
        id = re.search(r'\d{8}', response.text)
        return id.group()

    def get_jqsign(self, ktimes, jqnonce):
        """
        通过ktimes和jqnonce计算jqsign,jqsign是构造post_url需要的参数
        :param ktimes: ktimes
        :param jqnonce: jqnonce
        :return: 生成的jqsign
        """
        result = []
        b = ktimes % 10
        if b == 0:
            b = 1
        for char in list(jqnonce):
            f = ord(char) ^ b
            result.append(chr(f))
        return ''.join(result)

    def get_start_time(self, response):
        """
        通过正则表达式找出问卷starttime,问卷是构造post_url需要的参数
        :param response: 访问问卷网页，返回的reaponse
        :return: 找到的starttime
        """
        start_time = re.search(r'\d+?/\d+?/\d+?\s\d+?:\d{2}', response.text)
        return start_time.group()

    def set_post_url(self):
        """
        生成post_url
        :return:
        """
        self.set_header()  # 设置请求头，更换ip
        response = self.get_response()  # 访问问卷网页，获取response
        ktimes = self.get_ktimes()  # 获取ktimes
        jqnonce = self.get_jqnonce(response)  # 获取jqnonce
        rn = self.get_rn(response)  # 获取rn
        id = self.get_id(response)  # 获取问卷id
        jqsign = self.get_jqsign(ktimes, jqnonce)  # 生成jqsign
        start_time = self.get_start_time(response)  # 获取starttime
        time_stamp = '{}{}'.format(int(time.time()), random.randint(100, 200))  # 生成一个时间戳，最后三位为随机数
        url = 'https://www.wjx.cn/joinnew/processjq.ashx?submittype=1&curID={}&t={}&starttim' \
              'e={}&ktimes={}&rn={}&jqnonce={}&jqsign={}'.format(id, time_stamp, start_time, ktimes, rn, jqnonce, jqsign)
        self.post_url = url  # 设置url
        print(self.post_url)

    def post_data(self):
        """
        发送数据给服务器
        :return: 服务器返回的结果
        """
        self.set_data()
        response = requests.post(url=self.post_url, data=self.data, headers=self.header, cookies=self.cookie)
        return response

    def run(self):
        """
        填写一次问卷
        :return:
        """
        self.set_post_url()
        result = self.post_data()
        print(result.content.decode())

    def mul_run(self, n):
        """
        填写多次问卷
        :return:
        """
        for i in range(n):
            time.sleep(0.1)
            self.run()


if __name__ == '__main__':
    w = WenJuanXing('url')
    w.mul_run(100)