python3发新浪微博

拼搏现实的明天。 2022-07-13 10:29 250阅读 0赞

# python3发新浪微博 #

# 创建微博应用 #

登陆`http://open.weibo.com/apps`创建微博应用，获取`App Key`和`App Secret`，填写OAuth2.0授权回调页，如果不知道是什么就写微博默认的`https://api.weibo.com/oauth2/default.html`在 应用信息–>高级信息 中，授权回调页和取消授权回调页都填一样的。  
这个网上很多。

# 获取微博的python接口 #

微博官网提供的python接口是python2.7的，经网友改写成py3，这里贴出代码。  
`出处：http://www.cnblogs.com/txw1958/archive/2012/08/13/weibo-oauth2-python3.html`

#!/usr/bin/env python
    # -*- coding: utf-8 -*-
    
    __version__ = '1.04'
    __author__ = 'Liao Xuefeng (askxuefeng@gmail.com)'
    __publish__ = 'http://www.cnblogs.com/txw1958/'
    
    ''' Python3 client SDK for sina weibo API using OAuth 2. '''
    
    try:
        import json
    except ImportError:
        import simplejson as json
    import time
    import urllib.request
    import logging
    
    def _obj_hook(pairs):
        ''' convert json object to python object. '''
        o = JsonObject()
        for k, v in pairs.items():
            o[str(k)] = v
        return o
    
    class APIError(Exception):
        ''' raise APIError if got failed json message. '''
        def __init__(self, error_code, error, request):
            self.error_code = error_code
            self.error = error
            self.request = request
            Exception.__init__(self, error)
    
        def __str__(self):
            return 'APIError: %s: %s, request: %s' % (self.error_code, self.error, self.request)
    
    class JsonObject(dict):
        ''' general json object that can bind any fields but also act as a dict. '''
        def __getattr__(self, attr):
            return self[attr]
    
        def __setattr__(self, attr, value):
            self[attr] = value
    
    def _encode_params(**kw):
        ''' Encode parameters. '''
        args = []
        for k, v in kw.items():
            qv = v.encode('utf-8') if isinstance(v, str) else str(v)
            args.append('%s=%s' % (k, urllib.parse.quote(qv)))
        return '&'.join(args)
    
    def _encode_multipart(**kw):
        ''' Build a multipart/form-data body with generated random boundary. '''
        boundary = '----------%s' % hex(int(time.time() * 1000))
        data = []
        for k, v in kw.items():
            data.append('--%s' % boundary)
            if hasattr(v, 'read'):
                filename = getattr(v, 'name', '')
                n = filename.rfind('.')
                ext = filename[n:].lower() if n != (-1) else ""
                content = v.read()
                content = content.decode('ISO-8859-1')
                data.append('Content-Disposition: form-data; name="%s"; filename="hidden"' % k)
                data.append('Content-Length: %d' % len(content))
                data.append('Content-Type: %s\r\n' % _guess_content_type(ext))
                data.append(content)
            else:
                data.append('Content-Disposition: form-data; name="%s"\r\n' % k)
                data.append(v if isinstance(v, str) else v.decode('utf-8'))
        data.append('--%s--\r\n' % boundary)
        return '\r\n'.join(data), boundary
    
    _CONTENT_TYPES = { '.png': 'image/png', '.gif': 'image/gif', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.jpe': 'image/jpeg' }
    
    def _guess_content_type(ext):
        return _CONTENT_TYPES.get(ext, 'application/octet-stream')
    
    _HTTP_GET = 0
    _HTTP_POST = 1
    _HTTP_UPLOAD = 2
    
    def _http_get(url, authorization=None, **kw):
        logging.info('GET %s' % url)
        return _http_call(url, _HTTP_GET, authorization, **kw)
    
    def _http_post(url, authorization=None, **kw):
        logging.info('POST %s' % url)
        return _http_call(url, _HTTP_POST, authorization, **kw)
    
    def _http_upload(url, authorization=None, **kw):
        logging.info('MULTIPART POST %s' % url)
        return _http_call(url, _HTTP_UPLOAD, authorization, **kw)
    
    def _http_call(url, method, authorization, **kw):
        ''' send an http request and expect to return a json object if no error. '''
        params = None
        boundary = None
        if method==_HTTP_UPLOAD:
            params, boundary = _encode_multipart(**kw)
        else:
            params = _encode_params(**kw)
        http_url = '%s?%s' % (url, params) if method==_HTTP_GET else url
        http_body = None if method==_HTTP_GET else params.encode(encoding='utf-8')
        req = urllib.request.Request(http_url, data=http_body)
        if authorization:
            req.add_header('Authorization', 'OAuth2 %s' % authorization)
        if boundary:
            req.add_header('Content-Type', 'multipart/form-data; boundary=%s' % boundary)
        resp = urllib.request.urlopen(req)
        body = resp.read().decode("utf-8")
        r = json.loads(body, object_hook=_obj_hook)
        if 'error_code' in r:
            raise APIError(r.error_code, r['error_code'], r['request'])
        return r
    
    class HttpObject(object):
    
        def __init__(self, client, method):
            self.client = client
            self.method = method
    
        def __getattr__(self, attr):
            def wrap(**kw):
                if self.client.is_expires():
                    raise APIError('21327', 'expired_token', attr)
                return _http_call('%s%s.json' % (self.client.api_url, attr.replace('__', '/')), self.method, self.client.access_token, **kw)
            return wrap
    
    class APIClient(object):
        ''' API client using synchronized invocation. '''
        def __init__(self, app_key, app_secret, redirect_uri=None, response_type='code', domain='api.weibo.com', version='2'):
            self.client_id = app_key
            self.client_secret = app_secret
            self.redirect_uri = redirect_uri
            self.response_type = response_type
            self.auth_url = 'https://%s/oauth2/' % domain
            self.api_url = 'https://%s/%s/' % (domain, version)
            self.access_token = None
            self.expires = 0.0
            self.get = HttpObject(self, _HTTP_GET)
            self.post = HttpObject(self, _HTTP_POST)
            self.upload = HttpObject(self, _HTTP_UPLOAD)
    
        def set_access_token(self, access_token, expires_in):
            self.access_token = str(access_token)
            self.expires = float(expires_in)
    
        def get_authorize_url(self, redirect_uri=None, display='default'):
            ''' return the authroize url that should be redirect. '''
            redirect = redirect_uri if redirect_uri else self.redirect_uri
            if not redirect:
                raise APIError('21305', 'Parameter absent: redirect_uri', 'OAuth2 request')
            return '%s%s?%s' % (self.auth_url, 'authorize', \
                    _encode_params(client_id = self.client_id, \
                            response_type = 'code', \
                            display = display, \
                            redirect_uri = redirect))
    
        def request_access_token(self, code, redirect_uri=None):
            ''' return access token as object: {"access_token":"your-access-token","expires_in":12345678}, expires_in is standard unix-epoch-time '''
            redirect = redirect_uri if redirect_uri else self.redirect_uri
            if not redirect:
                raise APIError('21305', 'Parameter absent: redirect_uri', 'OAuth2 request')
    
            r = _http_post('%s%s' % (self.auth_url, 'access_token'), \
                    client_id = self.client_id, \
                    client_secret = self.client_secret, \
                    redirect_uri = redirect, \
                    code = code, grant_type = 'authorization_code')
    
            r.expires_in += int(time.time())
            return r
    
        def is_expires(self):
            return not self.access_token or time.time() > self.expires
    
        def __getattr__(self, attr):
            return getattr(self.get, attr)
    
    
    def main():
        try:
            #step 1 定义 app key，app secret，回调地址：
            APP_KEY = "12345678912"
            APP_SECRET = "7be6f636faf7b17d048888888888888888888"
            CALLBACK_URL = 'https://api.weibo.com/oauth2/default.html'
            #step 2 引导用户到授权地址
            client = APIClient(app_key=APP_KEY, app_secret=APP_SECRET, redirect_uri=CALLBACK_URL)
            print(client.get_authorize_url())
            #step 3 换取Access Token
            # 将上面的地址复制到浏览器中运行，输入账号密码授权，新的网址里面就有code
            r = client.request_access_token(input("Input code:"))  #输入授权地址中获得的CODE
            client.set_access_token(r.access_token, r.expires_in)
            #
            # 此时获取到access_token和expires_in应该保存下来，因为有一个有效期，如果短时间需要多次发微博，可以重复使用，而不需要每次获取。
            # 
            #step 4 使用获得的OAuth2.0 Access Token调用API
            print(client.get.account__get_uid())
            print(client.post.statuses__update(status='测试Python3 + OAuth 2.0发微博 ' + str(time.time())))
            #print(client.upload.statuses__upload(status='测试Python3 OAuth 2.0带图片发微博 ' + str(time.time()), pic=open('test.png', 'rb')))
    
        except Exception as pyOauth2Error:
            print(pyOauth2Error)
    
    if __name__ == '__main__':
        main()

# selenium操作浏览器获取code #

这里面有个不好的地方是，每次发微博都要将网址复制出来用浏览器打开才能得到code，岂不是很麻烦，还不如直接用浏览器发呢，现在的浏览器还能保存密码自动登陆呢。

顺便提一句，用selenium操作浏览器真是就是跟实际你打开浏览器上网的操作是一样的，根本不用操心反爬虫问题，还可以获取cookie，传给其他模块如urllib的操作，同样可以获取网页源码进而爬取数据

这里介绍用selenium操作浏览器自动登陆获取code的方法。  
方法中使用的是chrome浏览器最新版本的内核是55，需要下载对应的浏览器驱动，版本是2.27，并将驱动程序所在路径添加到环境变量中。  
selenium的chrome驱动下载地址：`http://chromedriver.storage.googleapis.com/index.html`  
chrome内核版本与驱动对应关系参考：`http://blog.csdn.net/huilan_same/article/details/51896672`  
需要注意的是，每操作一步记得等一等，time.sleep()一下，如果你不能浏览器加载完，会看不到结果的。

from selenium import webdriver
    from selenium.webdriver.common.keys import Keys #引入keys类操作
    import time
    
    # 打开chrome浏览器
    browser = webdriver.Chrome()
    # browser.implicitly_wait(30) # 隐性等待，最长等30秒
    time.sleep(30)
    
    # 打开授权页面
    # 这个页面是上一步 weibo.APIClient.get_authorize_url() 获取得到的
    url=r'https://api.weibo.com/oauth2/authorize?display=default&client_id=88888888&redirect_uri=https%3A//api.weibo.com/oauth2/default.html&response_type=code'
    browser.get(url)
    
    # 输入账号密码，然后点击登陆按钮
    # 这一步需要查看网页源码才知道为什么是这么写
    browser.find_element_by_id('userId').send_keys('your_user_name')
    time.sleep(1)
    browser.find_element_by_id('passwd').send_keys('your_password')
    time.sleep(3)
    browser.find_element_by_class_name('WB_btn_login').send_keys(Keys.ENTER)
    time.sleep(3)
    
    # 然后会自动跳转，获取url，从url中提取code
    # 用这个 code 就可以在 weibo.APIClient 中登陆了
    code_url = browser.current_url
    code = code_url.split('code=')[-1]
    
    # 获取网页源码
    browser.page_source
    # 获取cookie
    browser.get_cookies()

# 模拟鼠标键盘操作获取url #

我发现，360急速浏览器保存账号密码后，下次直接输入url就会自动跳转到code的页面，根本不需要输入账号密码，省心很多。这里通过模拟鼠标操作，键盘按键来获取url。  
原理是很简单，就是打开浏览器输入网址，将鼠标移动到指定的像素点位置，然后右键，F键，复制网址，最后通过获取剪贴板内容得到url。

import webbrowser  # 打开浏览器
    from pymouse import PyMouse  # 模拟鼠标
    from pykeyboard import PyKeyboard   # 模拟键盘
    import time
    import win32clipboard, win32con   # 剪切板
    
    # 在浏览器中打开网址
    url=r'https://api.weibo.com/oauth2/authorize?display=default&client_id=88888888&redirect_uri=https%3A//api.weibo.com/oauth2/default.html&response_type=code'
    webbrowser.open_new_tab(url)
    time.sleep(10)
    
    # 实例化鼠标键盘
    m = PyMouse()
    k = PyKeyboard()
    
    x_dim, y_dim = m.screen_size()  # 屏幕分辨率
    
    m.position()  # 鼠标位置，可以通过这个函数获取网址的像素点位置
    
    # 复制网址的方法是，右键网址，然后F键，可以在浏览器中手动操作一下
    # 移动到网址栏
    time.sleep(1)
    m.click(int(x_dim*0.5), int(y_dim*0.045), button=2, n=1)  # 移动到指定位置，然后右键单击
    time.sleep(1)
    
    k.press_key('F')  # 按下F键
    time.sleep(1)
    k.release_key('F')  # 释放F键
    time.sleep(1)
    
    # 关闭浏览器
    m.click(int(x_dim * 0.985), int(y_dim * 0.015), button=1, n=1)
    
    # alt+tab组合键
    # k.press_key(k.alt_key)
    # k.tap_key(k.tab_key)
    # k.release_key(k.alt_key)
    
    # 获取剪切板内容
    win32clipboard.OpenClipboard()
    time.sleep(1)
    new_url = win32clipboard.GetClipboardData(win32con.CF_TEXT)
    time.sleep(1)
    win32clipboard.CloseClipboard()
    new_url = new_url.decode('gbk')
    
    # 获取code
    code = new_url.split('code=')[-1]

总结：  
这种每次发微博都需要获取code的方法，真的太笨太繁琐了，只适合自娱自乐罢了。真正商业环境中肯定是用c或者java的接口去做。  
selenium很强大，还能登陆微博发微博呢，但是有一种情况不能处理，就是输入验证码啦。

# 参考 #

微博的python3接口  
[http://www.cnblogs.com/txw1958/archive/2012/08/13/weibo-oauth2-python3.html][http_www.cnblogs.com_txw1958_archive_2012_08_13_weibo-oauth2-python3.html]  
微博接口的详细使用方法  
[http://blog.csdn.net/dongtingzhizi/article/details/9098527][http_blog.csdn.net_dongtingzhizi_article_details_9098527]  
selenium使用方法  
[http://blog.163.com/ly676830315@126/blog/static/1017337222013102310617946/][http_blog.163.com_ly676830315_126_blog_static_1017337222013102310617946]  
[http://www.dataguru.cn/thread-477510-1-1.html][http_www.dataguru.cn_thread-477510-1-1.html]  
[https://my.oschina.net/yangyanxing/blog/280871?p=1][https_my.oschina.net_yangyanxing_blog_280871_p_1]  
[http://www.aichengxu.com/view/11949][http_www.aichengxu.com_view_11949]  
[http://blog.csdn.net/five3/article/details/50013159][http_blog.csdn.net_five3_article_details_50013159]  
chrome内核版本和驱动版本对应参考  
[http://blog.csdn.net/huilan\_same/article/details/51896672][http_blog.csdn.net_huilan_same_article_details_51896672]  
chrome驱动下载  
[http://chromedriver.storage.googleapis.com/index.html][http_chromedriver.storage.googleapis.com_index.html]  
模拟鼠标键盘操作  
[http://blog.csdn.net/shij19/article/details/53046048][http_blog.csdn.net_shij19_article_details_53046048]

[http_www.cnblogs.com_txw1958_archive_2012_08_13_weibo-oauth2-python3.html]: http://www.cnblogs.com/txw1958/archive/2012/08/13/weibo-oauth2-python3.html
[http_blog.csdn.net_dongtingzhizi_article_details_9098527]: http://blog.csdn.net/dongtingzhizi/article/details/9098527
[http_blog.163.com_ly676830315_126_blog_static_1017337222013102310617946]: http://blog.163.com/ly676830315@126/blog/static/1017337222013102310617946/
[http_www.dataguru.cn_thread-477510-1-1.html]: http://www.dataguru.cn/thread-477510-1-1.html
[https_my.oschina.net_yangyanxing_blog_280871_p_1]: https://my.oschina.net/yangyanxing/blog/280871?p=1
[http_www.aichengxu.com_view_11949]: http://www.aichengxu.com/view/11949
[http_blog.csdn.net_five3_article_details_50013159]: http://blog.csdn.net/five3/article/details/50013159
[http_blog.csdn.net_huilan_same_article_details_51896672]: http://blog.csdn.net/huilan_same/article/details/51896672
[http_chromedriver.storage.googleapis.com_index.html]: http://chromedriver.storage.googleapis.com/index.html
[http_blog.csdn.net_shij19_article_details_53046048]: http://blog.csdn.net/shij19/article/details/53046048