There are actually many things you don’t know about WeChat. Python WeChat platform development and writing records

This article mainly describes how to use Python to develop the WeChat public platform.

Note: If you are a Python novice or a web crawler novice, and find the code in this course obscure and difficult to understand, it doesn't matter. You don't need to understand it. Just follow the steps step by step. In this section, we mainly build a framework, and there is almost no real web crawler code. You may only use these codes and operations once in your life. In the next section, we will talk about how to expand our web crawler program based on this framework.

Required Action:

• Application for WeChat public account.
• Obtaining WeChat interface, setting SAE, etc.
• Simple Python crawler code writing

Knowledge points to master:

• Understand the connection between WeChat public accounts and cloud computing platforms and clarify their operating mechanisms.
• Understand the concept of web.py and the mechanism of wsgi.
• Understand simple python crawler knowledge, json parsing, API calls, and urllib library functions.

How automatic reply works

First, let's understand what kind of mechanism can realize the automatic reply function of WeChat? (Not the automatic reply of the WeChat system) The principle is that the WeChat platform sends the text entered by the user to the cloud platform, and then the program running on the cloud platform captures this text information and returns a result, and then the cloud platform returns the result to the WeChat platform. Finally, the WeChat platform displays the returned result to the user. Let's use a picture to show it:

WeChat developer mode and SAE settings

I will try to explain this section in detail. If there is still something unclear, you can send me a private message.

First of all, we need support from two major platforms:

• WeChat public platform; this application is relatively simple. As long as you have an email address, you can apply for a personal subscription account for free. No more details.
• Cloud computing platform; I use SAE here (Sina didn’t charge any fees last year, which was a rip-off. They started charging this year, and the minimum price for simple code hosting is 0.1 cent per day), or you can use Tencent Cloud.

Specific steps:

Application for WeChat public account.

As long as you have an email address, you can apply for a personal subscription account for free. No more details.

Application and setup of SAE

After registering and logging in to SAE, select SAE

Create a new project. SAE currently only supports Python 2.7, and Python 3 cannot be used for the time being.

If the project is small, it is recommended to fill in SVN, because it can be edited online. If the project is large, then Git is the best choice. Here, SVN is selected.

Creating the first version

You can start editing now~

Write config.yaml and index.wsgi files.

WSGI is Python Web Server Gateway Interface. We use the web.py framework. Other powerful frameworks of the same type include Django, Flask, etc. Why choose web.py? Because it is lightweight and has good XML parsing capabilities. As an aside, the developer of web.py, Aaron H. Swartz, was a genius, but unfortunately died young. There is a documentary about him that I recommend watching: The Internet's Son.

Okay, let's get back to the topic. Let's first write config.yaml

 name : pifuhandashu
 version: 1
 libraries:
 - name : webpy
 version: "0.36"  
 - name : lxml
 version: "2.3.4"  
 ...

Here we introduce the web.py framework and lxml module, and then we write the index.wsgi file.

 # coding: utf-8
 import os
 import sae
 import web
 from weixinInterface import WeixinInterface
 urls = ( '/weixin' , 'WeixinInterface' )
 app_root = os.path.dirname(__file__)
 templates_root = os.path.join (app_root, 'templates' )
 render = web.template.render(templates_root)
 app = web.application(urls, globals()).wsgifunc()
 application = sae.create_wsgi_app(app)

Here is some simple knowledge of Python web development using web.py. Set up the root directory, template directory, /weixin route, and start the application.

In order to make the page look neater, we created a new py file weixinInterface.py (weixinInterface.py and index.wsgi are in the same directory, see the screenshot below).

• Edit weixinInterface.py. Be sure to read the capitalization carefully, otherwise it is easy to make mistakes. Remember to fill in a unique token, which will be used in the WeChat public account settings later.

 # -*- coding: utf-8 -*-
 import hashlib
 import web
 import lxml
 import time  
 import os
 import urllib2,json
 from lxml import etree
 class WeixinInterface:
 def __init__(self):
 self.app_root = os.path.dirname(__file__)
 self.templates_root = os.path.join (self.app_root, 'templates' )
 self.render = web.template.render(self.templates_root)
 def GET(self):
 #Get input parameters
 data = web.input()
 signature = data.signature
 timestamp = data.timestamp  
 nonce = data.nonce
 echostr = data.echostr
 #Own token
 token = "XXXXXXXXXXX" #Note: Fill in the token entered in the WeChat public platform later! ! !
 # Lexicographic sorting
 list = [token, timestamp , nonce]
 list.sort()
 sha1 = hashlib.sha1()
 map( sha1.update ,list)
 hashcode = sha1.hexdigest()
 #sha1 encryption algorithm
 #If it is a request from WeChat, reply echostr
 if hashcode == signature:
 return echostr

Let's briefly explain the code. def __init__(self) tells us where the template file is loaded. def GET(self) is a token verification required by the WeChat public platform. The verification here uses a hash algorithm. For details, please refer to the official WeChat interface access instructions: WeChat public platform access guide. There is a PHP example in it. This article uses Python implementation.

WeChat developer mode settings

Basic Settings

Modify the configuration

The URL must be filled in carefully and checked carefully.

For example, view url application information:

Token must be the same as the one you just filled in Sina SAE. EncodingAESKey can be randomly generated. After filling in, click Submit. If it prompts "Submission successful". Congratulations, the most critical step has been completed. This stage may take a long time. After completion, be sure to enable the developer mode!!!! Remember!!!

WeChat robot implementation

After the previous step is completed, we can do something interesting: WeChat robot. But before that, there is still a small step to complete: template creation. Since WeChat development is in the form of XML. In order to realize automatic reply in text form first (later you can realize reply in the form of audio, text and pictures, etc.), first create a new template folder templates, and then create a reply_text.xml file in the templates folder (see the screenshot below for the file location). According to the passive reply of WeChat message, fill in the following code:

 $def with (toUser,fromUser,createTime,content)
 <xml>
 <ToUserName><![CDATA[$toUser]]></ToUserName>
 <FromUserName><![CDATA[$fromUser]]></FromUserName>
 <CreateTime>$createTime</CreateTime>
 <MsgType><![CDATA[text]]></MsgType>
 <Content>$content</Content>
 </xml>

Then, write the POST function after def GET(self) in weixinInterface.py. This function is used to obtain the user's ID, the type of message sent, the time of sending, etc. Determine the type of message sent by the user. If it is a plain text type, if mstype == 'text', then you can proceed to the next step.

 def POST(self):
 str_xml = web.data() #Get the data from post
 xml = etree.fromstring(str_xml)# XML parsing
 mstype = xml.find( "MsgType" ).text#Message type
 fromUser = xml.find( "FromUserName" ).text
 toUser = xml.find( "ToUserName" ).text

In order to implement WeChat robot, we need to implement automatic reply content. There are two ways to do this.

• Crawl the content of the robot replies on the Internet. For example, if I can’t find the interface of the little yellow chicken, I will crawl its reply results with my own crawler.
• Call the robot API that can automatically reply.

Here I choose the second method, which uses the Turing Robot API. This method is convenient and fast, and is generally not blocked. However, it has low freedom and poor scalability.

Register a Turing robot account. Note that you should use Turing's web API instead of authorization. Get the key for Turing robot replies. You can get automatic replies from WeChat robots with just a few lines of code~

Source code display

index.wsgi source code

 # coding: utf-8
 import os
 import sae
 import web
 from weixinInterface import WeixinInterface
 urls = (
 '/weixin' , 'WeixinInterface' ,
 )
 app_root = os.path.dirname(__file__)
 templates_root = os.path.join (app_root, 'templates' )
 render = web.template.render(templates_root)
 app = web.application(urls, globals()).wsgifunc()
 application = sae.create_wsgi_app(app)

config.yaml source code

 name : myzhihu
 version: 1
 libraries:
 - name : webpy
 version: "0.36"  
 - name : lxml
 version: "2.3.4"  
 ...

reply_text.xml source code under templates

 $def with (toUser,fromUser,createTime,content)
 <xml>
 <ToUserName><![CDATA[$toUser]]></ToUserName>
 <FromUserName><![CDATA[$fromUser]]></FromUserName>
 <CreateTime>$createTime</CreateTime>
 <MsgType><![CDATA[text]]></MsgType>
 <Content>$content</Content>
 </xml>

weixinInterface.py source code

 # -*- coding: utf-8 -*-
 import hashlib
 import web
 import lxml
 import time  
 import os
 import json
 import urllib
 from lxml import etree
 class WeixinInterface:
 def __init__(self):
 self.app_root = os.path.dirname(__file__)
 self.templates_root = os.path.join (self.app_root, 'templates' )
 self.render = web.template.render(self.templates_root)
 def GET(self):
 #Get input parameters
 data = web.input()
 signature=data.signature
 timestamp = data.timestamp  
 nonce=data.nonce
 echostr=data.echostr
 #Own token
 token = "#################" #Fill in the token entered in the WeChat public platform
 # Lexicographic sorting
 list=[token, timestamp ,nonce]
 list.sort()
 sha1 = hashlib.sha1()
 map( sha1.update ,list)
 hashcode = sha1.hexdigest()
 #sha1 encryption algorithm
 #If it is a request from WeChat, reply echostr
 if hashcode == signature:
 return echostr 
  
 def POST(self):
 str_xml = web.data() #Get the data from post
 xml = etree.fromstring(str_xml)# XML parsing
 mstype = xml.find( "MsgType" ).text
 fromUser = xml.find( "FromUserName" ).text
 toUser = xml.find( "ToUserName" ).text 
  
 if mstype == 'text' :
 content = xml.find( "Content" ).text#Get the content entered by the user
 key = '######################' ###Turing robot's key   
 api = 'http://www.tuling123.com/openapi/api?key=' + key + '&info='   
 info = content.encode( 'UTF-8' )
 url = api + info
 page = urllib.urlopen(url)
 html = page.read ()
 dic_json = json.loads(html)
 reply_content = dic_json[ 'text' ]
 return self.render.reply_text(fromUser,toUser, int ( time . time ()),reply_content)

Postscript

This tutorial uses Python to develop a WeChat public platform that can automatically reply to user input text. It includes the settings of the WeChat public platform, the settings of SAE, and the writing of related codes.